testautomation_video.c (65630B)
1 /** 2 * Video test suite 3 */ 4 5 #include <stdio.h> 6 #include <string.h> 7 8 /* Visual Studio 2008 doesn't have stdint.h */ 9 #if defined(_MSC_VER) && _MSC_VER <= 1500 10 #define UINT8_MAX ~(Uint8)0 11 #define UINT16_MAX ~(Uint16)0 12 #define UINT32_MAX ~(Uint32)0 13 #define UINT64_MAX ~(Uint64)0 14 #else 15 #include <stdint.h> 16 #endif 17 18 #include "SDL.h" 19 #include "SDL_test.h" 20 21 /* Private helpers */ 22 23 /* 24 * Create a test window 25 */ 26 SDL_Window *_createVideoSuiteTestWindow(const char *title) 27 { 28 SDL_Window* window; 29 int x, y, w, h; 30 SDL_WindowFlags flags; 31 32 /* Standard window */ 33 x = SDLTest_RandomIntegerInRange(1, 100); 34 y = SDLTest_RandomIntegerInRange(1, 100); 35 w = SDLTest_RandomIntegerInRange(320, 1024); 36 h = SDLTest_RandomIntegerInRange(320, 768); 37 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS; 38 39 window = SDL_CreateWindow(title, x, y, w, h, flags); 40 SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d)", x, y, w, h, flags); 41 SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL"); 42 43 return window; 44 } 45 46 /* 47 * Destroy test window 48 */ 49 void _destroyVideoSuiteTestWindow(SDL_Window *window) 50 { 51 if (window != NULL) { 52 SDL_DestroyWindow(window); 53 window = NULL; 54 SDLTest_AssertPass("Call to SDL_DestroyWindow()"); 55 } 56 } 57 58 /* Test case functions */ 59 60 /** 61 * @brief Enable and disable screensaver while checking state 62 */ 63 int 64 video_enableDisableScreensaver(void *arg) 65 { 66 SDL_bool initialResult; 67 SDL_bool result; 68 69 /* Get current state and proceed according to current state */ 70 initialResult = SDL_IsScreenSaverEnabled(); 71 SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()"); 72 if (initialResult == SDL_TRUE) { 73 74 /* Currently enabled: disable first, then enable again */ 75 76 /* Disable screensaver and check */ 77 SDL_DisableScreenSaver(); 78 SDLTest_AssertPass("Call to SDL_DisableScreenSaver()"); 79 result = SDL_IsScreenSaverEnabled(); 80 SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()"); 81 SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result); 82 83 /* Enable screensaver and check */ 84 SDL_EnableScreenSaver(); 85 SDLTest_AssertPass("Call to SDL_EnableScreenSaver()"); 86 result = SDL_IsScreenSaverEnabled(); 87 SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()"); 88 SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result); 89 90 } else { 91 92 /* Currently disabled: enable first, then disable again */ 93 94 /* Enable screensaver and check */ 95 SDL_EnableScreenSaver(); 96 SDLTest_AssertPass("Call to SDL_EnableScreenSaver()"); 97 result = SDL_IsScreenSaverEnabled(); 98 SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()"); 99 SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result); 100 101 /* Disable screensaver and check */ 102 SDL_DisableScreenSaver(); 103 SDLTest_AssertPass("Call to SDL_DisableScreenSaver()"); 104 result = SDL_IsScreenSaverEnabled(); 105 SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()"); 106 SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result); 107 } 108 109 return TEST_COMPLETED; 110 } 111 112 /** 113 * @brief Tests the functionality of the SDL_CreateWindow function using different positions 114 */ 115 int 116 video_createWindowVariousPositions(void *arg) 117 { 118 SDL_Window* window; 119 const char* title = "video_createWindowVariousPositions Test Window"; 120 int x, y, w, h; 121 int xVariation, yVariation; 122 123 for (xVariation = 0; xVariation < 6; xVariation++) { 124 for (yVariation = 0; yVariation < 6; yVariation++) { 125 switch(xVariation) { 126 case 0: 127 /* Zero X Position */ 128 x = 0; 129 break; 130 case 1: 131 /* Random X position inside screen */ 132 x = SDLTest_RandomIntegerInRange(1, 100); 133 break; 134 case 2: 135 /* Random X position outside screen (positive) */ 136 x = SDLTest_RandomIntegerInRange(10000, 11000); 137 break; 138 case 3: 139 /* Random X position outside screen (negative) */ 140 x = SDLTest_RandomIntegerInRange(-1000, -100); 141 break; 142 case 4: 143 /* Centered X position */ 144 x = SDL_WINDOWPOS_CENTERED; 145 break; 146 case 5: 147 /* Undefined X position */ 148 x = SDL_WINDOWPOS_UNDEFINED; 149 break; 150 } 151 152 switch(yVariation) { 153 case 0: 154 /* Zero X Position */ 155 y = 0; 156 break; 157 case 1: 158 /* Random X position inside screen */ 159 y = SDLTest_RandomIntegerInRange(1, 100); 160 break; 161 case 2: 162 /* Random X position outside screen (positive) */ 163 y = SDLTest_RandomIntegerInRange(10000, 11000); 164 break; 165 case 3: 166 /* Random Y position outside screen (negative) */ 167 y = SDLTest_RandomIntegerInRange(-1000, -100); 168 break; 169 case 4: 170 /* Centered Y position */ 171 y = SDL_WINDOWPOS_CENTERED; 172 break; 173 case 5: 174 /* Undefined Y position */ 175 y = SDL_WINDOWPOS_UNDEFINED; 176 break; 177 } 178 179 w = SDLTest_RandomIntegerInRange(32, 96); 180 h = SDLTest_RandomIntegerInRange(32, 96); 181 window = SDL_CreateWindow(title, x, y, w, h, SDL_WINDOW_SHOWN); 182 SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h); 183 SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL"); 184 185 /* Clean up */ 186 _destroyVideoSuiteTestWindow(window); 187 } 188 } 189 190 return TEST_COMPLETED; 191 } 192 193 /** 194 * @brief Tests the functionality of the SDL_CreateWindow function using different sizes 195 */ 196 int 197 video_createWindowVariousSizes(void *arg) 198 { 199 SDL_Window* window; 200 const char* title = "video_createWindowVariousSizes Test Window"; 201 int x, y, w, h; 202 int wVariation, hVariation; 203 204 x = SDLTest_RandomIntegerInRange(1, 100); 205 y = SDLTest_RandomIntegerInRange(1, 100); 206 for (wVariation = 0; wVariation < 3; wVariation++) { 207 for (hVariation = 0; hVariation < 3; hVariation++) { 208 switch(wVariation) { 209 case 0: 210 /* Width of 1 */ 211 w = 1; 212 break; 213 case 1: 214 /* Random "normal" width */ 215 w = SDLTest_RandomIntegerInRange(320, 1920); 216 break; 217 case 2: 218 /* Random "large" width */ 219 w = SDLTest_RandomIntegerInRange(2048, 4095); 220 break; 221 } 222 223 switch(hVariation) { 224 case 0: 225 /* Height of 1 */ 226 h = 1; 227 break; 228 case 1: 229 /* Random "normal" height */ 230 h = SDLTest_RandomIntegerInRange(320, 1080); 231 break; 232 case 2: 233 /* Random "large" height */ 234 h = SDLTest_RandomIntegerInRange(2048, 4095); 235 break; 236 } 237 238 window = SDL_CreateWindow(title, x, y, w, h, SDL_WINDOW_SHOWN); 239 SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h); 240 SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL"); 241 242 /* Clean up */ 243 _destroyVideoSuiteTestWindow(window); 244 } 245 } 246 247 return TEST_COMPLETED; 248 } 249 250 /** 251 * @brief Tests the functionality of the SDL_CreateWindow function using different flags 252 */ 253 int 254 video_createWindowVariousFlags(void *arg) 255 { 256 SDL_Window* window; 257 const char* title = "video_createWindowVariousFlags Test Window"; 258 int x, y, w, h; 259 int fVariation; 260 SDL_WindowFlags flags; 261 262 /* Standard window */ 263 x = SDLTest_RandomIntegerInRange(1, 100); 264 y = SDLTest_RandomIntegerInRange(1, 100); 265 w = SDLTest_RandomIntegerInRange(320, 1024); 266 h = SDLTest_RandomIntegerInRange(320, 768); 267 268 for (fVariation = 0; fVariation < 13; fVariation++) { 269 switch(fVariation) { 270 case 0: 271 flags = SDL_WINDOW_FULLSCREEN; 272 /* Skip - blanks screen; comment out next line to run test */ 273 continue; 274 break; 275 case 1: 276 flags = SDL_WINDOW_FULLSCREEN_DESKTOP; 277 /* Skip - blanks screen; comment out next line to run test */ 278 continue; 279 break; 280 case 2: 281 flags = SDL_WINDOW_OPENGL; 282 break; 283 case 3: 284 flags = SDL_WINDOW_SHOWN; 285 break; 286 case 4: 287 flags = SDL_WINDOW_HIDDEN; 288 break; 289 case 5: 290 flags = SDL_WINDOW_BORDERLESS; 291 break; 292 case 6: 293 flags = SDL_WINDOW_RESIZABLE; 294 break; 295 case 7: 296 flags = SDL_WINDOW_MINIMIZED; 297 break; 298 case 8: 299 flags = SDL_WINDOW_MAXIMIZED; 300 break; 301 case 9: 302 flags = SDL_WINDOW_INPUT_GRABBED; 303 break; 304 case 10: 305 flags = SDL_WINDOW_INPUT_FOCUS; 306 break; 307 case 11: 308 flags = SDL_WINDOW_MOUSE_FOCUS; 309 break; 310 case 12: 311 flags = SDL_WINDOW_FOREIGN; 312 break; 313 } 314 315 window = SDL_CreateWindow(title, x, y, w, h, flags); 316 SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d)", x, y, w, h, flags); 317 SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL"); 318 319 /* Clean up */ 320 _destroyVideoSuiteTestWindow(window); 321 } 322 323 return TEST_COMPLETED; 324 } 325 326 327 /** 328 * @brief Tests the functionality of the SDL_GetWindowFlags function 329 */ 330 int 331 video_getWindowFlags(void *arg) 332 { 333 SDL_Window* window; 334 const char* title = "video_getWindowFlags Test Window"; 335 SDL_WindowFlags flags; 336 Uint32 actualFlags; 337 338 /* Reliable flag set always set in test window */ 339 flags = SDL_WINDOW_SHOWN; 340 341 /* Call against new test window */ 342 window = _createVideoSuiteTestWindow(title); 343 if (window != NULL) { 344 actualFlags = SDL_GetWindowFlags(window); 345 SDLTest_AssertPass("Call to SDL_GetWindowFlags()"); 346 SDLTest_AssertCheck((flags & actualFlags) == flags, "Verify returned value has flags %d set, got: %d", flags, actualFlags); 347 } 348 349 /* Clean up */ 350 _destroyVideoSuiteTestWindow(window); 351 352 return TEST_COMPLETED; 353 } 354 355 /** 356 * @brief Tests the functionality of the SDL_GetNumDisplayModes function 357 */ 358 int 359 video_getNumDisplayModes(void *arg) 360 { 361 int result; 362 int displayNum; 363 int i; 364 365 /* Get number of displays */ 366 displayNum = SDL_GetNumVideoDisplays(); 367 SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays()"); 368 369 /* Make call for each display */ 370 for (i=0; i<displayNum; i++) { 371 result = SDL_GetNumDisplayModes(i); 372 SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d)", i); 373 SDLTest_AssertCheck(result >= 1, "Validate returned value from function; expected: >=1; got: %d", result); 374 } 375 376 return TEST_COMPLETED; 377 } 378 379 /** 380 * @brief Tests negative call to SDL_GetNumDisplayModes function 381 */ 382 int 383 video_getNumDisplayModesNegative(void *arg) 384 { 385 int result; 386 int displayNum; 387 int displayIndex; 388 389 /* Get number of displays */ 390 displayNum = SDL_GetNumVideoDisplays(); 391 SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays()"); 392 393 /* Invalid boundary values */ 394 displayIndex = SDLTest_RandomSint32BoundaryValue(0, displayNum, SDL_FALSE); 395 result = SDL_GetNumDisplayModes(displayIndex); 396 SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/boundary)", displayIndex); 397 SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result); 398 399 /* Large (out-of-bounds) display index */ 400 displayIndex = SDLTest_RandomIntegerInRange(-2000, -1000); 401 result = SDL_GetNumDisplayModes(displayIndex); 402 SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/large negative)", displayIndex); 403 SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result); 404 405 displayIndex = SDLTest_RandomIntegerInRange(1000, 2000); 406 result = SDL_GetNumDisplayModes(displayIndex); 407 SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/large positive)", displayIndex); 408 SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result); 409 410 return TEST_COMPLETED; 411 } 412 413 /** 414 * @brief Tests the functionality of the SDL_GetClosestDisplayMode function against current resolution 415 */ 416 int 417 video_getClosestDisplayModeCurrentResolution(void *arg) 418 { 419 int result; 420 SDL_DisplayMode current; 421 SDL_DisplayMode target; 422 SDL_DisplayMode closest; 423 SDL_DisplayMode* dResult; 424 int displayNum; 425 int i; 426 int variation; 427 428 /* Get number of displays */ 429 displayNum = SDL_GetNumVideoDisplays(); 430 SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays()"); 431 432 /* Make calls for each display */ 433 for (i=0; i<displayNum; i++) { 434 SDLTest_Log("Testing against display: %d", i); 435 436 /* Get first display mode to get a sane resolution; this should always work */ 437 result = SDL_GetDisplayMode(i, 0, ¤t); 438 SDLTest_AssertPass("Call to SDL_GetDisplayMode()"); 439 SDLTest_AssertCheck(result == 0, "Verify return value, expected: 0, got: %d", result); 440 if (result != 0) { 441 return TEST_ABORTED; 442 } 443 444 /* Set the desired resolution equals to current resolution */ 445 target.w = current.w; 446 target.h = current.h; 447 for (variation = 0; variation < 8; variation ++) { 448 /* Vary constraints on other query parameters */ 449 target.format = (variation & 1) ? current.format : 0; 450 target.refresh_rate = (variation & 2) ? current.refresh_rate : 0; 451 target.driverdata = (variation & 4) ? current.driverdata : 0; 452 453 /* Make call */ 454 dResult = SDL_GetClosestDisplayMode(i, &target, &closest); 455 SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=current/variation%d)", variation); 456 SDLTest_AssertCheck(dResult != NULL, "Verify returned value is not NULL"); 457 458 /* Check that one gets the current resolution back again */ 459 SDLTest_AssertCheck(closest.w == current.w, "Verify returned width matches current width; expected: %d, got: %d", current.w, closest.w); 460 SDLTest_AssertCheck(closest.h == current.h, "Verify returned height matches current height; expected: %d, got: %d", current.h, closest.h); 461 SDLTest_AssertCheck(closest.w == dResult->w, "Verify return value matches assigned value; expected: %d, got: %d", closest.w, dResult->w); 462 SDLTest_AssertCheck(closest.h == dResult->h, "Verify return value matches assigned value; expected: %d, got: %d", closest.h, dResult->h); 463 } 464 } 465 466 return TEST_COMPLETED; 467 } 468 469 /** 470 * @brief Tests the functionality of the SDL_GetClosestDisplayMode function against random resolution 471 */ 472 int 473 video_getClosestDisplayModeRandomResolution(void *arg) 474 { 475 SDL_DisplayMode target; 476 SDL_DisplayMode closest; 477 SDL_DisplayMode* dResult; 478 int displayNum; 479 int i; 480 int variation; 481 482 /* Get number of displays */ 483 displayNum = SDL_GetNumVideoDisplays(); 484 SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays()"); 485 486 /* Make calls for each display */ 487 for (i=0; i<displayNum; i++) { 488 SDLTest_Log("Testing against display: %d", i); 489 490 for (variation = 0; variation < 16; variation ++) { 491 492 /* Set random constraints */ 493 target.w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; 494 target.h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; 495 target.format = (variation & 4) ? SDLTest_RandomIntegerInRange(1, 10) : 0; 496 target.refresh_rate = (variation & 8) ? SDLTest_RandomIntegerInRange(25, 120) : 0; 497 target.driverdata = 0; 498 499 /* Make call; may or may not find anything, so don't validate any further */ 500 dResult = SDL_GetClosestDisplayMode(i, &target, &closest); 501 SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=random/variation%d)", variation); 502 } 503 } 504 505 return TEST_COMPLETED; 506 } 507 508 /** 509 * @brief Tests call to SDL_GetWindowBrightness 510 * 511 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowBrightness 512 */ 513 int 514 video_getWindowBrightness(void *arg) 515 { 516 SDL_Window* window; 517 const char* title = "video_getWindowBrightness Test Window"; 518 float result; 519 520 /* Call against new test window */ 521 window = _createVideoSuiteTestWindow(title); 522 if (window != NULL) { 523 result = SDL_GetWindowBrightness(window); 524 SDLTest_AssertPass("Call to SDL_GetWindowBrightness()"); 525 SDLTest_AssertCheck(result >= 0.0 && result <= 1.0, "Validate range of result value; expected: [0.0, 1.0], got: %f", result); 526 } 527 528 /* Clean up */ 529 _destroyVideoSuiteTestWindow(window); 530 531 return TEST_COMPLETED; 532 } 533 534 /** 535 * @brief Tests call to SDL_GetWindowBrightness with invalid input 536 * 537 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowBrightness 538 */ 539 int 540 video_getWindowBrightnessNegative(void *arg) 541 { 542 const char *invalidWindowError = "Invalid window"; 543 char *lastError; 544 float result; 545 546 /* Call against invalid window */ 547 result = SDL_GetWindowBrightness(NULL); 548 SDLTest_AssertPass("Call to SDL_GetWindowBrightness(window=NULL)"); 549 SDLTest_AssertCheck(result == 1.0, "Validate result value; expected: 1.0, got: %f", result); 550 lastError = (char *)SDL_GetError(); 551 SDLTest_AssertPass("SDL_GetError()"); 552 SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL"); 553 if (lastError != NULL) { 554 SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0, 555 "SDL_GetError(): expected message '%s', was message: '%s'", 556 invalidWindowError, 557 lastError); 558 } 559 560 return TEST_COMPLETED; 561 } 562 563 /** 564 * @brief Tests call to SDL_GetWindowDisplayMode 565 * 566 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode 567 */ 568 int 569 video_getWindowDisplayMode(void *arg) 570 { 571 SDL_Window* window; 572 const char* title = "video_getWindowDisplayMode Test Window"; 573 SDL_DisplayMode mode; 574 int result; 575 576 /* Invalidate part of the mode content so we can check values later */ 577 mode.w = -1; 578 mode.h = -1; 579 mode.refresh_rate = -1; 580 581 /* Call against new test window */ 582 window = _createVideoSuiteTestWindow(title); 583 if (window != NULL) { 584 result = SDL_GetWindowDisplayMode(window, &mode); 585 SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode()"); 586 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 587 SDLTest_AssertCheck(mode.w > 0, "Validate mode.w content; expected: >0, got: %d", mode.w); 588 SDLTest_AssertCheck(mode.h > 0, "Validate mode.h content; expected: >0, got: %d", mode.h); 589 SDLTest_AssertCheck(mode.refresh_rate > 0, "Validate mode.refresh_rate content; expected: >0, got: %d", mode.refresh_rate); 590 } 591 592 /* Clean up */ 593 _destroyVideoSuiteTestWindow(window); 594 595 return TEST_COMPLETED; 596 } 597 598 /* Helper function that checks for an 'Invalid window' error */ 599 void _checkInvalidWindowError() 600 { 601 const char *invalidWindowError = "Invalid window"; 602 char *lastError; 603 604 lastError = (char *)SDL_GetError(); 605 SDLTest_AssertPass("SDL_GetError()"); 606 SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL"); 607 if (lastError != NULL) { 608 SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0, 609 "SDL_GetError(): expected message '%s', was message: '%s'", 610 invalidWindowError, 611 lastError); 612 SDL_ClearError(); 613 SDLTest_AssertPass("Call to SDL_ClearError()"); 614 } 615 } 616 617 /** 618 * @brief Tests call to SDL_GetWindowDisplayMode with invalid input 619 * 620 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode 621 */ 622 int 623 video_getWindowDisplayModeNegative(void *arg) 624 { 625 const char *expectedError = "Parameter 'mode' is invalid"; 626 char *lastError; 627 SDL_Window* window; 628 const char* title = "video_getWindowDisplayModeNegative Test Window"; 629 SDL_DisplayMode mode; 630 int result; 631 632 /* Call against new test window */ 633 window = _createVideoSuiteTestWindow(title); 634 if (window != NULL) { 635 result = SDL_GetWindowDisplayMode(window, NULL); 636 SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(...,mode=NULL)"); 637 SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result); 638 lastError = (char *)SDL_GetError(); 639 SDLTest_AssertPass("SDL_GetError()"); 640 SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL"); 641 if (lastError != NULL) { 642 SDLTest_AssertCheck(SDL_strcmp(lastError, expectedError) == 0, 643 "SDL_GetError(): expected message '%s', was message: '%s'", 644 expectedError, 645 lastError); 646 } 647 } 648 649 /* Clean up */ 650 _destroyVideoSuiteTestWindow(window); 651 652 /* Call against invalid window */ 653 result = SDL_GetWindowDisplayMode(NULL, &mode); 654 SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(window=NULL,...)"); 655 SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result); 656 _checkInvalidWindowError(); 657 658 return TEST_COMPLETED; 659 } 660 661 /** 662 * @brief Tests call to SDL_GetWindowGammaRamp 663 * 664 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp 665 */ 666 int 667 video_getWindowGammaRamp(void *arg) 668 { 669 SDL_Window* window; 670 const char* title = "video_getWindowGammaRamp Test Window"; 671 Uint16 red[256]; 672 Uint16 green[256]; 673 Uint16 blue[256]; 674 int result; 675 676 /* Call against new test window */ 677 window = _createVideoSuiteTestWindow(title); 678 if (window == NULL) return TEST_ABORTED; 679 680 /* Retrieve no channel */ 681 result = SDL_GetWindowGammaRamp(window, NULL, NULL, NULL); 682 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(all NULL)"); 683 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 684 685 /* Retrieve single channel */ 686 result = SDL_GetWindowGammaRamp(window, red, NULL, NULL); 687 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r)"); 688 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 689 690 result = SDL_GetWindowGammaRamp(window, NULL, green, NULL); 691 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(g)"); 692 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 693 694 result = SDL_GetWindowGammaRamp(window, NULL, NULL, blue); 695 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(b)"); 696 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 697 698 /* Retrieve two channels */ 699 result = SDL_GetWindowGammaRamp(window, red, green, NULL); 700 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r, g)"); 701 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 702 703 result = SDL_GetWindowGammaRamp(window, NULL, green, blue); 704 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(g,b)"); 705 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 706 707 result = SDL_GetWindowGammaRamp(window, red, NULL, blue); 708 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r,b)"); 709 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 710 711 /* Retrieve all channels */ 712 result = SDL_GetWindowGammaRamp(window, red, green, blue); 713 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r,g,b)"); 714 SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); 715 716 /* Clean up */ 717 _destroyVideoSuiteTestWindow(window); 718 719 return TEST_COMPLETED; 720 } 721 722 /** 723 * @brief Tests call to SDL_GetWindowGammaRamp with invalid input 724 * 725 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp 726 */ 727 int 728 video_getWindowGammaRampNegative(void *arg) 729 { 730 Uint16 red[256]; 731 Uint16 green[256]; 732 Uint16 blue[256]; 733 int result; 734 735 SDL_ClearError(); 736 SDLTest_AssertPass("Call to SDL_ClearError()"); 737 738 /* Call against invalid window */ 739 result = SDL_GetWindowGammaRamp(NULL, red, green, blue); 740 SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(window=NULL,r,g,b)"); 741 SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %i", result); 742 _checkInvalidWindowError(); 743 744 return TEST_COMPLETED; 745 } 746 747 /* Helper for setting and checking the window grab state */ 748 void 749 _setAndCheckWindowGrabState(SDL_Window* window, SDL_bool desiredState) 750 { 751 SDL_bool currentState; 752 753 /* Set state */ 754 SDL_SetWindowGrab(window, desiredState); 755 SDLTest_AssertPass("Call to SDL_SetWindowGrab(%s)", (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE"); 756 757 /* Get and check state */ 758 currentState = SDL_GetWindowGrab(window); 759 SDLTest_AssertPass("Call to SDL_GetWindowGrab()"); 760 SDLTest_AssertCheck( 761 currentState == desiredState, 762 "Validate returned state; expected: %s, got: %s", 763 (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE", 764 (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE"); 765 } 766 767 /** 768 * @brief Tests call to SDL_GetWindowGrab and SDL_SetWindowGrab 769 * 770 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGrab 771 * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowGrab 772 */ 773 int 774 video_getSetWindowGrab(void *arg) 775 { 776 const char* title = "video_getSetWindowGrab Test Window"; 777 SDL_Window* window; 778 SDL_bool originalState, dummyState, currentState, desiredState; 779 780 /* Call against new test window */ 781 window = _createVideoSuiteTestWindow(title); 782 if (window == NULL) return TEST_ABORTED; 783 784 /* Get state */ 785 originalState = SDL_GetWindowGrab(window); 786 SDLTest_AssertPass("Call to SDL_GetWindowGrab()"); 787 788 /* F */ 789 _setAndCheckWindowGrabState(window, SDL_FALSE); 790 791 /* F --> F */ 792 _setAndCheckWindowGrabState(window, SDL_FALSE); 793 794 /* F --> T */ 795 _setAndCheckWindowGrabState(window, SDL_TRUE); 796 797 /* T --> T */ 798 _setAndCheckWindowGrabState(window, SDL_TRUE); 799 800 /* T --> F */ 801 _setAndCheckWindowGrabState(window, SDL_FALSE); 802 803 /* Negative tests */ 804 dummyState = SDL_GetWindowGrab(NULL); 805 SDLTest_AssertPass("Call to SDL_GetWindowGrab(window=NULL)"); 806 _checkInvalidWindowError(); 807 808 SDL_SetWindowGrab(NULL, SDL_FALSE); 809 SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)"); 810 _checkInvalidWindowError(); 811 812 SDL_SetWindowGrab(NULL, SDL_TRUE); 813 SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)"); 814 _checkInvalidWindowError(); 815 816 /* State should still be F */ 817 desiredState = SDL_FALSE; 818 currentState = SDL_GetWindowGrab(window); 819 SDLTest_AssertPass("Call to SDL_GetWindowGrab()"); 820 SDLTest_AssertCheck( 821 currentState == desiredState, 822 "Validate returned state; expected: %s, got: %s", 823 (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE", 824 (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE"); 825 826 /* Restore state */ 827 _setAndCheckWindowGrabState(window, originalState); 828 829 /* Clean up */ 830 _destroyVideoSuiteTestWindow(window); 831 832 return TEST_COMPLETED; 833 } 834 835 836 /** 837 * @brief Tests call to SDL_GetWindowID and SDL_GetWindowFromID 838 * 839 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowID 840 * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowFromID 841 */ 842 int 843 video_getWindowId(void *arg) 844 { 845 const char* title = "video_getWindowId Test Window"; 846 SDL_Window* window; 847 SDL_Window* result; 848 Uint32 id, randomId; 849 850 /* Call against new test window */ 851 window = _createVideoSuiteTestWindow(title); 852 if (window == NULL) return TEST_ABORTED; 853 854 /* Get ID */ 855 id = SDL_GetWindowID(window); 856 SDLTest_AssertPass("Call to SDL_GetWindowID()"); 857 858 /* Get window from ID */ 859 result = SDL_GetWindowFromID(id); 860 SDLTest_AssertPass("Call to SDL_GetWindowID(%d)", id); 861 SDLTest_AssertCheck(result == window, "Verify result matches window pointer"); 862 863 /* Get window from random large ID, no result check */ 864 randomId = SDLTest_RandomIntegerInRange(UINT8_MAX,UINT16_MAX); 865 result = SDL_GetWindowFromID(randomId); 866 SDLTest_AssertPass("Call to SDL_GetWindowID(%d/random_large)", randomId); 867 868 /* Get window from 0 and Uint32 max ID, no result check */ 869 result = SDL_GetWindowFromID(0); 870 SDLTest_AssertPass("Call to SDL_GetWindowID(0)"); 871 result = SDL_GetWindowFromID(UINT32_MAX); 872 SDLTest_AssertPass("Call to SDL_GetWindowID(UINT32_MAX)"); 873 874 /* Clean up */ 875 _destroyVideoSuiteTestWindow(window); 876 877 /* Get window from ID for closed window */ 878 result = SDL_GetWindowFromID(id); 879 SDLTest_AssertPass("Call to SDL_GetWindowID(%d/closed_window)", id); 880 SDLTest_AssertCheck(result == NULL, "Verify result is NULL"); 881 882 /* Negative test */ 883 SDL_ClearError(); 884 SDLTest_AssertPass("Call to SDL_ClearError()"); 885 id = SDL_GetWindowID(NULL); 886 SDLTest_AssertPass("Call to SDL_GetWindowID(window=NULL)"); 887 _checkInvalidWindowError(); 888 889 return TEST_COMPLETED; 890 } 891 892 /** 893 * @brief Tests call to SDL_GetWindowPixelFormat 894 * 895 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPixelFormat 896 */ 897 int 898 video_getWindowPixelFormat(void *arg) 899 { 900 const char* title = "video_getWindowPixelFormat Test Window"; 901 SDL_Window* window; 902 Uint32 format; 903 904 /* Call against new test window */ 905 window = _createVideoSuiteTestWindow(title); 906 if (window == NULL) return TEST_ABORTED; 907 908 /* Get format */ 909 format = SDL_GetWindowPixelFormat(window); 910 SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat()"); 911 SDLTest_AssertCheck(format != SDL_PIXELFORMAT_UNKNOWN, "Verify that returned format is valid; expected: != %d, got: %d", SDL_PIXELFORMAT_UNKNOWN, format); 912 913 /* Clean up */ 914 _destroyVideoSuiteTestWindow(window); 915 916 /* Negative test */ 917 SDL_ClearError(); 918 SDLTest_AssertPass("Call to SDL_ClearError()"); 919 format = SDL_GetWindowPixelFormat(NULL); 920 SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat(window=NULL)"); 921 _checkInvalidWindowError(); 922 923 return TEST_COMPLETED; 924 } 925 926 /** 927 * @brief Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition 928 * 929 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPosition 930 * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowPosition 931 */ 932 int 933 video_getSetWindowPosition(void *arg) 934 { 935 const char* title = "video_getSetWindowPosition Test Window"; 936 SDL_Window* window; 937 int xVariation, yVariation; 938 int referenceX, referenceY; 939 int currentX, currentY; 940 int desiredX, desiredY; 941 942 /* Call against new test window */ 943 window = _createVideoSuiteTestWindow(title); 944 if (window == NULL) return TEST_ABORTED; 945 946 for (xVariation = 0; xVariation < 4; xVariation++) { 947 for (yVariation = 0; yVariation < 4; yVariation++) { 948 switch(xVariation) { 949 case 0: 950 /* Zero X Position */ 951 desiredX = 0; 952 break; 953 case 1: 954 /* Random X position inside screen */ 955 desiredX = SDLTest_RandomIntegerInRange(1, 100); 956 break; 957 case 2: 958 /* Random X position outside screen (positive) */ 959 desiredX = SDLTest_RandomIntegerInRange(10000, 11000); 960 break; 961 case 3: 962 /* Random X position outside screen (negative) */ 963 desiredX = SDLTest_RandomIntegerInRange(-1000, -100); 964 break; 965 } 966 967 switch(yVariation) { 968 case 0: 969 /* Zero X Position */ 970 desiredY = 0; 971 break; 972 case 1: 973 /* Random X position inside screen */ 974 desiredY = SDLTest_RandomIntegerInRange(1, 100); 975 break; 976 case 2: 977 /* Random X position outside screen (positive) */ 978 desiredY = SDLTest_RandomIntegerInRange(10000, 11000); 979 break; 980 case 3: 981 /* Random Y position outside screen (negative) */ 982 desiredY = SDLTest_RandomIntegerInRange(-1000, -100); 983 break; 984 } 985 986 /* Set position */ 987 SDL_SetWindowPosition(window, desiredX, desiredY); 988 SDLTest_AssertPass("Call to SDL_SetWindowPosition(...,%d,%d)", desiredX, desiredY); 989 990 /* Get position */ 991 currentX = desiredX + 1; 992 currentY = desiredY + 1; 993 SDL_GetWindowPosition(window, ¤tX, ¤tY); 994 SDLTest_AssertPass("Call to SDL_GetWindowPosition()"); 995 SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX); 996 SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY); 997 998 /* Get position X */ 999 currentX = desiredX + 1; 1000 SDL_GetWindowPosition(window, ¤tX, NULL); 1001 SDLTest_AssertPass("Call to SDL_GetWindowPosition(&y=NULL)"); 1002 SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX); 1003 1004 /* Get position Y */ 1005 currentY = desiredY + 1; 1006 SDL_GetWindowPosition(window, NULL, ¤tY); 1007 SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL)"); 1008 SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY); 1009 } 1010 } 1011 1012 /* Dummy call with both pointers NULL */ 1013 SDL_GetWindowPosition(window, NULL, NULL); 1014 SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL,&y=NULL)"); 1015 1016 /* Clean up */ 1017 _destroyVideoSuiteTestWindow(window); 1018 1019 /* Set some 'magic' value for later check that nothing was changed */ 1020 referenceX = SDLTest_RandomSint32(); 1021 referenceY = SDLTest_RandomSint32(); 1022 currentX = referenceX; 1023 currentY = referenceY; 1024 desiredX = SDLTest_RandomSint32(); 1025 desiredY = SDLTest_RandomSint32(); 1026 1027 /* Negative tests */ 1028 SDL_ClearError(); 1029 SDLTest_AssertPass("Call to SDL_ClearError()"); 1030 SDL_GetWindowPosition(NULL, ¤tX, ¤tY); 1031 SDLTest_AssertPass("Call to SDL_GetWindowPosition(window=NULL)"); 1032 SDLTest_AssertCheck( 1033 currentX == referenceX && currentY == referenceY, 1034 "Verify that content of X and Y pointers has not been modified; expected: %d,%d; got: %d,%d", 1035 referenceX, referenceY, 1036 currentX, currentY); 1037 _checkInvalidWindowError(); 1038 1039 SDL_GetWindowPosition(NULL, NULL, NULL); 1040 SDLTest_AssertPass("Call to SDL_GetWindowPosition(NULL, NULL, NULL)"); 1041 _checkInvalidWindowError(); 1042 1043 SDL_SetWindowPosition(NULL, desiredX, desiredY); 1044 SDLTest_AssertPass("Call to SDL_SetWindowPosition(window=NULL)"); 1045 _checkInvalidWindowError(); 1046 1047 return TEST_COMPLETED; 1048 } 1049 1050 /* Helper function that checks for an 'Invalid parameter' error */ 1051 void _checkInvalidParameterError() 1052 { 1053 const char *invalidParameterError = "Parameter"; 1054 char *lastError; 1055 1056 lastError = (char *)SDL_GetError(); 1057 SDLTest_AssertPass("SDL_GetError()"); 1058 SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL"); 1059 if (lastError != NULL) { 1060 SDLTest_AssertCheck(SDL_strncmp(lastError, invalidParameterError, SDL_strlen(invalidParameterError)) == 0, 1061 "SDL_GetError(): expected message starts with '%s', was message: '%s'", 1062 invalidParameterError, 1063 lastError); 1064 SDL_ClearError(); 1065 SDLTest_AssertPass("Call to SDL_ClearError()"); 1066 } 1067 } 1068 1069 /** 1070 * @brief Tests call to SDL_GetWindowSize and SDL_SetWindowSize 1071 * 1072 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowSize 1073 * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowSize 1074 */ 1075 int 1076 video_getSetWindowSize(void *arg) 1077 { 1078 const char* title = "video_getSetWindowSize Test Window"; 1079 SDL_Window* window; 1080 int result; 1081 SDL_Rect display; 1082 int maxwVariation, maxhVariation; 1083 int wVariation, hVariation; 1084 int referenceW, referenceH; 1085 int currentW, currentH; 1086 int desiredW, desiredH; 1087 1088 /* Get display bounds for size range */ 1089 result = SDL_GetDisplayBounds(0, &display); 1090 SDLTest_AssertPass("SDL_GetDisplayBounds()"); 1091 SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0, got: %d", result); 1092 if (result != 0) return TEST_ABORTED; 1093 1094 /* Call against new test window */ 1095 window = _createVideoSuiteTestWindow(title); 1096 if (window == NULL) return TEST_ABORTED; 1097 1098 #ifdef __WIN32__ 1099 /* Platform clips window size to screen size */ 1100 maxwVariation = 4; 1101 maxhVariation = 4; 1102 #else 1103 /* Platform allows window size >= screen size */ 1104 maxwVariation = 5; 1105 maxhVariation = 5; 1106 #endif 1107 1108 for (wVariation = 0; wVariation < maxwVariation; wVariation++) { 1109 for (hVariation = 0; hVariation < maxhVariation; hVariation++) { 1110 switch(wVariation) { 1111 case 0: 1112 /* 1 Pixel Wide */ 1113 desiredW = 1; 1114 break; 1115 case 1: 1116 /* Random width inside screen */ 1117 desiredW = SDLTest_RandomIntegerInRange(1, 100); 1118 break; 1119 case 2: 1120 /* Width 1 pixel smaller than screen */ 1121 desiredW = display.w - 1; 1122 break; 1123 case 3: 1124 /* Width at screen size */ 1125 desiredW = display.w; 1126 break; 1127 case 4: 1128 /* Width 1 pixel larger than screen */ 1129 desiredW = display.w + 1; 1130 break; 1131 } 1132 1133 switch(hVariation) { 1134 case 0: 1135 /* 1 Pixel High */ 1136 desiredH = 1; 1137 break; 1138 case 1: 1139 /* Random height inside screen */ 1140 desiredH = SDLTest_RandomIntegerInRange(1, 100); 1141 break; 1142 case 2: 1143 /* Height 1 pixel smaller than screen */ 1144 desiredH = display.h - 1; 1145 break; 1146 case 3: 1147 /* Height at screen size */ 1148 desiredH = display.h; 1149 break; 1150 case 4: 1151 /* Height 1 pixel larger than screen */ 1152 desiredH = display.h + 1; 1153 break; 1154 } 1155 1156 /* Set size */ 1157 SDL_SetWindowSize(window, desiredW, desiredH); 1158 SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH); 1159 1160 /* Get size */ 1161 currentW = desiredW + 1; 1162 currentH = desiredH + 1; 1163 SDL_GetWindowSize(window, ¤tW, ¤tH); 1164 SDLTest_AssertPass("Call to SDL_GetWindowSize()"); 1165 SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW); 1166 SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH); 1167 1168 /* Get just width */ 1169 currentW = desiredW + 1; 1170 SDL_GetWindowSize(window, ¤tW, NULL); 1171 SDLTest_AssertPass("Call to SDL_GetWindowSize(&h=NULL)"); 1172 SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW); 1173 1174 /* Get just height */ 1175 currentH = desiredH + 1; 1176 SDL_GetWindowSize(window, NULL, ¤tH); 1177 SDLTest_AssertPass("Call to SDL_GetWindowSize(&w=NULL)"); 1178 SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH); 1179 } 1180 } 1181 1182 /* Dummy call with both pointers NULL */ 1183 SDL_GetWindowSize(window, NULL, NULL); 1184 SDLTest_AssertPass("Call to SDL_GetWindowSize(&w=NULL,&h=NULL)"); 1185 1186 /* Negative tests for parameter input */ 1187 SDL_ClearError(); 1188 SDLTest_AssertPass("Call to SDL_ClearError()"); 1189 for (desiredH = -2; desiredH < 2; desiredH++) { 1190 for (desiredW = -2; desiredW < 2; desiredW++) { 1191 if (desiredW <= 0 || desiredH <= 0) { 1192 SDL_SetWindowSize(window, desiredW, desiredH); 1193 SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH); 1194 _checkInvalidParameterError(); 1195 } 1196 } 1197 } 1198 1199 /* Clean up */ 1200 _destroyVideoSuiteTestWindow(window); 1201 1202 /* Set some 'magic' value for later check that nothing was changed */ 1203 referenceW = SDLTest_RandomSint32(); 1204 referenceH = SDLTest_RandomSint32(); 1205 currentW = referenceW; 1206 currentH = referenceH; 1207 desiredW = SDLTest_RandomSint32(); 1208 desiredH = SDLTest_RandomSint32(); 1209 1210 /* Negative tests for window input */ 1211 SDL_ClearError(); 1212 SDLTest_AssertPass("Call to SDL_ClearError()"); 1213 SDL_GetWindowSize(NULL, ¤tW, ¤tH); 1214 SDLTest_AssertPass("Call to SDL_GetWindowSize(window=NULL)"); 1215 SDLTest_AssertCheck( 1216 currentW == referenceW && currentH == referenceH, 1217 "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d", 1218 referenceW, referenceH, 1219 currentW, currentH); 1220 _checkInvalidWindowError(); 1221 1222 SDL_GetWindowSize(NULL, NULL, NULL); 1223 SDLTest_AssertPass("Call to SDL_GetWindowSize(NULL, NULL, NULL)"); 1224 _checkInvalidWindowError(); 1225 1226 SDL_SetWindowSize(NULL, desiredW, desiredH); 1227 SDLTest_AssertPass("Call to SDL_SetWindowSize(window=NULL)"); 1228 _checkInvalidWindowError(); 1229 1230 return TEST_COMPLETED; 1231 } 1232 1233 /** 1234 * @brief Tests call to SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize 1235 * 1236 */ 1237 int 1238 video_getSetWindowMinimumSize(void *arg) 1239 { 1240 const char* title = "video_getSetWindowMinimumSize Test Window"; 1241 SDL_Window* window; 1242 int result; 1243 SDL_Rect display; 1244 int wVariation, hVariation; 1245 int referenceW, referenceH; 1246 int currentW, currentH; 1247 int desiredW, desiredH; 1248 1249 /* Get display bounds for size range */ 1250 result = SDL_GetDisplayBounds(0, &display); 1251 SDLTest_AssertPass("SDL_GetDisplayBounds()"); 1252 SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0, got: %d", result); 1253 if (result != 0) return TEST_ABORTED; 1254 1255 /* Call against new test window */ 1256 window = _createVideoSuiteTestWindow(title); 1257 if (window == NULL) return TEST_ABORTED; 1258 1259 for (wVariation = 0; wVariation < 5; wVariation++) { 1260 for (hVariation = 0; hVariation < 5; hVariation++) { 1261 switch(wVariation) { 1262 case 0: 1263 /* 1 Pixel Wide */ 1264 desiredW = 1; 1265 break; 1266 case 1: 1267 /* Random width inside screen */ 1268 desiredW = SDLTest_RandomIntegerInRange(2, display.w - 1); 1269 break; 1270 case 2: 1271 /* Width at screen size */ 1272 desiredW = display.w; 1273 break; 1274 } 1275 1276 switch(hVariation) { 1277 case 0: 1278 /* 1 Pixel High */ 1279 desiredH = 1; 1280 break; 1281 case 1: 1282 /* Random height inside screen */ 1283 desiredH = SDLTest_RandomIntegerInRange(2, display.h - 1); 1284 break; 1285 case 2: 1286 /* Height at screen size */ 1287 desiredH = display.h; 1288 break; 1289 case 4: 1290 /* Height 1 pixel larger than screen */ 1291 desiredH = display.h + 1; 1292 break; 1293 } 1294 1295 /* Set size */ 1296 SDL_SetWindowMinimumSize(window, desiredW, desiredH); 1297 SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH); 1298 1299 /* Get size */ 1300 currentW = desiredW + 1; 1301 currentH = desiredH + 1; 1302 SDL_GetWindowMinimumSize(window, ¤tW, ¤tH); 1303 SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize()"); 1304 SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW); 1305 SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH); 1306 1307 /* Get just width */ 1308 currentW = desiredW + 1; 1309 SDL_GetWindowMinimumSize(window, ¤tW, NULL); 1310 SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&h=NULL)"); 1311 SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentH); 1312 1313 /* Get just height */ 1314 currentH = desiredH + 1; 1315 SDL_GetWindowMinimumSize(window, NULL, ¤tH); 1316 SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&w=NULL)"); 1317 SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredW, currentH); 1318 } 1319 } 1320 1321 /* Dummy call with both pointers NULL */ 1322 SDL_GetWindowMinimumSize(window, NULL, NULL); 1323 SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&w=NULL,&h=NULL)"); 1324 1325 /* Negative tests for parameter input */ 1326 SDL_ClearError(); 1327 SDLTest_AssertPass("Call to SDL_ClearError()"); 1328 for (desiredH = -2; desiredH < 2; desiredH++) { 1329 for (desiredW = -2; desiredW < 2; desiredW++) { 1330 if (desiredW <= 0 || desiredH <= 0) { 1331 SDL_SetWindowMinimumSize(window, desiredW, desiredH); 1332 SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH); 1333 _checkInvalidParameterError(); 1334 } 1335 } 1336 } 1337 1338 /* Clean up */ 1339 _destroyVideoSuiteTestWindow(window); 1340 1341 /* Set some 'magic' value for later check that nothing was changed */ 1342 referenceW = SDLTest_RandomSint32(); 1343 referenceH = SDLTest_RandomSint32(); 1344 currentW = referenceW; 1345 currentH = referenceH; 1346 desiredW = SDLTest_RandomSint32(); 1347 desiredH = SDLTest_RandomSint32(); 1348 1349 /* Negative tests for window input */ 1350 SDL_ClearError(); 1351 SDLTest_AssertPass("Call to SDL_ClearError()"); 1352 SDL_GetWindowMinimumSize(NULL, ¤tW, ¤tH); 1353 SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(window=NULL)"); 1354 SDLTest_AssertCheck( 1355 currentW == referenceW && currentH == referenceH, 1356 "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d", 1357 referenceW, referenceH, 1358 currentW, currentH); 1359 _checkInvalidWindowError(); 1360 1361 SDL_GetWindowMinimumSize(NULL, NULL, NULL); 1362 SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(NULL, NULL, NULL)"); 1363 _checkInvalidWindowError(); 1364 1365 SDL_SetWindowMinimumSize(NULL, desiredW, desiredH); 1366 SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(window=NULL)"); 1367 _checkInvalidWindowError(); 1368 1369 return TEST_COMPLETED; 1370 } 1371 1372 /** 1373 * @brief Tests call to SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize 1374 * 1375 */ 1376 int 1377 video_getSetWindowMaximumSize(void *arg) 1378 { 1379 const char* title = "video_getSetWindowMaximumSize Test Window"; 1380 SDL_Window* window; 1381 int result; 1382 SDL_Rect display; 1383 int wVariation, hVariation; 1384 int referenceW, referenceH; 1385 int currentW, currentH; 1386 int desiredW, desiredH; 1387 1388 /* Get display bounds for size range */ 1389 result = SDL_GetDisplayBounds(0, &display); 1390 SDLTest_AssertPass("SDL_GetDisplayBounds()"); 1391 SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0, got: %d", result); 1392 if (result != 0) return TEST_ABORTED; 1393 1394 /* Call against new test window */ 1395 window = _createVideoSuiteTestWindow(title); 1396 if (window == NULL) return TEST_ABORTED; 1397 1398 for (wVariation = 0; wVariation < 3; wVariation++) { 1399 for (hVariation = 0; hVariation < 3; hVariation++) { 1400 switch(wVariation) { 1401 case 0: 1402 /* 1 Pixel Wide */ 1403 desiredW = 1; 1404 break; 1405 case 1: 1406 /* Random width inside screen */ 1407 desiredW = SDLTest_RandomIntegerInRange(2, display.w - 1); 1408 break; 1409 case 2: 1410 /* Width at screen size */ 1411 desiredW = display.w; 1412 break; 1413 } 1414 1415 switch(hVariation) { 1416 case 0: 1417 /* 1 Pixel High */ 1418 desiredH = 1; 1419 break; 1420 case 1: 1421 /* Random height inside screen */ 1422 desiredH = SDLTest_RandomIntegerInRange(2, display.h - 1); 1423 break; 1424 case 2: 1425 /* Height at screen size */ 1426 desiredH = display.h; 1427 break; 1428 } 1429 1430 /* Set size */ 1431 SDL_SetWindowMaximumSize(window, desiredW, desiredH); 1432 SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH); 1433 1434 /* Get size */ 1435 currentW = desiredW + 1; 1436 currentH = desiredH + 1; 1437 SDL_GetWindowMaximumSize(window, ¤tW, ¤tH); 1438 SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize()"); 1439 SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW); 1440 SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH); 1441 1442 /* Get just width */ 1443 currentW = desiredW + 1; 1444 SDL_GetWindowMaximumSize(window, ¤tW, NULL); 1445 SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&h=NULL)"); 1446 SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentH); 1447 1448 /* Get just height */ 1449 currentH = desiredH + 1; 1450 SDL_GetWindowMaximumSize(window, NULL, ¤tH); 1451 SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&w=NULL)"); 1452 SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredW, currentH); 1453 } 1454 } 1455 1456 /* Dummy call with both pointers NULL */ 1457 SDL_GetWindowMaximumSize(window, NULL, NULL); 1458 SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&w=NULL,&h=NULL)"); 1459 1460 /* Negative tests for parameter input */ 1461 SDL_ClearError(); 1462 SDLTest_AssertPass("Call to SDL_ClearError()"); 1463 for (desiredH = -2; desiredH < 2; desiredH++) { 1464 for (desiredW = -2; desiredW < 2; desiredW++) { 1465 if (desiredW <= 0 || desiredH <= 0) { 1466 SDL_SetWindowMaximumSize(window, desiredW, desiredH); 1467 SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH); 1468 _checkInvalidParameterError(); 1469 } 1470 } 1471 } 1472 1473 /* Clean up */ 1474 _destroyVideoSuiteTestWindow(window); 1475 1476 /* Set some 'magic' value for later check that nothing was changed */ 1477 referenceW = SDLTest_RandomSint32(); 1478 referenceH = SDLTest_RandomSint32(); 1479 currentW = referenceW; 1480 currentH = referenceH; 1481 desiredW = SDLTest_RandomSint32(); 1482 desiredH = SDLTest_RandomSint32(); 1483 1484 /* Negative tests */ 1485 SDL_ClearError(); 1486 SDLTest_AssertPass("Call to SDL_ClearError()"); 1487 SDL_GetWindowMaximumSize(NULL, ¤tW, ¤tH); 1488 SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(window=NULL)"); 1489 SDLTest_AssertCheck( 1490 currentW == referenceW && currentH == referenceH, 1491 "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d", 1492 referenceW, referenceH, 1493 currentW, currentH); 1494 _checkInvalidWindowError(); 1495 1496 SDL_GetWindowMaximumSize(NULL, NULL, NULL); 1497 SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(NULL, NULL, NULL)"); 1498 _checkInvalidWindowError(); 1499 1500 SDL_SetWindowMaximumSize(NULL, desiredW, desiredH); 1501 SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(window=NULL)"); 1502 _checkInvalidWindowError(); 1503 1504 return TEST_COMPLETED; 1505 } 1506 1507 1508 /** 1509 * @brief Tests call to SDL_SetWindowData and SDL_GetWindowData 1510 * 1511 * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowData 1512 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowData 1513 */ 1514 int 1515 video_getSetWindowData(void *arg) 1516 { 1517 int returnValue = TEST_COMPLETED; 1518 const char* title = "video_setGetWindowData Test Window"; 1519 SDL_Window* window; 1520 const char *referenceName = "TestName"; 1521 const char *name = "TestName"; 1522 const char *referenceName2 = "TestName2"; 1523 const char *name2 = "TestName2"; 1524 int datasize; 1525 char *referenceUserdata = NULL; 1526 char *userdata = NULL; 1527 char *referenceUserdata2 = NULL; 1528 char *userdata2 = NULL; 1529 char *result; 1530 int iteration; 1531 1532 /* Call against new test window */ 1533 window = _createVideoSuiteTestWindow(title); 1534 if (window == NULL) return TEST_ABORTED; 1535 1536 /* Create testdata */ 1537 datasize = SDLTest_RandomIntegerInRange(1, 32); 1538 referenceUserdata = SDLTest_RandomAsciiStringOfSize(datasize); 1539 if (referenceUserdata == NULL) { 1540 returnValue = TEST_ABORTED; 1541 goto cleanup; 1542 } 1543 userdata = SDL_strdup(referenceUserdata); 1544 if (userdata == NULL) { 1545 returnValue = TEST_ABORTED; 1546 goto cleanup; 1547 } 1548 datasize = SDLTest_RandomIntegerInRange(1, 32); 1549 referenceUserdata2 = SDLTest_RandomAsciiStringOfSize(datasize); 1550 if (referenceUserdata2 == NULL) { 1551 returnValue = TEST_ABORTED; 1552 goto cleanup; 1553 } 1554 userdata2 = (char *)SDL_strdup(referenceUserdata2); 1555 if (userdata2 == NULL) { 1556 returnValue = TEST_ABORTED; 1557 goto cleanup; 1558 } 1559 1560 /* Get non-existent data */ 1561 result = (char *)SDL_GetWindowData(window, name); 1562 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name); 1563 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1564 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1565 1566 /* Set data */ 1567 result = (char *)SDL_SetWindowData(window, name, userdata); 1568 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s)", name, userdata); 1569 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1570 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1571 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1572 1573 /* Get data (twice) */ 1574 for (iteration = 1; iteration <= 2; iteration++) { 1575 result = (char *)SDL_GetWindowData(window, name); 1576 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [iteration %d]", name, iteration); 1577 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result); 1578 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1579 } 1580 1581 /* Set data again twice */ 1582 for (iteration = 1; iteration <= 2; iteration++) { 1583 result = (char *)SDL_SetWindowData(window, name, userdata); 1584 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [iteration %d]", name, userdata, iteration); 1585 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result); 1586 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1587 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1588 } 1589 1590 /* Get data again */ 1591 result = (char *)SDL_GetWindowData(window, name); 1592 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [again]", name); 1593 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result); 1594 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1595 1596 /* Set data with new data */ 1597 result = (char *)SDL_SetWindowData(window, name, userdata2); 1598 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [new userdata]", name, userdata2); 1599 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result); 1600 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1601 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1602 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2); 1603 1604 /* Set data with new data again */ 1605 result = (char *)SDL_SetWindowData(window, name, userdata2); 1606 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [new userdata again]", name, userdata2); 1607 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result); 1608 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1609 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1610 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2); 1611 1612 /* Get new data */ 1613 result = (char *)SDL_GetWindowData(window, name); 1614 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name); 1615 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result); 1616 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1617 1618 /* Set data with NULL to clear */ 1619 result = (char *)SDL_SetWindowData(window, name, NULL); 1620 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,NULL)", name); 1621 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result); 1622 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1623 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1624 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2); 1625 1626 /* Set data with NULL to clear again */ 1627 result = (char *)SDL_SetWindowData(window, name, NULL); 1628 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,NULL) [again]", name); 1629 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1630 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1631 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1632 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2); 1633 1634 /* Get non-existent data */ 1635 result = (char *)SDL_GetWindowData(window, name); 1636 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name); 1637 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1638 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1639 1640 /* Get non-existent data new name */ 1641 result = (char *)SDL_GetWindowData(window, name2); 1642 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name2); 1643 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1644 SDLTest_AssertCheck(SDL_strcmp(referenceName2, name2) == 0, "Validate that name2 was not changed, expected: %s, got: %s", referenceName2, name2); 1645 1646 /* Set data (again) */ 1647 result = (char *)SDL_SetWindowData(window, name, userdata); 1648 SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [again, after clear]", name, userdata); 1649 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1650 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1651 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata); 1652 1653 /* Get data (again) */ 1654 result = (char *)SDL_GetWindowData(window, name); 1655 SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [again, after clear]", name); 1656 SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result); 1657 SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name); 1658 1659 /* Negative test */ 1660 SDL_ClearError(); 1661 SDLTest_AssertPass("Call to SDL_ClearError()"); 1662 1663 /* Set with invalid window */ 1664 result = (char *)SDL_SetWindowData(NULL, name, userdata); 1665 SDLTest_AssertPass("Call to SDL_SetWindowData(window=NULL)"); 1666 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1667 _checkInvalidWindowError(); 1668 1669 /* Set data with NULL name, valid userdata */ 1670 result = (char *)SDL_SetWindowData(window, NULL, userdata); 1671 SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL)"); 1672 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1673 _checkInvalidParameterError(); 1674 1675 /* Set data with empty name, valid userdata */ 1676 result = (char *)SDL_SetWindowData(window, "", userdata); 1677 SDLTest_AssertPass("Call to SDL_SetWindowData(name='')"); 1678 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1679 _checkInvalidParameterError(); 1680 1681 /* Set data with NULL name, NULL userdata */ 1682 result = (char *)SDL_SetWindowData(window, NULL, NULL); 1683 SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL,userdata=NULL)"); 1684 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1685 _checkInvalidParameterError(); 1686 1687 /* Set data with empty name, NULL userdata */ 1688 result = (char *)SDL_SetWindowData(window, "", NULL); 1689 SDLTest_AssertPass("Call to SDL_SetWindowData(name='',userdata=NULL)"); 1690 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1691 _checkInvalidParameterError(); 1692 1693 /* Get with invalid window */ 1694 result = (char *)SDL_GetWindowData(NULL, name); 1695 SDLTest_AssertPass("Call to SDL_GetWindowData(window=NULL)"); 1696 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1697 _checkInvalidWindowError(); 1698 1699 /* Get data with NULL name */ 1700 result = (char *)SDL_GetWindowData(window, NULL); 1701 SDLTest_AssertPass("Call to SDL_GetWindowData(name=NULL)"); 1702 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1703 _checkInvalidParameterError(); 1704 1705 /* Get data with empty name */ 1706 result = (char *)SDL_GetWindowData(window, ""); 1707 SDLTest_AssertPass("Call to SDL_GetWindowData(name='')"); 1708 SDLTest_AssertCheck(result == NULL, "Validate that result is NULL"); 1709 _checkInvalidParameterError(); 1710 1711 /* Clean up */ 1712 _destroyVideoSuiteTestWindow(window); 1713 1714 cleanup: 1715 SDL_free(referenceUserdata); 1716 SDL_free(referenceUserdata2); 1717 SDL_free(userdata); 1718 SDL_free(userdata2); 1719 1720 return returnValue; 1721 } 1722 1723 1724 /* ================= Test References ================== */ 1725 1726 /* Video test cases */ 1727 static const SDLTest_TestCaseReference videoTest1 = 1728 { (SDLTest_TestCaseFp)video_enableDisableScreensaver, "video_enableDisableScreensaver", "Enable and disable screenaver while checking state", TEST_ENABLED }; 1729 1730 static const SDLTest_TestCaseReference videoTest2 = 1731 { (SDLTest_TestCaseFp)video_createWindowVariousPositions, "video_createWindowVariousPositions", "Create windows at various locations", TEST_ENABLED }; 1732 1733 static const SDLTest_TestCaseReference videoTest3 = 1734 { (SDLTest_TestCaseFp)video_createWindowVariousSizes, "video_createWindowVariousSizes", "Create windows with various sizes", TEST_ENABLED }; 1735 1736 static const SDLTest_TestCaseReference videoTest4 = 1737 { (SDLTest_TestCaseFp)video_createWindowVariousFlags, "video_createWindowVariousFlags", "Create windows using various flags", TEST_ENABLED }; 1738 1739 static const SDLTest_TestCaseReference videoTest5 = 1740 { (SDLTest_TestCaseFp)video_getWindowFlags, "video_getWindowFlags", "Get window flags set during SDL_CreateWindow", TEST_ENABLED }; 1741 1742 static const SDLTest_TestCaseReference videoTest6 = 1743 { (SDLTest_TestCaseFp)video_getNumDisplayModes, "video_getNumDisplayModes", "Use SDL_GetNumDisplayModes function to get number of display modes", TEST_ENABLED }; 1744 1745 static const SDLTest_TestCaseReference videoTest7 = 1746 { (SDLTest_TestCaseFp)video_getNumDisplayModesNegative, "video_getNumDisplayModesNegative", "Negative tests for SDL_GetNumDisplayModes", TEST_ENABLED }; 1747 1748 static const SDLTest_TestCaseReference videoTest8 = 1749 { (SDLTest_TestCaseFp)video_getClosestDisplayModeCurrentResolution, "video_getClosestDisplayModeCurrentResolution", "Use function to get closes match to requested display mode for current resolution", TEST_ENABLED }; 1750 1751 static const SDLTest_TestCaseReference videoTest9 = 1752 { (SDLTest_TestCaseFp)video_getClosestDisplayModeRandomResolution, "video_getClosestDisplayModeRandomResolution", "Use function to get closes match to requested display mode for random resolution", TEST_ENABLED }; 1753 1754 static const SDLTest_TestCaseReference videoTest10 = 1755 { (SDLTest_TestCaseFp)video_getWindowBrightness, "video_getWindowBrightness", "Get window brightness", TEST_ENABLED }; 1756 1757 static const SDLTest_TestCaseReference videoTest11 = 1758 { (SDLTest_TestCaseFp)video_getWindowBrightnessNegative, "video_getWindowBrightnessNegative", "Get window brightness with invalid input", TEST_ENABLED }; 1759 1760 static const SDLTest_TestCaseReference videoTest12 = 1761 { (SDLTest_TestCaseFp)video_getWindowDisplayMode, "video_getWindowDisplayMode", "Get window display mode", TEST_ENABLED }; 1762 1763 static const SDLTest_TestCaseReference videoTest13 = 1764 { (SDLTest_TestCaseFp)video_getWindowDisplayModeNegative, "video_getWindowDisplayModeNegative", "Get window display mode with invalid input", TEST_ENABLED }; 1765 1766 static const SDLTest_TestCaseReference videoTest14 = 1767 { (SDLTest_TestCaseFp)video_getWindowGammaRamp, "video_getWindowGammaRamp", "Get window gamma ramp", TEST_ENABLED }; 1768 1769 static const SDLTest_TestCaseReference videoTest15 = 1770 { (SDLTest_TestCaseFp)video_getWindowGammaRampNegative, "video_getWindowGammaRampNegative", "Get window gamma ramp against invalid input", TEST_ENABLED }; 1771 1772 static const SDLTest_TestCaseReference videoTest16 = 1773 { (SDLTest_TestCaseFp)video_getSetWindowGrab, "video_getSetWindowGrab", "Checks SDL_GetWindowGrab and SDL_SetWindowGrab positive and negative cases", TEST_ENABLED }; 1774 1775 static const SDLTest_TestCaseReference videoTest17 = 1776 { (SDLTest_TestCaseFp)video_getWindowId, "video_getWindowId", "Checks SDL_GetWindowID and SDL_GetWindowFromID", TEST_ENABLED }; 1777 1778 static const SDLTest_TestCaseReference videoTest18 = 1779 { (SDLTest_TestCaseFp)video_getWindowPixelFormat, "video_getWindowPixelFormat", "Checks SDL_GetWindowPixelFormat", TEST_ENABLED }; 1780 1781 static const SDLTest_TestCaseReference videoTest19 = 1782 { (SDLTest_TestCaseFp)video_getSetWindowPosition, "video_getSetWindowPosition", "Checks SDL_GetWindowPosition and SDL_SetWindowPosition positive and negative cases", TEST_ENABLED }; 1783 1784 static const SDLTest_TestCaseReference videoTest20 = 1785 { (SDLTest_TestCaseFp)video_getSetWindowSize, "video_getSetWindowSize", "Checks SDL_GetWindowSize and SDL_SetWindowSize positive and negative cases", TEST_ENABLED }; 1786 1787 static const SDLTest_TestCaseReference videoTest21 = 1788 { (SDLTest_TestCaseFp)video_getSetWindowMinimumSize, "video_getSetWindowMinimumSize", "Checks SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize positive and negative cases", TEST_ENABLED }; 1789 1790 static const SDLTest_TestCaseReference videoTest22 = 1791 { (SDLTest_TestCaseFp)video_getSetWindowMaximumSize, "video_getSetWindowMaximumSize", "Checks SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize positive and negative cases", TEST_ENABLED }; 1792 1793 static const SDLTest_TestCaseReference videoTest23 = 1794 { (SDLTest_TestCaseFp)video_getSetWindowData, "video_getSetWindowData", "Checks SDL_SetWindowData and SDL_GetWindowData positive and negative cases", TEST_ENABLED }; 1795 1796 /* Sequence of Video test cases */ 1797 static const SDLTest_TestCaseReference *videoTests[] = { 1798 &videoTest1, &videoTest2, &videoTest3, &videoTest4, &videoTest5, &videoTest6, 1799 &videoTest7, &videoTest8, &videoTest9, &videoTest10, &videoTest11, &videoTest12, 1800 &videoTest13, &videoTest14, &videoTest15, &videoTest16, &videoTest17, 1801 &videoTest18, &videoTest19, &videoTest20, &videoTest21, &videoTest22, 1802 &videoTest23, NULL 1803 }; 1804 1805 /* Video test suite (global) */ 1806 SDLTest_TestSuiteReference videoTestSuite = { 1807 "Video", 1808 NULL, 1809 videoTests, 1810 NULL 1811 };