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, ¤t);
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, ¤tX, ¤tY);
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, ¤tX, 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, ¤tY);
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, ¤tX, ¤tY);
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, ¤tW, ¤tH);
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, ¤tW, 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, ¤tH);
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, ¤tW, ¤tH);
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, ¤tW, ¤tH);
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, ¤tW, 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, ¤tH);
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, ¤tW, ¤tH);
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, ¤tW, ¤tH);
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, ¤tW, 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, ¤tH);
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, ¤tW, ¤tH);
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