test/testautomation_video.c

   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, &current);
 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, &currentX, &currentY);
 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, &currentX, 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, &currentY);
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, &currentX, &currentY);
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, &currentW, &currentH);
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, &currentW, 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, &currentH);
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, &currentW, &currentH);
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, &currentW, &currentH);
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, &currentW, 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, &currentH);
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, &currentW, &currentH);
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, &currentW, &currentH);
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, &currentW, 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, &currentH);
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, &currentW, &currentH);
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 };