ftrandom.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <dirent.h>
#include <signal.h>
#include <time.h>
#include <ft2build.h>

Include dependency graph for ftrandom.c:

Go to the source code of this file.

Classes
struct	fontlist

Macros
#define	_XOPEN_SOURCE   500 /* for `kill', `strdup', `random', and `srandom' */
#define	true   1
#define	false   0
#define	forever   for (;;)
#define	GOOD_FONTS_DIR   "/usr/local/share/fonts"

Functions
static int	FT_MoveTo (const FT_Vector *to, void *user)
static int	FT_LineTo (const FT_Vector *to, void *user)
static int	FT_ConicTo (const FT_Vector *_cp, const FT_Vector *to, void *user)
static int	FT_CubicTo (const FT_Vector *cp1, const FT_Vector *cp2, const FT_Vector *to, void *user)
static void	TestFace (FT_Face face)
static void	ExecuteTest (char *testfont)
static int	extmatch (char *filename, char **extensions)
static void	figurefiletype (struct fontlist *item)
static void	FindFonts (char **fontdirs, char **extensions)
static unsigned int	getErrorCnt (struct fontlist *item)
static int	getRandom (int low, int high)
static int	copyfont (struct fontlist *item, char *newfont)
static void	abort_test (int sig)
static void	do_test (void)
static void	usage (FILE *out, char *name)
int	main (int argc, char **argv)

Variables
static int	check_outlines = false
static int	nohints = false
static int	rasterize = false
static char *	results_dir = "results"
static char *	default_dir_list []
static char *	default_ext_list []
static unsigned int	error_count = 1
static double	error_fraction = 0.0
static FT_F26Dot6	font_size = 12 * 64
static struct fontlist *	fontlist
static unsigned int	fcnt
static FT_Outline_Funcs	outlinefuncs
static int	child_pid

Macro Definition Documentation

_XOPEN_SOURCE

#define _XOPEN_SOURCE   500 /* for `kill', `strdup', `random', and `srandom' */

Definition at line 32 of file ftrandom.c.

false

#define false   0

Definition at line 52 of file ftrandom.c.

forever

#define forever   for (;;)

Definition at line 53 of file ftrandom.c.

GOOD_FONTS_DIR

#define GOOD_FONTS_DIR   "/usr/local/share/fonts"

Definition at line 61 of file ftrandom.c.

true

#define true   1

Definition at line 51 of file ftrandom.c.

Function Documentation

abort_test()

static void abort_test ( int  sig )

static

Definition at line 505 of file ftrandom.c.

  {
    FT_UNUSED( sig );
 
    /* If a time-out happens, then kill the child */
    kill( child_pid, SIGFPE );
    write( 2, "Timeout... ", 11 );
  }

Referenced by do_test().

copyfont()

static int copyfont ( struct fontlist *  item, char *  newfont  )

static

Definition at line 437 of file ftrandom.c.

  {
    static char   buffer[8096];
    FILE          *good, *newf;
    size_t        len;
    unsigned int  i, err_cnt;
 
 
    good = fopen( item->name, "r" );
    if ( !good )
    {
      fprintf( stderr, "Can't open `%s'\n", item->name );
      return false;
    }
 
    newf = fopen( newfont, "w+" );
    if ( !newf )
    {
      fprintf( stderr, "Can't create temporary output file `%s'\n",
               newfont );
      exit( 1 );
    }
 
    while ( ( len = fread( buffer, 1, sizeof ( buffer ), good ) ) > 0 )
      fwrite( buffer, 1, len, newf );
 
    fclose( good );
 
    err_cnt = getErrorCnt( item );
    for ( i = 0; i < err_cnt; i++ )
    {
      fseek( newf, getRandom( 0, (int)( item->len - 1 ) ), SEEK_SET );
 
      if ( item->isbinary )
        putc( getRandom( 0, 0xFF ), newf );
      else if ( item->isascii )
        putc( getRandom( 0x20, 0x7E ), newf );
      else
      {
        int  hex = getRandom( 0, 15 );
 
 
        if ( hex < 10 )
          hex += '0';
        else
          hex += 'A' - 10;
 
        putc( hex, newf );
      }
    }
 
    if ( ferror( newf ) )
    {
      fclose( newf );
      unlink( newfont );
      return false;
    }
 
    fclose( newf );
 
    return true;
  }

Referenced by do_test().

do_test()

static void do_test ( void  )

static

Definition at line 516 of file ftrandom.c.

  {
    int         i        = getRandom( 0, (int)( fcnt - 1 ) );
    static int  test_num = 0;
    char        buffer[1024];
 
 
    sprintf( buffer, "%s/test%d", results_dir, test_num++ );
 
    if ( copyfont ( &fontlist[i], buffer ) )
    {
      signal( SIGALRM, abort_test );
      /* Anything that takes more than 20 seconds */
      /* to parse and/or rasterize is an error.   */
      alarm( 20 );
      if ( ( child_pid = fork() ) == 0 )
        ExecuteTest( buffer );
      else if ( child_pid != -1 )
      {
        int  status;
 
 
        waitpid( child_pid, &status, 0 );
        alarm( 0 );
        if ( WIFSIGNALED ( status ) )
          printf( "Error found in file `%s'\n", buffer );
        else
          unlink( buffer );
      }
      else
      {
        fprintf( stderr, "Can't fork test case.\n" );
        exit( 1 );
      }
      alarm( 0 );
    }
  }

Referenced by main(), and TestASet().

ExecuteTest()

static void ExecuteTest ( char *  testfont )

static

Definition at line 200 of file ftrandom.c.

  {
    FT_Library  context;
    FT_Face     face;
 
 
    if ( FT_Init_FreeType( &context ) )
    {
      fprintf( stderr, "Can't initialize FreeType.\n" );
      exit( 1 );
    }
 
    if ( FT_New_Face( context, testfont, 0, &face ) )
    {
      /* The font is erroneous, so if this fails that's ok. */
      exit( 0 );
    }
 
    if ( face->num_faces == 1 )
      TestFace( face );
    else
    {
      long  i, num;
 
 
      num = face->num_faces;
      FT_Done_Face( face );
 
      for ( i = 0; i < num; i++ )
      {
        if ( !FT_New_Face( context, testfont, i, &face ) )
          TestFace( face );
      }
    }
 
    FT_Done_FreeType( context );
 
    exit( 0 );
  }

Referenced by do_test(), and main().

extmatch()

static int extmatch ( char *  filename, char **  extensions  )

static

Definition at line 242 of file ftrandom.c.

  {
    int    i;
    char*  pt;
 
 
    if ( !extensions )
      return true;
 
    pt = strrchr( filename, '.' );
    if ( !pt )
      return false;
    if ( pt < strrchr( filename, '/' ) )
      return false;
 
    for ( i = 0; extensions[i] != NULL; i++ )
      if ( strcasecmp( pt + 1, extensions[i] ) == 0 ||
           strcasecmp( pt,     extensions[i] ) == 0 )
        return true;
 
    return false;
  }

Referenced by FindFonts().

figurefiletype()

static void figurefiletype ( struct fontlist *  item )

static

Definition at line 268 of file ftrandom.c.

  {
    FILE*  foo;
 
 
    item->isbinary = item->isascii = item->ishex = false;
 
    foo = fopen( item->name, "rb" );
    if ( foo )
    {
      /* Try to guess the file type from the first few characters... */
      int  ch1 = getc( foo );
      int  ch2 = getc( foo );
      int  ch3 = getc( foo );
      int  ch4 = getc( foo );
 
 
      fclose( foo );
 
      if ( ( ch1 == 0   && ch2 == 1   && ch3 == 0   && ch4 == 0   ) ||
           ( ch1 == 'O' && ch2 == 'T' && ch3 == 'T' && ch4 == 'O' ) ||
           ( ch1 == 't' && ch2 == 'r' && ch3 == 'u' && ch4 == 'e' ) ||
           ( ch1 == 't' && ch2 == 't' && ch3 == 'c' && ch4 == 'f' ) )
      {
        /* ttf, otf, ttc files */
        item->isbinary = true;
      }
      else if ( ch1 == 0x80 && ch2 == '\01' )
      {
        /* PFB header */
        item->isbinary = true;
      }
      else if ( ch1 == '%' && ch2 == '!' )
      {
        /* Random PostScript */
        if ( strstr( item->name, ".pfa" ) ||
             strstr( item->name, ".PFA" ) )
          item->ishex = true;
        else
          item->isascii = true;
      }
      else if ( ch1 == 1 && ch2 == 0 && ch3 == 4 )
      {
        /* Bare CFF */
        item->isbinary = true;
      }
      else if ( ch1 == 'S' && ch2 == 'T' && ch3 == 'A' && ch4 == 'R' )
      {
        /* BDF */
        item->ishex = true;
      }
      else if ( ch1 == 'P' && ch2 == 'F' && ch3 == 'R' && ch4 == '0' )
      {
        /* PFR */
        item->isbinary = true;
      }
      else if ( ( ch1 == '\1' && ch2 == 'f' && ch3 == 'c' && ch4 == 'p' ) ||
                ( ch1 == 'M'  && ch2 == 'Z' )                             )
      {
        /* Windows FON */
        item->isbinary = true;
      }
      else
      {
        fprintf( stderr,
                 "Can't recognize file type of `%s', assuming binary\n",
                 item->name );
        item->isbinary = true;
      }
    }
    else
    {
      fprintf( stderr, "Can't open `%s' for typing the file.\n",
               item->name );
      item->isbinary = true;
    }
  }

Referenced by FindFonts().

FindFonts()

static void FindFonts ( char **  fontdirs, char **  extensions  )

static

Definition at line 348 of file ftrandom.c.

  {
    int           i;
    unsigned int  max;
    char          buffer[1025];
    struct stat   statb;
 
 
    max  = 0;
    fcnt = 0;
 
    for ( i = 0; fontdirs[i] != NULL; i++ )
    {
      DIR*            examples;
      struct dirent*  ent;
 
 
      examples = opendir( fontdirs[i] );
      if ( !examples )
      {
        fprintf( stderr,
                 "Can't open example font directory `%s'\n",
                 fontdirs[i] );
        exit( 1 );
      }
 
      while ( ( ent = readdir( examples ) ) != NULL )
      {
        snprintf( buffer, sizeof ( buffer ),
                  "%s/%s", fontdirs[i], ent->d_name );
        if ( stat( buffer, &statb ) == -1 || S_ISDIR( statb.st_mode ) )
          continue;
        if ( !extensions || extmatch( buffer, extensions ) )
        {
          if ( fcnt >= max )
          {
            max += 100;
            fontlist = realloc( fontlist, max * sizeof ( struct fontlist ) );
            if ( !fontlist )
            {
              fprintf( stderr, "Can't allocate memory\n" );
              exit( 1 );
            }
          }
 
          fontlist[fcnt].name = strdup( buffer );
          fontlist[fcnt].len  = statb.st_size;
 
          figurefiletype( &fontlist[fcnt] );
          fcnt++;
        }
      }
 
      closedir( examples );
    }
 
    if ( fcnt == 0 )
    {
      fprintf( stderr, "Can't find matching font files.\n" );
      exit( 1 );
    }
 
    fontlist[fcnt].name = NULL;
  }

Referenced by main().

FT_ConicTo()

static int FT_ConicTo ( const FT_Vector *  _cp, const FT_Vector *  to, void *  user  )

static

Definition at line 127 of file ftrandom.c.

  {
    FT_UNUSED( _cp );
    FT_UNUSED( to );
    FT_UNUSED( user );
 
    return 0;
  }

FT_CubicTo()

static int FT_CubicTo ( const FT_Vector *  cp1, const FT_Vector *  cp2, const FT_Vector *  to, void *  user  )

static

Definition at line 140 of file ftrandom.c.

  {
    FT_UNUSED( cp1 );
    FT_UNUSED( cp2 );
    FT_UNUSED( to );
    FT_UNUSED( user );
 
    return 0;
  }

FT_LineTo()

static int FT_LineTo ( const FT_Vector *  to, void *  user  )

static

Definition at line 116 of file ftrandom.c.

  {
    FT_UNUSED( to );
    FT_UNUSED( user );
 
    return 0;
  }

FT_MoveTo()

static int FT_MoveTo ( const FT_Vector *  to, void *  user  )

static

Definition at line 105 of file ftrandom.c.

  {
    FT_UNUSED( to );
    FT_UNUSED( user );
 
    return 0;
  }

getErrorCnt()

static unsigned int getErrorCnt ( struct fontlist *  item )

static

Definition at line 416 of file ftrandom.c.

  {
    if ( error_count == 0 && error_fraction == 0.0 )
      return 0;
 
    return error_count + (unsigned int)( error_fraction * item->len );
  }

Referenced by copyfont().

getRandom()

static int getRandom ( int  low, int  high  )

static

Definition at line 426 of file ftrandom.c.

  {
    if ( low - high < 0x10000L )
      return low + ( ( random() >> 8 ) % ( high + 1 - low ) );
 
    return low + ( random() % ( high + 1 - low ) );
  }

Referenced by copyfont(), and do_test().

main()

int main	(	int argc	,
		char **	argv
	)

Definition at line 599 of file ftrandom.c.

  {
    char    **dirs, **exts;
    int     dcnt = 0, ecnt = 0, rset = false, allexts = false;
    int     i;
    time_t  now;
    char*   testfile = NULL;
 
 
    dirs = calloc( (size_t)( argc + 1 ), sizeof ( char ** ) );
    exts = calloc( (size_t)( argc + 1 ), sizeof ( char ** ) );
 
    for ( i = 1; i < argc; i++ )
    {
      char*  pt = argv[i];
      char*  end;
 
 
      if ( pt[0] == '-' && pt[1] == '-' )
        pt++;
 
      if ( strcmp( pt, "-all" ) == 0 )
        allexts = true;
      else if ( strcmp( pt, "-check-outlines" ) == 0 )
        check_outlines = true;
      else if ( strcmp( pt, "-dir" ) == 0 )
        dirs[dcnt++] = argv[++i];
      else if ( strcmp( pt, "-error-count" ) == 0 )
      {
        if ( !rset )
          error_fraction = 0.0;
        rset = true;
        error_count = (unsigned int)strtoul( argv[++i], &end, 10 );
        if ( *end != '\0' )
        {
          fprintf( stderr, "Bad value for error-count: %s\n", argv[i] );
          exit( 1 );
        }
      }
      else if ( strcmp( pt, "-error-fraction" ) == 0 )
      {
        if ( !rset )
          error_count = 0;
        rset = true;
        error_fraction = strtod( argv[++i], &end );
        if ( *end != '\0' )
        {
          fprintf( stderr, "Bad value for error-fraction: %s\n", argv[i] );
          exit( 1 );
        }
        if ( error_fraction < 0.0 || error_fraction > 1.0 )
        {
          fprintf( stderr, "error-fraction must be in the range [0;1]\n" );
          exit( 1 );
        }
      }
      else if ( strcmp( pt, "-ext" ) == 0 )
        exts[ecnt++] = argv[++i];
      else if ( strcmp( pt, "-help" ) == 0 )
      {
        usage( stdout, argv[0] );
        exit( 0 );
      }
      else if ( strcmp( pt, "-nohints" ) == 0 )
        nohints = true;
      else if ( strcmp( pt, "-rasterize" ) == 0 )
        rasterize = true;
      else if ( strcmp( pt, "-results" ) == 0 )
        results_dir = argv[++i];
      else if ( strcmp( pt, "-size" ) == 0 )
      {
        font_size = (FT_F26Dot6)( strtod( argv[++i], &end ) * 64 );
        if ( *end != '\0' || font_size < 64 )
        {
          fprintf( stderr, "Bad value for size: %s\n", argv[i] );
          exit( 1 );
        }
      }
      else if ( strcmp( pt, "-test" ) == 0 )
        testfile = argv[++i];
      else
      {
        usage( stderr, argv[0] );
        exit( 1 );
      }
    }
 
    if ( allexts )
    {
      free( exts );
      exts = NULL;
    }
    else if ( ecnt == 0 )
    {
      free( exts );
      exts = default_ext_list;
    }
 
    if ( dcnt == 0 )
    {
      free( dirs );
      dirs = default_dir_list;
    }
 
    if ( testfile )
      ExecuteTest( testfile );         /* This should never return */
 
    time( &now );
    srandom( (unsigned int)now );
 
    FindFonts( dirs, exts );
    mkdir( results_dir, 0755 );
 
    forever
      do_test();
 
    return 0;
  }

TestFace()

static void TestFace ( FT_Face  face )

static

Definition at line 165 of file ftrandom.c.

  {
    unsigned int  gid;
    int           load_flags = FT_LOAD_DEFAULT;
 
 
    if ( check_outlines         &&
         FT_IS_SCALABLE( face ) )
      load_flags = FT_LOAD_NO_BITMAP;
 
    if ( nohints )
      load_flags |= FT_LOAD_NO_HINTING;
 
    FT_Set_Char_Size( face, 0, font_size, 72, 72 );
 
    for ( gid = 0; gid < face->num_glyphs; gid++ )
    {
      if ( check_outlines         &&
           FT_IS_SCALABLE( face ) )
      {
        if ( !FT_Load_Glyph( face, gid, load_flags ) )
          FT_Outline_Decompose( &face->glyph->outline, &outlinefuncs, NULL );
      }
      else
        FT_Load_Glyph( face, gid, load_flags );
 
      if ( rasterize )
        FT_Render_Glyph( face->glyph, ft_render_mode_normal );
    }
 
    FT_Done_Face( face );
  }

Referenced by ExecuteTest().

usage()

static void usage ( FILE *  out, char *  name  )

static

Definition at line 556 of file ftrandom.c.

  {
    char**  d = default_dir_list;
    char**  e = default_ext_list;
 
 
    fprintf( out, "%s [options] -- Generate random erroneous fonts\n"
                  "  and attempt to parse them with FreeType.\n\n", name );
 
    fprintf( out, "  --all                    All non-directory files are assumed to be fonts.\n" );
    fprintf( out, "  --check-outlines         Make sure we can parse the outlines of each glyph.\n" );
    fprintf( out, "  --dir <path>             Append <path> to list of font search directories\n"
                  "                           (no recursive search).\n" );
    fprintf( out, "  --error-count <cnt>      Introduce <cnt> single byte errors into each font\n"
                  "                           (default: 1)\n" );
    fprintf( out, "  --error-fraction <frac>  Introduce <frac>*filesize single byte errors\n"
                  "                           into each font (default: 0.0).\n" );
    fprintf( out, "  --ext <ext>              Add <ext> to list of extensions indicating fonts.\n" );
    fprintf( out, "  --help                   Print this.\n" );
    fprintf( out, "  --nohints                Turn off hinting.\n" );
    fprintf( out, "  --rasterize              Attempt to rasterize each glyph.\n" );
    fprintf( out, "  --results <path>         Place the created test fonts into <path>\n"
                  "                           (default: `results')\n" );
    fprintf( out, "  --size <float>           Use the given font size for the tests.\n" );
    fprintf( out, "  --test <file>            Run a single test on an already existing file.\n" );
    fprintf( out, "\n" );
 
    fprintf( out, "Default font extensions:\n" );
    fprintf( out, " " );
    while ( *e )
      fprintf( out, " .%s", *e++ );
    fprintf( out, "\n" );
 
    fprintf( out, "Default font directories:\n" );
    fprintf( out, " " );
    while ( *d )
      fprintf( out, " %s", *d++ );
    fprintf( out, "\n" );
  }

Variable Documentation

check_outlines

int check_outlines = false

static

Definition at line 56 of file ftrandom.c.

Referenced by main(), and TestFace().

child_pid

int child_pid

static

Definition at line 502 of file ftrandom.c.

Referenced by abort_test(), and do_test().

default_dir_list

char* default_dir_list[]

static

Initial value:

=
  {
    GOOD_FONTS_DIR,
    NULL
  }

Definition at line 63 of file ftrandom.c.

Referenced by main(), and usage().

default_ext_list

char* default_ext_list[]

static

Initial value:

=
  {
    "ttf",
    "otf",
    "ttc",
    "cid",
    "pfb",
    "pfa",
    "bdf",
    "pcf",
    "pfr",
    "fon",
    "otb",
    "cff",
    NULL
  }

Definition at line 69 of file ftrandom.c.

Referenced by main(), and usage().

error_count

unsigned int error_count = 1

static

Definition at line 86 of file ftrandom.c.

Referenced by getErrorCnt(), and main().

error_fraction

double error_fraction = 0.0

static

Definition at line 87 of file ftrandom.c.

Referenced by getErrorCnt(), and main().

fcnt

unsigned int fcnt

static

Definition at line 101 of file ftrandom.c.

Referenced by do_test(), and FindFonts().

font_size

FT_F26Dot6 font_size = 12 * 64

static

Definition at line 89 of file ftrandom.c.

Referenced by GdipGetFontHeightGivenDPI(), load_font(), main(), test_AddFontMemResource(), test_GdipMeasureString(), test_measured_extra_space(), and TestFace().

fontlist

struct fontlist * fontlist

static

nohints

int nohints = false

static

Definition at line 57 of file ftrandom.c.

Referenced by main(), and TestFace().

outlinefuncs

FT_Outline_Funcs outlinefuncs

static

Initial value:

=
  {
    FT_MoveTo,
    FT_LineTo,
    FT_ConicTo,
    FT_CubicTo,
    0, 0          
  }

Definition at line 154 of file ftrandom.c.

Referenced by TestFace().

rasterize

int rasterize = false

static

Definition at line 58 of file ftrandom.c.

Referenced by main(), and TestFace().

results_dir

char* results_dir = "results"

static

Definition at line 59 of file ftrandom.c.

Referenced by do_test(), and main().