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