test/testautomation_surface.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:09 -0800
changeset 11730 ac6c607e065c
parent 9282 e3ee6ba9eae8
child 13249 0d2519c40e47
permissions -rw-r--r--
Enable building the Metal renderer by default, and weak link the Metal framework so the SDL library is safe to use on older Macs
Also generate iOS versions of the Metal shaders
     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 };