test/testautomation_surface.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:47 -0800
changeset 11731 30f337dc8c74
parent 9282 e3ee6ba9eae8
child 13249 0d2519c40e47
permissions -rw-r--r--
Added iOS and OSX 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 };