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