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