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  */
_createVideoSuiteTestWindow(const char * title)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  */
_destroyVideoSuiteTestWindow(SDL_Window * window)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
video_enableDisableScreensaver(void * arg)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
video_createWindowVariousPositions(void * arg)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
video_createWindowVariousSizes(void * arg)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
video_createWindowVariousFlags(void * arg)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
video_getWindowFlags(void * arg)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
video_getNumDisplayModes(void * arg)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
video_getNumDisplayModesNegative(void * arg)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
video_getClosestDisplayModeCurrentResolution(void * arg)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
video_getClosestDisplayModeRandomResolution(void * arg)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
video_getWindowBrightness(void * arg)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
video_getWindowBrightnessNegative(void * arg)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
video_getWindowDisplayMode(void * arg)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 */
_checkInvalidWindowError()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
video_getWindowDisplayModeNegative(void * arg)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
video_getWindowGammaRamp(void * arg)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
video_getWindowGammaRampNegative(void * arg)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
_setAndCheckWindowGrabState(SDL_Window * window,SDL_bool desiredState)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
video_getSetWindowGrab(void * arg)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
video_getWindowId(void * arg)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
video_getWindowPixelFormat(void * arg)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
video_getSetWindowPosition(void * arg)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 */
_checkInvalidParameterError()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
video_getSetWindowSize(void * arg)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
video_getSetWindowMinimumSize(void * arg)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
video_getSetWindowMaximumSize(void * arg)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
video_getSetWindowData(void * arg)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 };
1812