pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add surface test suite; minor improvements to render suite; refactor image saving into test lib compare function; fix for Haiku build

Browse source
This commit is contained in:
Andreas Schiffler 2012-12-26 22:26:44 -08:00
parent d9a9083464
commit 9ddb1f459d
6 changed files with 636 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/SDL_test_images.h
View file

@ -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 */

22
src/test/SDL_test_compare.c
View file

@ -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;
}

3
test/Makefile.in
View file

@ -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

147
test/testautomation_render.c
View file

@ -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 );
return TEST_COMPLETED;
/* Clean up. */
if (referenceSurface != NULL) {
SDL_FreeSurface(referenceSurface);
referenceSurface = NULL;
}
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);
}
}
/**

4
test/testautomation_suites.h
View file

@ -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

519
test/testautomation_surface.c Normal file
View file

@ -0,0 +1,519 @@
/**
* Original code: automated SDL surface test written by Edgar Simo "bobbens"
* Adapted/rewritten for test lib by Andreas Schiffler
*/
#include <stdio.h>
#include <sys/stat.h>
#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
};