tests/loaders/Loader.h

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2014 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #ifndef TESTS_LOADER_H
  24 #define TESTS_LOADER_H
  25
  26 #include "loaders/GP_IO.h"
  27
  28 struct testcase {
  29         GP_Size w;
  30         GP_Size h;
  31         GP_Pixel pix;
  32         char *path;
  33 };
  34
  35 static int test_check(struct testcase *test, GP_Pixmap *img)
  36 {
  37         unsigned int x, y, err = 0;
  38
  39         if (img->w != test->w || img->h != test->h) {
  40                 tst_msg("Invalid image size have %ux%u expected %ux%u",
  41                         img->w, img->h, test->w, test->h);
  42                 GP_PixmapFree(img);
  43                 return TST_FAILED;
  44         }
  45
  46         for (x = 0; x < img->w; x++) {
  47                 for (y = 0; y < img->h; y++) {
  48
  49                         GP_Pixel pix = GP_GetPixel(img, x, y);
  50
  51                         if (pix != test->pix) {
  52                                 if (err < 5)
  53                                         tst_msg("%08x instead of %08x (%ux%u)",
  54                                                 pix, test->pix, x, y);
  55                                 err++;
  56                         }
  57                 }
  58         }
  59
  60         if (err > 5)
  61                 tst_msg("And %u errors...", err);
  62
  63         if (err)
  64                 return TST_FAILED;
  65
  66         return TST_SUCCESS;
  67 }
  68
  69 static int test_read(struct testcase *test)
  70 {
  71         GP_Pixmap *img;
  72         GP_IO *io;
  73         int err;
  74
  75         io = GP_IOMem(test->path, strlen(test->path), NULL);
  76
  77         if (!io) {
  78                 tst_msg("Failed to initialize memory IO: %s", strerror(errno));
  79                 return TST_UNTESTED;
  80         }
  81
  82         img = READ(io, NULL);
  83
  84         if (!img) {
  85                 switch (errno) {
  86                 case ENOSYS:
  87                         tst_msg("Not Implemented");
  88                         err = TST_SKIPPED;
  89                         goto out;
  90                 default:
  91                         tst_msg("Got %s", strerror(errno));
  92                         err = TST_FAILED;
  93                         goto out;
  94                 }
  95         }
  96
  97         err = test_check(test, img);
  98
  99         GP_PixmapFree(img);
 100 out:
 101         GP_IOClose(io);
 102         return err;
 103 }
 104
 105 # ifdef LOAD
 106
 107 static int test_load(struct testcase *test)
 108 {
 109         GP_Pixmap *img;
 110         int err;
 111
 112         errno = 0;
 113
 114         img = LOAD(test->path, NULL);
 115
 116         if (!img) {
 117                 switch (errno) {
 118                 case ENOSYS:
 119                         tst_msg("Not Implemented");
 120                         return TST_SKIPPED;
 121                 default:
 122                         tst_msg("Got %s", strerror(errno));
 123                         return TST_FAILED;
 124                 }
 125         }
 126
 127         err = test_check(test, img);
 128
 129         GP_PixmapFree(img);
 130
 131         return err;
 132 }
 133
 134
 135 static int test_load_fail(const char *path)
 136 {
 137         GP_Pixmap *img;
 138
 139         errno = 0;
 140
 141         img = LOAD(path, NULL);
 142
 143         if (img != NULL) {
 144                 tst_msg("Succeeded unexpectedly");
 145                 GP_PixmapFree(img);
 146                 return TST_FAILED;
 147         }
 148
 149         switch (errno) {
 150         case ENOSYS:
 151                 tst_msg("Not Implemented");
 152                 return TST_SKIPPED;
 153         case 0:
 154                 tst_msg("Load failed and errno == 0");
 155                 return TST_FAILED;
 156         default:
 157                 tst_msg("Got %s", strerror(errno));
 158                 return TST_SUCCESS;
 159         }
 160 }
 161
 162 # endif /* LOAD */
 163
 164
 165 # if defined(SAVE) && defined(LOAD)
 166
 167 /*
 168  * Saves and loads image using the SAVE and LOAD functions
 169  * and compares the results.
 170  */
 171 struct testcase_save_load {
 172         GP_PixelType pixel_type;
 173         GP_Size w, h;
 174 };
 175
 176 static int test_save_load(struct testcase_save_load *test)
 177 {
 178         GP_Pixmap *img, *img2;
 179         unsigned int x, y;
 180
 181         img = GP_PixmapAlloc(test->w, test->h, test->pixel_type);
 182
 183         if (img == NULL) {
 184                 tst_msg("Failed to allocate pixmap %ux%u %s",
 185                         test->w, test->h, GP_PixelTypeName(test->pixel_type));
 186                 return TST_FAILED;
 187         }
 188
 189         for (x = 0; x < img->w; x++)
 190                 for (y = 0; y < img->w; y++)
 191                         GP_PutPixel(img, x, y, 0);
 192
 193         errno = 0;
 194
 195         if (SAVE(img, "testfile", NULL)) {
 196                 if (errno == ENOSYS) {
 197                         tst_msg("Not implemented");
 198                         return TST_SKIPPED;
 199                 }
 200
 201                 tst_msg("Failed to save pixmap %ux%u %s: %s",
 202                         test->w, test->h, GP_PixelTypeName(test->pixel_type),
 203                         strerror(errno));
 204                 return TST_FAILED;
 205         }
 206
 207
 208         img2 = LOAD("testfile", NULL);
 209
 210         if (img2 == NULL) {
 211                 switch (errno) {
 212                 case ENOSYS:
 213                         tst_msg("Not Implemented");
 214                         GP_PixmapFree(img);
 215                         return TST_SKIPPED;
 216                 default:
 217                         tst_msg("Got %s", strerror(errno));
 218                         GP_PixmapFree(img);
 219                         return TST_FAILED;
 220                 }
 221         }
 222
 223         if (img->w != img2->w || img->h != img2->h) {
 224                 tst_msg("Source size %ux%u and loaded size %ux%u differs",
 225                         img->w, img->h, img2->w, img2->h);
 226                 GP_PixmapFree(img);
 227                 GP_PixmapFree(img2);
 228                 return TST_FAILED;
 229         }
 230
 231         if (img->pixel_type != img2->pixel_type) {
 232                 GP_PixmapFree(img);
 233                 GP_PixmapFree(img2);
 234                 tst_msg("Source pixel type %s and loaded type %s differs",
 235                         GP_PixelTypeName(img->pixel_type),
 236                         GP_PixelTypeName(img2->pixel_type));
 237                 return TST_FAILED;
 238         }
 239
 240         if (GP_GetPixel(img2, 0, 0) != 0) {
 241                 tst_msg("Pixel value is wrong %x", GP_GetPixel(img2, 0, 0));
 242                 GP_PixmapFree(img);
 243                 GP_PixmapFree(img2);
 244                 return TST_FAILED;
 245         }
 246
 247         GP_PixmapFree(img);
 248         GP_PixmapFree(img2);
 249
 250         return TST_SUCCESS;
 251 }
 252
 253 # endif /* SAVE && LOAD */
 254
 255 #endif /* TESTS_LOADER_H */