Home | History | Annotate | Download | only in test 
      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   const char* title = "video_getWindowBrightnessNegative Test Window";
    545   float result;
    546 
    547   /* Call against invalid window */
    548   result = SDL_GetWindowBrightness(NULL);
    549   SDLTest_AssertPass("Call to SDL_GetWindowBrightness(window=NULL)");
    550   SDLTest_AssertCheck(result == 1.0, "Validate result value; expected: 1.0, got: %f", result);
    551   lastError = (char *)SDL_GetError();
    552   SDLTest_AssertPass("SDL_GetError()");
    553   SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
    554   if (lastError != NULL) {
    555       SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0,
    556          "SDL_GetError(): expected message '%s', was message: '%s'",
    557          invalidWindowError,
    558          lastError);
    559   }
    560 
    561   return TEST_COMPLETED;
    562 }
    563 
    564 /**
    565  * @brief Tests call to SDL_GetWindowDisplayMode
    566  *
    567  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode
    568  */
    569 int
    570 video_getWindowDisplayMode(void *arg)
    571 {
    572   SDL_Window* window;
    573   const char* title = "video_getWindowDisplayMode Test Window";
    574   SDL_DisplayMode mode;
    575   int result;
    576 
    577   /* Invalidate part of the mode content so we can check values later */
    578   mode.w = -1;
    579   mode.h = -1;
    580   mode.refresh_rate = -1;
    581 
    582   /* Call against new test window */
    583   window = _createVideoSuiteTestWindow(title);
    584   if (window != NULL) {
    585       result = SDL_GetWindowDisplayMode(window, &mode);
    586       SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode");
    587       SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    588       SDLTest_AssertCheck(mode.w > 0, "Validate mode.w content; expected: >0, got: %d", mode.w);
    589       SDLTest_AssertCheck(mode.h > 0, "Validate mode.h content; expected: >0, got: %d", mode.h);
    590       SDLTest_AssertCheck(mode.refresh_rate > 0, "Validate mode.refresh_rate content; expected: >0, got: %d", mode.refresh_rate);
    591   }
    592 
    593   /* Clean up */
    594   _destroyVideoSuiteTestWindow(window);
    595 
    596   return TEST_COMPLETED;
    597 }
    598 
    599 /* Helper function that checks for an 'Invalid window' error */
    600 void _checkInvalidWindowError()
    601 {
    602   const char *invalidWindowError = "Invalid window";
    603   char *lastError;
    604 
    605   lastError = (char *)SDL_GetError();
    606   SDLTest_AssertPass("SDL_GetError()");
    607   SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
    608   if (lastError != NULL) {
    609       SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0,
    610          "SDL_GetError(): expected message '%s', was message: '%s'",
    611          invalidWindowError,
    612          lastError);
    613       SDL_ClearError();
    614       SDLTest_AssertPass("Call to SDL_ClearError()");
    615   }
    616 }
    617 
    618 /**
    619  * @brief Tests call to SDL_GetWindowDisplayMode with invalid input
    620  *
    621  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode
    622  */
    623 int
    624 video_getWindowDisplayModeNegative(void *arg)
    625 {
    626   const char *expectedError = "Parameter 'mode' is invalid";
    627   char *lastError;
    628   SDL_Window* window;
    629   const char* title = "video_getWindowDisplayModeNegative Test Window";
    630   SDL_DisplayMode mode;
    631   int result;
    632 
    633   /* Call against new test window */
    634   window = _createVideoSuiteTestWindow(title);
    635   if (window != NULL) {
    636       result = SDL_GetWindowDisplayMode(window, NULL);
    637       SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(...,mode=NULL)");
    638       SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result);
    639       lastError = (char *)SDL_GetError();
    640       SDLTest_AssertPass("SDL_GetError()");
    641       SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
    642       if (lastError != NULL) {
    643         SDLTest_AssertCheck(SDL_strcmp(lastError, expectedError) == 0,
    644              "SDL_GetError(): expected message '%s', was message: '%s'",
    645              expectedError,
    646              lastError);
    647       }
    648   }
    649 
    650   /* Clean up */
    651   _destroyVideoSuiteTestWindow(window);
    652 
    653   /* Call against invalid window */
    654   result = SDL_GetWindowDisplayMode(NULL, &mode);
    655   SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(window=NULL,...)");
    656   SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result);
    657   _checkInvalidWindowError();
    658 
    659   return TEST_COMPLETED;
    660 }
    661 
    662 /**
    663  * @brief Tests call to SDL_GetWindowGammaRamp
    664  *
    665  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp
    666  */
    667 int
    668 video_getWindowGammaRamp(void *arg)
    669 {
    670   SDL_Window* window;
    671   const char* title = "video_getWindowGammaRamp Test Window";
    672   Uint16 red[256];
    673   Uint16 green[256];
    674   Uint16 blue[256];
    675   int result;
    676 
    677   /* Call against new test window */
    678   window = _createVideoSuiteTestWindow(title);
    679   if (window == NULL) return TEST_ABORTED;
    680 
    681   /* Retrieve no channel */
    682   result = SDL_GetWindowGammaRamp(window, NULL, NULL, NULL);
    683   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(all NULL)");
    684   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    685 
    686   /* Retrieve single channel */
    687   result = SDL_GetWindowGammaRamp(window, red, NULL, NULL);
    688   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r)");
    689   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    690 
    691   result = SDL_GetWindowGammaRamp(window, NULL, green, NULL);
    692   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(g)");
    693   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    694 
    695   result = SDL_GetWindowGammaRamp(window, NULL, NULL, blue);
    696   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(b)");
    697   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    698 
    699   /* Retrieve two channels */
    700   result = SDL_GetWindowGammaRamp(window, red, green, NULL);
    701   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r, g)");
    702   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    703 
    704   result = SDL_GetWindowGammaRamp(window, NULL, green, blue);
    705   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(g,b)");
    706   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    707 
    708   result = SDL_GetWindowGammaRamp(window, red, NULL, blue);
    709   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r,b)");
    710   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    711 
    712   /* Retrieve all channels */
    713   result = SDL_GetWindowGammaRamp(window, red, green, blue);
    714   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r,g,b)");
    715   SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
    716 
    717   /* Clean up */
    718   _destroyVideoSuiteTestWindow(window);
    719 
    720   return TEST_COMPLETED;
    721 }
    722 
    723 /**
    724  * @brief Tests call to SDL_GetWindowGammaRamp with invalid input
    725  *
    726 * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp
    727  */
    728 int
    729 video_getWindowGammaRampNegative(void *arg)
    730 {
    731   const char* title = "video_getWindowGammaRampNegative Test Window";
    732   Uint16 red[256];
    733   Uint16 green[256];
    734   Uint16 blue[256];
    735   int result;
    736 
    737   SDL_ClearError();
    738   SDLTest_AssertPass("Call to SDL_ClearError()");
    739 
    740   /* Call against invalid window */
    741   result = SDL_GetWindowGammaRamp(NULL, red, green, blue);
    742   SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(window=NULL,r,g,b)");
    743   SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %f", result);
    744   _checkInvalidWindowError();
    745 
    746   return TEST_COMPLETED;
    747 }
    748 
    749 /* Helper for setting and checking the window grab state */
    750 void
    751 _setAndCheckWindowGrabState(SDL_Window* window, SDL_bool desiredState)
    752 {
    753   SDL_bool currentState;
    754 
    755   /* Set state */
    756   SDL_SetWindowGrab(window, desiredState);
    757   SDLTest_AssertPass("Call to SDL_SetWindowGrab(%s)", (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
    758 
    759   /* Get and check state */
    760   currentState = SDL_GetWindowGrab(window);
    761   SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
    762   SDLTest_AssertCheck(
    763       currentState == desiredState,
    764       "Validate returned state; expected: %s, got: %s",
    765       (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
    766       (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
    767 }
    768 
    769 /**
    770  * @brief Tests call to SDL_GetWindowGrab and SDL_SetWindowGrab
    771  *
    772  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGrab
    773  * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowGrab
    774  */
    775 int
    776 video_getSetWindowGrab(void *arg)
    777 {
    778   const char* title = "video_getSetWindowGrab Test Window";
    779   SDL_Window* window;
    780   SDL_bool originalState, dummyState, currentState, desiredState;
    781 
    782   /* Call against new test window */
    783   window = _createVideoSuiteTestWindow(title);
    784   if (window == NULL) return TEST_ABORTED;
    785 
    786   /* Get state */
    787   originalState = SDL_GetWindowGrab(window);
    788   SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
    789 
    790   /* F */
    791   _setAndCheckWindowGrabState(window, SDL_FALSE);
    792 
    793   /* F --> F */
    794   _setAndCheckWindowGrabState(window, SDL_FALSE);
    795 
    796   /* F --> T */
    797   _setAndCheckWindowGrabState(window, SDL_TRUE);
    798 
    799   /* T --> T */
    800   _setAndCheckWindowGrabState(window, SDL_TRUE);
    801 
    802   /* T --> F */
    803   _setAndCheckWindowGrabState(window, SDL_FALSE);
    804 
    805   /* Negative tests */
    806   dummyState = SDL_GetWindowGrab(NULL);
    807   SDLTest_AssertPass("Call to SDL_GetWindowGrab(window=NULL)");
    808   _checkInvalidWindowError();
    809 
    810   SDL_SetWindowGrab(NULL, SDL_FALSE);
    811   SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
    812   _checkInvalidWindowError();
    813 
    814   SDL_SetWindowGrab(NULL, SDL_TRUE);
    815   SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
    816   _checkInvalidWindowError();
    817 
    818   /* State should still be F */
    819   desiredState = SDL_FALSE;
    820   currentState = SDL_GetWindowGrab(window);
    821   SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
    822   SDLTest_AssertCheck(
    823       currentState == desiredState,
    824       "Validate returned state; expected: %s, got: %s",
    825       (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
    826       (currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
    827 
    828   /* Restore state */
    829   _setAndCheckWindowGrabState(window, originalState);
    830 
    831   /* Clean up */
    832   _destroyVideoSuiteTestWindow(window);
    833 
    834   return TEST_COMPLETED;
    835 }
    836 
    837 
    838 /**
    839  * @brief Tests call to SDL_GetWindowID and SDL_GetWindowFromID
    840  *
    841  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowID
    842  * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowFromID
    843  */
    844 int
    845 video_getWindowId(void *arg)
    846 {
    847   const char* title = "video_getWindowId Test Window";
    848   SDL_Window* window;
    849   SDL_Window* result;
    850   Uint32 id, randomId;
    851 
    852   /* Call against new test window */
    853   window = _createVideoSuiteTestWindow(title);
    854   if (window == NULL) return TEST_ABORTED;
    855 
    856   /* Get ID */
    857   id = SDL_GetWindowID(window);
    858   SDLTest_AssertPass("Call to SDL_GetWindowID()");
    859 
    860   /* Get window from ID */
    861   result = SDL_GetWindowFromID(id);
    862   SDLTest_AssertPass("Call to SDL_GetWindowID(%d)", id);
    863   SDLTest_AssertCheck(result == window, "Verify result matches window pointer");
    864 
    865   /* Get window from random large ID, no result check */
    866   randomId = SDLTest_RandomIntegerInRange(UINT8_MAX,UINT16_MAX);
    867   result = SDL_GetWindowFromID(randomId);
    868   SDLTest_AssertPass("Call to SDL_GetWindowID(%d/random_large)", randomId);
    869 
    870   /* Get window from 0 and Uint32 max ID, no result check */
    871   result = SDL_GetWindowFromID(0);
    872   SDLTest_AssertPass("Call to SDL_GetWindowID(0)");
    873   result = SDL_GetWindowFromID(UINT32_MAX);
    874   SDLTest_AssertPass("Call to SDL_GetWindowID(UINT32_MAX)");
    875 
    876   /* Clean up */
    877   _destroyVideoSuiteTestWindow(window);
    878 
    879   /* Get window from ID for closed window */
    880   result = SDL_GetWindowFromID(id);
    881   SDLTest_AssertPass("Call to SDL_GetWindowID(%d/closed_window)", id);
    882   SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
    883 
    884   /* Negative test */
    885   SDL_ClearError();
    886   SDLTest_AssertPass("Call to SDL_ClearError()");
    887   id = SDL_GetWindowID(NULL);
    888   SDLTest_AssertPass("Call to SDL_GetWindowID(window=NULL)");
    889   _checkInvalidWindowError();
    890 
    891   return TEST_COMPLETED;
    892 }
    893 
    894 /**
    895  * @brief Tests call to SDL_GetWindowPixelFormat
    896  *
    897  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPixelFormat
    898  */
    899 int
    900 video_getWindowPixelFormat(void *arg)
    901 {
    902   const char* title = "video_getWindowPixelFormat Test Window";
    903   SDL_Window* window;
    904   Uint32 format;
    905 
    906   /* Call against new test window */
    907   window = _createVideoSuiteTestWindow(title);
    908   if (window == NULL) return TEST_ABORTED;
    909 
    910   /* Get format */
    911   format = SDL_GetWindowPixelFormat(window);
    912   SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat()");
    913   SDLTest_AssertCheck(format != SDL_PIXELFORMAT_UNKNOWN, "Verify that returned format is valid; expected: != %d, got: %d", SDL_PIXELFORMAT_UNKNOWN, format);
    914 
    915   /* Clean up */
    916   _destroyVideoSuiteTestWindow(window);
    917 
    918   /* Negative test */
    919   SDL_ClearError();
    920   SDLTest_AssertPass("Call to SDL_ClearError()");
    921   format = SDL_GetWindowPixelFormat(NULL);
    922   SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat(window=NULL)");
    923   _checkInvalidWindowError();
    924 
    925   return TEST_COMPLETED;
    926 }
    927 
    928 /**
    929  * @brief Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition
    930  *
    931  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPosition
    932  * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowPosition
    933  */
    934 int
    935 video_getSetWindowPosition(void *arg)
    936 {
    937   const char* title = "video_getSetWindowPosition Test Window";
    938   SDL_Window* window;
    939   int xVariation, yVariation;
    940   int referenceX, referenceY;
    941   int currentX, currentY;
    942   int desiredX, desiredY;
    943 
    944   /* Call against new test window */
    945   window = _createVideoSuiteTestWindow(title);
    946   if (window == NULL) return TEST_ABORTED;
    947 
    948   for (xVariation = 0; xVariation < 4; xVariation++) {
    949    for (yVariation = 0; yVariation < 4; yVariation++) {
    950     switch(xVariation) {
    951      case 0:
    952       /* Zero X Position */
    953       desiredX = 0;
    954       break;
    955      case 1:
    956       /* Random X position inside screen */
    957       desiredX = SDLTest_RandomIntegerInRange(1, 100);
    958       break;
    959      case 2:
    960       /* Random X position outside screen (positive) */
    961       desiredX = SDLTest_RandomIntegerInRange(10000, 11000);
    962       break;
    963      case 3:
    964       /* Random X position outside screen (negative) */
    965       desiredX = SDLTest_RandomIntegerInRange(-1000, -100);
    966       break;
    967     }
    968 
    969     switch(yVariation) {
    970      case 0:
    971       /* Zero X Position */
    972       desiredY = 0;
    973       break;
    974      case 1:
    975       /* Random X position inside screen */
    976       desiredY = SDLTest_RandomIntegerInRange(1, 100);
    977       break;
    978      case 2:
    979       /* Random X position outside screen (positive) */
    980       desiredY = SDLTest_RandomIntegerInRange(10000, 11000);
    981       break;
    982      case 3:
    983       /* Random Y position outside screen (negative) */
    984       desiredY = SDLTest_RandomIntegerInRange(-1000, -100);
    985       break;
    986     }
    987 
    988     /* Set position */
    989     SDL_SetWindowPosition(window, desiredX, desiredY);
    990     SDLTest_AssertPass("Call to SDL_SetWindowPosition(...,%d,%d)", desiredX, desiredY);
    991 
    992     /* Get position */
    993     currentX = desiredX + 1;
    994     currentY = desiredY + 1;
    995     SDL_GetWindowPosition(window, &currentX, &currentY);
    996     SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
    997     SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX);
    998     SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY);
    999 
   1000     /* Get position X */
   1001     currentX = desiredX + 1;
   1002     SDL_GetWindowPosition(window, &currentX, NULL);
   1003     SDLTest_AssertPass("Call to SDL_GetWindowPosition(&y=NULL)");
   1004     SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX);
   1005 
   1006     /* Get position Y */
   1007     currentY = desiredY + 1;
   1008     SDL_GetWindowPosition(window, NULL, &currentY);
   1009     SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL)");
   1010     SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY);
   1011    }
   1012   }
   1013 
   1014   /* Dummy call with both pointers NULL */
   1015   SDL_GetWindowPosition(window, NULL, NULL);
   1016   SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL,&y=NULL)");
   1017 
   1018   /* Clean up */
   1019   _destroyVideoSuiteTestWindow(window);
   1020 
   1021   /* Set some 'magic' value for later check that nothing was changed */
   1022   referenceX = SDLTest_RandomSint32();
   1023   referenceY = SDLTest_RandomSint32();
   1024   currentX = referenceX;
   1025   currentY = referenceY;
   1026   desiredX = SDLTest_RandomSint32();
   1027   desiredY = SDLTest_RandomSint32();
   1028 
   1029   /* Negative tests */
   1030   SDL_ClearError();
   1031   SDLTest_AssertPass("Call to SDL_ClearError()");
   1032   SDL_GetWindowPosition(NULL, &currentX, &currentY);
   1033   SDLTest_AssertPass("Call to SDL_GetWindowPosition(window=NULL)");
   1034   SDLTest_AssertCheck(
   1035     currentX == referenceX && currentY == referenceY,
   1036     "Verify that content of X and Y pointers has not been modified; expected: %d,%d; got: %d,%d",
   1037     referenceX, referenceY,
   1038     currentX, currentY);
   1039   _checkInvalidWindowError();
   1040 
   1041   SDL_GetWindowPosition(NULL, NULL, NULL);
   1042   SDLTest_AssertPass("Call to SDL_GetWindowPosition(NULL, NULL, NULL)");
   1043   _checkInvalidWindowError();
   1044 
   1045   SDL_SetWindowPosition(NULL, desiredX, desiredY);
   1046   SDLTest_AssertPass("Call to SDL_SetWindowPosition(window=NULL)");
   1047   _checkInvalidWindowError();
   1048 
   1049   return TEST_COMPLETED;
   1050 }
   1051 
   1052 /* Helper function that checks for an 'Invalid parameter' error */
   1053 void _checkInvalidParameterError()
   1054 {
   1055   const char *invalidParameterError = "Parameter";
   1056   char *lastError;
   1057 
   1058   lastError = (char *)SDL_GetError();
   1059   SDLTest_AssertPass("SDL_GetError()");
   1060   SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
   1061   if (lastError != NULL) {
   1062       SDLTest_AssertCheck(SDL_strncmp(lastError, invalidParameterError, SDL_strlen(invalidParameterError)) == 0,
   1063          "SDL_GetError(): expected message starts with '%s', was message: '%s'",
   1064          invalidParameterError,
   1065          lastError);
   1066       SDL_ClearError();
   1067       SDLTest_AssertPass("Call to SDL_ClearError()");
   1068   }
   1069 }
   1070 
   1071 /**
   1072  * @brief Tests call to SDL_GetWindowSize and SDL_SetWindowSize
   1073  *
   1074  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowSize
   1075  * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowSize
   1076  */
   1077 int
   1078 video_getSetWindowSize(void *arg)
   1079 {
   1080   const char* title = "video_getSetWindowSize Test Window";
   1081   SDL_Window* window;
   1082   int result;
   1083   SDL_Rect display;
   1084   int maxwVariation, maxhVariation;
   1085   int wVariation, hVariation;
   1086   int referenceW, referenceH;
   1087   int currentW, currentH;
   1088   int desiredW, desiredH;
   1089 
   1090   /* Get display bounds for size range */
   1091   result = SDL_GetDisplayBounds(0, &display);
   1092   SDLTest_AssertPass("SDL_GetDisplayBounds()");
   1093   SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0, got: %d", result);
   1094   if (result != 0) return TEST_ABORTED;
   1095 
   1096   /* Call against new test window */
   1097   window = _createVideoSuiteTestWindow(title);
   1098   if (window == NULL) return TEST_ABORTED;
   1099 
   1100 #ifdef __WIN32__
   1101   /* Platform clips window size to screen size */
   1102   maxwVariation = 4;
   1103   maxhVariation = 4;
   1104 #else
   1105   /* Platform allows window size >= screen size */
   1106   maxwVariation = 5;
   1107   maxhVariation = 5;
   1108 #endif
   1109 
   1110   for (wVariation = 0; wVariation < maxwVariation; wVariation++) {
   1111    for (hVariation = 0; hVariation < maxhVariation; hVariation++) {
   1112     switch(wVariation) {
   1113      case 0:
   1114       /* 1 Pixel Wide */
   1115       desiredW = 1;
   1116       break;
   1117      case 1:
   1118       /* Random width inside screen */
   1119       desiredW = SDLTest_RandomIntegerInRange(1, 100);
   1120       break;
   1121      case 2:
   1122       /* Width 1 pixel smaller than screen */
   1123       desiredW = display.w - 1;
   1124       break;
   1125      case 3:
   1126       /* Width at screen size */
   1127       desiredW = display.w;
   1128       break;
   1129      case 4:
   1130       /* Width 1 pixel larger than screen */
   1131       desiredW = display.w + 1;
   1132       break;
   1133     }
   1134 
   1135     switch(hVariation) {
   1136      case 0:
   1137       /* 1 Pixel High */
   1138       desiredH = 1;
   1139       break;
   1140      case 1:
   1141       /* Random height inside screen */
   1142       desiredH = SDLTest_RandomIntegerInRange(1, 100);
   1143       break;
   1144      case 2:
   1145       /* Height 1 pixel smaller than screen */
   1146       desiredH = display.h - 1;
   1147       break;
   1148      case 3:
   1149       /* Height at screen size */
   1150       desiredH = display.h;
   1151       break;
   1152      case 4:
   1153       /* Height 1 pixel larger than screen */
   1154       desiredH = display.h + 1;
   1155       break;
   1156     }
   1157 
   1158     /* Set size */
   1159     SDL_SetWindowSize(window, desiredW, desiredH);
   1160     SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH);
   1161 
   1162     /* Get size */
   1163     currentW = desiredW + 1;
   1164     currentH = desiredH + 1;
   1165     SDL_GetWindowSize(window, &currentW, &currentH);
   1166     SDLTest_AssertPass("Call to SDL_GetWindowSize()");
   1167     SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
   1168     SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
   1169 
   1170     /* Get just width */
   1171     currentW = desiredW + 1;
   1172     SDL_GetWindowSize(window, &currentW, NULL);
   1173     SDLTest_AssertPass("Call to SDL_GetWindowSize(&h=NULL)");
   1174     SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
   1175 
   1176     /* Get just height */
   1177     currentH = desiredH + 1;
   1178     SDL_GetWindowSize(window, NULL, &currentH);
   1179     SDLTest_AssertPass("Call to SDL_GetWindowSize(&w=NULL)");
   1180     SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
   1181    }
   1182   }
   1183 
   1184   /* Dummy call with both pointers NULL */
   1185   SDL_GetWindowSize(window, NULL, NULL);
   1186   SDLTest_AssertPass("Call to SDL_GetWindowSize(&w=NULL,&h=NULL)");
   1187 
   1188   /* Negative tests for parameter input */
   1189   SDL_ClearError();
   1190   SDLTest_AssertPass("Call to SDL_ClearError()");
   1191   for (desiredH = -2; desiredH < 2; desiredH++) {
   1192     for (desiredW = -2; desiredW < 2; desiredW++) {
   1193       if (desiredW <= 0 || desiredH <= 0) {
   1194         SDL_SetWindowSize(window, desiredW, desiredH);
   1195         SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH);
   1196         _checkInvalidParameterError();
   1197       }
   1198     }
   1199   }
   1200 
   1201   /* Clean up */
   1202   _destroyVideoSuiteTestWindow(window);
   1203 
   1204   /* Set some 'magic' value for later check that nothing was changed */
   1205   referenceW = SDLTest_RandomSint32();
   1206   referenceH = SDLTest_RandomSint32();
   1207   currentW = referenceW;
   1208   currentH = referenceH;
   1209   desiredW = SDLTest_RandomSint32();
   1210   desiredH = SDLTest_RandomSint32();
   1211 
   1212   /* Negative tests for window input */
   1213   SDL_ClearError();
   1214   SDLTest_AssertPass("Call to SDL_ClearError()");
   1215   SDL_GetWindowSize(NULL, &currentW, &currentH);
   1216   SDLTest_AssertPass("Call to SDL_GetWindowSize(window=NULL)");
   1217   SDLTest_AssertCheck(
   1218     currentW == referenceW && currentH == referenceH,
   1219     "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
   1220     referenceW, referenceH,
   1221     currentW, currentH);
   1222   _checkInvalidWindowError();
   1223 
   1224   SDL_GetWindowSize(NULL, NULL, NULL);
   1225   SDLTest_AssertPass("Call to SDL_GetWindowSize(NULL, NULL, NULL)");
   1226   _checkInvalidWindowError();
   1227 
   1228   SDL_SetWindowSize(NULL, desiredW, desiredH);
   1229   SDLTest_AssertPass("Call to SDL_SetWindowSize(window=NULL)");
   1230   _checkInvalidWindowError();
   1231 
   1232   return TEST_COMPLETED;
   1233 }
   1234 
   1235 /**
   1236  * @brief Tests call to SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize
   1237  *
   1238  */
   1239 int
   1240 video_getSetWindowMinimumSize(void *arg)
   1241 {
   1242   const char* title = "video_getSetWindowMinimumSize Test Window";
   1243   SDL_Window* window;
   1244   int result;
   1245   SDL_Rect display;
   1246   int wVariation, hVariation;
   1247   int referenceW, referenceH;
   1248   int currentW, currentH;
   1249   int desiredW, desiredH;
   1250 
   1251   /* Get display bounds for size range */
   1252   result = SDL_GetDisplayBounds(0, &display);
   1253   SDLTest_AssertPass("SDL_GetDisplayBounds()");
   1254   SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0, got: %d", result);
   1255   if (result != 0) return TEST_ABORTED;
   1256 
   1257   /* Call against new test window */
   1258   window = _createVideoSuiteTestWindow(title);
   1259   if (window == NULL) return TEST_ABORTED;
   1260 
   1261   for (wVariation = 0; wVariation < 5; wVariation++) {
   1262    for (hVariation = 0; hVariation < 5; hVariation++) {
   1263     switch(wVariation) {
   1264      case 0:
   1265       /* 1 Pixel Wide */
   1266       desiredW = 1;
   1267       break;
   1268      case 1:
   1269       /* Random width inside screen */
   1270       desiredW = SDLTest_RandomIntegerInRange(2, display.w - 1);
   1271       break;
   1272      case 2:
   1273       /* Width at screen size */
   1274       desiredW = display.w;
   1275       break;
   1276     }
   1277 
   1278     switch(hVariation) {
   1279      case 0:
   1280       /* 1 Pixel High */
   1281       desiredH = 1;
   1282       break;
   1283      case 1:
   1284       /* Random height inside screen */
   1285       desiredH = SDLTest_RandomIntegerInRange(2, display.h - 1);
   1286       break;
   1287      case 2:
   1288       /* Height at screen size */
   1289       desiredH = display.h;
   1290       break;
   1291      case 4:
   1292       /* Height 1 pixel larger than screen */
   1293       desiredH = display.h + 1;
   1294       break;
   1295     }
   1296 
   1297     /* Set size */
   1298     SDL_SetWindowMinimumSize(window, desiredW, desiredH);
   1299     SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH);
   1300 
   1301     /* Get size */
   1302     currentW = desiredW + 1;
   1303     currentH = desiredH + 1;
   1304     SDL_GetWindowMinimumSize(window, &currentW, &currentH);
   1305     SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize()");
   1306     SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
   1307     SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
   1308 
   1309     /* Get just width */
   1310     currentW = desiredW + 1;
   1311     SDL_GetWindowMinimumSize(window, &currentW, NULL);
   1312     SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&h=NULL)");
   1313     SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentH);
   1314 
   1315     /* Get just height */
   1316     currentH = desiredH + 1;
   1317     SDL_GetWindowMinimumSize(window, NULL, &currentH);
   1318     SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&w=NULL)");
   1319     SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredW, currentH);
   1320    }
   1321   }
   1322 
   1323   /* Dummy call with both pointers NULL */
   1324   SDL_GetWindowMinimumSize(window, NULL, NULL);
   1325   SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(&w=NULL,&h=NULL)");
   1326 
   1327   /* Negative tests for parameter input */
   1328   SDL_ClearError();
   1329   SDLTest_AssertPass("Call to SDL_ClearError()");
   1330   for (desiredH = -2; desiredH < 2; desiredH++) {
   1331     for (desiredW = -2; desiredW < 2; desiredW++) {
   1332       if (desiredW <= 0 || desiredH <= 0) {
   1333         SDL_SetWindowMinimumSize(window, desiredW, desiredH);
   1334         SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH);
   1335         _checkInvalidParameterError();
   1336       }
   1337     }
   1338   }
   1339 
   1340   /* Clean up */
   1341   _destroyVideoSuiteTestWindow(window);
   1342 
   1343   /* Set some 'magic' value for later check that nothing was changed */
   1344   referenceW = SDLTest_RandomSint32();
   1345   referenceH = SDLTest_RandomSint32();
   1346   currentW = referenceW;
   1347   currentH = referenceH;
   1348   desiredW = SDLTest_RandomSint32();
   1349   desiredH = SDLTest_RandomSint32();
   1350 
   1351   /* Negative tests for window input */
   1352   SDL_ClearError();
   1353   SDLTest_AssertPass("Call to SDL_ClearError()");
   1354   SDL_GetWindowMinimumSize(NULL, &currentW, &currentH);
   1355   SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(window=NULL)");
   1356   SDLTest_AssertCheck(
   1357     currentW == referenceW && currentH == referenceH,
   1358     "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
   1359     referenceW, referenceH,
   1360     currentW, currentH);
   1361   _checkInvalidWindowError();
   1362 
   1363   SDL_GetWindowMinimumSize(NULL, NULL, NULL);
   1364   SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(NULL, NULL, NULL)");
   1365   _checkInvalidWindowError();
   1366 
   1367   SDL_SetWindowMinimumSize(NULL, desiredW, desiredH);
   1368   SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(window=NULL)");
   1369   _checkInvalidWindowError();
   1370 
   1371   return TEST_COMPLETED;
   1372 }
   1373 
   1374 /**
   1375  * @brief Tests call to SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize
   1376  *
   1377  */
   1378 int
   1379 video_getSetWindowMaximumSize(void *arg)
   1380 {
   1381   const char* title = "video_getSetWindowMaximumSize Test Window";
   1382   SDL_Window* window;
   1383   int result;
   1384   SDL_Rect display;
   1385   int wVariation, hVariation;
   1386   int referenceW, referenceH;
   1387   int currentW, currentH;
   1388   int desiredW, desiredH;
   1389 
   1390   /* Get display bounds for size range */
   1391   result = SDL_GetDisplayBounds(0, &display);
   1392   SDLTest_AssertPass("SDL_GetDisplayBounds()");
   1393   SDLTest_AssertCheck(result == 0, "Verify return value; expected: 0, got: %d", result);
   1394   if (result != 0) return TEST_ABORTED;
   1395 
   1396   /* Call against new test window */
   1397   window = _createVideoSuiteTestWindow(title);
   1398   if (window == NULL) return TEST_ABORTED;
   1399 
   1400   for (wVariation = 0; wVariation < 3; wVariation++) {
   1401    for (hVariation = 0; hVariation < 3; hVariation++) {
   1402     switch(wVariation) {
   1403      case 0:
   1404       /* 1 Pixel Wide */
   1405       desiredW = 1;
   1406       break;
   1407      case 1:
   1408       /* Random width inside screen */
   1409       desiredW = SDLTest_RandomIntegerInRange(2, display.w - 1);
   1410       break;
   1411      case 2:
   1412       /* Width at screen size */
   1413       desiredW = display.w;
   1414       break;
   1415     }
   1416 
   1417     switch(hVariation) {
   1418      case 0:
   1419       /* 1 Pixel High */
   1420       desiredH = 1;
   1421       break;
   1422      case 1:
   1423       /* Random height inside screen */
   1424       desiredH = SDLTest_RandomIntegerInRange(2, display.h - 1);
   1425       break;
   1426      case 2:
   1427       /* Height at screen size */
   1428       desiredH = display.h;
   1429       break;
   1430     }
   1431 
   1432     /* Set size */
   1433     SDL_SetWindowMaximumSize(window, desiredW, desiredH);
   1434     SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH);
   1435 
   1436     /* Get size */
   1437     currentW = desiredW + 1;
   1438     currentH = desiredH + 1;
   1439     SDL_GetWindowMaximumSize(window, &currentW, &currentH);
   1440     SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize()");
   1441     SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentW);
   1442     SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredH, currentH);
   1443 
   1444     /* Get just width */
   1445     currentW = desiredW + 1;
   1446     SDL_GetWindowMaximumSize(window, &currentW, NULL);
   1447     SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&h=NULL)");
   1448     SDLTest_AssertCheck(desiredW == currentW, "Verify returned width; expected: %d, got: %d", desiredW, currentH);
   1449 
   1450     /* Get just height */
   1451     currentH = desiredH + 1;
   1452     SDL_GetWindowMaximumSize(window, NULL, &currentH);
   1453     SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&w=NULL)");
   1454     SDLTest_AssertCheck(desiredH == currentH, "Verify returned height; expected: %d, got: %d", desiredW, currentH);
   1455    }
   1456   }
   1457 
   1458   /* Dummy call with both pointers NULL */
   1459   SDL_GetWindowMaximumSize(window, NULL, NULL);
   1460   SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(&w=NULL,&h=NULL)");
   1461 
   1462   /* Negative tests for parameter input */
   1463   SDL_ClearError();
   1464   SDLTest_AssertPass("Call to SDL_ClearError()");
   1465   for (desiredH = -2; desiredH < 2; desiredH++) {
   1466     for (desiredW = -2; desiredW < 2; desiredW++) {
   1467       if (desiredW <= 0 || desiredH <= 0) {
   1468         SDL_SetWindowMaximumSize(window, desiredW, desiredH);
   1469         SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH);
   1470         _checkInvalidParameterError();
   1471       }
   1472     }
   1473   }
   1474 
   1475   /* Clean up */
   1476   _destroyVideoSuiteTestWindow(window);
   1477 
   1478   /* Set some 'magic' value for later check that nothing was changed */
   1479   referenceW = SDLTest_RandomSint32();
   1480   referenceH = SDLTest_RandomSint32();
   1481   currentW = referenceW;
   1482   currentH = referenceH;
   1483   desiredW = SDLTest_RandomSint32();
   1484   desiredH = SDLTest_RandomSint32();
   1485 
   1486   /* Negative tests */
   1487   SDL_ClearError();
   1488   SDLTest_AssertPass("Call to SDL_ClearError()");
   1489   SDL_GetWindowMaximumSize(NULL, &currentW, &currentH);
   1490   SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(window=NULL)");
   1491   SDLTest_AssertCheck(
   1492     currentW == referenceW && currentH == referenceH,
   1493     "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
   1494     referenceW, referenceH,
   1495     currentW, currentH);
   1496   _checkInvalidWindowError();
   1497 
   1498   SDL_GetWindowMaximumSize(NULL, NULL, NULL);
   1499   SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(NULL, NULL, NULL)");
   1500   _checkInvalidWindowError();
   1501 
   1502   SDL_SetWindowMaximumSize(NULL, desiredW, desiredH);
   1503   SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(window=NULL)");
   1504   _checkInvalidWindowError();
   1505 
   1506   return TEST_COMPLETED;
   1507 }
   1508 
   1509 
   1510 /**
   1511  * @brief Tests call to SDL_SetWindowData and SDL_GetWindowData
   1512  *
   1513  * @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowData
   1514  * @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowData
   1515  */
   1516 int
   1517 video_getSetWindowData(void *arg)
   1518 {
   1519   int returnValue = TEST_COMPLETED;
   1520   const char* title = "video_setGetWindowData Test Window";
   1521   SDL_Window* window;
   1522   const char *referenceName = "TestName";
   1523   const char *name = "TestName";
   1524   const char *referenceName2 = "TestName2";
   1525   const char *name2 = "TestName2";
   1526   int datasize;
   1527   char *referenceUserdata;
   1528   char *userdata;
   1529   char *referenceUserdata2;
   1530   char *userdata2;
   1531   char *result;
   1532   int iteration;
   1533 
   1534   /* Call against new test window */
   1535   window = _createVideoSuiteTestWindow(title);
   1536   if (window == NULL) return TEST_ABORTED;
   1537 
   1538   /* Create testdata */
   1539   datasize = SDLTest_RandomIntegerInRange(1, 32);
   1540   referenceUserdata =  SDLTest_RandomAsciiStringOfSize(datasize);
   1541   if (referenceUserdata == NULL) {
   1542     returnValue = TEST_ABORTED;
   1543     goto cleanup;
   1544   }
   1545   userdata = SDL_strdup(referenceUserdata);
   1546   if (userdata == NULL) {
   1547     returnValue = TEST_ABORTED;
   1548     goto cleanup;
   1549   }
   1550   datasize = SDLTest_RandomIntegerInRange(1, 32);
   1551   referenceUserdata2 =  SDLTest_RandomAsciiStringOfSize(datasize);
   1552   if (referenceUserdata2 == NULL) {
   1553     returnValue = TEST_ABORTED;
   1554     goto cleanup;
   1555   }
   1556   userdata2 = (char *)SDL_strdup(referenceUserdata2);
   1557   if (userdata2 == NULL) {
   1558     returnValue = TEST_ABORTED;
   1559     goto cleanup;
   1560   }
   1561 
   1562   /* Get non-existent data */
   1563   result = (char *)SDL_GetWindowData(window, name);
   1564   SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name);
   1565   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1566   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1567 
   1568   /* Set data */
   1569   result = (char *)SDL_SetWindowData(window, name, userdata);
   1570   SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s)", name, userdata);
   1571   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1572   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1573   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1574 
   1575   /* Get data (twice) */
   1576   for (iteration = 1; iteration <= 2; iteration++) {
   1577     result = (char *)SDL_GetWindowData(window, name);
   1578     SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [iteration %d]", name, iteration);
   1579     SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
   1580     SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1581   }
   1582 
   1583   /* Set data again twice */
   1584   for (iteration = 1; iteration <= 2; iteration++) {
   1585     result = (char *)SDL_SetWindowData(window, name, userdata);
   1586     SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [iteration %d]", name, userdata, iteration);
   1587     SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
   1588     SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1589     SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1590   }
   1591 
   1592   /* Get data again */
   1593   result = (char *)SDL_GetWindowData(window, name);
   1594   SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [again]", name);
   1595   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
   1596   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1597 
   1598   /* Set data with new data */
   1599   result = (char *)SDL_SetWindowData(window, name, userdata2);
   1600   SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [new userdata]", name, userdata2);
   1601   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
   1602   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1603   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1604   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
   1605 
   1606   /* Set data with new data again */
   1607   result = (char *)SDL_SetWindowData(window, name, userdata2);
   1608   SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [new userdata again]", name, userdata2);
   1609   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result);
   1610   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1611   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1612   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
   1613 
   1614   /* Get new data */
   1615   result = (char *)SDL_GetWindowData(window, name);
   1616   SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name);
   1617   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result);
   1618   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1619 
   1620   /* Set data with NULL to clear */
   1621   result = (char *)SDL_SetWindowData(window, name, NULL);
   1622   SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,NULL)", name, userdata);
   1623   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata2, result);
   1624   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1625   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1626   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
   1627 
   1628   /* Set data with NULL to clear again */
   1629   result = (char *)SDL_SetWindowData(window, name, NULL);
   1630   SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,NULL) [again]", name, userdata);
   1631   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1632   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1633   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1634   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata2, userdata2) == 0, "Validate that userdata2 was not changed, expected: %s, got: %s", referenceUserdata2, userdata2);
   1635 
   1636   /* Get non-existent data */
   1637   result = (char *)SDL_GetWindowData(window, name);
   1638   SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name);
   1639   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1640   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1641 
   1642   /* Get non-existent data new name */
   1643   result = (char *)SDL_GetWindowData(window, name2);
   1644   SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s)", name2);
   1645   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1646   SDLTest_AssertCheck(SDL_strcmp(referenceName2, name2) == 0, "Validate that name2 was not changed, expected: %s, got: %s", referenceName2, name2);
   1647 
   1648   /* Set data (again) */
   1649   result = (char *)SDL_SetWindowData(window, name, userdata);
   1650   SDLTest_AssertPass("Call to SDL_SetWindowData(...%s,%s) [again, after clear]", name, userdata);
   1651   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1652   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1653   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, userdata) == 0, "Validate that userdata was not changed, expected: %s, got: %s", referenceUserdata, userdata);
   1654 
   1655   /* Get data (again) */
   1656   result = (char *)SDL_GetWindowData(window, name);
   1657   SDLTest_AssertPass("Call to SDL_GetWindowData(..,%s) [again, after clear]", name);
   1658   SDLTest_AssertCheck(SDL_strcmp(referenceUserdata, result) == 0, "Validate that correct result was returned; expected: %s, got: %s", referenceUserdata, result);
   1659   SDLTest_AssertCheck(SDL_strcmp(referenceName, name) == 0, "Validate that name was not changed, expected: %s, got: %s", referenceName, name);
   1660 
   1661   /* Negative test */
   1662   SDL_ClearError();
   1663   SDLTest_AssertPass("Call to SDL_ClearError()");
   1664 
   1665   /* Set with invalid window */
   1666   result = (char *)SDL_SetWindowData(NULL, name, userdata);
   1667   SDLTest_AssertPass("Call to SDL_SetWindowData(window=NULL)");
   1668   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1669   _checkInvalidWindowError();
   1670 
   1671   /* Set data with NULL name, valid userdata */
   1672   result = (char *)SDL_SetWindowData(window, NULL, userdata);
   1673   SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL)");
   1674   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1675   _checkInvalidParameterError();
   1676 
   1677   /* Set data with empty name, valid userdata */
   1678   result = (char *)SDL_SetWindowData(window, "", userdata);
   1679   SDLTest_AssertPass("Call to SDL_SetWindowData(name='')");
   1680   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1681   _checkInvalidParameterError();
   1682 
   1683   /* Set data with NULL name, NULL userdata */
   1684   result = (char *)SDL_SetWindowData(window, NULL, NULL);
   1685   SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL,userdata=NULL)");
   1686   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1687   _checkInvalidParameterError();
   1688 
   1689   /* Set data with empty name, NULL userdata */
   1690   result = (char *)SDL_SetWindowData(window, "", NULL);
   1691   SDLTest_AssertPass("Call to SDL_SetWindowData(name='',userdata=NULL)");
   1692   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1693   _checkInvalidParameterError();
   1694 
   1695   /* Get with invalid window */
   1696   result = (char *)SDL_GetWindowData(NULL, name);
   1697   SDLTest_AssertPass("Call to SDL_GetWindowData(window=NULL)");
   1698   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1699   _checkInvalidWindowError();
   1700 
   1701   /* Get data with NULL name */
   1702   result = (char *)SDL_GetWindowData(window, NULL);
   1703   SDLTest_AssertPass("Call to SDL_GetWindowData(name=NULL)");
   1704   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1705   _checkInvalidParameterError();
   1706 
   1707   /* Get data with empty name */
   1708   result = (char *)SDL_GetWindowData(window, "");
   1709   SDLTest_AssertPass("Call to SDL_GetWindowData(name='')");
   1710   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
   1711   _checkInvalidParameterError();
   1712 
   1713   /* Clean up */
   1714   _destroyVideoSuiteTestWindow(window);
   1715 
   1716   cleanup:
   1717   SDL_free(referenceUserdata);
   1718   SDL_free(referenceUserdata2);
   1719   SDL_free(userdata);
   1720   SDL_free(userdata2);
   1721 
   1722   return returnValue;
   1723 }
   1724 
   1725 
   1726 /* ================= Test References ================== */
   1727 
   1728 /* Video test cases */
   1729 static const SDLTest_TestCaseReference videoTest1 =
   1730         { (SDLTest_TestCaseFp)video_enableDisableScreensaver, "video_enableDisableScreensaver",  "Enable and disable screenaver while checking state", TEST_ENABLED };
   1731 
   1732 static const SDLTest_TestCaseReference videoTest2 =
   1733         { (SDLTest_TestCaseFp)video_createWindowVariousPositions, "video_createWindowVariousPositions",  "Create windows at various locations", TEST_ENABLED };
   1734 
   1735 static const SDLTest_TestCaseReference videoTest3 =
   1736         { (SDLTest_TestCaseFp)video_createWindowVariousSizes, "video_createWindowVariousSizes",  "Create windows with various sizes", TEST_ENABLED };
   1737 
   1738 static const SDLTest_TestCaseReference videoTest4 =
   1739         { (SDLTest_TestCaseFp)video_createWindowVariousFlags, "video_createWindowVariousFlags",  "Create windows using various flags", TEST_ENABLED };
   1740 
   1741 static const SDLTest_TestCaseReference videoTest5 =
   1742         { (SDLTest_TestCaseFp)video_getWindowFlags, "video_getWindowFlags",  "Get window flags set during SDL_CreateWindow", TEST_ENABLED };
   1743 
   1744 static const SDLTest_TestCaseReference videoTest6 =
   1745         { (SDLTest_TestCaseFp)video_getNumDisplayModes, "video_getNumDisplayModes",  "Use SDL_GetNumDisplayModes function to get number of display modes", TEST_ENABLED };
   1746 
   1747 static const SDLTest_TestCaseReference videoTest7 =
   1748         { (SDLTest_TestCaseFp)video_getNumDisplayModesNegative, "video_getNumDisplayModesNegative",  "Negative tests for SDL_GetNumDisplayModes", TEST_ENABLED };
   1749 
   1750 static const SDLTest_TestCaseReference videoTest8 =
   1751         { (SDLTest_TestCaseFp)video_getClosestDisplayModeCurrentResolution, "video_getClosestDisplayModeCurrentResolution",  "Use function to get closes match to requested display mode for current resolution", TEST_ENABLED };
   1752 
   1753 static const SDLTest_TestCaseReference videoTest9 =
   1754         { (SDLTest_TestCaseFp)video_getClosestDisplayModeRandomResolution, "video_getClosestDisplayModeRandomResolution",  "Use function to get closes match to requested display mode for random resolution", TEST_ENABLED };
   1755 
   1756 static const SDLTest_TestCaseReference videoTest10 =
   1757         { (SDLTest_TestCaseFp)video_getWindowBrightness, "video_getWindowBrightness",  "Get window brightness", TEST_ENABLED };
   1758 
   1759 static const SDLTest_TestCaseReference videoTest11 =
   1760         { (SDLTest_TestCaseFp)video_getWindowBrightnessNegative, "video_getWindowBrightnessNegative",  "Get window brightness with invalid input", TEST_ENABLED };
   1761 
   1762 static const SDLTest_TestCaseReference videoTest12 =
   1763         { (SDLTest_TestCaseFp)video_getWindowDisplayMode, "video_getWindowDisplayMode",  "Get window display mode", TEST_ENABLED };
   1764 
   1765 static const SDLTest_TestCaseReference videoTest13 =
   1766         { (SDLTest_TestCaseFp)video_getWindowDisplayModeNegative, "video_getWindowDisplayModeNegative",  "Get window display mode with invalid input", TEST_ENABLED };
   1767 
   1768 static const SDLTest_TestCaseReference videoTest14 =
   1769         { (SDLTest_TestCaseFp)video_getWindowGammaRamp, "video_getWindowGammaRamp",  "Get window gamma ramp", TEST_ENABLED };
   1770 
   1771 static const SDLTest_TestCaseReference videoTest15 =
   1772         { (SDLTest_TestCaseFp)video_getWindowGammaRampNegative, "video_getWindowGammaRampNegative",  "Get window gamma ramp against invalid input", TEST_ENABLED };
   1773 
   1774 static const SDLTest_TestCaseReference videoTest16 =
   1775         { (SDLTest_TestCaseFp)video_getSetWindowGrab, "video_getSetWindowGrab",  "Checks SDL_GetWindowGrab and SDL_SetWindowGrab positive and negative cases", TEST_ENABLED };
   1776 
   1777 static const SDLTest_TestCaseReference videoTest17 =
   1778         { (SDLTest_TestCaseFp)video_getWindowId, "video_getWindowId",  "Checks SDL_GetWindowID and SDL_GetWindowFromID", TEST_ENABLED };
   1779 
   1780 static const SDLTest_TestCaseReference videoTest18 =
   1781         { (SDLTest_TestCaseFp)video_getWindowPixelFormat, "video_getWindowPixelFormat",  "Checks SDL_GetWindowPixelFormat", TEST_ENABLED };
   1782 
   1783 static const SDLTest_TestCaseReference videoTest19 =
   1784         { (SDLTest_TestCaseFp)video_getSetWindowPosition, "video_getSetWindowPosition",  "Checks SDL_GetWindowPosition and SDL_SetWindowPosition positive and negative cases", TEST_ENABLED };
   1785 
   1786 static const SDLTest_TestCaseReference videoTest20 =
   1787         { (SDLTest_TestCaseFp)video_getSetWindowSize, "video_getSetWindowSize",  "Checks SDL_GetWindowSize and SDL_SetWindowSize positive and negative cases", TEST_ENABLED };
   1788 
   1789 static const SDLTest_TestCaseReference videoTest21 =
   1790         { (SDLTest_TestCaseFp)video_getSetWindowMinimumSize, "video_getSetWindowMinimumSize",  "Checks SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize positive and negative cases", TEST_ENABLED };
   1791 
   1792 static const SDLTest_TestCaseReference videoTest22 =
   1793         { (SDLTest_TestCaseFp)video_getSetWindowMaximumSize, "video_getSetWindowMaximumSize",  "Checks SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize positive and negative cases", TEST_ENABLED };
   1794 
   1795 static const SDLTest_TestCaseReference videoTest23 =
   1796         { (SDLTest_TestCaseFp)video_getSetWindowData, "video_getSetWindowData",  "Checks SDL_SetWindowData and SDL_GetWindowData positive and negative cases", TEST_ENABLED };
   1797 
   1798 /* Sequence of Video test cases */
   1799 static const SDLTest_TestCaseReference *videoTests[] =  {
   1800     &videoTest1, &videoTest2, &videoTest3, &videoTest4, &videoTest5, &videoTest6,
   1801     &videoTest7, &videoTest8, &videoTest9, &videoTest10, &videoTest11, &videoTest12,
   1802     &videoTest13, &videoTest14, &videoTest15, &videoTest16, &videoTest17,
   1803     &videoTest18, &videoTest19, &videoTest20, &videoTest21, &videoTest22,
   1804     &videoTest23, NULL
   1805 };
   1806 
   1807 /* Video test suite (global) */
   1808 SDLTest_TestSuiteReference videoTestSuite = {
   1809     "Video",
   1810     NULL,
   1811     videoTests,
   1812     NULL
   1813 };
   1814