test/testautomation_surface.c
author Sam Lantinga <slouken@libsdl.org>
Fri, 28 Nov 2014 04:51:33 -0800
changeset 9246 a761913e5e91
parent 9218 74b8ddd028c7
child 9278 8900afb78a19
permissions -rw-r--r--
Fixed bug 2786 - "UCS-2-INTERNAL" iconv encoding is not supported everywhere, use UTF-16LE instead

Jonas Kulla

src/main/windows/SDL_windows_main.c:137:
cmdline = SDL_iconv_string("UTF-8", "UCS-2-INTERNAL", (char *)(text), (SDL_wcslen(text)+1)*sizeof(WCHAR));

I'm trying to compile an SDL2 application for windows using the mingw-w64 32bit toolchain provided by my distro (Fedora 19). However, even the simplest test program that does nothing at all fails to startup with a "Fatal error - out of memory" message because the mingw iconv library provided by my distro does not support the "UCS-2-INTERNAL" encoding and the conversion returns null.

From my little bit of research, it turns out that even though this encoding is supported by the external GNU libiconv library, some glibc versions (?) don't support it with their internal iconv routines, and will instead provide the native endian encoding when "UCS-2" is specified.

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