Pileus Git - ~andy/gtk/blob - tests/pixbuf-random.c

   1 /* -*- Mode: C; c-basic-offset: 2; -*- */
   2 /* GdkPixbuf library - assault loaders with random data
   3  *
   4  * Copyright (C) 2001 Søren Sandmann (sandmann@daimi.au.dk)
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "gdk-pixbuf/gdk-pixbuf.h"
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <time.h>
  26 #include <string.h>
  27
  28 static void
  29 assault (const guchar *header, gsize header_size, int n_images)
  30 {
  31   FILE *f;
  32   enum { N_CHARACTERS = 10000 };
  33
  34   int j;
  35
  36   for (j = 0; j < n_images; ++j)
  37     {
  38       GError *err = NULL;
  39       int i;
  40       GdkPixbufLoader *loader;
  41
  42       f = fopen ("pixbuf-random-image", "w");
  43       if (!f)
  44         {
  45           perror ("fopen");
  46           exit (EXIT_FAILURE);
  47         }
  48
  49       loader = gdk_pixbuf_loader_new ();
  50
  51       gdk_pixbuf_loader_write (loader, header, header_size, &err);
  52       if (err)
  53         {
  54           g_error_free (err);
  55           continue;
  56         }
  57
  58       for (i = 0; i < N_CHARACTERS; ++i)
  59         {
  60           int r = g_random_int ();
  61
  62           fwrite (&r, 1, sizeof (r), f);
  63           if (ferror (f))
  64             {
  65               perror ("fwrite");
  66               exit (EXIT_FAILURE);
  67             }
  68
  69           gdk_pixbuf_loader_write (loader, (guchar *)&r, sizeof (r), &err);
  70           if (err)
  71             {
  72               g_error_free (err);
  73               err = NULL;
  74               break;
  75             }
  76         }
  77
  78       fclose (f);
  79
  80       gdk_pixbuf_loader_close (loader, &err);
  81       if (err)
  82         {
  83           g_error_free (err);
  84           err = NULL;
  85         }
  86
  87       g_object_unref (loader);
  88     }
  89 }
  90
  91 static void
  92 write_seed (int seed)
  93 {
  94   FILE *f;
  95   /* write this so you can reproduce failed tests */
  96   f = fopen ("pixbuf-random-seed", "w");
  97   if (!f)
  98     {
  99       perror ("fopen");
 100       exit (EXIT_FAILURE);
 101     }
 102   if (fprintf (f, "%d\n", seed) < 0)
 103     {
 104       perror ("fprintf");
 105       exit (EXIT_FAILURE);
 106     }
 107   if (fclose (f) < 0)
 108     {
 109       perror ("fclose");
 110       exit (EXIT_FAILURE);
 111     }
 112   g_print ("seed: %d\n", seed);
 113 }
 114
 115 int
 116 main (int argc, char **argv)
 117 {
 118   int seed;
 119
 120   if (argc > 1)
 121     seed = atoi (argv[1]);
 122   else
 123     {
 124       seed = time (NULL);
 125       write_seed (seed);
 126     }
 127   g_print ("the last tested image is saved to the file \"pixbuf-random-image\"\n\n");
 128
 129   g_type_init ();
 130   g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
 131
 132   g_random_set_seed (seed);
 133
 134 #define GIF_HEADER 'G', 'I', 'F', '8', '9', 'a'
 135 #define PNG_HEADER 0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a
 136 #define TIFF1_HEADER 'M', 'M', 0x00, 0x2a
 137 #define TIFF2_HEADER 'I', 'I', 0x2a, 0x00
 138 #define JPEG_HEADER 0xFF, 0xd8
 139 #define PNM_HEADER 'P', '6'
 140 #define XBM_HEADER '#', 'd', 'e', 'f', 'i', 'n', 'e', ' '
 141 #define BMP_HEADER 'B', 'M'
 142 #define XPM_HEADER '/', '*', ' ', 'X', 'P', 'M', ' ', '*', '/'
 143 #define RAS_HEADER 0x59, 0xA6, 0x6A, 0x95
 144
 145 #define TEST_RANDOM(header, n_img)                              \
 146 do {                                                            \
 147         static guchar h[] = { header };                         \
 148         g_print (#header);                                      \
 149         fflush (stdout);                                        \
 150         assault (h, sizeof (h), n_img);                         \
 151         g_print ("\t\tpassed\n");                               \
 152 } while (0)
 153
 154   for (;;)
 155     {
 156       TEST_RANDOM (GIF_HEADER,   150);
 157       TEST_RANDOM (PNG_HEADER,   110);
 158       TEST_RANDOM (JPEG_HEADER,  800);
 159       TEST_RANDOM (TIFF1_HEADER, 150);
 160       TEST_RANDOM (TIFF2_HEADER, 150);
 161       TEST_RANDOM (PNM_HEADER,   150);
 162       TEST_RANDOM (XBM_HEADER,   150);
 163       TEST_RANDOM (BMP_HEADER,   150);
 164       TEST_RANDOM (XPM_HEADER,   150);
 165       TEST_RANDOM (RAS_HEADER,   300);
 166       g_print ("===========================\n");
 167     }
 168
 169   return 0;
 170 }