Mercurial Mercurial > SDL / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
test/testautomation_video.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 29 Aug 2013 08:29:21 -0700
changeset 7719 31b5f9ff36ca
parent 7677 871d43c6968a
child 9219 c65108ddbeb0
permissions -rw-r--r--
Christoph Mallon: Remove pointless if (x) before SDL_free(x) 
     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 };
SDL