testautomation_surface.c (20674B)
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 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 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 */ 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 };