test/testautomation_video.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:09 -0800
changeset 11730 ac6c607e065c
parent 9892 f8e6273be2fa
permissions -rw-r--r--
Enable building the Metal renderer by default, and weak link the Metal framework so the SDL library is safe to use on older Macs
Also generate iOS versions of the Metal shaders
     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 };