test/testautomation_surface.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 25 Apr 2013 00:26:17 -0700
changeset 7110 2a98852fd58d
parent 6822 18f6818ba281
child 7172 b3569dff1c6e
permissions -rw-r--r--
Fixed bug 1582 - Allow disabling SDL_VIDEO_DRIVER_WINDOWS

Marcus von Appen

Trying to build SDL 2.x (HG) on Win32 platforms with either VS.NET or MinGW requires one to have the video subsystem and SDL_VIDEO_DRIVER_WINDOWS flag enabled due to the helper window creation routines.

The attached patch changes the helper window creation behaviour, so that one can build SDL2 without the video subsystem or Windows video drivers on Win32 platforms.
aschiffler@6773
     1
/**
aschiffler@6773
     2
 * Original code: automated SDL surface test written by Edgar Simo "bobbens"
aschiffler@6773
     3
 * Adapted/rewritten for test lib by Andreas Schiffler
aschiffler@6773
     4
 */
aschiffler@6773
     5
aschiffler@6780
     6
/* Supress C4996 VS compiler warnings for unlink() */
aschiffler@6811
     7
#define _CRT_SECURE_NO_DEPRECATE
aschiffler@6780
     8
#define _CRT_NONSTDC_NO_DEPRECATE
aschiffler@6780
     9
aschiffler@6773
    10
#include <stdio.h>
aschiffler@6773
    11
#include <sys/stat.h>
aschiffler@6773
    12
aschiffler@6773
    13
#include "SDL.h"
aschiffler@6773
    14
#include "SDL_test.h"
aschiffler@6773
    15
aschiffler@6773
    16
/* ================= Test Case Implementation ================== */
aschiffler@6773
    17
aschiffler@6773
    18
/* Shared test surface */
aschiffler@6773
    19
aschiffler@6779
    20
static SDL_Surface *referenceSurface = NULL;
aschiffler@6779
    21
static SDL_Surface *testSurface = NULL;
aschiffler@6779
    22
aschiffler@6779
    23
/* Helper functions for the test cases */
aschiffler@6779
    24
aschiffler@6779
    25
#define TEST_SURFACE_WIDTH testSurface->w
aschiffler@6779
    26
#define TEST_SURFACE_HEIGHT testSurface->h
aschiffler@6773
    27
aschiffler@6773
    28
/* Fixture */
aschiffler@6773
    29
aschiffler@6811
    30
/* Create a 32-bit writable surface for blitting tests */
aschiffler@6773
    31
void
aschiffler@6773
    32
_surfaceSetUp(void *arg)
aschiffler@6773
    33
{
aschiffler@6811
    34
    int result;
aschiffler@6811
    35
    SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
aschiffler@6811
    36
    SDL_BlendMode currentBlendMode;
aschiffler@6811
    37
    Uint32 rmask, gmask, bmask, amask;
aschiffler@6811
    38
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
aschiffler@6811
    39
    rmask = 0xff000000;
aschiffler@6811
    40
    gmask = 0x00ff0000;
aschiffler@6811
    41
    bmask = 0x0000ff00;
aschiffler@6811
    42
    amask = 0x000000ff;
aschiffler@6811
    43
#else
aschiffler@6811
    44
    rmask = 0x000000ff;
aschiffler@6811
    45
    gmask = 0x0000ff00;
aschiffler@6811
    46
    bmask = 0x00ff0000;
aschiffler@6811
    47
    amask = 0xff000000;
aschiffler@6811
    48
#endif
aschiffler@6811
    49
aschiffler@6811
    50
    referenceSurface = SDLTest_ImageBlit(); /* For size info */
aschiffler@6811
    51
    testSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, referenceSurface->w, referenceSurface->h, 32, rmask, gmask, bmask, amask);
aschiffler@6779
    52
    SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL");
aschiffler@6811
    53
    if (testSurface != NULL) {
aschiffler@6811
    54
      /* Disable blend mode for target surface */
aschiffler@6811
    55
      result = SDL_SetSurfaceBlendMode(testSurface, blendMode);
aschiffler@6811
    56
      SDLTest_AssertCheck(result == 0, "Validate result from SDL_SetSurfaceBlendMode, expected: 0, got: %i", result);
aschiffler@6811
    57
      result = SDL_GetSurfaceBlendMode(testSurface, &currentBlendMode);
aschiffler@6811
    58
      SDLTest_AssertCheck(result == 0, "Validate result from SDL_GetSurfaceBlendMode, expected: 0, got: %i", result);
aschiffler@6811
    59
      SDLTest_AssertCheck(currentBlendMode == blendMode, "Validate blendMode, expected: %i, got: %i", blendMode, currentBlendMode);      
aschiffler@6811
    60
    }
aschiffler@6773
    61
}
aschiffler@6773
    62
aschiffler@6773
    63
void
aschiffler@6773
    64
_surfaceTearDown(void *arg)
aschiffler@6773
    65
{
aschiffler@6779
    66
	if (referenceSurface != NULL) {
aschiffler@6779
    67
		SDL_FreeSurface(referenceSurface);
aschiffler@6779
    68
		referenceSurface = NULL;
aschiffler@6779
    69
	}
aschiffler@6779
    70
	if (testSurface != NULL) {
aschiffler@6779
    71
		SDL_FreeSurface(testSurface);
aschiffler@6779
    72
		testSurface = NULL;
aschiffler@6773
    73
	}
aschiffler@6773
    74
}
aschiffler@6773
    75
aschiffler@6773
    76
/**
aschiffler@6773
    77
 * Helper that clears the test surface
aschiffler@6773
    78
 */
aschiffler@6773
    79
void _clearTestSurface()
aschiffler@6773
    80
{
aschiffler@6773
    81
	int ret;
aschiffler@6773
    82
	Uint32 color;
aschiffler@6811
    83
aschiffler@6773
    84
	/* Clear surface. */
aschiffler@6811
    85
	color = SDL_MapRGBA( testSurface->format, 0, 0, 0, 0);
aschiffler@6811
    86
	SDLTest_AssertPass("Call to SDL_MapRGBA()");
aschiffler@6779
    87
	ret = SDL_FillRect( testSurface, NULL, color);
aschiffler@6773
    88
	SDLTest_AssertPass("Call to SDL_FillRect()");
aschiffler@6773
    89
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_FillRect, expected: 0, got: %i", ret);
aschiffler@6773
    90
}
aschiffler@6773
    91
aschiffler@6773
    92
/**
aschiffler@6773
    93
 * Helper that blits in a specific blend mode, -1 for basic blitting, -2 for color mod, -3 for alpha mod, -4 for mixed blend modes.
aschiffler@6773
    94
 */
aschiffler@6773
    95
void _testBlitBlendMode(int mode)
aschiffler@6773
    96
{
aschiffler@6773
    97
	int ret;
aschiffler@6773
    98
	int i, j, ni, nj;
aschiffler@6773
    99
	SDL_Surface *face;
aschiffler@6773
   100
	SDL_Rect rect;
aschiffler@6773
   101
	int nmode;
aschiffler@6779
   102
	SDL_BlendMode bmode;
aschiffler@6773
   103
	int checkFailCount1;
aschiffler@6773
   104
	int checkFailCount2;
aschiffler@6773
   105
	int checkFailCount3;
aschiffler@6773
   106
	int checkFailCount4;
aschiffler@6773
   107
aschiffler@6773
   108
	/* Check test surface */
aschiffler@6779
   109
	SDLTest_AssertCheck(testSurface != NULL, "Verify testSurface is not NULL");
aschiffler@6779
   110
	if (testSurface == NULL) return;
aschiffler@6773
   111
	
aschiffler@6773
   112
	/* Create sample surface */
aschiffler@6773
   113
	face = SDLTest_ImageFace();
aschiffler@6773
   114
	SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
aschiffler@6773
   115
	if (face == NULL) return;
aschiffler@6773
   116
aschiffler@6811
   117
        /* Reset alpha modulation */	
aschiffler@6811
   118
	ret = SDL_SetSurfaceAlphaMod(face, 255);
aschiffler@6811
   119
	SDLTest_AssertPass("Call to SDL_SetSurfaceAlphaMod()");
aschiffler@6811
   120
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceAlphaMod(), expected: 0, got: %i", ret);
aschiffler@6811
   121
aschiffler@6811
   122
        /* Reset color modulation */	
aschiffler@6811
   123
	ret = SDL_SetSurfaceColorMod(face, 255, 255, 255);
aschiffler@6811
   124
	SDLTest_AssertPass("Call to SDL_SetSurfaceColorMod()");
aschiffler@6811
   125
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorMod(), expected: 0, got: %i", ret);
aschiffler@6811
   126
aschiffler@6811
   127
        /* Reset color key */	
aschiffler@6811
   128
	ret = SDL_SetColorKey(face, SDL_FALSE, 0);
aschiffler@6811
   129
	SDLTest_AssertPass("Call to SDL_SetColorKey()");
aschiffler@6811
   130
	SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey(), expected: 0, got: %i", ret);
aschiffler@6811
   131
aschiffler@6773
   132
	/* Clear the test surface */
aschiffler@6773
   133
        _clearTestSurface();
aschiffler@6773
   134
        
aschiffler@6773
   135
	/* Target rect size */
aschiffler@6773
   136
	rect.w = face->w;
aschiffler@6773
   137
	rect.h = face->h;
aschiffler@6773
   138
	
aschiffler@6773
   139
	/* Steps to take */
aschiffler@6779
   140
	ni = testSurface->w - face->w;
aschiffler@6779
   141
	nj = testSurface->h - face->h;
aschiffler@6773
   142
aschiffler@6773
   143
	/* Optionally set blend mode. */
aschiffler@6773
   144
	if (mode >= 0) {
aschiffler@6773
   145
		ret = SDL_SetSurfaceBlendMode( face, (SDL_BlendMode)mode );
aschiffler@6773
   146
		SDLTest_AssertPass("Call to SDL_SetSurfaceBlendMode()");
aschiffler@6773
   147
		SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceBlendMode(..., %i), expected: 0, got: %i", mode, ret);
aschiffler@6773
   148
	}
aschiffler@6773
   149
	
aschiffler@6773
   150
	/* Test blend mode. */
aschiffler@6773
   151
	checkFailCount1 = 0;
aschiffler@6773
   152
	checkFailCount2 = 0;
aschiffler@6773
   153
	checkFailCount3 = 0;
aschiffler@6773
   154
	checkFailCount4 = 0;
aschiffler@6773
   155
	for (j=0; j <= nj; j+=4) {
aschiffler@6773
   156
	  for (i=0; i <= ni; i+=4) {
aschiffler@6773
   157
	  	if (mode == -2) {
aschiffler@6773
   158
			/* Set colour mod. */
aschiffler@6773
   159
			ret = SDL_SetSurfaceColorMod( face, (255/nj)*j, (255/ni)*i, (255/nj)*j );
aschiffler@6773
   160
			if (ret != 0) checkFailCount2++;
aschiffler@6773
   161
		}
aschiffler@6773
   162
	  	else if (mode == -3) {
aschiffler@6773
   163
	  		/* Set alpha mod. */
aschiffler@6773
   164
			ret = SDL_SetSurfaceAlphaMod( face, (255/ni)*i );
aschiffler@6773
   165
			if (ret != 0) checkFailCount3++;
aschiffler@6773
   166
		}
aschiffler@6773
   167
		else if (mode == -4) {
aschiffler@6773
   168
			/* Crazy blending mode magic. */
aschiffler@6773
   169
			nmode = (i/4*j/4) % 4;
aschiffler@6811
   170
			if (nmode==0) {
aschiffler@6811
   171
				bmode = SDL_BLENDMODE_NONE;
aschiffler@6811
   172
			} else if (nmode==1) {
aschiffler@6811
   173
				bmode = SDL_BLENDMODE_BLEND;
aschiffler@6811
   174
			} else if (nmode==2) {
aschiffler@6811
   175
				bmode = SDL_BLENDMODE_ADD;				
aschiffler@6811
   176
			} else if (nmode==3) {
aschiffler@6811
   177
				bmode = SDL_BLENDMODE_MOD;
aschiffler@6811
   178
			}
aschiffler@6811
   179
			ret = SDL_SetSurfaceBlendMode( face, bmode );
aschiffler@6773
   180
			if (ret != 0) checkFailCount4++;
aschiffler@6773
   181
		}
aschiffler@6773
   182
aschiffler@6773
   183
		 /* Blitting. */
aschiffler@6773
   184
		 rect.x = i;
aschiffler@6773
   185
		 rect.y = j;
aschiffler@6779
   186
		 ret = SDL_BlitSurface( face, NULL, testSurface, &rect );
aschiffler@6773
   187
		 if (ret != 0) checkFailCount1++;
aschiffler@6773
   188
	  }
aschiffler@6773
   189
	}
aschiffler@6773
   190
	SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_BlitSurface, expected: 0, got: %i", checkFailCount1);
aschiffler@6773
   191
	SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetSurfaceColorMod, expected: 0, got: %i", checkFailCount2);
aschiffler@6773
   192
	SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetSurfaceAlphaMod, expected: 0, got: %i", checkFailCount3);
aschiffler@6773
   193
	SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_SetSurfaceBlendMode, expected: 0, got: %i", checkFailCount4);
aschiffler@6773
   194
	
aschiffler@6773
   195
	/* Clean up */
aschiffler@6773
   196
	if (face != NULL) {
aschiffler@6773
   197
		SDL_FreeSurface(face);
aschiffler@6773
   198
		face = NULL;
aschiffler@6773
   199
	}
aschiffler@6773
   200
}
aschiffler@6773
   201
aschiffler@6773
   202
/* Helper to check that a file exists */
aschiffler@6773
   203
void
aschiffler@6773
   204
_AssertFileExist(const char *filename)
aschiffler@6773
   205
{
aschiffler@6773
   206
	struct stat st;
aschiffler@6773
   207
	int ret = stat(filename, &st);
aschiffler@6773
   208
aschiffler@6773
   209
	SDLTest_AssertCheck(ret == 0, "Verify file '%s' exists", filename);
aschiffler@6773
   210
}
aschiffler@6773
   211
aschiffler@6773
   212
aschiffler@6773
   213
/* Test case functions */
aschiffler@6773
   214
aschiffler@6773
   215
/**
aschiffler@6773
   216
 * @brief Tests sprite saving and loading
aschiffler@6773
   217
 */
aschiffler@6773
   218
int
aschiffler@6773
   219
surface_testSaveLoadBitmap(void *arg)
aschiffler@6773
   220
{
aschiffler@6773
   221
    int ret;
aschiffler@6773
   222
    const char *sampleFilename = "testSaveLoadBitmap.bmp";
aschiffler@6773
   223
    SDL_Surface *face;
aschiffler@6773
   224
    SDL_Surface *rface;
aschiffler@6773
   225
aschiffler@6773
   226
    /* Create sample surface */
aschiffler@6773
   227
    face = SDLTest_ImageFace();
aschiffler@6773
   228
    SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
aschiffler@6779
   229
    if (face == NULL) return TEST_ABORTED;
aschiffler@6773
   230
aschiffler@6773
   231
    /* Delete test file; ignore errors */
aschiffler@6773
   232
    unlink(sampleFilename);
aschiffler@6773
   233
aschiffler@6773
   234
    /* Save a surface */
aschiffler@6773
   235
    ret = SDL_SaveBMP(face, sampleFilename);
aschiffler@6773
   236
    SDLTest_AssertPass("Call to SDL_SaveBMP()");
aschiffler@6773
   237
    SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SaveBMP, expected: 0, got: %i", ret); 
aschiffler@6773
   238
    _AssertFileExist(sampleFilename);
aschiffler@6773
   239
    	
aschiffler@6773
   240
    /* Load a surface */
aschiffler@6773
   241
    rface = SDL_LoadBMP(sampleFilename);
aschiffler@6773
   242
    SDLTest_AssertPass("Call to SDL_LoadBMP()");
aschiffler@6773
   243
    SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_LoadBMP is not NULL");
aschiffler@6773
   244
    if (rface != NULL) {
aschiffler@6773
   245
	    SDLTest_AssertCheck(face->w == rface->w, "Verify width of loaded surface, expected: %i, got: %i", face->w, rface->w);
aschiffler@6773
   246
	    SDLTest_AssertCheck(face->h == rface->h, "Verify height of loaded surface, expected: %i, got: %i", face->h, rface->h);
aschiffler@6773
   247
    }
aschiffler@6773
   248
aschiffler@6773
   249
    /* Delete test file; ignore errors */
aschiffler@6773
   250
    unlink(sampleFilename);
aschiffler@6773
   251
aschiffler@6773
   252
    /* Clean up */
aschiffler@6773
   253
    if (face != NULL) {
aschiffler@6773
   254
	SDL_FreeSurface(face);
aschiffler@6773
   255
	face = NULL;
aschiffler@6773
   256
    }
aschiffler@6773
   257
    if (rface != NULL) {
aschiffler@6773
   258
	SDL_FreeSurface(rface);
aschiffler@6773
   259
	rface = NULL;
aschiffler@6773
   260
    }
aschiffler@6773
   261
    
aschiffler@6773
   262
    return TEST_COMPLETED;
aschiffler@6773
   263
}
aschiffler@6773
   264
aschiffler@6773
   265
/*!
aschiffler@6773
   266
 *  Tests surface conversion.
aschiffler@6773
   267
 */
aschiffler@6773
   268
int
aschiffler@6773
   269
surface_testSurfaceConversion(void *arg)
aschiffler@6773
   270
{
aschiffler@6773
   271
	SDL_Surface *rface = NULL, *face = NULL;
aschiffler@6773
   272
	int ret = 0;
aschiffler@6773
   273
aschiffler@6773
   274
	/* Create sample surface */
aschiffler@6773
   275
	face = SDLTest_ImageFace();
aschiffler@6773
   276
	SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
aschiffler@6773
   277
	if (face == NULL) 
aschiffler@6773
   278
		return TEST_ABORTED;
aschiffler@6773
   279
aschiffler@6773
   280
	/* Set transparent pixel as the pixel at (0,0) */
aschiffler@6773
   281
	if (face->format->palette) {
aschiffler@6773
   282
	   ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
aschiffler@6773
   283
	   SDLTest_AssertPass("Call to SDL_SetColorKey()");
aschiffler@6773
   284
	   SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
aschiffler@6773
   285
	}
aschiffler@6773
   286
aschiffler@6773
   287
	/* Convert to 32 bit to compare. */
aschiffler@6779
   288
	rface = SDL_ConvertSurface( face, testSurface->format, 0 );
aschiffler@6773
   289
	SDLTest_AssertPass("Call to SDL_ConvertSurface()");
aschiffler@6773
   290
	SDLTest_AssertCheck(rface != NULL, "Verify result from SDL_ConvertSurface is not NULL");
aschiffler@6773
   291
aschiffler@6773
   292
	/* Compare surface. */
aschiffler@6773
   293
	ret = SDLTest_CompareSurfaces( rface, face, 0 );
aschiffler@6773
   294
	SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   295
	
aschiffler@6773
   296
	/* Clean up. */
aschiffler@6773
   297
	if (face != NULL) {
aschiffler@6773
   298
		SDL_FreeSurface( face );
aschiffler@6773
   299
		face = NULL;
aschiffler@6773
   300
	}
aschiffler@6773
   301
	if (rface != NULL) {
aschiffler@6773
   302
		SDL_FreeSurface( rface );
aschiffler@6773
   303
		rface = NULL;
aschiffler@6773
   304
	}	
aschiffler@6773
   305
aschiffler@6773
   306
	return TEST_COMPLETED;
aschiffler@6773
   307
}
aschiffler@6773
   308
aschiffler@6773
   309
aschiffler@6773
   310
/**
aschiffler@6773
   311
 * @brief Tests sprite loading. A failure case.
aschiffler@6773
   312
 */
aschiffler@6773
   313
int
aschiffler@6773
   314
surface_testLoadFailure(void *arg)
aschiffler@6773
   315
{
aschiffler@6773
   316
	SDL_Surface *face = SDL_LoadBMP("nonexistant.bmp");
aschiffler@6773
   317
	SDLTest_AssertCheck(face == NULL, "SDL_CreateLoadBmp");
aschiffler@6773
   318
aschiffler@6773
   319
	return TEST_COMPLETED;
aschiffler@6773
   320
}
aschiffler@6773
   321
aschiffler@6773
   322
/**
aschiffler@6773
   323
 * @brief Tests some blitting routines.
aschiffler@6773
   324
 */
aschiffler@6773
   325
int
aschiffler@6773
   326
surface_testBlit(void *arg)
aschiffler@6773
   327
{
aschiffler@6773
   328
   int ret;
aschiffler@6822
   329
   SDL_Surface *compareSurface;
aschiffler@6773
   330
aschiffler@6773
   331
   /* Basic blitting */ 
aschiffler@6773
   332
   _testBlitBlendMode(-1);
aschiffler@6773
   333
   
aschiffler@6773
   334
   /* Verify result by comparing surfaces */
aschiffler@6822
   335
   compareSurface = SDLTest_ImageBlit();
aschiffler@6822
   336
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   337
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   338
   
aschiffler@6773
   339
   /* Clean up. */
aschiffler@6822
   340
   if (compareSurface != NULL) {   
aschiffler@6822
   341
   	SDL_FreeSurface( compareSurface );
aschiffler@6773
   342
   }
aschiffler@6773
   343
aschiffler@6773
   344
   return TEST_COMPLETED;
aschiffler@6773
   345
}
aschiffler@6773
   346
aschiffler@6773
   347
/**
aschiffler@6773
   348
 * @brief Tests some blitting routines with color mod
aschiffler@6773
   349
 */
aschiffler@6773
   350
int
aschiffler@6773
   351
surface_testBlitColorMod(void *arg)
aschiffler@6773
   352
{
aschiffler@6773
   353
   int ret;
aschiffler@6822
   354
   SDL_Surface *compareSurface;
aschiffler@6773
   355
aschiffler@6773
   356
   /* Basic blitting with color mod */ 
aschiffler@6773
   357
   _testBlitBlendMode(-2);
aschiffler@6773
   358
   
aschiffler@6773
   359
   /* Verify result by comparing surfaces */
aschiffler@6822
   360
   compareSurface = SDLTest_ImageBlitColor();
aschiffler@6822
   361
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   362
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   363
   
aschiffler@6773
   364
   /* Clean up. */
aschiffler@6822
   365
   if (compareSurface != NULL) {   
aschiffler@6822
   366
   	SDL_FreeSurface( compareSurface );
aschiffler@6773
   367
   }
aschiffler@6773
   368
aschiffler@6773
   369
   return TEST_COMPLETED;
aschiffler@6773
   370
}
aschiffler@6773
   371
aschiffler@6773
   372
/**
aschiffler@6773
   373
 * @brief Tests some blitting routines with alpha mod
aschiffler@6773
   374
 */
aschiffler@6773
   375
int
aschiffler@6773
   376
surface_testBlitAlphaMod(void *arg)
aschiffler@6773
   377
{
aschiffler@6773
   378
   int ret;
aschiffler@6822
   379
   SDL_Surface *compareSurface;
aschiffler@6773
   380
aschiffler@6773
   381
   /* Basic blitting with alpha mod */ 
aschiffler@6773
   382
   _testBlitBlendMode(-3);
aschiffler@6773
   383
   
aschiffler@6773
   384
   /* Verify result by comparing surfaces */
aschiffler@6822
   385
   compareSurface = SDLTest_ImageBlitAlpha();
aschiffler@6822
   386
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   387
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   388
   
aschiffler@6773
   389
   /* Clean up. */
aschiffler@6822
   390
   if (compareSurface != NULL) {   
aschiffler@6822
   391
   	SDL_FreeSurface( compareSurface );
aschiffler@6773
   392
   }
aschiffler@6773
   393
aschiffler@6773
   394
   return TEST_COMPLETED;
aschiffler@6773
   395
}
aschiffler@6773
   396
aschiffler@6773
   397
aschiffler@6773
   398
/**
aschiffler@6773
   399
 * @brief Tests some more blitting routines.
aschiffler@6773
   400
 */
aschiffler@6773
   401
int
aschiffler@6773
   402
surface_testBlitBlendNone(void *arg)
aschiffler@6773
   403
{
aschiffler@6773
   404
   int ret;
aschiffler@6822
   405
   SDL_Surface *compareSurface;
aschiffler@6773
   406
aschiffler@6773
   407
   /* Basic blitting */ 
aschiffler@6773
   408
   _testBlitBlendMode(SDL_BLENDMODE_NONE);
aschiffler@6773
   409
   
aschiffler@6773
   410
   /* Verify result by comparing surfaces */
aschiffler@6822
   411
   compareSurface = SDLTest_ImageBlitBlendNone();
aschiffler@6822
   412
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   413
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   414
   
aschiffler@6773
   415
   /* Clean up. */
aschiffler@6822
   416
   if (compareSurface != NULL) {   
aschiffler@6822
   417
   	SDL_FreeSurface( compareSurface );
aschiffler@6773
   418
   }
aschiffler@6773
   419
aschiffler@6773
   420
   return TEST_COMPLETED;
aschiffler@6773
   421
}
aschiffler@6773
   422
aschiffler@6773
   423
/**
aschiffler@6773
   424
 * @brief Tests some more blitting routines.
aschiffler@6773
   425
 */
aschiffler@6773
   426
int
aschiffler@6773
   427
surface_testBlitBlendBlend(void *arg)
aschiffler@6773
   428
{
aschiffler@6773
   429
   int ret;
aschiffler@6822
   430
   SDL_Surface *compareSurface;
aschiffler@6773
   431
aschiffler@6773
   432
   /* Blend blitting */ 
aschiffler@6773
   433
   _testBlitBlendMode(SDL_BLENDMODE_BLEND);
aschiffler@6773
   434
   
aschiffler@6773
   435
   /* Verify result by comparing surfaces */
aschiffler@6822
   436
   compareSurface = SDLTest_ImageBlitBlend();
aschiffler@6822
   437
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   438
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   439
   
aschiffler@6773
   440
   /* Clean up. */
aschiffler@6822
   441
   if (compareSurface != NULL) {   
aschiffler@6822
   442
   	SDL_FreeSurface( compareSurface );
aschiffler@6773
   443
   }
aschiffler@6773
   444
aschiffler@6773
   445
   return TEST_COMPLETED;
aschiffler@6773
   446
}
aschiffler@6773
   447
aschiffler@6773
   448
/**
aschiffler@6773
   449
 * @brief Tests some more blitting routines.
aschiffler@6773
   450
 */
aschiffler@6773
   451
int
aschiffler@6773
   452
surface_testBlitBlendAdd(void *arg)
aschiffler@6773
   453
{
aschiffler@6773
   454
   int ret;
aschiffler@6822
   455
   SDL_Surface *compareSurface;
aschiffler@6773
   456
aschiffler@6773
   457
   /* Add blitting */ 
aschiffler@6773
   458
   _testBlitBlendMode(SDL_BLENDMODE_ADD);
aschiffler@6773
   459
   
aschiffler@6773
   460
   /* Verify result by comparing surfaces */
aschiffler@6822
   461
   compareSurface = SDLTest_ImageBlitBlendAdd();
aschiffler@6822
   462
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   463
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   464
   
aschiffler@6773
   465
   /* Clean up. */
aschiffler@6822
   466
   if (compareSurface != NULL) {   
aschiffler@6822
   467
   	SDL_FreeSurface( compareSurface );
aschiffler@6773
   468
   }
aschiffler@6773
   469
aschiffler@6773
   470
   return TEST_COMPLETED;
aschiffler@6773
   471
}
aschiffler@6773
   472
aschiffler@6773
   473
/**
aschiffler@6773
   474
 * @brief Tests some more blitting routines.
aschiffler@6773
   475
 */
aschiffler@6773
   476
int
aschiffler@6773
   477
surface_testBlitBlendMod(void *arg)
aschiffler@6773
   478
{
aschiffler@6773
   479
   int ret;
aschiffler@6822
   480
   SDL_Surface *compareSurface;
aschiffler@6773
   481
aschiffler@6773
   482
   /* Mod blitting */ 
aschiffler@6773
   483
   _testBlitBlendMode(SDL_BLENDMODE_MOD);
aschiffler@6773
   484
   
aschiffler@6773
   485
   /* Verify result by comparing surfaces */
aschiffler@6822
   486
   compareSurface = SDLTest_ImageBlitBlendMod();
aschiffler@6822
   487
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   488
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   489
   
aschiffler@6773
   490
   /* Clean up. */
aschiffler@6822
   491
   if (compareSurface != NULL) {   
aschiffler@6822
   492
   	  SDL_FreeSurface( compareSurface );
aschiffler@6773
   493
   }
aschiffler@6773
   494
aschiffler@6773
   495
   return TEST_COMPLETED;
aschiffler@6773
   496
}
aschiffler@6773
   497
aschiffler@6773
   498
/**
aschiffler@6773
   499
 * @brief Tests some more blitting routines with loop
aschiffler@6773
   500
 */
aschiffler@6773
   501
int
aschiffler@6773
   502
surface_testBlitBlendLoop(void *arg) {
aschiffler@6773
   503
aschiffler@6773
   504
   int ret;
aschiffler@6822
   505
   SDL_Surface *compareSurface;
aschiffler@6773
   506
aschiffler@6811
   507
   /* All blitting modes */ 
aschiffler@6773
   508
   _testBlitBlendMode(-4);
aschiffler@6773
   509
   
aschiffler@6773
   510
   /* Verify result by comparing surfaces */
aschiffler@6822
   511
   compareSurface = SDLTest_ImageBlitBlendAll();
aschiffler@6822
   512
   ret = SDLTest_CompareSurfaces( testSurface, compareSurface, 0 );
aschiffler@6773
   513
   SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
aschiffler@6773
   514
   
aschiffler@6773
   515
   /* Clean up. */
aschiffler@6822
   516
   if (compareSurface != NULL) {   
aschiffler@6822
   517
   	 SDL_FreeSurface(compareSurface);
aschiffler@6773
   518
   }
aschiffler@6773
   519
aschiffler@6773
   520
   return TEST_COMPLETED;
aschiffler@6773
   521
aschiffler@6773
   522
}
aschiffler@6773
   523
aschiffler@6773
   524
/* ================= Test References ================== */
aschiffler@6773
   525
aschiffler@6773
   526
/* Surface test cases */
aschiffler@6773
   527
static const SDLTest_TestCaseReference surfaceTest1 =
aschiffler@6773
   528
		{ (SDLTest_TestCaseFp)surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED};
aschiffler@6773
   529
aschiffler@6773
   530
static const SDLTest_TestCaseReference surfaceTest2 =
aschiffler@6773
   531
		{ (SDLTest_TestCaseFp)surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED};
aschiffler@6773
   532
aschiffler@6773
   533
static const SDLTest_TestCaseReference surfaceTest3 =
aschiffler@6773
   534
		{ (SDLTest_TestCaseFp)surface_testBlitBlendNone, "surface_testBlitBlendNone", "Tests blitting routines with none blending mode.", TEST_ENABLED};
aschiffler@6773
   535
aschiffler@6773
   536
static const SDLTest_TestCaseReference surfaceTest4 =
aschiffler@6773
   537
		{ (SDLTest_TestCaseFp)surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED};
aschiffler@6773
   538
aschiffler@6773
   539
static const SDLTest_TestCaseReference surfaceTest5 =
aschiffler@6773
   540
		{ (SDLTest_TestCaseFp)surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED};
aschiffler@6773
   541
aschiffler@6773
   542
static const SDLTest_TestCaseReference surfaceTest6 =
aschiffler@6773
   543
		{ (SDLTest_TestCaseFp)surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED};
aschiffler@6773
   544
aschiffler@6773
   545
static const SDLTest_TestCaseReference surfaceTest7 =
aschiffler@6773
   546
		{ (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED};
aschiffler@6773
   547
aschiffler@6773
   548
static const SDLTest_TestCaseReference surfaceTest8 =
aschiffler@6773
   549
		{ (SDLTest_TestCaseFp)surface_testBlitBlendLoop, "surface_testBlitBlendLoop", "Test blittin routines with verious blending modes", TEST_ENABLED};
aschiffler@6773
   550
aschiffler@6773
   551
static const SDLTest_TestCaseReference surfaceTest9 =
aschiffler@6773
   552
		{ (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_ENABLED};
aschiffler@6773
   553
aschiffler@6773
   554
static const SDLTest_TestCaseReference surfaceTest10 =
aschiffler@6773
   555
		{ (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_ENABLED};
aschiffler@6773
   556
aschiffler@6773
   557
static const SDLTest_TestCaseReference surfaceTest11 =
aschiffler@6773
   558
		{ (SDLTest_TestCaseFp)surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED};
aschiffler@6773
   559
aschiffler@6773
   560
/* Sequence of Surface test cases */
aschiffler@6773
   561
static const SDLTest_TestCaseReference *surfaceTests[] =  {
aschiffler@6773
   562
	&surfaceTest1, &surfaceTest2, &surfaceTest3, &surfaceTest4, &surfaceTest5,
aschiffler@6773
   563
	&surfaceTest6, &surfaceTest7, &surfaceTest8, &surfaceTest9, &surfaceTest10, &surfaceTest11, NULL
aschiffler@6773
   564
};
aschiffler@6773
   565
aschiffler@6773
   566
/* Surface test suite (global) */
aschiffler@6773
   567
SDLTest_TestSuiteReference surfaceTestSuite = {
aschiffler@6773
   568
	"Surface",
aschiffler@6773
   569
	_surfaceSetUp,
aschiffler@6773
   570
	surfaceTests,
aschiffler@6773
   571
	_surfaceTearDown
aschiffler@6773
   572
aschiffler@6773
   573
};