test/testautomation_video.c
author Sam Lantinga <slouken@libsdl.org>
Fri, 28 Nov 2014 04:51:33 -0800
changeset 9246 a761913e5e91
parent 9219 c65108ddbeb0
child 9254 6c469ea796e4
permissions -rw-r--r--
Fixed bug 2786 - "UCS-2-INTERNAL" iconv encoding is not supported everywhere, use UTF-16LE instead

Jonas Kulla

src/main/windows/SDL_windows_main.c:137:
cmdline = SDL_iconv_string("UTF-8", "UCS-2-INTERNAL", (char *)(text), (SDL_wcslen(text)+1)*sizeof(WCHAR));

I'm trying to compile an SDL2 application for windows using the mingw-w64 32bit toolchain provided by my distro (Fedora 19). However, even the simplest test program that does nothing at all fails to startup with a "Fatal error - out of memory" message because the mingw iconv library provided by my distro does not support the "UCS-2-INTERNAL" encoding and the conversion returns null.

From my little bit of research, it turns out that even though this encoding is supported by the external GNU libiconv library, some glibc versions (?) don't support it with their internal iconv routines, and will instead provide the native endian encoding when "UCS-2" is specified.

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