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