testautomation_pixels.c (18303B)
1 /** 2 * Pixels test suite 3 */ 4 5 #include <stdio.h> 6 7 #include "SDL.h" 8 #include "SDL_test.h" 9 10 /* Test case functions */ 11 12 /* Definition of all RGB formats used to test pixel conversions */ 13 const int _numRGBPixelFormats = 31; 14 Uint32 _RGBPixelFormats[] = 15 { 16 SDL_PIXELFORMAT_INDEX1LSB, 17 SDL_PIXELFORMAT_INDEX1MSB, 18 SDL_PIXELFORMAT_INDEX4LSB, 19 SDL_PIXELFORMAT_INDEX4MSB, 20 SDL_PIXELFORMAT_INDEX8, 21 SDL_PIXELFORMAT_RGB332, 22 SDL_PIXELFORMAT_RGB444, 23 SDL_PIXELFORMAT_BGR444, 24 SDL_PIXELFORMAT_RGB555, 25 SDL_PIXELFORMAT_BGR555, 26 SDL_PIXELFORMAT_ARGB4444, 27 SDL_PIXELFORMAT_RGBA4444, 28 SDL_PIXELFORMAT_ABGR4444, 29 SDL_PIXELFORMAT_BGRA4444, 30 SDL_PIXELFORMAT_ARGB1555, 31 SDL_PIXELFORMAT_RGBA5551, 32 SDL_PIXELFORMAT_ABGR1555, 33 SDL_PIXELFORMAT_BGRA5551, 34 SDL_PIXELFORMAT_RGB565, 35 SDL_PIXELFORMAT_BGR565, 36 SDL_PIXELFORMAT_RGB24, 37 SDL_PIXELFORMAT_BGR24, 38 SDL_PIXELFORMAT_RGB888, 39 SDL_PIXELFORMAT_RGBX8888, 40 SDL_PIXELFORMAT_BGR888, 41 SDL_PIXELFORMAT_BGRX8888, 42 SDL_PIXELFORMAT_ARGB8888, 43 SDL_PIXELFORMAT_RGBA8888, 44 SDL_PIXELFORMAT_ABGR8888, 45 SDL_PIXELFORMAT_BGRA8888, 46 SDL_PIXELFORMAT_ARGB2101010 47 }; 48 char* _RGBPixelFormatsVerbose[] = 49 { 50 "SDL_PIXELFORMAT_INDEX1LSB", 51 "SDL_PIXELFORMAT_INDEX1MSB", 52 "SDL_PIXELFORMAT_INDEX4LSB", 53 "SDL_PIXELFORMAT_INDEX4MSB", 54 "SDL_PIXELFORMAT_INDEX8", 55 "SDL_PIXELFORMAT_RGB332", 56 "SDL_PIXELFORMAT_RGB444", 57 "SDL_PIXELFORMAT_BGR444", 58 "SDL_PIXELFORMAT_RGB555", 59 "SDL_PIXELFORMAT_BGR555", 60 "SDL_PIXELFORMAT_ARGB4444", 61 "SDL_PIXELFORMAT_RGBA4444", 62 "SDL_PIXELFORMAT_ABGR4444", 63 "SDL_PIXELFORMAT_BGRA4444", 64 "SDL_PIXELFORMAT_ARGB1555", 65 "SDL_PIXELFORMAT_RGBA5551", 66 "SDL_PIXELFORMAT_ABGR1555", 67 "SDL_PIXELFORMAT_BGRA5551", 68 "SDL_PIXELFORMAT_RGB565", 69 "SDL_PIXELFORMAT_BGR565", 70 "SDL_PIXELFORMAT_RGB24", 71 "SDL_PIXELFORMAT_BGR24", 72 "SDL_PIXELFORMAT_RGB888", 73 "SDL_PIXELFORMAT_RGBX8888", 74 "SDL_PIXELFORMAT_BGR888", 75 "SDL_PIXELFORMAT_BGRX8888", 76 "SDL_PIXELFORMAT_ARGB8888", 77 "SDL_PIXELFORMAT_RGBA8888", 78 "SDL_PIXELFORMAT_ABGR8888", 79 "SDL_PIXELFORMAT_BGRA8888", 80 "SDL_PIXELFORMAT_ARGB2101010" 81 }; 82 83 /* Definition of all Non-RGB formats used to test pixel conversions */ 84 const int _numNonRGBPixelFormats = 7; 85 Uint32 _nonRGBPixelFormats[] = 86 { 87 SDL_PIXELFORMAT_YV12, 88 SDL_PIXELFORMAT_IYUV, 89 SDL_PIXELFORMAT_YUY2, 90 SDL_PIXELFORMAT_UYVY, 91 SDL_PIXELFORMAT_YVYU, 92 SDL_PIXELFORMAT_NV12, 93 SDL_PIXELFORMAT_NV21 94 }; 95 char* _nonRGBPixelFormatsVerbose[] = 96 { 97 "SDL_PIXELFORMAT_YV12", 98 "SDL_PIXELFORMAT_IYUV", 99 "SDL_PIXELFORMAT_YUY2", 100 "SDL_PIXELFORMAT_UYVY", 101 "SDL_PIXELFORMAT_YVYU", 102 "SDL_PIXELFORMAT_NV12", 103 "SDL_PIXELFORMAT_NV21" 104 }; 105 106 /* Definition of some invalid formats for negative tests */ 107 const int _numInvalidPixelFormats = 2; 108 Uint32 _invalidPixelFormats[] = 109 { 110 0xfffffffe, 111 0xffffffff 112 }; 113 char* _invalidPixelFormatsVerbose[] = 114 { 115 "SDL_PIXELFORMAT_UNKNOWN", 116 "SDL_PIXELFORMAT_UNKNOWN" 117 }; 118 119 /* Test case functions */ 120 121 /** 122 * @brief Call to SDL_AllocFormat and SDL_FreeFormat 123 * 124 * @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocFormat 125 * @sa http://wiki.libsdl.org/moin.fcg/SDL_FreeFormat 126 */ 127 int 128 pixels_allocFreeFormat(void *arg) 129 { 130 const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN"; 131 const char *expectedError = "Parameter 'format' is invalid"; 132 const char *error; 133 int i; 134 Uint32 format; 135 Uint32 masks; 136 SDL_PixelFormat* result; 137 138 /* Blank/unknown format */ 139 format = 0; 140 SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format); 141 142 /* Allocate format */ 143 result = SDL_AllocFormat(format); 144 SDLTest_AssertPass("Call to SDL_AllocFormat()"); 145 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 146 if (result != NULL) { 147 SDLTest_AssertCheck(result->format == format, "Verify value of result.format; expected: %u, got %u", format, result->format); 148 SDLTest_AssertCheck(result->BitsPerPixel == 0, "Verify value of result.BitsPerPixel; expected: 0, got %u", result->BitsPerPixel); 149 SDLTest_AssertCheck(result->BytesPerPixel == 0, "Verify value of result.BytesPerPixel; expected: 0, got %u", result->BytesPerPixel); 150 masks = result->Rmask | result->Gmask | result->Bmask | result->Amask; 151 SDLTest_AssertCheck(masks == 0, "Verify value of result.[RGBA]mask combined; expected: 0, got %u", masks); 152 153 /* Deallocate again */ 154 SDL_FreeFormat(result); 155 SDLTest_AssertPass("Call to SDL_FreeFormat()"); 156 } 157 158 /* RGB formats */ 159 for (i = 0; i < _numRGBPixelFormats; i++) { 160 format = _RGBPixelFormats[i]; 161 SDLTest_Log("RGB Format: %s (%u)", _RGBPixelFormatsVerbose[i], format); 162 163 /* Allocate format */ 164 result = SDL_AllocFormat(format); 165 SDLTest_AssertPass("Call to SDL_AllocFormat()"); 166 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 167 if (result != NULL) { 168 SDLTest_AssertCheck(result->format == format, "Verify value of result.format; expected: %u, got %u", format, result->format); 169 SDLTest_AssertCheck(result->BitsPerPixel > 0, "Verify value of result.BitsPerPixel; expected: >0, got %u", result->BitsPerPixel); 170 SDLTest_AssertCheck(result->BytesPerPixel > 0, "Verify value of result.BytesPerPixel; expected: >0, got %u", result->BytesPerPixel); 171 if (result->palette != NULL) { 172 masks = result->Rmask | result->Gmask | result->Bmask | result->Amask; 173 SDLTest_AssertCheck(masks > 0, "Verify value of result.[RGBA]mask combined; expected: >0, got %u", masks); 174 } 175 176 /* Deallocate again */ 177 SDL_FreeFormat(result); 178 SDLTest_AssertPass("Call to SDL_FreeFormat()"); 179 } 180 } 181 182 /* Non-RGB formats */ 183 for (i = 0; i < _numNonRGBPixelFormats; i++) { 184 format = _nonRGBPixelFormats[i]; 185 SDLTest_Log("non-RGB Format: %s (%u)", _nonRGBPixelFormatsVerbose[i], format); 186 187 /* Try to allocate format */ 188 result = SDL_AllocFormat(format); 189 SDLTest_AssertPass("Call to SDL_AllocFormat()"); 190 SDLTest_AssertCheck(result == NULL, "Verify result is NULL"); 191 } 192 193 /* Negative cases */ 194 195 /* Invalid Formats */ 196 for (i = 0; i < _numInvalidPixelFormats; i++) { 197 SDL_ClearError(); 198 SDLTest_AssertPass("Call to SDL_ClearError()"); 199 format = _invalidPixelFormats[i]; 200 result = SDL_AllocFormat(format); 201 SDLTest_AssertPass("Call to SDL_AllocFormat(%u)", format); 202 SDLTest_AssertCheck(result == NULL, "Verify result is NULL"); 203 error = SDL_GetError(); 204 SDLTest_AssertPass("Call to SDL_GetError()"); 205 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 206 if (error != NULL) { 207 SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 208 "Validate error message, expected: '%s', got: '%s'", expectedError, error); 209 } 210 } 211 212 /* Invalid free pointer */ 213 SDL_ClearError(); 214 SDLTest_AssertPass("Call to SDL_ClearError()"); 215 SDL_FreeFormat(NULL); 216 SDLTest_AssertPass("Call to SDL_FreeFormat(NULL)"); 217 error = SDL_GetError(); 218 SDLTest_AssertPass("Call to SDL_GetError()"); 219 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 220 if (error != NULL) { 221 SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 222 "Validate error message, expected: '%s', got: '%s'", expectedError, error); 223 } 224 225 return TEST_COMPLETED; 226 } 227 228 /** 229 * @brief Call to SDL_GetPixelFormatName 230 * 231 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetPixelFormatName 232 */ 233 int 234 pixels_getPixelFormatName(void *arg) 235 { 236 const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN"; 237 const char *error; 238 int i; 239 Uint32 format; 240 char* result; 241 242 /* Blank/undefined format */ 243 format = 0; 244 SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format); 245 246 /* Get name of format */ 247 result = (char *)SDL_GetPixelFormatName(format); 248 SDLTest_AssertPass("Call to SDL_GetPixelFormatName()"); 249 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 250 if (result != NULL) { 251 SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty"); 252 SDLTest_AssertCheck(SDL_strcmp(result, unknownFormat) == 0, 253 "Verify result text; expected: %s, got %s", unknownFormat, result); 254 } 255 256 /* RGB formats */ 257 for (i = 0; i < _numRGBPixelFormats; i++) { 258 format = _RGBPixelFormats[i]; 259 SDLTest_Log("RGB Format: %s (%u)", _RGBPixelFormatsVerbose[i], format); 260 261 /* Get name of format */ 262 result = (char *)SDL_GetPixelFormatName(format); 263 SDLTest_AssertPass("Call to SDL_GetPixelFormatName()"); 264 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 265 if (result != NULL) { 266 SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty"); 267 SDLTest_AssertCheck(SDL_strcmp(result, _RGBPixelFormatsVerbose[i]) == 0, 268 "Verify result text; expected: %s, got %s", _RGBPixelFormatsVerbose[i], result); 269 } 270 } 271 272 /* Non-RGB formats */ 273 for (i = 0; i < _numNonRGBPixelFormats; i++) { 274 format = _nonRGBPixelFormats[i]; 275 SDLTest_Log("non-RGB Format: %s (%u)", _nonRGBPixelFormatsVerbose[i], format); 276 277 /* Get name of format */ 278 result = (char *)SDL_GetPixelFormatName(format); 279 SDLTest_AssertPass("Call to SDL_GetPixelFormatName()"); 280 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 281 if (result != NULL) { 282 SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty"); 283 SDLTest_AssertCheck(SDL_strcmp(result, _nonRGBPixelFormatsVerbose[i]) == 0, 284 "Verify result text; expected: %s, got %s", _nonRGBPixelFormatsVerbose[i], result); 285 } 286 } 287 288 /* Negative cases */ 289 290 /* Invalid Formats */ 291 SDL_ClearError(); 292 SDLTest_AssertPass("Call to SDL_ClearError()"); 293 for (i = 0; i < _numInvalidPixelFormats; i++) { 294 format = _invalidPixelFormats[i]; 295 result = (char *)SDL_GetPixelFormatName(format); 296 SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%u)", format); 297 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 298 if (result != NULL) { 299 SDLTest_AssertCheck(result[0] != '\0', 300 "Verify result is non-empty; got: %s", result); 301 SDLTest_AssertCheck(SDL_strcmp(result, _invalidPixelFormatsVerbose[i]) == 0, 302 "Validate name is UNKNOWN, expected: '%s', got: '%s'", _invalidPixelFormatsVerbose[i], result); 303 } 304 error = SDL_GetError(); 305 SDLTest_AssertPass("Call to SDL_GetError()"); 306 SDLTest_AssertCheck(error == NULL || error[0] == '\0', "Validate that error message is empty"); 307 } 308 309 return TEST_COMPLETED; 310 } 311 312 /** 313 * @brief Call to SDL_AllocPalette and SDL_FreePalette 314 * 315 * @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocPalette 316 * @sa http://wiki.libsdl.org/moin.fcg/SDL_FreePalette 317 */ 318 int 319 pixels_allocFreePalette(void *arg) 320 { 321 const char *expectedError1 = "Parameter 'ncolors' is invalid"; 322 const char *expectedError2 = "Parameter 'palette' is invalid"; 323 const char *error; 324 int variation; 325 int i; 326 int ncolors; 327 SDL_Palette* result; 328 329 /* Allocate palette */ 330 for (variation = 1; variation <= 3; variation++) { 331 switch (variation) { 332 /* Just one color */ 333 case 1: 334 ncolors = 1; 335 break; 336 /* Two colors */ 337 case 2: 338 ncolors = 2; 339 break; 340 /* More than two colors */ 341 case 3: 342 ncolors = SDLTest_RandomIntegerInRange(8, 16); 343 break; 344 } 345 346 result = SDL_AllocPalette(ncolors); 347 SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors); 348 SDLTest_AssertCheck(result != NULL, "Verify result is not NULL"); 349 if (result != NULL) { 350 SDLTest_AssertCheck(result->ncolors == ncolors, "Verify value of result.ncolors; expected: %u, got %u", ncolors, result->ncolors); 351 if (result->ncolors > 0) { 352 SDLTest_AssertCheck(result->colors != NULL, "Verify value of result.colors is not NULL"); 353 if (result->colors != NULL) { 354 for(i = 0; i < result->ncolors; i++) { 355 SDLTest_AssertCheck(result->colors[i].r == 255, "Verify value of result.colors[%d].r; expected: 255, got %u", i, result->colors[i].r); 356 SDLTest_AssertCheck(result->colors[i].g == 255, "Verify value of result.colors[%d].g; expected: 255, got %u", i, result->colors[i].g); 357 SDLTest_AssertCheck(result->colors[i].b == 255, "Verify value of result.colors[%d].b; expected: 255, got %u", i, result->colors[i].b); 358 } 359 } 360 } 361 362 /* Deallocate again */ 363 SDL_FreePalette(result); 364 SDLTest_AssertPass("Call to SDL_FreePalette()"); 365 } 366 } 367 368 /* Negative cases */ 369 370 /* Invalid number of colors */ 371 for (ncolors = 0; ncolors > -3; ncolors--) { 372 SDL_ClearError(); 373 SDLTest_AssertPass("Call to SDL_ClearError()"); 374 result = SDL_AllocPalette(ncolors); 375 SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors); 376 SDLTest_AssertCheck(result == NULL, "Verify result is NULL"); 377 error = SDL_GetError(); 378 SDLTest_AssertPass("Call to SDL_GetError()"); 379 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 380 if (error != NULL) { 381 SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0, 382 "Validate error message, expected: '%s', got: '%s'", expectedError1, error); 383 } 384 } 385 386 /* Invalid free pointer */ 387 SDL_ClearError(); 388 SDLTest_AssertPass("Call to SDL_ClearError()"); 389 SDL_FreePalette(NULL); 390 SDLTest_AssertPass("Call to SDL_FreePalette(NULL)"); 391 error = SDL_GetError(); 392 SDLTest_AssertPass("Call to SDL_GetError()"); 393 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 394 if (error != NULL) { 395 SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0, 396 "Validate error message, expected: '%s', got: '%s'", expectedError2, error); 397 } 398 399 return TEST_COMPLETED; 400 } 401 402 /** 403 * @brief Call to SDL_CalculateGammaRamp 404 * 405 * @sa http://wiki.libsdl.org/moin.fcg/SDL_CalculateGammaRamp 406 */ 407 int 408 pixels_calcGammaRamp(void *arg) 409 { 410 const char *expectedError1 = "Parameter 'gamma' is invalid"; 411 const char *expectedError2 = "Parameter 'ramp' is invalid"; 412 const char *error; 413 float gamma; 414 Uint16 *ramp; 415 int variation; 416 int i; 417 int changed; 418 Uint16 magic = 0xbeef; 419 420 /* Allocate temp ramp array and fill with some value */ 421 ramp = (Uint16 *)SDL_malloc(256 * sizeof(Uint16)); 422 SDLTest_AssertCheck(ramp != NULL, "Validate temp ramp array could be allocated"); 423 if (ramp == NULL) return TEST_ABORTED; 424 425 /* Make call with different gamma values */ 426 for (variation = 0; variation < 4; variation++) { 427 switch (variation) { 428 /* gamma = 0 all black */ 429 case 0: 430 gamma = 0.0f; 431 break; 432 /* gamma = 1 identity */ 433 case 1: 434 gamma = 1.0f; 435 break; 436 /* gamma = [0.2,0.8] normal range */ 437 case 2: 438 gamma = 0.2f + 0.8f * SDLTest_RandomUnitFloat(); 439 break; 440 /* gamma = >1.1 non-standard range */ 441 case 3: 442 gamma = 1.1f + SDLTest_RandomUnitFloat(); 443 break; 444 } 445 446 /* Make call and check that values were updated */ 447 for (i = 0; i < 256; i++) ramp[i] = magic; 448 SDL_CalculateGammaRamp(gamma, ramp); 449 SDLTest_AssertPass("Call to SDL_CalculateGammaRamp(%f)", gamma); 450 changed = 0; 451 for (i = 0; i < 256; i++) if (ramp[i] != magic) changed++; 452 SDLTest_AssertCheck(changed > 250, "Validate that ramp was calculated; expected: >250 values changed, got: %d values changed", changed); 453 454 /* Additional value checks for some cases */ 455 i = SDLTest_RandomIntegerInRange(64,192); 456 switch (variation) { 457 case 0: 458 SDLTest_AssertCheck(ramp[i] == 0, "Validate value at position %d; expected: 0, got: %d", i, ramp[i]); 459 break; 460 case 1: 461 SDLTest_AssertCheck(ramp[i] == ((i << 8) | i), "Validate value at position %d; expected: %d, got: %d", i, (i << 8) | i, ramp[i]); 462 break; 463 case 2: 464 case 3: 465 SDLTest_AssertCheck(ramp[i] > 0, "Validate value at position %d; expected: >0, got: %d", i, ramp[i]); 466 break; 467 } 468 } 469 470 /* Negative cases */ 471 SDL_ClearError(); 472 SDLTest_AssertPass("Call to SDL_ClearError()"); 473 gamma = -1; 474 for (i=0; i<256; i++) ramp[i] = magic; 475 SDL_CalculateGammaRamp(gamma, ramp); 476 SDLTest_AssertPass("Call to SDL_CalculateGammaRamp(%f)", gamma); 477 error = SDL_GetError(); 478 SDLTest_AssertPass("Call to SDL_GetError()"); 479 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 480 if (error != NULL) { 481 SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0, 482 "Validate error message, expected: '%s', got: '%s'", expectedError1, error); 483 } 484 changed = 0; 485 for (i = 0; i < 256; i++) if (ramp[i] != magic) changed++; 486 SDLTest_AssertCheck(changed ==0, "Validate that ramp unchanged; expected: 0 values changed got: %d values changed", changed); 487 488 SDL_CalculateGammaRamp(0.5f, NULL); 489 SDLTest_AssertPass("Call to SDL_CalculateGammaRamp(0.5,NULL)"); 490 error = SDL_GetError(); 491 SDLTest_AssertPass("Call to SDL_GetError()"); 492 SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL"); 493 if (error != NULL) { 494 SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0, 495 "Validate error message, expected: '%s', got: '%s'", expectedError2, error); 496 } 497 498 /* Cleanup */ 499 SDL_free(ramp); 500 501 502 return TEST_COMPLETED; 503 } 504 505 /* ================= Test References ================== */ 506 507 /* Pixels test cases */ 508 static const SDLTest_TestCaseReference pixelsTest1 = 509 { (SDLTest_TestCaseFp)pixels_allocFreeFormat, "pixels_allocFreeFormat", "Call to SDL_AllocFormat and SDL_FreeFormat", TEST_ENABLED }; 510 511 static const SDLTest_TestCaseReference pixelsTest2 = 512 { (SDLTest_TestCaseFp)pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_AllocPalette and SDL_FreePalette", TEST_ENABLED }; 513 514 static const SDLTest_TestCaseReference pixelsTest3 = 515 { (SDLTest_TestCaseFp)pixels_calcGammaRamp, "pixels_calcGammaRamp", "Call to SDL_CalculateGammaRamp", TEST_ENABLED }; 516 517 static const SDLTest_TestCaseReference pixelsTest4 = 518 { (SDLTest_TestCaseFp)pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED }; 519 520 /* Sequence of Pixels test cases */ 521 static const SDLTest_TestCaseReference *pixelsTests[] = { 522 &pixelsTest1, &pixelsTest2, &pixelsTest3, &pixelsTest4, NULL 523 }; 524 525 /* Pixels test suite (global) */ 526 SDLTest_TestSuiteReference pixelsTestSuite = { 527 "Pixels", 528 NULL, 529 pixelsTests, 530 NULL 531 };