test/testautomation_video.c
author Andreas Schiffler <aschiffler@ferzkopp.net>
Sun, 30 Nov 2014 20:55:27 -0800
changeset 9254 6c469ea796e4
parent 9219 c65108ddbeb0
child 9310 01f418c16580
permissions -rw-r--r--
Fix assert format strings/parameters in testautomation modules; improve output of SDL_CompareSurfaces to aid debugging; update platform_testSetErrorInvalidInput for SDL changes
     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: %i", 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);
  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);
  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 };