From ea16a2e693a646c1fd408503424ef136a0672d3d Mon Sep 17 00:00:00 2001 From: Andreas Schiffler Date: Wed, 26 Dec 2012 22:26:44 -0800 Subject: [PATCH] Add surface test suite; minor improvements to render suite; refactor image saving into test lib compare function; fix for Haiku build --- include/SDL_test_images.h | 2 +- src/test/SDL_test_compare.c | 22 +- test/Makefile.in | 3 +- test/testautomation_render.c | 147 ++++++---- test/testautomation_suites.h | 4 +- test/testautomation_surface.c | 519 ++++++++++++++++++++++++++++++++++ 6 files changed, 636 insertions(+), 61 deletions(-) create mode 100644 test/testautomation_surface.c diff --git a/include/SDL_test_images.h b/include/SDL_test_images.h index a5f531669..70c96898e 100644 --- a/include/SDL_test_images.h +++ b/include/SDL_test_images.h @@ -53,7 +53,7 @@ typedef struct SDLTest_SurfaceImage_s { int width; int height; unsigned int bytes_per_pixel; /* 3:RGB, 4:RGBA */ - const unsigned char pixel_data[]; + unsigned char pixel_data[]; } SDLTest_SurfaceImage_t; /* Test images */ diff --git a/src/test/SDL_test_compare.c b/src/test/SDL_test_compare.c index 22ca6481e..29d9a5faa 100644 --- a/src/test/SDL_test_compare.c +++ b/src/test/SDL_test_compare.c @@ -32,7 +32,11 @@ #include "SDL_test.h" -int SDLTest_CompareSurfaces( SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error ) +/* Counter for _CompareSurface calls; used for filename creation when comparisons fail */ +static int _CompareSurfaceCount = 0; + +/* Compare surfaces */ +int SDLTest_CompareSurfaces(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error) { int ret; int i,j; @@ -41,18 +45,20 @@ int SDLTest_CompareSurfaces( SDL_Surface *surface, SDL_Surface *referenceSurface int dist; Uint8 R, G, B, A; Uint8 Rd, Gd, Bd, Ad; + char imageFilename[128]; + char referenceFilename[128]; /* Validate input surfaces */ if (surface == NULL || referenceSurface == NULL) { return -1; } - /* Make surface size is the same. */ + /* Make sure surface size is the same. */ if ((surface->w != referenceSurface->w) || (surface->h != referenceSurface->h)) { return -2; } - /* Sanitize input */ + /* Sanitize input value */ if (allowable_error<0) { allowable_error = 0; } @@ -87,5 +93,15 @@ int SDLTest_CompareSurfaces( SDL_Surface *surface, SDL_Surface *referenceSurface SDL_UnlockSurface( surface ); SDL_UnlockSurface( referenceSurface ); + /* Save test image and reference for analysis on failures */ + _CompareSurfaceCount++; + if (ret != 0) { + SDL_snprintf(imageFilename, 127, "CompareSurfaces%04d_TestOutput.bmp", _CompareSurfaceCount); + SDL_SaveBMP(surface, imageFilename); + SDL_snprintf(referenceFilename, 127, "CompareSurfaces%04d_Reference.bmp", _CompareSurfaceCount); + SDL_SaveBMP(referenceSurface, referenceFilename); + SDLTest_LogError("Surfaces from failed comparison saved as '%s' and '%s'", imageFilename, referenceFilename); + } + return ret; } diff --git a/test/Makefile.in b/test/Makefile.in index c18be7637..850fb22a8 100644 --- a/test/Makefile.in +++ b/test/Makefile.in @@ -74,7 +74,8 @@ testautomation$(EXE): $(srcdir)/testautomation.c \ $(srcdir)/testautomation_rect.c \ $(srcdir)/testautomation_render.c \ $(srcdir)/testautomation_rwops.c \ - $(srcdir)/testautomation_audio.c + $(srcdir)/testautomation_audio.c \ + $(srcdir)/testautomation_surface.c $(CC) -o $@ $^ $(CFLAGS) -lSDL2_test $(LIBS) testmultiaudio$(EXE): $(srcdir)/testmultiaudio.c diff --git a/test/testautomation_render.c b/test/testautomation_render.c index 74db37dca..eb129202b 100644 --- a/test/testautomation_render.c +++ b/test/testautomation_render.c @@ -22,13 +22,14 @@ #define ALLOWABLE_ERROR_OPAQUE 0 #define ALLOWABLE_ERROR_BLENDED 64 +/* Test window and renderer */ SDL_Window *window = NULL; SDL_Renderer *renderer = NULL; /* Prototypes for helper functions */ static int _clearScreen (void); -static void _compare(const char *msg, SDL_Surface *s, int allowable_error); +static void _compare(SDL_Surface *reference, int allowable_error); static int _hasTexAlpha(void); static int _hasTexColor(void); static SDL_Texture *_loadTestFace(void); @@ -53,7 +54,7 @@ void InitCreateRenderer(void *arg) renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); SDLTest_AssertPass("SDL_CreateRenderer()"); SDLTest_AssertCheck(renderer != 0, "Check SDL_CreateRenderer result"); - if (renderer == 0) { + if (renderer == NULL) { SDL_DestroyWindow(window); return; } @@ -66,11 +67,13 @@ void CleanupDestroyRenderer(void *arg) { if (renderer != NULL) { SDL_DestroyRenderer(renderer); + renderer = NULL; SDLTest_AssertPass("SDL_DestroyRenderer()"); } if (window != NULL) { SDL_DestroyWindow(window); + window = NULL; SDLTest_AssertPass("SDL_DestroyWindow"); } } @@ -106,6 +109,7 @@ int render_testPrimitives (void *arg) int ret; int x, y; SDL_Rect rect; + SDL_Surface *referenceSurface = NULL; int checkFailCount1; int checkFailCount2; @@ -182,7 +186,14 @@ int render_testPrimitives (void *arg) SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret); /* See if it's the same. */ - _compare( "Primitives output not the same.", SDLTest_ImagePrimitives(), ALLOWABLE_ERROR_OPAQUE ); + referenceSurface = SDLTest_ImagePrimitives(); + _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE ); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } return TEST_COMPLETED; } @@ -200,6 +211,7 @@ int render_testPrimitivesBlend (void *arg) int ret; int i, j; SDL_Rect rect; + SDL_Surface *referenceSurface = NULL; int checkFailCount1; int checkFailCount2; int checkFailCount3; @@ -317,9 +329,16 @@ int render_testPrimitivesBlend (void *arg) SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount3); /* See if it's the same. */ - _compare( "Blended primitives output not the same.", SDLTest_ImagePrimitivesBlend(), ALLOWABLE_ERROR_BLENDED ); + referenceSurface = SDLTest_ImagePrimitivesBlend(); + _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED ); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } - return TEST_COMPLETED; + return TEST_COMPLETED; } @@ -337,6 +356,7 @@ render_testBlit(void *arg) int ret; SDL_Rect rect; SDL_Texture *tface; + SDL_Surface *referenceSurface = NULL; Uint32 tformat; int taccess, tw, th; int i, j, ni, nj; @@ -374,11 +394,16 @@ render_testBlit(void *arg) } SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount1); + /* See if it's the same */ + referenceSurface = SDLTest_ImageBlit(); + _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE ); + /* Clean up. */ SDL_DestroyTexture( tface ); - - /* See if it's the same */ - _compare( "Blit output not the same.", SDLTest_ImageBlit(), ALLOWABLE_ERROR_OPAQUE ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } return TEST_COMPLETED; } @@ -398,6 +423,7 @@ render_testBlitColor (void *arg) int ret; SDL_Rect rect; SDL_Texture *tface; + SDL_Surface *referenceSurface = NULL; Uint32 tformat; int taccess, tw, th; int i, j, ni, nj; @@ -438,12 +464,16 @@ render_testBlitColor (void *arg) SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1); SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2); + /* See if it's the same. */ + referenceSurface = SDLTest_ImageBlitColor(); + _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE ); + /* Clean up. */ SDL_DestroyTexture( tface ); - - /* See if it's the same. */ - _compare( "Blit output not the same (using SDL_SetTextureColorMod).", - SDLTest_ImageBlitColor(), ALLOWABLE_ERROR_OPAQUE ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } return TEST_COMPLETED; } @@ -463,13 +493,13 @@ render_testBlitAlpha (void *arg) int ret; SDL_Rect rect; SDL_Texture *tface; + SDL_Surface *referenceSurface = NULL; Uint32 tformat; int taccess, tw, th; int i, j, ni, nj; int checkFailCount1; int checkFailCount2; - /* Need alpha or just skip test. */ SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha"); @@ -507,12 +537,16 @@ render_testBlitAlpha (void *arg) SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount1); SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2); + /* See if it's the same. */ + referenceSurface = SDLTest_ImageBlitAlpha(); + _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED ); + /* Clean up. */ SDL_DestroyTexture( tface ); - - /* See if it's the same. */ - _compare( "Blit output not the same (using SDL_SetSurfaceAlphaMod).", - SDLTest_ImageBlitAlpha(), ALLOWABLE_ERROR_BLENDED ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } return TEST_COMPLETED; } @@ -584,6 +618,7 @@ render_testBlitBlend (void *arg) int ret; SDL_Rect rect; SDL_Texture *tface; + SDL_Surface *referenceSurface = NULL; Uint32 tformat; int taccess, tw, th; int i, j, ni, nj; @@ -618,26 +653,39 @@ render_testBlitBlend (void *arg) /* Test None. */ _testBlitBlendMode( tface, SDL_BLENDMODE_NONE ); - /* See if it's the same. */ - _compare( "Blit blending output not the same (using SDL_BLENDMODE_NONE).", - SDLTest_ImageBlitBlendNone(), ALLOWABLE_ERROR_OPAQUE ); - - + referenceSurface = SDLTest_ImageBlitBlendNone(); + _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } + /* Test Blend. */ _testBlitBlendMode( tface, SDL_BLENDMODE_BLEND ); - _compare( "Blit blending output not the same (using SDL_BLENDMODE_BLEND).", - SDLTest_ImageBlitBlend(), ALLOWABLE_ERROR_BLENDED ); - + referenceSurface = SDLTest_ImageBlitBlend(); + _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } /* Test Add. */ _testBlitBlendMode( tface, SDL_BLENDMODE_ADD ); - _compare( "Blit blending output not the same (using SDL_BLENDMODE_ADD).", - SDLTest_ImageBlitBlendAdd(), ALLOWABLE_ERROR_BLENDED ); + referenceSurface = SDLTest_ImageBlitBlendAdd(); + _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } /* Test Mod. */ _testBlitBlendMode( tface, SDL_BLENDMODE_MOD); - _compare( "Blit blending output not the same (using SDL_BLENDMODE_MOD).", - SDLTest_ImageBlitBlendMod(), ALLOWABLE_ERROR_BLENDED ); + referenceSurface = SDLTest_ImageBlitBlendMod(); + _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED ); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } /* Clear surface. */ _clearScreen(); @@ -682,9 +730,13 @@ render_testBlitBlend (void *arg) /* Clean up. */ SDL_DestroyTexture( tface ); - /* Check to see if matches. */ - _compare( "Blit blending output not the same (using SDL_BLENDMODE_*).", - SDLTest_ImageBlitBlendAll(), ALLOWABLE_ERROR_BLENDED); + /* Check to see if final image matches. */ + referenceSurface = SDLTest_ImageBlitBlendAll(); + _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED); + if (referenceSurface != NULL) { + SDL_FreeSurface(referenceSurface); + referenceSurface = NULL; + } return TEST_COMPLETED; } @@ -902,9 +954,6 @@ _hasTexAlpha(void) return 1; } -/* Counter for _compare calls use for filename creation when comparisons fail */ -static int _renderCompareCount = 0; - /** * @brief Compares screen pixels with image pixels. Helper function. * @@ -918,17 +967,15 @@ static int _renderCompareCount = 0; * http://wiki.libsdl.org/moin.cgi/SDL_FreeSurface */ static void -_compare(const char *msg, SDL_Surface *s, int allowable_error) +_compare(SDL_Surface *referenceSurface, int allowable_error) { int ret; SDL_Rect rect; Uint8 pix[4*TESTRENDER_SCREEN_W*TESTRENDER_SCREEN_H]; - SDL_Surface *testsur; - char imageFilename[128]; - char referenceFilename[128]; + SDL_Surface *testSurface; /* Read pixels. */ - /* Explicitly specify the rect in case the window isn't expected size... */ + /* Explicitly specify the rect in case the window isn't the expected size... */ rect.x = 0; rect.y = 0; rect.w = TESTRENDER_SCREEN_W; @@ -937,26 +984,18 @@ _compare(const char *msg, SDL_Surface *s, int allowable_error) SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderReadPixels, expected: 0, got: %i", ret); /* Create surface. */ - testsur = SDL_CreateRGBSurfaceFrom( pix, TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, 32, TESTRENDER_SCREEN_W*4, + testSurface = SDL_CreateRGBSurfaceFrom( pix, TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, 32, TESTRENDER_SCREEN_W*4, RENDER_COMPARE_RMASK, RENDER_COMPARE_GMASK, RENDER_COMPARE_BMASK, RENDER_COMPARE_AMASK); - SDLTest_AssertCheck(testsur != NULL, "Verify result from SDL_CreateRGBSurfaceFrom"); + SDLTest_AssertCheck(testSurface != NULL, "Verify result from SDL_CreateRGBSurfaceFrom"); /* Compare surface. */ - ret = SDLTest_CompareSurfaces( testsur, s, allowable_error ); + ret = SDLTest_CompareSurfaces( testSurface, referenceSurface, allowable_error ); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); - /* Save source image and reference image for analysis */ - _renderCompareCount++; - if (ret != 0) { - SDL_snprintf(imageFilename, 127, "compare%04d_SourceImage.bmp", _renderCompareCount); - SDL_SaveBMP(testsur, imageFilename); - SDL_snprintf(referenceFilename, 127, "compare%04d_ReferenceImage.bmp", _renderCompareCount); - SDL_SaveBMP(s, referenceFilename); - SDLTest_LogError("Surfaces from failed comparison saved as '%s' and '%s'", imageFilename, referenceFilename); - } - /* Clean up. */ - SDL_FreeSurface(testsur); + if (testSurface != NULL) { + SDL_FreeSurface(testSurface); + } } /** diff --git a/test/testautomation_suites.h b/test/testautomation_suites.h index d2ddac928..3cbbd3229 100644 --- a/test/testautomation_suites.h +++ b/test/testautomation_suites.h @@ -17,7 +17,7 @@ extern SDLTest_TestSuiteReference platformTestSuite; extern SDLTest_TestSuiteReference rectTestSuite; extern SDLTest_TestSuiteReference renderTestSuite; extern SDLTest_TestSuiteReference rwopsTestSuite; -//extern SDLTest_TestSuiteReference surfaceTestSuite; +extern SDLTest_TestSuiteReference surfaceTestSuite; //extern SDLTest_TestSuiteReference syswmTestSuite; //extern SDLTest_TestSuiteReference videoTestSuite; @@ -31,7 +31,7 @@ SDLTest_TestSuiteReference *testSuites[] = { &rectTestSuite, &renderTestSuite, &rwopsTestSuite, -// &surfaceTestSuite, + &surfaceTestSuite, // &syswmTestSuite, // &videoTestSuite, NULL diff --git a/test/testautomation_surface.c b/test/testautomation_surface.c new file mode 100644 index 000000000..c5b919e03 --- /dev/null +++ b/test/testautomation_surface.c @@ -0,0 +1,519 @@ +/** + * Original code: automated SDL surface test written by Edgar Simo "bobbens" + * Adapted/rewritten for test lib by Andreas Schiffler + */ + +#include +#include + +#include "SDL.h" +#include "SDL_test.h" + +/* ================= Test Case Implementation ================== */ + + +/* Shared test surface */ + +static SDL_Surface *testsurface = NULL; + +/* Fixture */ + +void +_surfaceSetUp(void *arg) +{ + testsurface = SDLTest_ImageBlit(); + SDLTest_AssertCheck(testsurface != NULL, "Check that testsurface is not NULL"); +} + +void +_surfaceTearDown(void *arg) +{ + if (testsurface != NULL) { + SDL_FreeSurface(testsurface); + testsurface = NULL; + } +} + +/* Helper functions for the test cases */ + +#define TEST_SURFACE_WIDTH testsurface->w +#define TEST_SURFACE_HEIGHT testsurface->h + +/** + * Helper that clears the test surface + */ +void _clearTestSurface() +{ + int ret; + Uint32 color; + + /* Clear surface. */ + color = SDL_MapRGB( testsurface->format, 0, 0, 0); + SDLTest_AssertPass("Call to SDL_MapRGB()"); + 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; + Uint32 color; + int nmode; + 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; + + /* 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 colour 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) nmode = SDL_BLENDMODE_NONE; + else if (nmode==1) nmode = SDL_BLENDMODE_BLEND; + else if (nmode==2) nmode = SDL_BLENDMODE_ADD; + else if (nmode==3) nmode = SDL_BLENDMODE_MOD; + ret = SDL_SetSurfaceBlendMode( face, nmode ); + 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 */ + if (face != NULL) { + 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; + + /* 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 */ + if (face != NULL) { + SDL_FreeSurface(face); + face = NULL; + } + if (rface != 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. */ + if (face != NULL) { + SDL_FreeSurface( face ); + face = NULL; + } + if (rface != NULL) { + SDL_FreeSurface( rface ); + rface = NULL; + } + + 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 *referenceSurface; + + /* Basic blitting */ + _testBlitBlendMode(-1); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlit(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + +/** + * @brief Tests some blitting routines with color mod + */ +int +surface_testBlitColorMod(void *arg) +{ + int ret; + SDL_Surface *referenceSurface; + + /* Basic blitting with color mod */ + _testBlitBlendMode(-2); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitColor(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + +/** + * @brief Tests some blitting routines with alpha mod + */ +int +surface_testBlitAlphaMod(void *arg) +{ + int ret; + SDL_Surface *referenceSurface; + + /* Basic blitting with alpha mod */ + _testBlitBlendMode(-3); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitAlpha(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + + +/** + * @brief Tests some more blitting routines. + */ +int +surface_testBlitBlendNone(void *arg) +{ + int ret; + SDL_Surface *referenceSurface; + + /* Basic blitting */ + _testBlitBlendMode(SDL_BLENDMODE_NONE); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitBlendNone(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + +/** + * @brief Tests some more blitting routines. + */ +int +surface_testBlitBlendBlend(void *arg) +{ + int ret; + SDL_Surface *referenceSurface; + + /* Blend blitting */ + _testBlitBlendMode(SDL_BLENDMODE_BLEND); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitBlend(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + +/** + * @brief Tests some more blitting routines. + */ +int +surface_testBlitBlendAdd(void *arg) +{ + int ret; + SDL_Surface *referenceSurface; + + /* Add blitting */ + _testBlitBlendMode(SDL_BLENDMODE_ADD); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitBlendAdd(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + +/** + * @brief Tests some more blitting routines. + */ +int +surface_testBlitBlendMod(void *arg) +{ + int ret; + SDL_Surface *referenceSurface; + + /* Mod blitting */ + _testBlitBlendMode(SDL_BLENDMODE_MOD); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitBlendMod(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + return TEST_COMPLETED; +} + +/** + * @brief Tests some more blitting routines with loop + */ +int +surface_testBlitBlendLoop(void *arg) { + + int ret; + SDL_Surface *referenceSurface; + + /* All blitting */ + _testBlitBlendMode(-4); + + /* Verify result by comparing surfaces */ + referenceSurface = SDLTest_ImageBlitBlendAll(); + ret = SDLTest_CompareSurfaces( testsurface, referenceSurface, 0 ); + SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); + + /* Clean up. */ + if (referenceSurface != NULL) { + SDL_FreeSurface( referenceSurface ); + } + + 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_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED}; + +static const SDLTest_TestCaseReference surfaceTest7 = + { (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED}; + +static const SDLTest_TestCaseReference surfaceTest8 = + { (SDLTest_TestCaseFp)surface_testBlitBlendLoop, "surface_testBlitBlendLoop", "Test blittin routines with verious blending modes", TEST_ENABLED}; + +static const SDLTest_TestCaseReference surfaceTest9 = + { (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_ENABLED}; + +static const SDLTest_TestCaseReference surfaceTest10 = + { (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_ENABLED}; + +static const SDLTest_TestCaseReference surfaceTest11 = + { (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, NULL +}; + +/* Surface test suite (global) */ +SDLTest_TestSuiteReference surfaceTestSuite = { + "Surface", + _surfaceSetUp, + surfaceTests, + _surfaceTearDown + +};