SDL  2.0
testautomation_video.c
Go to the documentation of this file.
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  */
27 {
29  int x, y, w, h;
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);
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  */
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
65 {
66  SDL_bool initialResult;
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 */
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 */
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 */
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 */
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
117 {
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 */
145  break;
146  case 5:
147  /* Undefined X position */
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 */
172  break;
173  case 5:
174  /* Undefined Y position */
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 */
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
198 {
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 */
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
255 {
257  const char* title = "video_createWindowVariousFlags Test Window";
258  int x, y, w, h;
259  int fVariation;
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:
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 */
321  }
322 
323  return TEST_COMPLETED;
324 }
325 
326 
327 /**
328  * @brief Tests the functionality of the SDL_GetWindowFlags function
329  */
330 int
332 {
334  const char* title = "video_getWindowFlags Test Window";
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 */
351 
352  return TEST_COMPLETED;
353 }
354 
355 /**
356  * @brief Tests the functionality of the SDL_GetNumDisplayModes function
357  */
358 int
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
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
418 {
419  int result;
420  SDL_DisplayMode current;
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
474 {
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
515 {
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 */
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
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
570 {
572  const char* title = "video_getWindowDisplayMode Test Window";
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 */
594 
595  return TEST_COMPLETED;
596 }
597 
598 /* Helper function that checks for an 'Invalid window' error */
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
624 {
625  const char *expectedError = "Parameter 'mode' is invalid";
626  char *lastError;
628  const char* title = "video_getWindowDisplayModeNegative Test Window";
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 */
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);
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
668 {
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 */
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
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);
743 
744  return TEST_COMPLETED;
745 }
746 
747 /* Helper for setting and checking the window grab state */
748 void
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()");
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
775 {
776  const char* title = "video_getSetWindowGrab Test 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 */
790 
791  /* F --> F */
793 
794  /* F --> T */
796 
797  /* T --> T */
799 
800  /* T --> F */
802 
803  /* Negative tests */
804  dummyState = SDL_GetWindowGrab(NULL);
805  SDLTest_AssertPass("Call to SDL_GetWindowGrab(window=NULL)");
807 
809  SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
811 
813  SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
815 
816  /* State should still be F */
817  desiredState = SDL_FALSE;
818  currentState = SDL_GetWindowGrab(window);
819  SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
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 */
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
844 {
845  const char* title = "video_getWindowId Test Window";
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 */
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)");
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
899 {
900  const char* title = "video_getWindowPixelFormat Test 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 */
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)");
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
934 {
935  const char* title = "video_getSetWindowPosition Test 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 */
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)");
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);
1038 
1040  SDLTest_AssertPass("Call to SDL_GetWindowPosition(NULL, NULL, NULL)");
1042 
1043  SDL_SetWindowPosition(NULL, desiredX, desiredY);
1044  SDLTest_AssertPass("Call to SDL_SetWindowPosition(window=NULL)");
1046 
1047  return TEST_COMPLETED;
1048 }
1049 
1050 /* Helper function that checks for an 'Invalid parameter' error */
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
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);
1195  }
1196  }
1197  }
1198 
1199  /* Clean up */
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)");
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);
1221 
1223  SDLTest_AssertPass("Call to SDL_GetWindowSize(NULL, NULL, NULL)");
1225 
1226  SDL_SetWindowSize(NULL, desiredW, desiredH);
1227  SDLTest_AssertPass("Call to SDL_SetWindowSize(window=NULL)");
1229 
1230  return TEST_COMPLETED;
1231 }
1232 
1233 /**
1234  * @brief Tests call to SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize
1235  *
1236  */
1237 int
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 */
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);
1334  }
1335  }
1336  }
1337 
1338  /* Clean up */
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)");
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);
1360 
1362  SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(NULL, NULL, NULL)");
1364 
1365  SDL_SetWindowMinimumSize(NULL, desiredW, desiredH);
1366  SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(window=NULL)");
1368 
1369  return TEST_COMPLETED;
1370 }
1371 
1372 /**
1373  * @brief Tests call to SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize
1374  *
1375  */
1376 int
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 */
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);
1469  }
1470  }
1471  }
1472 
1473  /* Clean up */
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)");
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);
1495 
1497  SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(NULL, NULL, NULL)");
1499 
1500  SDL_SetWindowMaximumSize(NULL, desiredW, desiredH);
1501  SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(window=NULL)");
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
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");
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");
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");
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");
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");
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");
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");
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");
1710 
1711  /* Clean up */
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 */
1728  { (SDLTest_TestCaseFp)video_enableDisableScreensaver, "video_enableDisableScreensaver", "Enable and disable screenaver while checking state", TEST_ENABLED };
1729 
1731  { (SDLTest_TestCaseFp)video_createWindowVariousPositions, "video_createWindowVariousPositions", "Create windows at various locations", TEST_ENABLED };
1732 
1734  { (SDLTest_TestCaseFp)video_createWindowVariousSizes, "video_createWindowVariousSizes", "Create windows with various sizes", TEST_ENABLED };
1735 
1737  { (SDLTest_TestCaseFp)video_createWindowVariousFlags, "video_createWindowVariousFlags", "Create windows using various flags", TEST_ENABLED };
1738 
1740  { (SDLTest_TestCaseFp)video_getWindowFlags, "video_getWindowFlags", "Get window flags set during SDL_CreateWindow", TEST_ENABLED };
1741 
1743  { (SDLTest_TestCaseFp)video_getNumDisplayModes, "video_getNumDisplayModes", "Use SDL_GetNumDisplayModes function to get number of display modes", TEST_ENABLED };
1744 
1746  { (SDLTest_TestCaseFp)video_getNumDisplayModesNegative, "video_getNumDisplayModesNegative", "Negative tests for SDL_GetNumDisplayModes", TEST_ENABLED };
1747 
1749  { (SDLTest_TestCaseFp)video_getClosestDisplayModeCurrentResolution, "video_getClosestDisplayModeCurrentResolution", "Use function to get closes match to requested display mode for current resolution", TEST_ENABLED };
1750 
1752  { (SDLTest_TestCaseFp)video_getClosestDisplayModeRandomResolution, "video_getClosestDisplayModeRandomResolution", "Use function to get closes match to requested display mode for random resolution", TEST_ENABLED };
1753 
1755  { (SDLTest_TestCaseFp)video_getWindowBrightness, "video_getWindowBrightness", "Get window brightness", TEST_ENABLED };
1756 
1758  { (SDLTest_TestCaseFp)video_getWindowBrightnessNegative, "video_getWindowBrightnessNegative", "Get window brightness with invalid input", TEST_ENABLED };
1759 
1761  { (SDLTest_TestCaseFp)video_getWindowDisplayMode, "video_getWindowDisplayMode", "Get window display mode", TEST_ENABLED };
1762 
1764  { (SDLTest_TestCaseFp)video_getWindowDisplayModeNegative, "video_getWindowDisplayModeNegative", "Get window display mode with invalid input", TEST_ENABLED };
1765 
1767  { (SDLTest_TestCaseFp)video_getWindowGammaRamp, "video_getWindowGammaRamp", "Get window gamma ramp", TEST_ENABLED };
1768 
1770  { (SDLTest_TestCaseFp)video_getWindowGammaRampNegative, "video_getWindowGammaRampNegative", "Get window gamma ramp against invalid input", TEST_ENABLED };
1771 
1773  { (SDLTest_TestCaseFp)video_getSetWindowGrab, "video_getSetWindowGrab", "Checks SDL_GetWindowGrab and SDL_SetWindowGrab positive and negative cases", TEST_ENABLED };
1774 
1776  { (SDLTest_TestCaseFp)video_getWindowId, "video_getWindowId", "Checks SDL_GetWindowID and SDL_GetWindowFromID", TEST_ENABLED };
1777 
1779  { (SDLTest_TestCaseFp)video_getWindowPixelFormat, "video_getWindowPixelFormat", "Checks SDL_GetWindowPixelFormat", TEST_ENABLED };
1780 
1782  { (SDLTest_TestCaseFp)video_getSetWindowPosition, "video_getSetWindowPosition", "Checks SDL_GetWindowPosition and SDL_SetWindowPosition positive and negative cases", TEST_ENABLED };
1783 
1785  { (SDLTest_TestCaseFp)video_getSetWindowSize, "video_getSetWindowSize", "Checks SDL_GetWindowSize and SDL_SetWindowSize positive and negative cases", TEST_ENABLED };
1786 
1788  { (SDLTest_TestCaseFp)video_getSetWindowMinimumSize, "video_getSetWindowMinimumSize", "Checks SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize positive and negative cases", TEST_ENABLED };
1789 
1791  { (SDLTest_TestCaseFp)video_getSetWindowMaximumSize, "video_getSetWindowMaximumSize", "Checks SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize positive and negative cases", TEST_ENABLED };
1792 
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 */
1802  &videoTest23, NULL
1803 };
1804 
1805 /* Video test suite (global) */
1807  "Video",
1808  NULL,
1809  videoTests,
1810  NULL
1811 };
#define SDL_SetWindowMaximumSize
static const SDLTest_TestCaseReference videoTest10
#define SDL_ClearError
static const SDLTest_TestCaseReference videoTest18
GLuint id
#define SDL_GetWindowData
int video_getClosestDisplayModeCurrentResolution(void *arg)
Tests the functionality of the SDL_GetClosestDisplayMode function against current resolution...
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:139
SDL_WindowFlags
The flags on a window.
Definition: SDL_video.h:97
static const SDLTest_TestCaseReference videoTest9
#define SDL_GetError
#define TEST_ABORTED
GLuint64EXT * result
#define SDL_GetDisplayMode
#define SDL_IsScreenSaverEnabled
#define SDL_GetWindowID
#define SDL_SetWindowMinimumSize
static const SDLTest_TestCaseReference videoTest5
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
Sint32 SDLTest_RandomIntegerInRange(Sint32 min, Sint32 max)
static const SDLTest_TestCaseReference videoTest17
int video_getWindowGammaRamp(void *arg)
Tests call to SDL_GetWindowGammaRamp.
Sint32 SDLTest_RandomSint32(void)
static const SDLTest_TestCaseReference videoTest1
void SDLTest_AssertPass(SDL_PRINTF_FORMAT_STRING const char *assertDescription,...) SDL_PRINTF_VARARG_FUNC(1)
Explicitly pass without checking an assertion condition. Updates assertion counter.
static const SDLTest_TestCaseReference videoTest16
SDLTest_TestSuiteReference videoTestSuite
static const SDLTest_TestCaseReference videoTest19
GLfloat GLfloat GLfloat GLfloat h
#define SDL_SetWindowSize
int video_getNumDisplayModesNegative(void *arg)
Tests negative call to SDL_GetNumDisplayModes function.
int video_getWindowDisplayModeNegative(void *arg)
Tests call to SDL_GetWindowDisplayMode with invalid input.
int video_createWindowVariousFlags(void *arg)
Tests the functionality of the SDL_CreateWindow function using different flags.
The structure that defines a display mode.
Definition: SDL_video.h:53
#define SDL_GetWindowFlags
GLbyte green
int video_createWindowVariousSizes(void *arg)
Tests the functionality of the SDL_CreateWindow function using different sizes.
#define SDL_CreateWindow
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:130
int video_getWindowBrightnessNegative(void *arg)
Tests call to SDL_GetWindowBrightness with invalid input.
uint32_t Uint32
Definition: SDL_stdinc.h:181
int video_getNumDisplayModes(void *arg)
Tests the functionality of the SDL_GetNumDisplayModes function.
int video_getWindowFlags(void *arg)
Tests the functionality of the SDL_GetWindowFlags function.
static const SDLTest_TestCaseReference videoTest20
#define SDL_strncmp
static const SDLTest_TestCaseReference videoTest6
#define SDL_GetWindowGammaRamp
GLuint const GLchar * name
int video_getSetWindowSize(void *arg)
Tests call to SDL_GetWindowSize and SDL_SetWindowSize.
static void iteration()
const GLubyte GLuint red
Definition: SDL_glfuncs.h:79
static const SDLTest_TestCaseReference videoTest23
#define SDL_GetNumVideoDisplays
void _setAndCheckWindowGrabState(SDL_Window *window, SDL_bool desiredState)
#define SDL_SetWindowData
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
#define SDL_GetWindowSize
int(* SDLTest_TestCaseFp)(void *arg)
static const SDLTest_TestCaseReference videoTest4
int video_enableDisableScreensaver(void *arg)
Enable and disable screensaver while checking state.
void _checkInvalidWindowError()
char * SDLTest_RandomAsciiStringOfSize(int size)
#define SDL_GetWindowDisplayMode
#define SDL_SetWindowGrab
int SDLTest_AssertCheck(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *assertDescription,...) SDL_PRINTF_VARARG_FUNC(2)
Assert for test cases that logs but does not break execution flow on failures. Updates assertion coun...
static const SDLTest_TestCaseReference videoTest22
#define SDL_DisableScreenSaver
static const SDLTest_TestCaseReference * videoTests[]
static const SDLTest_TestCaseReference videoTest2
#define SDL_EnableScreenSaver
#define SDL_free
Sint32 SDLTest_RandomSint32BoundaryValue(Sint32 boundary1, Sint32 boundary2, SDL_bool validDomain)
void * driverdata
Definition: SDL_video.h:59
static const SDLTest_TestCaseReference videoTest7
int video_getSetWindowMaximumSize(void *arg)
Tests call to SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize.
int video_createWindowVariousPositions(void *arg)
Tests the functionality of the SDL_CreateWindow function using different positions.
static const SDLTest_TestCaseReference videoTest21
static const SDLTest_TestCaseReference videoTest8
GLenum mode
GLubyte GLubyte GLubyte GLubyte w
#define SDL_GetDisplayBounds
int video_getSetWindowMinimumSize(void *arg)
Tests call to SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize.
int video_getWindowDisplayMode(void *arg)
Tests call to SDL_GetWindowDisplayMode.
#define SDL_GetWindowPosition
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
#define SDL_GetWindowMinimumSize
#define SDL_GetWindowFromID
#define TEST_COMPLETED
int w
Definition: SDL_rect.h:67
static const SDLTest_TestCaseReference videoTest13
void _destroyVideoSuiteTestWindow(SDL_Window *window)
#define SDL_GetWindowBrightness
int video_getWindowBrightness(void *arg)
Tests call to SDL_GetWindowBrightness.
#define TEST_ENABLED
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
GLenum target
int video_getWindowId(void *arg)
Tests call to SDL_GetWindowID and SDL_GetWindowFromID.
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:139
static const SDLTest_TestCaseReference videoTest14
GLbitfield flags
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
#define SDL_strlen
int h
Definition: SDL_rect.h:67
#define SDL_strdup
int video_getClosestDisplayModeRandomResolution(void *arg)
Tests the functionality of the SDL_GetClosestDisplayMode function against random resolution.
The type used to identify a window.
Definition: SDL_sysvideo.h:73
GLbyte GLbyte blue
#define SDL_GetWindowGrab
#define SDL_GetWindowPixelFormat
static const SDLTest_TestCaseReference videoTest15
uint16_t Uint16
Definition: SDL_stdinc.h:169
void SDLTest_Log(SDL_PRINTF_FORMAT_STRING const char *fmt,...) SDL_PRINTF_VARARG_FUNC(1)
Prints given message with a timestamp in the TEST category and INFO priority.
Definition: SDL_test_log.c:85
static const SDLTest_TestCaseReference videoTest12
#define SDL_GetWindowMaximumSize
#define SDL_GetNumDisplayModes
#define SDL_strcmp
Uint32 format
Definition: SDL_video.h:55
int video_getWindowGammaRampNegative(void *arg)
Tests call to SDL_GetWindowGammaRamp with invalid input.
void _checkInvalidParameterError()
int video_getSetWindowData(void *arg)
Tests call to SDL_SetWindowData and SDL_GetWindowData.
int video_getSetWindowGrab(void *arg)
Tests call to SDL_GetWindowGrab and SDL_SetWindowGrab.
#define SDL_GetClosestDisplayMode
static void cleanup(void)
Definition: testfile.c:44
int video_getWindowPixelFormat(void *arg)
Tests call to SDL_GetWindowPixelFormat.
static const SDLTest_TestCaseReference videoTest3
static const SDLTest_TestCaseReference videoTest11
#define SDL_DestroyWindow
int video_getSetWindowPosition(void *arg)
Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition.
#define SDL_SetWindowPosition
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
SDL_Window * _createVideoSuiteTestWindow(const char *title)