test/testautomation_surface.c
author Sam Lantinga <slouken@libsdl.org>
Tue, 28 Jan 2020 21:41:13 -0800
changeset 13455 8df06b35fd6e
parent 13249 0d2519c40e47
permissions -rw-r--r--
Fixed member order to make more sense
     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_BGR444,
   314         SDL_PIXELFORMAT_RGB555,
   315         SDL_PIXELFORMAT_BGR555,
   316         SDL_PIXELFORMAT_ARGB4444,
   317         SDL_PIXELFORMAT_RGBA4444,
   318         SDL_PIXELFORMAT_ABGR4444,
   319         SDL_PIXELFORMAT_BGRA4444,
   320         SDL_PIXELFORMAT_ARGB1555,
   321         SDL_PIXELFORMAT_RGBA5551,
   322         SDL_PIXELFORMAT_ABGR1555,
   323         SDL_PIXELFORMAT_BGRA5551,
   324         SDL_PIXELFORMAT_RGB565,
   325         SDL_PIXELFORMAT_BGR565,
   326         SDL_PIXELFORMAT_RGB24,
   327         SDL_PIXELFORMAT_BGR24,
   328         SDL_PIXELFORMAT_RGB888,
   329         SDL_PIXELFORMAT_RGBX8888,
   330         SDL_PIXELFORMAT_BGR888,
   331         SDL_PIXELFORMAT_BGRX8888,
   332         SDL_PIXELFORMAT_ARGB8888,
   333         SDL_PIXELFORMAT_RGBA8888,
   334         SDL_PIXELFORMAT_ABGR8888,
   335         SDL_PIXELFORMAT_BGRA8888,
   336         SDL_PIXELFORMAT_ARGB2101010,
   337     };
   338     SDL_Surface *face = NULL, *cvt1, *cvt2, *final;
   339     SDL_PixelFormat *fmt1, *fmt2;
   340     int i, j, ret = 0;
   341 
   342     /* Create sample surface */
   343     face = SDLTest_ImageFace();
   344     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
   345     if (face == NULL)
   346         return TEST_ABORTED;
   347 
   348     /* Set transparent pixel as the pixel at (0,0) */
   349     if (face->format->palette) {
   350        ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
   351        SDLTest_AssertPass("Call to SDL_SetColorKey()");
   352        SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
   353     }
   354 
   355     for ( i = 0; i < SDL_arraysize(pixel_formats); ++i ) {
   356         for ( j = 0; j < SDL_arraysize(pixel_formats); ++j ) {
   357             fmt1 = SDL_AllocFormat(pixel_formats[i]);
   358             SDL_assert(fmt1 != NULL);
   359             cvt1 = SDL_ConvertSurface(face, fmt1, 0);
   360             SDL_assert(cvt1 != NULL);
   361 
   362             fmt2 = SDL_AllocFormat(pixel_formats[j]);
   363             SDL_assert(fmt1 != NULL);
   364             cvt2 = SDL_ConvertSurface(cvt1, fmt2, 0);
   365             SDL_assert(cvt2 != NULL);
   366 
   367             if ( fmt1->BytesPerPixel == face->format->BytesPerPixel &&
   368                  fmt2->BytesPerPixel == face->format->BytesPerPixel &&
   369                  (fmt1->Amask != 0) == (face->format->Amask != 0) &&
   370                  (fmt2->Amask != 0) == (face->format->Amask != 0) ) {
   371                 final = SDL_ConvertSurface( cvt2, face->format, 0 );
   372                 SDL_assert(final != NULL);
   373 
   374                 /* Compare surface. */
   375                 ret = SDLTest_CompareSurfaces( face, final, 0 );
   376                 SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   377                 SDL_FreeSurface(final);
   378             }
   379 
   380             SDL_FreeSurface(cvt1);
   381             SDL_FreeFormat(fmt1);
   382             SDL_FreeSurface(cvt2);
   383             SDL_FreeFormat(fmt2);
   384         }
   385     }
   386 
   387     /* Clean up. */
   388     SDL_FreeSurface( face );
   389 
   390     return TEST_COMPLETED;
   391 }
   392 
   393 
   394 /**
   395  * @brief Tests sprite loading. A failure case.
   396  */
   397 int
   398 surface_testLoadFailure(void *arg)
   399 {
   400     SDL_Surface *face = SDL_LoadBMP("nonexistant.bmp");
   401     SDLTest_AssertCheck(face == NULL, "SDL_CreateLoadBmp");
   402 
   403     return TEST_COMPLETED;
   404 }
   405 
   406 /**
   407  * @brief Tests some blitting routines.
   408  */
   409 int
   410 surface_testBlit(void *arg)
   411 {
   412    int ret;
   413    SDL_Surface *compareSurface;
   414 
   415    /* Basic blitting */
   416    _testBlitBlendMode(-1);
   417 
   418    /* Verify result by comparing surfaces */
   419    compareSurface = SDLTest_ImageBlit();
   420    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   421    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   422 
   423    /* Clean up. */
   424    SDL_FreeSurface(compareSurface);
   425 
   426    return TEST_COMPLETED;
   427 }
   428 
   429 /**
   430  * @brief Tests some blitting routines with color mod
   431  */
   432 int
   433 surface_testBlitColorMod(void *arg)
   434 {
   435    int ret;
   436    SDL_Surface *compareSurface;
   437 
   438    /* Basic blitting with color mod */
   439    _testBlitBlendMode(-2);
   440 
   441    /* Verify result by comparing surfaces */
   442    compareSurface = SDLTest_ImageBlitColor();
   443    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   444    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   445 
   446    /* Clean up. */
   447    SDL_FreeSurface(compareSurface);
   448 
   449    return TEST_COMPLETED;
   450 }
   451 
   452 /**
   453  * @brief Tests some blitting routines with alpha mod
   454  */
   455 int
   456 surface_testBlitAlphaMod(void *arg)
   457 {
   458    int ret;
   459    SDL_Surface *compareSurface;
   460 
   461    /* Basic blitting with alpha mod */
   462    _testBlitBlendMode(-3);
   463 
   464    /* Verify result by comparing surfaces */
   465    compareSurface = SDLTest_ImageBlitAlpha();
   466    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   467    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   468 
   469    /* Clean up. */
   470    SDL_FreeSurface(compareSurface);
   471 
   472    return TEST_COMPLETED;
   473 }
   474 
   475 
   476 /**
   477  * @brief Tests some more blitting routines.
   478  */
   479 int
   480 surface_testBlitBlendNone(void *arg)
   481 {
   482    int ret;
   483    SDL_Surface *compareSurface;
   484 
   485    /* Basic blitting */
   486    _testBlitBlendMode(SDL_BLENDMODE_NONE);
   487 
   488    /* Verify result by comparing surfaces */
   489    compareSurface = SDLTest_ImageBlitBlendNone();
   490    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   491    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   492 
   493    /* Clean up. */
   494    SDL_FreeSurface(compareSurface);
   495 
   496    return TEST_COMPLETED;
   497 }
   498 
   499 /**
   500  * @brief Tests some more blitting routines.
   501  */
   502 int
   503 surface_testBlitBlendBlend(void *arg)
   504 {
   505    int ret;
   506    SDL_Surface *compareSurface;
   507 
   508    /* Blend blitting */
   509    _testBlitBlendMode(SDL_BLENDMODE_BLEND);
   510 
   511    /* Verify result by comparing surfaces */
   512    compareSurface = SDLTest_ImageBlitBlend();
   513    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   514    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   515 
   516    /* Clean up. */
   517    SDL_FreeSurface(compareSurface);
   518 
   519    return TEST_COMPLETED;
   520 }
   521 
   522 /**
   523  * @brief Tests some more blitting routines.
   524  */
   525 int
   526 surface_testBlitBlendAdd(void *arg)
   527 {
   528    int ret;
   529    SDL_Surface *compareSurface;
   530 
   531    /* Add blitting */
   532    _testBlitBlendMode(SDL_BLENDMODE_ADD);
   533 
   534    /* Verify result by comparing surfaces */
   535    compareSurface = SDLTest_ImageBlitBlendAdd();
   536    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   537    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   538 
   539    /* Clean up. */
   540    SDL_FreeSurface(compareSurface);
   541 
   542    return TEST_COMPLETED;
   543 }
   544 
   545 /**
   546  * @brief Tests some more blitting routines.
   547  */
   548 int
   549 surface_testBlitBlendMod(void *arg)
   550 {
   551    int ret;
   552    SDL_Surface *compareSurface;
   553 
   554    /* Mod blitting */
   555    _testBlitBlendMode(SDL_BLENDMODE_MOD);
   556 
   557    /* Verify result by comparing surfaces */
   558    compareSurface = SDLTest_ImageBlitBlendMod();
   559    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   560    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   561 
   562    /* Clean up. */
   563    SDL_FreeSurface(compareSurface);
   564 
   565    return TEST_COMPLETED;
   566 }
   567 
   568 /**
   569  * @brief Tests some more blitting routines with loop
   570  */
   571 int
   572 surface_testBlitBlendLoop(void *arg) {
   573 
   574    int ret;
   575    SDL_Surface *compareSurface;
   576 
   577    /* All blitting modes */
   578    _testBlitBlendMode(-4);
   579 
   580    /* Verify result by comparing surfaces */
   581    compareSurface = SDLTest_ImageBlitBlendAll();
   582    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
   583    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
   584 
   585    /* Clean up. */
   586    SDL_FreeSurface(compareSurface);
   587 
   588    return TEST_COMPLETED;
   589 
   590 }
   591 
   592 /* ================= Test References ================== */
   593 
   594 /* Surface test cases */
   595 static const SDLTest_TestCaseReference surfaceTest1 =
   596         { (SDLTest_TestCaseFp)surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED};
   597 
   598 static const SDLTest_TestCaseReference surfaceTest2 =
   599         { (SDLTest_TestCaseFp)surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED};
   600 
   601 static const SDLTest_TestCaseReference surfaceTest3 =
   602         { (SDLTest_TestCaseFp)surface_testBlitBlendNone, "surface_testBlitBlendNone", "Tests blitting routines with none blending mode.", TEST_ENABLED};
   603 
   604 static const SDLTest_TestCaseReference surfaceTest4 =
   605         { (SDLTest_TestCaseFp)surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED};
   606 
   607 static const SDLTest_TestCaseReference surfaceTest5 =
   608         { (SDLTest_TestCaseFp)surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED};
   609 
   610 static const SDLTest_TestCaseReference surfaceTest6 =
   611         { (SDLTest_TestCaseFp)surface_testCompleteSurfaceConversion, "surface_testCompleteSurfaceConversion", "Tests surface conversion across all pixel formats", TEST_ENABLED};
   612 
   613 static const SDLTest_TestCaseReference surfaceTest7 =
   614         { (SDLTest_TestCaseFp)surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED};
   615 
   616 static const SDLTest_TestCaseReference surfaceTest8 =
   617         { (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED};
   618 
   619 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
   620 static const SDLTest_TestCaseReference surfaceTest9 =
   621         { (SDLTest_TestCaseFp)surface_testBlitBlendLoop, "surface_testBlitBlendLoop", "Test blitting routines with various blending modes", TEST_DISABLED};
   622 
   623 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
   624 static const SDLTest_TestCaseReference surfaceTest10 =
   625         { (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_DISABLED};
   626 
   627 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
   628 static const SDLTest_TestCaseReference surfaceTest11 =
   629         { (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_DISABLED};
   630 
   631 static const SDLTest_TestCaseReference surfaceTest12 =
   632         { (SDLTest_TestCaseFp)surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED};
   633 
   634 /* Sequence of Surface test cases */
   635 static const SDLTest_TestCaseReference *surfaceTests[] =  {
   636     &surfaceTest1, &surfaceTest2, &surfaceTest3, &surfaceTest4, &surfaceTest5,
   637     &surfaceTest6, &surfaceTest7, &surfaceTest8, &surfaceTest9, &surfaceTest10,
   638     &surfaceTest11, &surfaceTest12, NULL
   639 };
   640 
   641 /* Surface test suite (global) */
   642 SDLTest_TestSuiteReference surfaceTestSuite = {
   643     "Surface",
   644     _surfaceSetUp,
   645     surfaceTests,
   646     _surfaceTearDown
   647 
   648 };