test/testautomation_surface.c - third_party/sdl - Git at Google

 /**
  * Original code: automated SDL surface test written by Edgar Simo "bobbens"
  * Adapted/rewritten for test lib by Andreas Schiffler
  */

 /* Supress C4996 VS compiler warnings for unlink() */
 #define _CRT_SECURE_NO_DEPRECATE
 #define _CRT_NONSTDC_NO_DEPRECATE

 #include <stdio.h>
 #ifndef _MSC_VER
 #include <unistd.h>
 #endif
 #include <sys/stat.h>

 #include "SDL.h"
 #include "SDL_test.h"

 #ifdef __MACOSX__
 #include <unistd.h> /* For unlink() */
 #endif

 /* ================= Test Case Implementation ================== */

 /* Shared test surface */

 static SDL_Surface *referenceSurface = NULL;
 static SDL_Surface *testSurface = NULL;

 /* Helper functions for the test cases */

 #define TEST_SURFACE_WIDTH testSurface->w
 #define TEST_SURFACE_HEIGHT testSurface->h

 /* Fixture */

 /* Create a 32-bit writable surface for blitting tests */
 void
 _surfaceSetUp(void *arg)
 {
     int result;
     SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
     SDL_BlendMode currentBlendMode;
     Uint32 rmask, gmask, bmask, amask;
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
     rmask = 0xff000000;
     gmask = 0x00ff0000;
     bmask = 0x0000ff00;
     amask = 0x000000ff;
 #else
     rmask = 0x000000ff;
     gmask = 0x0000ff00;
     bmask = 0x00ff0000;
     amask = 0xff000000;
 #endif

     referenceSurface = SDLTest_ImageBlit(); /* For size info */
     testSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, referenceSurface->w, referenceSurface->h, 32, rmask, gmask, bmask, amask);
     SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL");
     if (testSurface != NULL) {
       /* Disable blend mode for target surface */
       result = SDL_SetSurfaceBlendMode(testSurface, blendMode);
       SDLTest_AssertCheck(result == 0, "Validate result from SDL_SetSurfaceBlendMode, expected: 0, got: %i", result);
       result = SDL_GetSurfaceBlendMode(testSurface, &currentBlendMode);
       SDLTest_AssertCheck(result == 0, "Validate result from SDL_GetSurfaceBlendMode, expected: 0, got: %i", result);
       SDLTest_AssertCheck(currentBlendMode == blendMode, "Validate blendMode, expected: %i, got: %i", blendMode, currentBlendMode);
     }
 }

 void
 _surfaceTearDown(void *arg)
 {
     SDL_FreeSurface(referenceSurface);
     referenceSurface = NULL;
     SDL_FreeSurface(testSurface);
     testSurface = NULL;
 }

 /**
  * Helper that clears the test surface
  */
 void _clearTestSurface()
 {
     int ret;
     Uint32 color;

     /* Clear surface. */
     color = SDL_MapRGBA( testSurface->format, 0, 0, 0, 0);
     SDLTest_AssertPass("Call to SDL_MapRGBA()");
     ret = SDL_FillRect( testSurface, NULL, color);
     SDLTest_AssertPass("Call to SDL_FillRect()");
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_FillRect, expected: 0, got: %i", ret);
 }

 /**
  * 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.
  */
 void _testBlitBlendMode(int mode)
 {
     int ret;
     int i, j, ni, nj;
     SDL_Surface *face;
     SDL_Rect rect;
     int nmode;
     SDL_BlendMode bmode;
     int checkFailCount1;
     int checkFailCount2;
     int checkFailCount3;
     int checkFailCount4;

     /* Check test surface */
     SDLTest_AssertCheck(testSurface != NULL, "Verify testSurface is not NULL");
     if (testSurface == NULL) return;

     /* Create sample surface */
     face = SDLTest_ImageFace();
     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
     if (face == NULL) return;

         /* Reset alpha modulation */
     ret = SDL_SetSurfaceAlphaMod(face, 255);
     SDLTest_AssertPass("Call to SDL_SetSurfaceAlphaMod()");
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceAlphaMod(), expected: 0, got: %i", ret);

         /* Reset color modulation */
     ret = SDL_SetSurfaceColorMod(face, 255, 255, 255);
     SDLTest_AssertPass("Call to SDL_SetSurfaceColorMod()");
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorMod(), expected: 0, got: %i", ret);

         /* Reset color key */
     ret = SDL_SetColorKey(face, SDL_FALSE, 0);
     SDLTest_AssertPass("Call to SDL_SetColorKey()");
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey(), expected: 0, got: %i", ret);

     /* Clear the test surface */
         _clearTestSurface();

     /* Target rect size */
     rect.w = face->w;
     rect.h = face->h;

     /* Steps to take */
     ni = testSurface->w - face->w;
     nj = testSurface->h - face->h;

     /* Optionally set blend mode. */
     if (mode >= 0) {
         ret = SDL_SetSurfaceBlendMode( face, (SDL_BlendMode)mode );
         SDLTest_AssertPass("Call to SDL_SetSurfaceBlendMode()");
         SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceBlendMode(..., %i), expected: 0, got: %i", mode, ret);
     }

     /* Test blend mode. */
     checkFailCount1 = 0;
     checkFailCount2 = 0;
     checkFailCount3 = 0;
     checkFailCount4 = 0;
     for (j=0; j <= nj; j+=4) {
       for (i=0; i <= ni; i+=4) {
         if (mode == -2) {
             /* Set color mod. */
             ret = SDL_SetSurfaceColorMod( face, (255/nj)*j, (255/ni)*i, (255/nj)*j );
             if (ret != 0) checkFailCount2++;
         }
         else if (mode == -3) {
             /* Set alpha mod. */
             ret = SDL_SetSurfaceAlphaMod( face, (255/ni)*i );
             if (ret != 0) checkFailCount3++;
         }
         else if (mode == -4) {
             /* Crazy blending mode magic. */
             nmode = (i/4*j/4) % 4;
             if (nmode==0) {
                 bmode = SDL_BLENDMODE_NONE;
             } else if (nmode==1) {
                 bmode = SDL_BLENDMODE_BLEND;
             } else if (nmode==2) {
                 bmode = SDL_BLENDMODE_ADD;
             } else if (nmode==3) {
                 bmode = SDL_BLENDMODE_MOD;
             }
             ret = SDL_SetSurfaceBlendMode( face, bmode );
             if (ret != 0) checkFailCount4++;
         }

          /* Blitting. */
          rect.x = i;
          rect.y = j;
          ret = SDL_BlitSurface( face, NULL, testSurface, &rect );
          if (ret != 0) checkFailCount1++;
       }
     }
     SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_BlitSurface, expected: 0, got: %i", checkFailCount1);
     SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetSurfaceColorMod, expected: 0, got: %i", checkFailCount2);
     SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetSurfaceAlphaMod, expected: 0, got: %i", checkFailCount3);
     SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_SetSurfaceBlendMode, expected: 0, got: %i", checkFailCount4);

     /* Clean up */
     SDL_FreeSurface(face);
     face = NULL;
 }

 /* Helper to check that a file exists */
 void
 _AssertFileExist(const char *filename)
 {
     struct stat st;
     int ret = stat(filename, &st);

     SDLTest_AssertCheck(ret == 0, "Verify file '%s' exists", filename);
 }


 /* Test case functions */

 /**
  * @brief Tests sprite saving and loading
  */
 int
 surface_testSaveLoadBitmap(void *arg)
 {
     int ret;
     const char *sampleFilename = "testSaveLoadBitmap.bmp";
     SDL_Surface *face;
     SDL_Surface *rface;

     /* Create sample surface */
     face = SDLTest_ImageFace();
     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
     if (face == NULL) return TEST_ABORTED;

     /* Delete test file; ignore errors */
     unlink(sampleFilename);

     /* Save a surface */
     ret = SDL_SaveBMP(face, sampleFilename);
     SDLTest_AssertPass("Call to SDL_SaveBMP()");
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SaveBMP, expected: 0, got: %i", ret);
     _AssertFileExist(sampleFilename);

     /* Load a surface */
     rface = SDL_LoadBMP(sampleFilename);
     SDLTest_AssertPass("Call to SDL_LoadBMP()");
     SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_LoadBMP is not NULL");
     if (rface != NULL) {
         SDLTest_AssertCheck(face->w == rface->w, "Verify width of loaded surface, expected: %i, got: %i", face->w, rface->w);
         SDLTest_AssertCheck(face->h == rface->h, "Verify height of loaded surface, expected: %i, got: %i", face->h, rface->h);
     }

     /* Delete test file; ignore errors */
     unlink(sampleFilename);

     /* Clean up */
     SDL_FreeSurface(face);
     face = NULL;
     SDL_FreeSurface(rface);
     rface = NULL;

     return TEST_COMPLETED;
 }

 /* !
  *  Tests surface conversion.
  */
 int
 surface_testSurfaceConversion(void *arg)
 {
     SDL_Surface *rface = NULL, *face = NULL;
     int ret = 0;

     /* Create sample surface */
     face = SDLTest_ImageFace();
     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
     if (face == NULL)
         return TEST_ABORTED;

     /* Set transparent pixel as the pixel at (0,0) */
     if (face->format->palette) {
        ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
        SDLTest_AssertPass("Call to SDL_SetColorKey()");
        SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
     }

     /* Convert to 32 bit to compare. */
     rface = SDL_ConvertSurface( face, testSurface->format, 0 );
     SDLTest_AssertPass("Call to SDL_ConvertSurface()");
     SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_ConvertSurface is not NULL");

     /* Compare surface. */
     ret = SDLTest_CompareSurfaces( rface, face, 0 );
     SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

     /* Clean up. */
     SDL_FreeSurface(face);
     face = NULL;
     SDL_FreeSurface(rface);
     rface = NULL;

     return TEST_COMPLETED;
 }


 /* !
  *  Tests surface conversion across all pixel formats.
  */
 int
 surface_testCompleteSurfaceConversion(void *arg)
 {
     Uint32 pixel_formats[] = {
         SDL_PIXELFORMAT_INDEX8,
         SDL_PIXELFORMAT_RGB332,
         SDL_PIXELFORMAT_RGB444,
         SDL_PIXELFORMAT_BGR444,
         SDL_PIXELFORMAT_RGB555,
         SDL_PIXELFORMAT_BGR555,
         SDL_PIXELFORMAT_ARGB4444,
         SDL_PIXELFORMAT_RGBA4444,
         SDL_PIXELFORMAT_ABGR4444,
         SDL_PIXELFORMAT_BGRA4444,
         SDL_PIXELFORMAT_ARGB1555,
         SDL_PIXELFORMAT_RGBA5551,
         SDL_PIXELFORMAT_ABGR1555,
         SDL_PIXELFORMAT_BGRA5551,
         SDL_PIXELFORMAT_RGB565,
         SDL_PIXELFORMAT_BGR565,
         SDL_PIXELFORMAT_RGB24,
         SDL_PIXELFORMAT_BGR24,
         SDL_PIXELFORMAT_RGB888,
         SDL_PIXELFORMAT_RGBX8888,
         SDL_PIXELFORMAT_BGR888,
         SDL_PIXELFORMAT_BGRX8888,
         SDL_PIXELFORMAT_ARGB8888,
         SDL_PIXELFORMAT_RGBA8888,
         SDL_PIXELFORMAT_ABGR8888,
         SDL_PIXELFORMAT_BGRA8888,
         SDL_PIXELFORMAT_ARGB2101010,
     };
     SDL_Surface *face = NULL, *cvt1, *cvt2, *final;
     SDL_PixelFormat *fmt1, *fmt2;
     int i, j, ret = 0;

     /* Create sample surface */
     face = SDLTest_ImageFace();
     SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
     if (face == NULL)
         return TEST_ABORTED;

     /* Set transparent pixel as the pixel at (0,0) */
     if (face->format->palette) {
        ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
        SDLTest_AssertPass("Call to SDL_SetColorKey()");
        SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
     }

     for ( i = 0; i < SDL_arraysize(pixel_formats); ++i ) {
         for ( j = 0; j < SDL_arraysize(pixel_formats); ++j ) {
             fmt1 = SDL_AllocFormat(pixel_formats[i]);
             SDL_assert(fmt1 != NULL);
             cvt1 = SDL_ConvertSurface(face, fmt1, 0);
             SDL_assert(cvt1 != NULL);

             fmt2 = SDL_AllocFormat(pixel_formats[j]);
             SDL_assert(fmt1 != NULL);
             cvt2 = SDL_ConvertSurface(cvt1, fmt2, 0);
             SDL_assert(cvt2 != NULL);

             if ( fmt1->BytesPerPixel == face->format->BytesPerPixel &&
                  fmt2->BytesPerPixel == face->format->BytesPerPixel &&
                  (fmt1->Amask != 0) == (face->format->Amask != 0) &&
                  (fmt2->Amask != 0) == (face->format->Amask != 0) ) {
                 final = SDL_ConvertSurface( cvt2, face->format, 0 );
                 SDL_assert(final != NULL);

                 /* Compare surface. */
                 ret = SDLTest_CompareSurfaces( face, final, 0 );
                 SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
                 SDL_FreeSurface(final);
             }

             SDL_FreeSurface(cvt1);
             SDL_FreeFormat(fmt1);
             SDL_FreeSurface(cvt2);
             SDL_FreeFormat(fmt2);
         }
     }

     /* Clean up. */
     SDL_FreeSurface( face );

     return TEST_COMPLETED;
 }


 /**
  * @brief Tests sprite loading. A failure case.
  */
 int
 surface_testLoadFailure(void *arg)
 {
     SDL_Surface *face = SDL_LoadBMP("nonexistant.bmp");
     SDLTest_AssertCheck(face == NULL, "SDL_CreateLoadBmp");

     return TEST_COMPLETED;
 }

 /**
  * @brief Tests some blitting routines.
  */
 int
 surface_testBlit(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Basic blitting */
    _testBlitBlendMode(-1);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlit();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }

 /**
  * @brief Tests some blitting routines with color mod
  */
 int
 surface_testBlitColorMod(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Basic blitting with color mod */
    _testBlitBlendMode(-2);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitColor();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }

 /**
  * @brief Tests some blitting routines with alpha mod
  */
 int
 surface_testBlitAlphaMod(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Basic blitting with alpha mod */
    _testBlitBlendMode(-3);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitAlpha();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }


 /**
  * @brief Tests some more blitting routines.
  */
 int
 surface_testBlitBlendNone(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Basic blitting */
    _testBlitBlendMode(SDL_BLENDMODE_NONE);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitBlendNone();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }

 /**
  * @brief Tests some more blitting routines.
  */
 int
 surface_testBlitBlendBlend(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Blend blitting */
    _testBlitBlendMode(SDL_BLENDMODE_BLEND);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitBlend();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }

 /**
  * @brief Tests some more blitting routines.
  */
 int
 surface_testBlitBlendAdd(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Add blitting */
    _testBlitBlendMode(SDL_BLENDMODE_ADD);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitBlendAdd();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }

 /**
  * @brief Tests some more blitting routines.
  */
 int
 surface_testBlitBlendMod(void *arg)
 {
    int ret;
    SDL_Surface *compareSurface;

    /* Mod blitting */
    _testBlitBlendMode(SDL_BLENDMODE_MOD);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitBlendMod();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;
 }

 /**
  * @brief Tests some more blitting routines with loop
  */
 int
 surface_testBlitBlendLoop(void *arg) {

    int ret;
    SDL_Surface *compareSurface;

    /* All blitting modes */
    _testBlitBlendMode(-4);

    /* Verify result by comparing surfaces */
    compareSurface = SDLTest_ImageBlitBlendAll();
    ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
    SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

    /* Clean up. */
    SDL_FreeSurface(compareSurface);

    return TEST_COMPLETED;

 }

 /* ================= Test References ================== */

 /* Surface test cases */
 static const SDLTest_TestCaseReference surfaceTest1 =
         { (SDLTest_TestCaseFp)surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest2 =
         { (SDLTest_TestCaseFp)surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest3 =
         { (SDLTest_TestCaseFp)surface_testBlitBlendNone, "surface_testBlitBlendNone", "Tests blitting routines with none blending mode.", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest4 =
         { (SDLTest_TestCaseFp)surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest5 =
         { (SDLTest_TestCaseFp)surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest6 =
         { (SDLTest_TestCaseFp)surface_testCompleteSurfaceConversion, "surface_testCompleteSurfaceConversion", "Tests surface conversion across all pixel formats", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest7 =
         { (SDLTest_TestCaseFp)surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED};

 static const SDLTest_TestCaseReference surfaceTest8 =
         { (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED};

 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
 static const SDLTest_TestCaseReference surfaceTest9 =
         { (SDLTest_TestCaseFp)surface_testBlitBlendLoop, "surface_testBlitBlendLoop", "Test blitting routines with various blending modes", TEST_DISABLED};

 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
 static const SDLTest_TestCaseReference surfaceTest10 =
         { (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_DISABLED};

 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
 static const SDLTest_TestCaseReference surfaceTest11 =
         { (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_DISABLED};

 static const SDLTest_TestCaseReference surfaceTest12 =
         { (SDLTest_TestCaseFp)surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED};

 /* Sequence of Surface test cases */
 static const SDLTest_TestCaseReference *surfaceTests[] =  {
     &surfaceTest1, &surfaceTest2, &surfaceTest3, &surfaceTest4, &surfaceTest5,
     &surfaceTest6, &surfaceTest7, &surfaceTest8, &surfaceTest9, &surfaceTest10,
     &surfaceTest11, &surfaceTest12, NULL
 };

 /* Surface test suite (global) */
 SDLTest_TestSuiteReference surfaceTestSuite = {
     "Surface",
     _surfaceSetUp,
     surfaceTests,
     _surfaceTearDown

 };
	/**
	* Original code: automated SDL surface test written by Edgar Simo "bobbens"
	* Adapted/rewritten for test lib by Andreas Schiffler
	*/

	/* Supress C4996 VS compiler warnings for unlink() */
	#define _CRT_SECURE_NO_DEPRECATE
	#define _CRT_NONSTDC_NO_DEPRECATE

	#include <stdio.h>
	#ifndef _MSC_VER
	#include <unistd.h>
	#endif
	#include <sys/stat.h>

	#include "SDL.h"
	#include "SDL_test.h"

	#ifdef __MACOSX__
	#include <unistd.h> /* For unlink() */
	#endif

	/* ================= Test Case Implementation ================== */

	/* Shared test surface */

	static SDL_Surface *referenceSurface = NULL;
	static SDL_Surface *testSurface = NULL;

	/* Helper functions for the test cases */

	#define TEST_SURFACE_WIDTH testSurface->w
	#define TEST_SURFACE_HEIGHT testSurface->h

	/* Fixture */

	/* Create a 32-bit writable surface for blitting tests */
	void
	_surfaceSetUp(void *arg)
	{
	int result;
	SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
	SDL_BlendMode currentBlendMode;
	Uint32 rmask, gmask, bmask, amask;
	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	rmask = 0xff000000;
	gmask = 0x00ff0000;
	bmask = 0x0000ff00;
	amask = 0x000000ff;
	#else
	rmask = 0x000000ff;
	gmask = 0x0000ff00;
	bmask = 0x00ff0000;
	amask = 0xff000000;
	#endif

	referenceSurface = SDLTest_ImageBlit(); /* For size info */
	testSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, referenceSurface->w, referenceSurface->h, 32, rmask, gmask, bmask, amask);
	SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL");
	if (testSurface != NULL) {
	/* Disable blend mode for target surface */
	result = SDL_SetSurfaceBlendMode(testSurface, blendMode);
	SDLTest_AssertCheck(result == 0, "Validate result from SDL_SetSurfaceBlendMode, expected: 0, got: %i", result);
	result = SDL_GetSurfaceBlendMode(testSurface, &currentBlendMode);
	SDLTest_AssertCheck(result == 0, "Validate result from SDL_GetSurfaceBlendMode, expected: 0, got: %i", result);
	SDLTest_AssertCheck(currentBlendMode == blendMode, "Validate blendMode, expected: %i, got: %i", blendMode, currentBlendMode);
	}
	}

	void
	_surfaceTearDown(void *arg)
	{
	SDL_FreeSurface(referenceSurface);
	referenceSurface = NULL;
	SDL_FreeSurface(testSurface);
	testSurface = NULL;
	}

	/**
	* Helper that clears the test surface
	*/
	void _clearTestSurface()
	{
	int ret;
	Uint32 color;

	/* Clear surface. */
	color = SDL_MapRGBA( testSurface->format, 0, 0, 0, 0);
	SDLTest_AssertPass("Call to SDL_MapRGBA()");
	ret = SDL_FillRect( testSurface, NULL, color);
	SDLTest_AssertPass("Call to SDL_FillRect()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_FillRect, expected: 0, got: %i", ret);
	}

	/**
	* 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.
	*/
	void _testBlitBlendMode(int mode)
	{
	int ret;
	int i, j, ni, nj;
	SDL_Surface *face;
	SDL_Rect rect;
	int nmode;
	SDL_BlendMode bmode;
	int checkFailCount1;
	int checkFailCount2;
	int checkFailCount3;
	int checkFailCount4;

	/* Check test surface */
	SDLTest_AssertCheck(testSurface != NULL, "Verify testSurface is not NULL");
	if (testSurface == NULL) return;

	/* Create sample surface */
	face = SDLTest_ImageFace();
	SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
	if (face == NULL) return;

	/* Reset alpha modulation */
	ret = SDL_SetSurfaceAlphaMod(face, 255);
	SDLTest_AssertPass("Call to SDL_SetSurfaceAlphaMod()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceAlphaMod(), expected: 0, got: %i", ret);

	/* Reset color modulation */
	ret = SDL_SetSurfaceColorMod(face, 255, 255, 255);
	SDLTest_AssertPass("Call to SDL_SetSurfaceColorMod()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorMod(), expected: 0, got: %i", ret);

	/* Reset color key */
	ret = SDL_SetColorKey(face, SDL_FALSE, 0);
	SDLTest_AssertPass("Call to SDL_SetColorKey()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey(), expected: 0, got: %i", ret);

	/* Clear the test surface */
	_clearTestSurface();

	/* Target rect size */
	rect.w = face->w;
	rect.h = face->h;

	/* Steps to take */
	ni = testSurface->w - face->w;
	nj = testSurface->h - face->h;

	/* Optionally set blend mode. */
	if (mode >= 0) {
	ret = SDL_SetSurfaceBlendMode( face, (SDL_BlendMode)mode );
	SDLTest_AssertPass("Call to SDL_SetSurfaceBlendMode()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceBlendMode(..., %i), expected: 0, got: %i", mode, ret);
	}

	/* Test blend mode. */
	checkFailCount1 = 0;
	checkFailCount2 = 0;
	checkFailCount3 = 0;
	checkFailCount4 = 0;
	for (j=0; j <= nj; j+=4) {
	for (i=0; i <= ni; i+=4) {
	if (mode == -2) {
	/* Set color mod. */
	ret = SDL_SetSurfaceColorMod( face, (255/nj)j, (255/ni)i, (255/nj)*j );
	if (ret != 0) checkFailCount2++;
	}
	else if (mode == -3) {
	/* Set alpha mod. */
	ret = SDL_SetSurfaceAlphaMod( face, (255/ni)*i );
	if (ret != 0) checkFailCount3++;
	}
	else if (mode == -4) {
	/* Crazy blending mode magic. */
	nmode = (i/4*j/4) % 4;
	if (nmode==0) {
	bmode = SDL_BLENDMODE_NONE;
	} else if (nmode==1) {
	bmode = SDL_BLENDMODE_BLEND;
	} else if (nmode==2) {
	bmode = SDL_BLENDMODE_ADD;
	} else if (nmode==3) {
	bmode = SDL_BLENDMODE_MOD;
	}
	ret = SDL_SetSurfaceBlendMode( face, bmode );
	if (ret != 0) checkFailCount4++;
	}

	/* Blitting. */
	rect.x = i;
	rect.y = j;
	ret = SDL_BlitSurface( face, NULL, testSurface, &rect );
	if (ret != 0) checkFailCount1++;
	}
	}
	SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_BlitSurface, expected: 0, got: %i", checkFailCount1);
	SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetSurfaceColorMod, expected: 0, got: %i", checkFailCount2);
	SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetSurfaceAlphaMod, expected: 0, got: %i", checkFailCount3);
	SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_SetSurfaceBlendMode, expected: 0, got: %i", checkFailCount4);

	/* Clean up */
	SDL_FreeSurface(face);
	face = NULL;
	}

	/* Helper to check that a file exists */
	void
	_AssertFileExist(const char *filename)
	{
	struct stat st;
	int ret = stat(filename, &st);

	SDLTest_AssertCheck(ret == 0, "Verify file '%s' exists", filename);
	}


	/* Test case functions */

	/**
	* @brief Tests sprite saving and loading
	*/
	int
	surface_testSaveLoadBitmap(void *arg)
	{
	int ret;
	const char *sampleFilename = "testSaveLoadBitmap.bmp";
	SDL_Surface *face;
	SDL_Surface *rface;

	/* Create sample surface */
	face = SDLTest_ImageFace();
	SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
	if (face == NULL) return TEST_ABORTED;

	/* Delete test file; ignore errors */
	unlink(sampleFilename);

	/* Save a surface */
	ret = SDL_SaveBMP(face, sampleFilename);
	SDLTest_AssertPass("Call to SDL_SaveBMP()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SaveBMP, expected: 0, got: %i", ret);
	_AssertFileExist(sampleFilename);

	/* Load a surface */
	rface = SDL_LoadBMP(sampleFilename);
	SDLTest_AssertPass("Call to SDL_LoadBMP()");
	SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_LoadBMP is not NULL");
	if (rface != NULL) {
	SDLTest_AssertCheck(face->w == rface->w, "Verify width of loaded surface, expected: %i, got: %i", face->w, rface->w);
	SDLTest_AssertCheck(face->h == rface->h, "Verify height of loaded surface, expected: %i, got: %i", face->h, rface->h);
	}

	/* Delete test file; ignore errors */
	unlink(sampleFilename);

	/* Clean up */
	SDL_FreeSurface(face);
	face = NULL;
	SDL_FreeSurface(rface);
	rface = NULL;

	return TEST_COMPLETED;
	}

	/* !
	* Tests surface conversion.
	*/
	int
	surface_testSurfaceConversion(void *arg)
	{
	SDL_Surface rface = NULL, face = NULL;
	int ret = 0;

	/* Create sample surface */
	face = SDLTest_ImageFace();
	SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
	if (face == NULL)
	return TEST_ABORTED;

	/* Set transparent pixel as the pixel at (0,0) */
	if (face->format->palette) {
	ret = SDL_SetColorKey(face, SDL_RLEACCEL, (Uint8 ) face->pixels);
	SDLTest_AssertPass("Call to SDL_SetColorKey()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
	}

	/* Convert to 32 bit to compare. */
	rface = SDL_ConvertSurface( face, testSurface->format, 0 );
	SDLTest_AssertPass("Call to SDL_ConvertSurface()");
	SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_ConvertSurface is not NULL");

	/* Compare surface. */
	ret = SDLTest_CompareSurfaces( rface, face, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(face);
	face = NULL;
	SDL_FreeSurface(rface);
	rface = NULL;

	return TEST_COMPLETED;
	}


	/* !
	* Tests surface conversion across all pixel formats.
	*/
	int
	surface_testCompleteSurfaceConversion(void *arg)
	{
	Uint32 pixel_formats[] = {
	SDL_PIXELFORMAT_INDEX8,
	SDL_PIXELFORMAT_RGB332,
	SDL_PIXELFORMAT_RGB444,
	SDL_PIXELFORMAT_BGR444,
	SDL_PIXELFORMAT_RGB555,
	SDL_PIXELFORMAT_BGR555,
	SDL_PIXELFORMAT_ARGB4444,
	SDL_PIXELFORMAT_RGBA4444,
	SDL_PIXELFORMAT_ABGR4444,
	SDL_PIXELFORMAT_BGRA4444,
	SDL_PIXELFORMAT_ARGB1555,
	SDL_PIXELFORMAT_RGBA5551,
	SDL_PIXELFORMAT_ABGR1555,
	SDL_PIXELFORMAT_BGRA5551,
	SDL_PIXELFORMAT_RGB565,
	SDL_PIXELFORMAT_BGR565,
	SDL_PIXELFORMAT_RGB24,
	SDL_PIXELFORMAT_BGR24,
	SDL_PIXELFORMAT_RGB888,
	SDL_PIXELFORMAT_RGBX8888,
	SDL_PIXELFORMAT_BGR888,
	SDL_PIXELFORMAT_BGRX8888,
	SDL_PIXELFORMAT_ARGB8888,
	SDL_PIXELFORMAT_RGBA8888,
	SDL_PIXELFORMAT_ABGR8888,
	SDL_PIXELFORMAT_BGRA8888,
	SDL_PIXELFORMAT_ARGB2101010,
	};
	SDL_Surface face = NULL, cvt1, cvt2, final;
	SDL_PixelFormat fmt1, fmt2;
	int i, j, ret = 0;

	/* Create sample surface */
	face = SDLTest_ImageFace();
	SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
	if (face == NULL)
	return TEST_ABORTED;

	/* Set transparent pixel as the pixel at (0,0) */
	if (face->format->palette) {
	ret = SDL_SetColorKey(face, SDL_RLEACCEL, (Uint8 ) face->pixels);
	SDLTest_AssertPass("Call to SDL_SetColorKey()");
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
	}

	for ( i = 0; i < SDL_arraysize(pixel_formats); ++i ) {
	for ( j = 0; j < SDL_arraysize(pixel_formats); ++j ) {
	fmt1 = SDL_AllocFormat(pixel_formats[i]);
	SDL_assert(fmt1 != NULL);
	cvt1 = SDL_ConvertSurface(face, fmt1, 0);
	SDL_assert(cvt1 != NULL);

	fmt2 = SDL_AllocFormat(pixel_formats[j]);
	SDL_assert(fmt1 != NULL);
	cvt2 = SDL_ConvertSurface(cvt1, fmt2, 0);
	SDL_assert(cvt2 != NULL);

	if ( fmt1->BytesPerPixel == face->format->BytesPerPixel &&
	fmt2->BytesPerPixel == face->format->BytesPerPixel &&
	(fmt1->Amask != 0) == (face->format->Amask != 0) &&
	(fmt2->Amask != 0) == (face->format->Amask != 0) ) {
	final = SDL_ConvertSurface( cvt2, face->format, 0 );
	SDL_assert(final != NULL);

	/* Compare surface. */
	ret = SDLTest_CompareSurfaces( face, final, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
	SDL_FreeSurface(final);
	}

	SDL_FreeSurface(cvt1);
	SDL_FreeFormat(fmt1);
	SDL_FreeSurface(cvt2);
	SDL_FreeFormat(fmt2);
	}
	}

	/* Clean up. */
	SDL_FreeSurface( face );

	return TEST_COMPLETED;
	}


	/**
	* @brief Tests sprite loading. A failure case.
	*/
	int
	surface_testLoadFailure(void *arg)
	{
	SDL_Surface *face = SDL_LoadBMP("nonexistant.bmp");
	SDLTest_AssertCheck(face == NULL, "SDL_CreateLoadBmp");

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some blitting routines.
	*/
	int
	surface_testBlit(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Basic blitting */
	_testBlitBlendMode(-1);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlit();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some blitting routines with color mod
	*/
	int
	surface_testBlitColorMod(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Basic blitting with color mod */
	_testBlitBlendMode(-2);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitColor();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some blitting routines with alpha mod
	*/
	int
	surface_testBlitAlphaMod(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Basic blitting with alpha mod */
	_testBlitBlendMode(-3);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitAlpha();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}


	/**
	* @brief Tests some more blitting routines.
	*/
	int
	surface_testBlitBlendNone(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Basic blitting */
	_testBlitBlendMode(SDL_BLENDMODE_NONE);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitBlendNone();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some more blitting routines.
	*/
	int
	surface_testBlitBlendBlend(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Blend blitting */
	_testBlitBlendMode(SDL_BLENDMODE_BLEND);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitBlend();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some more blitting routines.
	*/
	int
	surface_testBlitBlendAdd(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Add blitting */
	_testBlitBlendMode(SDL_BLENDMODE_ADD);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitBlendAdd();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some more blitting routines.
	*/
	int
	surface_testBlitBlendMod(void *arg)
	{
	int ret;
	SDL_Surface *compareSurface;

	/* Mod blitting */
	_testBlitBlendMode(SDL_BLENDMODE_MOD);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitBlendMod();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;
	}

	/**
	* @brief Tests some more blitting routines with loop
	*/
	int
	surface_testBlitBlendLoop(void *arg) {

	int ret;
	SDL_Surface *compareSurface;

	/* All blitting modes */
	_testBlitBlendMode(-4);

	/* Verify result by comparing surfaces */
	compareSurface = SDLTest_ImageBlitBlendAll();
	ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);

	/* Clean up. */
	SDL_FreeSurface(compareSurface);

	return TEST_COMPLETED;

	}

	/* ================= Test References ================== */

	/* Surface test cases */
	static const SDLTest_TestCaseReference surfaceTest1 =
	{ (SDLTest_TestCaseFp)surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest2 =
	{ (SDLTest_TestCaseFp)surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest3 =
	{ (SDLTest_TestCaseFp)surface_testBlitBlendNone, "surface_testBlitBlendNone", "Tests blitting routines with none blending mode.", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest4 =
	{ (SDLTest_TestCaseFp)surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest5 =
	{ (SDLTest_TestCaseFp)surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest6 =
	{ (SDLTest_TestCaseFp)surface_testCompleteSurfaceConversion, "surface_testCompleteSurfaceConversion", "Tests surface conversion across all pixel formats", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest7 =
	{ (SDLTest_TestCaseFp)surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED};

	static const SDLTest_TestCaseReference surfaceTest8 =
	{ (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED};

	/* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
	static const SDLTest_TestCaseReference surfaceTest9 =
	{ (SDLTest_TestCaseFp)surface_testBlitBlendLoop, "surface_testBlitBlendLoop", "Test blitting routines with various blending modes", TEST_DISABLED};

	/* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
	static const SDLTest_TestCaseReference surfaceTest10 =
	{ (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_DISABLED};

	/* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
	static const SDLTest_TestCaseReference surfaceTest11 =
	{ (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_DISABLED};

	static const SDLTest_TestCaseReference surfaceTest12 =
	{ (SDLTest_TestCaseFp)surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED};

	/* Sequence of Surface test cases */
	static const SDLTest_TestCaseReference *surfaceTests[] = {
	&surfaceTest1, &surfaceTest2, &surfaceTest3, &surfaceTest4, &surfaceTest5,
	&surfaceTest6, &surfaceTest7, &surfaceTest8, &surfaceTest9, &surfaceTest10,
	&surfaceTest11, &surfaceTest12, NULL
	};

	/* Surface test suite (global) */
	SDLTest_TestSuiteReference surfaceTestSuite = {
	"Surface",
	_surfaceSetUp,
	surfaceTests,
	_surfaceTearDown

	};