test/testautomation_surface.c

   1 /**
   2  * Original code: automated SDL surface test written by Edgar Simo "bobbens"
   3  * Adapted/rewritten for test lib by Andreas Schiffler
   4  */
   5
   6 /* Supress C4996 VS compiler warnings for unlink() */
   7 #define _CRT_SECURE_NO_DEPRECATE
   8 #define _CRT_NONSTDC_NO_DEPRECATE
   9
  10 #include <stdio.h>
  11 #ifndef _MSC_VER
  12 #include <unistd.h>
  13 #endif
  14 #include <sys/stat.h>
  15
  16 #include "SDL.h"
  17 #include "SDL_test.h"
  18
  19 #ifdef __MACOSX__
  20 #include <unistd.h> /* For unlink() */
  21 #endif
  22
  23 /* ================= Test Case Implementation ================== */
  24
  25 /* Shared test surface */
  26
  27 static SDL_Surface *referenceSurface = NULL;
  28 static SDL_Surface *testSurface = NULL;
  29
  30 /* Helper functions for the test cases */
  31
  32 #define TEST_SURFACE_WIDTH testSurface->w
  33 #define TEST_SURFACE_HEIGHT testSurface->h
  34
  35 /* Fixture */
  36
  37 /* Create a 32-bit writable surface for blitting tests */
  38 void
  39 _surfaceSetUp(void *arg)
  40 {
  41     int result;
  42     SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
  43     SDL_BlendMode currentBlendMode;
  44     Uint32 rmask, gmask, bmask, amask;
  45 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
  46     rmask = 0xff000000;
  47     gmask = 0x00ff0000;
  48     bmask = 0x0000ff00;
  49     amask = 0x000000ff;
  50 #else
  51     rmask = 0x000000ff;
  52     gmask = 0x0000ff00;
  53     bmask = 0x00ff0000;
  54     amask = 0xff000000;
  55 #endif
  56
  57     referenceSurface = SDLTest_ImageBlit(); /* For size info */
  58     testSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, referenceSurface->w, referenceSurface->h, 32, rmask, gmask, bmask, amask);
  59     SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL");
  60     if (testSurface != NULL) {
  61       /* Disable blend mode for target surface */
  62       result = SDL_SetSurfaceBlendMode(testSurface, blendMode);
  63       SDLTest_AssertCheck(result == 0, "Validate result from SDL_SetSurfaceBlendMode, expected: 0, got: %i", result);
  64       result = SDL_GetSurfaceBlendMode(testSurface, &currentBlendMode);
  65       SDLTest_AssertCheck(result == 0, "Validate result from SDL_GetSurfaceBlendMode, expected: 0, got: %i", result);
  66       SDLTest_AssertCheck(currentBlendMode == blendMode, "Validate blendMode, expected: %i, got: %i", blendMode, currentBlendMode);
  67     }
  68 }
  69
  70 void
  71 _surfaceTearDown(void *arg)
  72 {
  73     SDL_FreeSurface(referenceSurface);
  74     referenceSurface = NULL;
  75     SDL_FreeSurface(testSurface);
  76     testSurface = NULL;
  77 }
  78
  79 /**
  80  * Helper that clears the test surface
  81  */
  82 void _clearTestSurface()
  83 {
  84     int ret;
  85     Uint32 color;
  86
  87     /* Clear surface. */
  88     color = SDL_MapRGBA( testSurface->format, 0, 0, 0, 0);
  89     SDLTest_AssertPass("Call to SDL_MapRGBA()");
  90     ret = SDL_FillRect( testSurface, NULL, color);
  91     SDLTest_AssertPass("Call to SDL_FillRect()");
  92     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_FillRect, expected: 0, got: %i", ret);
  93 }
  94
  95 /**
  96  * Helper that blits in a specific blend mode, -1 for basic blitting, -2 for color mod, -3 for alpha mod, -4 for mixed blend modes.
  97  */
  98 void _testBlitBlendMode(int mode)
  99 {
 100     int ret;
 101     int i, j, ni, nj;
 102     SDL_Surface *face;
 103     SDL_Rect rect;
 104     int nmode;
 105     SDL_BlendMode bmode;
 106     int checkFailCount1;
 107     int checkFailCount2;
 108     int checkFailCount3;
 109     int checkFailCount4;
 110
 111     /* Check test surface */
 112     SDLTest_AssertCheck(testSurface != NULL, "Verify testSurface is not NULL");
 113     if (testSurface == NULL) return;
 114
 115     /* Create sample surface */
 116     face = SDLTest_ImageFace();
 117     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
 118     if (face == NULL) return;
 119
 120         /* Reset alpha modulation */
 121     ret = SDL_SetSurfaceAlphaMod(face, 255);
 122     SDLTest_AssertPass("Call to SDL_SetSurfaceAlphaMod()");
 123     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceAlphaMod(), expected: 0, got: %i", ret);
 124
 125         /* Reset color modulation */
 126     ret = SDL_SetSurfaceColorMod(face, 255, 255, 255);
 127     SDLTest_AssertPass("Call to SDL_SetSurfaceColorMod()");
 128     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorMod(), expected: 0, got: %i", ret);
 129
 130         /* Reset color key */
 131     ret = SDL_SetColorKey(face, SDL_FALSE, 0);
 132     SDLTest_AssertPass("Call to SDL_SetColorKey()");
 133     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey(), expected: 0, got: %i", ret);
 134
 135     /* Clear the test surface */
 136         _clearTestSurface();
 137
 138     /* Target rect size */
 139     rect.w = face->w;
 140     rect.h = face->h;
 141
 142     /* Steps to take */
 143     ni = testSurface->w - face->w;
 144     nj = testSurface->h - face->h;
 145
 146     /* Optionally set blend mode. */
 147     if (mode >= 0) {
 148         ret = SDL_SetSurfaceBlendMode( face, (SDL_BlendMode)mode );
 149         SDLTest_AssertPass("Call to SDL_SetSurfaceBlendMode()");
 150         SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceBlendMode(..., %i), expected: 0, got: %i", mode, ret);
 151     }
 152
 153     /* Test blend mode. */
 154     checkFailCount1 = 0;
 155     checkFailCount2 = 0;
 156     checkFailCount3 = 0;
 157     checkFailCount4 = 0;
 158     for (j=0; j <= nj; j+=4) {
 159       for (i=0; i <= ni; i+=4) {
 160         if (mode == -2) {
 161             /* Set color mod. */
 162             ret = SDL_SetSurfaceColorMod( face, (255/nj)*j, (255/ni)*i, (255/nj)*j );
 163             if (ret != 0) checkFailCount2++;
 164         }
 165         else if (mode == -3) {
 166             /* Set alpha mod. */
 167             ret = SDL_SetSurfaceAlphaMod( face, (255/ni)*i );
 168             if (ret != 0) checkFailCount3++;
 169         }
 170         else if (mode == -4) {
 171             /* Crazy blending mode magic. */
 172             nmode = (i/4*j/4) % 4;
 173             if (nmode==0) {
 174                 bmode = SDL_BLENDMODE_NONE;
 175             } else if (nmode==1) {
 176                 bmode = SDL_BLENDMODE_BLEND;
 177             } else if (nmode==2) {
 178                 bmode = SDL_BLENDMODE_ADD;
 179             } else if (nmode==3) {
 180                 bmode = SDL_BLENDMODE_MOD;
 181             }
 182             ret = SDL_SetSurfaceBlendMode( face, bmode );
 183             if (ret != 0) checkFailCount4++;
 184         }
 185
 186          /* Blitting. */
 187          rect.x = i;
 188          rect.y = j;
 189          ret = SDL_BlitSurface( face, NULL, testSurface, &rect );
 190          if (ret != 0) checkFailCount1++;
 191       }
 192     }
 193     SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_BlitSurface, expected: 0, got: %i", checkFailCount1);
 194     SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetSurfaceColorMod, expected: 0, got: %i", checkFailCount2);
 195     SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetSurfaceAlphaMod, expected: 0, got: %i", checkFailCount3);
 196     SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_SetSurfaceBlendMode, expected: 0, got: %i", checkFailCount4);
 197
 198     /* Clean up */
 199     SDL_FreeSurface(face);
 200     face = NULL;
 201 }
 202
 203 /* Helper to check that a file exists */
 204 void
 205 _AssertFileExist(const char *filename)
 206 {
 207     struct stat st;
 208     int ret = stat(filename, &st);
 209
 210     SDLTest_AssertCheck(ret == 0, "Verify file '%s' exists", filename);
 211 }
 212
 213
 214 /* Test case functions */
 215
 216 /**
 217  * @brief Tests sprite saving and loading
 218  */
 219 int
 220 surface_testSaveLoadBitmap(void *arg)
 221 {
 222     int ret;
 223     const char *sampleFilename = "testSaveLoadBitmap.bmp";
 224     SDL_Surface *face;
 225     SDL_Surface *rface;
 226
 227     /* Create sample surface */
 228     face = SDLTest_ImageFace();
 229     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
 230     if (face == NULL) return TEST_ABORTED;
 231
 232     /* Delete test file; ignore errors */
 233     unlink(sampleFilename);
 234
 235     /* Save a surface */
 236     ret = SDL_SaveBMP(face, sampleFilename);
 237     SDLTest_AssertPass("Call to SDL_SaveBMP()");
 238     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SaveBMP, expected: 0, got: %i", ret);
 239     _AssertFileExist(sampleFilename);
 240
 241     /* Load a surface */
 242     rface = SDL_LoadBMP(sampleFilename);
 243     SDLTest_AssertPass("Call to SDL_LoadBMP()");
 244     SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_LoadBMP is not NULL");
 245     if (rface != NULL) {
 246         SDLTest_AssertCheck(face->w == rface->w, "Verify width of loaded surface, expected: %i, got: %i", face->w, rface->w);
 247         SDLTest_AssertCheck(face->h == rface->h, "Verify height of loaded surface, expected: %i, got: %i", face->h, rface->h);
 248     }
 249
 250     /* Delete test file; ignore errors */
 251     unlink(sampleFilename);
 252
 253     /* Clean up */
 254     SDL_FreeSurface(face);
 255     face = NULL;
 256     SDL_FreeSurface(rface);
 257     rface = NULL;
 258
 259     return TEST_COMPLETED;
 260 }
 261
 262 /* !
 263  *  Tests surface conversion.
 264  */
 265 int
 266 surface_testSurfaceConversion(void *arg)
 267 {
 268     SDL_Surface *rface = NULL, *face = NULL;
 269     int ret = 0;
 270
 271     /* Create sample surface */
 272     face = SDLTest_ImageFace();
 273     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
 274     if (face == NULL)
 275         return TEST_ABORTED;
 276
 277     /* Set transparent pixel as the pixel at (0,0) */
 278     if (face->format->palette) {
 279        ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
 280        SDLTest_AssertPass("Call to SDL_SetColorKey()");
 281        SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
 282     }
 283
 284     /* Convert to 32 bit to compare. */
 285     rface = SDL_ConvertSurface( face, testSurface->format, 0 );
 286     SDLTest_AssertPass("Call to SDL_ConvertSurface()");
 287     SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_ConvertSurface is not NULL");
 288
 289     /* Compare surface. */
 290     ret = SDLTest_CompareSurfaces( rface, face, 0 );
 291     SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 292
 293     /* Clean up. */
 294     SDL_FreeSurface(face);
 295     face = NULL;
 296     SDL_FreeSurface(rface);
 297     rface = NULL;
 298
 299     return TEST_COMPLETED;
 300 }
 301
 302
 303 /* !
 304  *  Tests surface conversion across all pixel formats.
 305  */
 306 int
 307 surface_testCompleteSurfaceConversion(void *arg)
 308 {
 309     Uint32 pixel_formats[] = {
 310         SDL_PIXELFORMAT_INDEX8,
 311         SDL_PIXELFORMAT_RGB332,
 312         SDL_PIXELFORMAT_RGB444,
 313         SDL_PIXELFORMAT_RGB555,
 314         SDL_PIXELFORMAT_BGR555,
 315         SDL_PIXELFORMAT_ARGB4444,
 316         SDL_PIXELFORMAT_RGBA4444,
 317         SDL_PIXELFORMAT_ABGR4444,
 318         SDL_PIXELFORMAT_BGRA4444,
 319         SDL_PIXELFORMAT_ARGB1555,
 320         SDL_PIXELFORMAT_RGBA5551,
 321         SDL_PIXELFORMAT_ABGR1555,
 322         SDL_PIXELFORMAT_BGRA5551,
 323         SDL_PIXELFORMAT_RGB565,
 324         SDL_PIXELFORMAT_BGR565,
 325         SDL_PIXELFORMAT_RGB24,
 326         SDL_PIXELFORMAT_BGR24,
 327         SDL_PIXELFORMAT_RGB888,
 328         SDL_PIXELFORMAT_RGBX8888,
 329         SDL_PIXELFORMAT_BGR888,
 330         SDL_PIXELFORMAT_BGRX8888,
 331         SDL_PIXELFORMAT_ARGB8888,
 332         SDL_PIXELFORMAT_RGBA8888,
 333         SDL_PIXELFORMAT_ABGR8888,
 334         SDL_PIXELFORMAT_BGRA8888,
 335         SDL_PIXELFORMAT_ARGB2101010,
 336     };
 337     SDL_Surface *face = NULL, *cvt1, *cvt2, *final;
 338     SDL_PixelFormat *fmt1, *fmt2;
 339     int i, j, ret = 0;
 340
 341     /* Create sample surface */
 342     face = SDLTest_ImageFace();
 343     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
 344     if (face == NULL)
 345         return TEST_ABORTED;
 346
 347     /* Set transparent pixel as the pixel at (0,0) */
 348     if (face->format->palette) {
 349        ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
 350        SDLTest_AssertPass("Call to SDL_SetColorKey()");
 351        SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
 352     }
 353
 354     for ( i = 0; i < SDL_arraysize(pixel_formats); ++i ) {
 355         for ( j = 0; j < SDL_arraysize(pixel_formats); ++j ) {
 356             fmt1 = SDL_AllocFormat(pixel_formats[i]);
 357             SDL_assert(fmt1 != NULL);
 358             cvt1 = SDL_ConvertSurface(face, fmt1, 0);
 359             SDL_assert(cvt1 != NULL);
 360
 361             fmt2 = SDL_AllocFormat(pixel_formats[j]);
 362             SDL_assert(fmt1 != NULL);
 363             cvt2 = SDL_ConvertSurface(cvt1, fmt2, 0);
 364             SDL_assert(cvt2 != NULL);
 365
 366             if ( fmt1->BytesPerPixel == face->format->BytesPerPixel &&
 367                  fmt2->BytesPerPixel == face->format->BytesPerPixel &&
 368                  (fmt1->Amask != 0) == (face->format->Amask != 0) &&
 369                  (fmt2->Amask != 0) == (face->format->Amask != 0) ) {
 370                 final = SDL_ConvertSurface( cvt2, face->format, 0 );
 371                 SDL_assert(final != NULL);
 372
 373                 /* Compare surface. */
 374                 ret = SDLTest_CompareSurfaces( face, final, 0 );
 375                 SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 376                 SDL_FreeSurface(final);
 377             }
 378
 379             SDL_FreeSurface(cvt1);
 380             SDL_FreeFormat(fmt1);
 381             SDL_FreeSurface(cvt2);
 382             SDL_FreeFormat(fmt2);
 383         }
 384     }
 385
 386     /* Clean up. */
 387     SDL_FreeSurface( face );
 388
 389     return TEST_COMPLETED;
 390 }
 391
 392
 393 /**
 394  * @brief Tests sprite loading. A failure case.
 395  */
 396 int
 397 surface_testLoadFailure(void *arg)
 398 {
 399     SDL_Surface *face = SDL_LoadBMP("nonexistant.bmp");
 400     SDLTest_AssertCheck(face == NULL, "SDL_CreateLoadBmp");
 401
 402     return TEST_COMPLETED;
 403 }
 404
 405 /**
 406  * @brief Tests some blitting routines.
 407  */
 408 int
 409 surface_testBlit(void *arg)
 410 {
 411    int ret;
 412    SDL_Surface *compareSurface;
 413
 414    /* Basic blitting */
 415    _testBlitBlendMode(-1);
 416
 417    /* Verify result by comparing surfaces */
 418    compareSurface = SDLTest_ImageBlit();
 419    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 420    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 421
 422    /* Clean up. */
 423    SDL_FreeSurface(compareSurface);
 424
 425    return TEST_COMPLETED;
 426 }
 427
 428 /**
 429  * @brief Tests some blitting routines with color mod
 430  */
 431 int
 432 surface_testBlitColorMod(void *arg)
 433 {
 434    int ret;
 435    SDL_Surface *compareSurface;
 436
 437    /* Basic blitting with color mod */
 438    _testBlitBlendMode(-2);
 439
 440    /* Verify result by comparing surfaces */
 441    compareSurface = SDLTest_ImageBlitColor();
 442    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 443    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 444
 445    /* Clean up. */
 446    SDL_FreeSurface(compareSurface);
 447
 448    return TEST_COMPLETED;
 449 }
 450
 451 /**
 452  * @brief Tests some blitting routines with alpha mod
 453  */
 454 int
 455 surface_testBlitAlphaMod(void *arg)
 456 {
 457    int ret;
 458    SDL_Surface *compareSurface;
 459
 460    /* Basic blitting with alpha mod */
 461    _testBlitBlendMode(-3);
 462
 463    /* Verify result by comparing surfaces */
 464    compareSurface = SDLTest_ImageBlitAlpha();
 465    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 466    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 467
 468    /* Clean up. */
 469    SDL_FreeSurface(compareSurface);
 470
 471    return TEST_COMPLETED;
 472 }
 473
 474
 475 /**
 476  * @brief Tests some more blitting routines.
 477  */
 478 int
 479 surface_testBlitBlendNone(void *arg)
 480 {
 481    int ret;
 482    SDL_Surface *compareSurface;
 483
 484    /* Basic blitting */
 485    _testBlitBlendMode(SDL_BLENDMODE_NONE);
 486
 487    /* Verify result by comparing surfaces */
 488    compareSurface = SDLTest_ImageBlitBlendNone();
 489    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 490    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 491
 492    /* Clean up. */
 493    SDL_FreeSurface(compareSurface);
 494
 495    return TEST_COMPLETED;
 496 }
 497
 498 /**
 499  * @brief Tests some more blitting routines.
 500  */
 501 int
 502 surface_testBlitBlendBlend(void *arg)
 503 {
 504    int ret;
 505    SDL_Surface *compareSurface;
 506
 507    /* Blend blitting */
 508    _testBlitBlendMode(SDL_BLENDMODE_BLEND);
 509
 510    /* Verify result by comparing surfaces */
 511    compareSurface = SDLTest_ImageBlitBlend();
 512    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 513    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 514
 515    /* Clean up. */
 516    SDL_FreeSurface(compareSurface);
 517
 518    return TEST_COMPLETED;
 519 }
 520
 521 /**
 522  * @brief Tests some more blitting routines.
 523  */
 524 int
 525 surface_testBlitBlendAdd(void *arg)
 526 {
 527    int ret;
 528    SDL_Surface *compareSurface;
 529
 530    /* Add blitting */
 531    _testBlitBlendMode(SDL_BLENDMODE_ADD);
 532
 533    /* Verify result by comparing surfaces */
 534    compareSurface = SDLTest_ImageBlitBlendAdd();
 535    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 536    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 537
 538    /* Clean up. */
 539    SDL_FreeSurface(compareSurface);
 540
 541    return TEST_COMPLETED;
 542 }
 543
 544 /**
 545  * @brief Tests some more blitting routines.
 546  */
 547 int
 548 surface_testBlitBlendMod(void *arg)
 549 {
 550    int ret;
 551    SDL_Surface *compareSurface;
 552
 553    /* Mod blitting */
 554    _testBlitBlendMode(SDL_BLENDMODE_MOD);
 555
 556    /* Verify result by comparing surfaces */
 557    compareSurface = SDLTest_ImageBlitBlendMod();
 558    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 559    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 560
 561    /* Clean up. */
 562    SDL_FreeSurface(compareSurface);
 563
 564    return TEST_COMPLETED;
 565 }
 566
 567 /**
 568  * @brief Tests some more blitting routines with loop
 569  */
 570 int
 571 surface_testBlitBlendLoop(void *arg) {
 572
 573    int ret;
 574    SDL_Surface *compareSurface;
 575
 576    /* All blitting modes */
 577    _testBlitBlendMode(-4);
 578
 579    /* Verify result by comparing surfaces */
 580    compareSurface = SDLTest_ImageBlitBlendAll();
 581    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
 582    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
 583
 584    /* Clean up. */
 585    SDL_FreeSurface(compareSurface);
 586
 587    return TEST_COMPLETED;
 588
 589 }
 590
 591 /* ================= Test References ================== */
 592
 593 /* Surface test cases */
 594 static const SDLTest_TestCaseReference surfaceTest1 =
 595         { (SDLTest_TestCaseFp)surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED};
 596
 597 static const SDLTest_TestCaseReference surfaceTest2 =
 598         { (SDLTest_TestCaseFp)surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED};
 599
 600 static const SDLTest_TestCaseReference surfaceTest3 =
 601         { (SDLTest_TestCaseFp)surface_testBlitBlendNone, "surface_testBlitBlendNone", "Tests blitting routines with none blending mode.", TEST_ENABLED};
 602
 603 static const SDLTest_TestCaseReference surfaceTest4 =
 604         { (SDLTest_TestCaseFp)surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED};
 605
 606 static const SDLTest_TestCaseReference surfaceTest5 =
 607         { (SDLTest_TestCaseFp)surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED};
 608
 609 static const SDLTest_TestCaseReference surfaceTest6 =
 610         { (SDLTest_TestCaseFp)surface_testCompleteSurfaceConversion, "surface_testCompleteSurfaceConversion", "Tests surface conversion across all pixel formats", TEST_ENABLED};
 611
 612 static const SDLTest_TestCaseReference surfaceTest7 =
 613         { (SDLTest_TestCaseFp)surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED};
 614
 615 static const SDLTest_TestCaseReference surfaceTest8 =
 616         { (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED};
 617
 618 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
 619 static const SDLTest_TestCaseReference surfaceTest9 =
 620         { (SDLTest_TestCaseFp)surface_testBlitBlendLoop, "surface_testBlitBlendLoop", "Test blitting routines with various blending modes", TEST_DISABLED};
 621
 622 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
 623 static const SDLTest_TestCaseReference surfaceTest10 =
 624         { (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_DISABLED};
 625
 626 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
 627 static const SDLTest_TestCaseReference surfaceTest11 =
 628         { (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_DISABLED};
 629
 630 static const SDLTest_TestCaseReference surfaceTest12 =
 631         { (SDLTest_TestCaseFp)surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED};
 632
 633 /* Sequence of Surface test cases */
 634 static const SDLTest_TestCaseReference *surfaceTests[] =  {
 635     &surfaceTest1, &surfaceTest2, &surfaceTest3, &surfaceTest4, &surfaceTest5,
 636     &surfaceTest6, &surfaceTest7, &surfaceTest8, &surfaceTest9, &surfaceTest10,
 637     &surfaceTest11, &surfaceTest12, NULL
 638 };
 639
 640 /* Surface test suite (global) */
 641 SDLTest_TestSuiteReference surfaceTestSuite = {
 642     "Surface",
 643     _surfaceSetUp,
 644     surfaceTests,
 645     _surfaceTearDown
 646
 647 };