This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
testautomation_video.c
1813 lines (1548 loc) · 64.3 KB
1
2
3
4
5
/**
* Video test suite
*/
#include <stdio.h>
6
#include <string.h>
7
8
9
10
11
12
13
14
15
16
17
/* Visual Studio 2008 doesn't have stdint.h */
#if defined(_MSC_VER) && _MSC_VER <= 1500
#define UINT8_MAX ~(Uint8)0
#define UINT16_MAX ~(Uint16)0
#define UINT32_MAX ~(Uint32)0
#define UINT64_MAX ~(Uint64)0
#else
#include <stdint.h>
#endif
18
19
20
#include "SDL.h"
#include "SDL_test.h"
21
22
/* Private helpers */
23
/*
24
25
26
27
28
29
30
31
32
33
34
35
36
* Create a test window
*/
SDL_Window *_createVideoSuiteTestWindow(const char *title)
{
SDL_Window* window;
int x, y, w, h;
SDL_WindowFlags flags;
/* Standard window */
x = SDLTest_RandomIntegerInRange(1, 100);
y = SDLTest_RandomIntegerInRange(1, 100);
w = SDLTest_RandomIntegerInRange(320, 1024);
h = SDLTest_RandomIntegerInRange(320, 768);
37
flags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS;
38
39
40
41
42
43
44
45
46
window = SDL_CreateWindow(title, x, y, w, h, flags);
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d)", x, y, w, h, flags);
SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
return window;
}
/*
47
* Destroy test window
48
49
50
*/
void _destroyVideoSuiteTestWindow(SDL_Window *window)
{
51
if (window != NULL) {
52
53
54
55
56
57
SDL_DestroyWindow(window);
window = NULL;
SDLTest_AssertPass("Call to SDL_DestroyWindow");
}
}
58
59
60
61
62
63
64
65
/* Test case functions */
/**
* @brief Enable and disable screensaver while checking state
*/
int
video_enableDisableScreensaver(void *arg)
{
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
SDL_bool initialResult;
SDL_bool result;
/* Get current state and proceed according to current state */
initialResult = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
if (initialResult == SDL_TRUE) {
/* Currently enabled: disable first, then enable again */
/* Disable screensaver and check */
SDL_DisableScreenSaver();
SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result);
/* Enable screensaver and check */
SDL_EnableScreenSaver();
SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result);
} else {
/* Currently disabled: enable first, then disable again */
/* Enable screensaver and check */
SDL_EnableScreenSaver();
SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result);
/* Disable screensaver and check */
SDL_DisableScreenSaver();
SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");
result = SDL_IsScreenSaverEnabled();
SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");
SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result);
}
return TEST_COMPLETED;
110
111
}
112
113
114
115
116
117
118
119
120
121
/**
* @brief Tests the functionality of the SDL_CreateWindow function using different positions
*/
int
video_createWindowVariousPositions(void *arg)
{
SDL_Window* window;
const char* title = "video_createWindowVariousPositions Test Window";
int x, y, w, h;
int xVariation, yVariation;
122
123
124
125
126
for (xVariation = 0; xVariation < 6; xVariation++) {
for (yVariation = 0; yVariation < 6; yVariation++) {
switch(xVariation) {
case 0:
127
/* Zero X Position */
128
129
130
x = 0;
break;
case 1:
131
/* Random X position inside screen */
132
133
134
x = SDLTest_RandomIntegerInRange(1, 100);
break;
case 2:
135
/* Random X position outside screen (positive) */
136
137
138
x = SDLTest_RandomIntegerInRange(10000, 11000);
break;
case 3:
139
/* Random X position outside screen (negative) */
140
141
142
x = SDLTest_RandomIntegerInRange(-1000, -100);
break;
case 4:
143
/* Centered X position */
144
145
146
x = SDL_WINDOWPOS_CENTERED;
break;
case 5:
147
/* Undefined X position */
148
149
150
151
152
153
x = SDL_WINDOWPOS_UNDEFINED;
break;
}
switch(yVariation) {
case 0:
154
/* Zero X Position */
155
156
157
y = 0;
break;
case 1:
158
/* Random X position inside screen */
159
160
161
y = SDLTest_RandomIntegerInRange(1, 100);
break;
case 2:
162
/* Random X position outside screen (positive) */
163
164
165
y = SDLTest_RandomIntegerInRange(10000, 11000);
break;
case 3:
166
/* Random Y position outside screen (negative) */
167
168
169
y = SDLTest_RandomIntegerInRange(-1000, -100);
break;
case 4:
170
/* Centered Y position */
171
172
173
y = SDL_WINDOWPOS_CENTERED;
break;
case 5:
174
/* Undefined Y position */
175
176
177
y = SDL_WINDOWPOS_UNDEFINED;
break;
}
178
179
180
181
182
183
w = SDLTest_RandomIntegerInRange(32, 96);
h = SDLTest_RandomIntegerInRange(32, 96);
window = SDL_CreateWindow(title, x, y, w, h, SDL_WINDOW_SHOWN);
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h);
SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
184
185
/* Clean up */
186
_destroyVideoSuiteTestWindow(window);
187
}
188
}
189
190
191
192
193
194
195
196
197
198
199
200
201
202
return TEST_COMPLETED;
}
/**
* @brief Tests the functionality of the SDL_CreateWindow function using different sizes
*/
int
video_createWindowVariousSizes(void *arg)
{
SDL_Window* window;
const char* title = "video_createWindowVariousSizes Test Window";
int x, y, w, h;
int wVariation, hVariation;
203
204
205
206
207
208
209
x = SDLTest_RandomIntegerInRange(1, 100);
y = SDLTest_RandomIntegerInRange(1, 100);
for (wVariation = 0; wVariation < 3; wVariation++) {
for (hVariation = 0; hVariation < 3; hVariation++) {
switch(wVariation) {
case 0:
210
/* Width of 1 */
211
212
213
w = 1;
break;
case 1:
214
/* Random "normal" width */
215
216
217
w = SDLTest_RandomIntegerInRange(320, 1920);
break;
case 2:
218
/* Random "large" width */
219
220
221
222
223
224
w = SDLTest_RandomIntegerInRange(2048, 4095);
break;
}
switch(hVariation) {
case 0:
225
/* Height of 1 */
226
227
228
h = 1;
break;
case 1:
229
/* Random "normal" height */
230
231
232
h = SDLTest_RandomIntegerInRange(320, 1080);
break;
case 2:
233
/* Random "large" height */
234
235
236
h = SDLTest_RandomIntegerInRange(2048, 4095);
break;
}
237
238
239
240
window = SDL_CreateWindow(title, x, y, w, h, SDL_WINDOW_SHOWN);
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h);
SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
241
242
/* Clean up */
243
_destroyVideoSuiteTestWindow(window);
244
}
245
}
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
return TEST_COMPLETED;
}
/**
* @brief Tests the functionality of the SDL_CreateWindow function using different flags
*/
int
video_createWindowVariousFlags(void *arg)
{
SDL_Window* window;
const char* title = "video_createWindowVariousFlags Test Window";
int x, y, w, h;
int fVariation;
SDL_WindowFlags flags;
261
262
263
264
265
266
267
268
269
270
271
272
/* Standard window */
x = SDLTest_RandomIntegerInRange(1, 100);
y = SDLTest_RandomIntegerInRange(1, 100);
w = SDLTest_RandomIntegerInRange(320, 1024);
h = SDLTest_RandomIntegerInRange(320, 768);
for (fVariation = 0; fVariation < 13; fVariation++) {
switch(fVariation) {
case 0:
flags = SDL_WINDOW_FULLSCREEN;
/* Skip - blanks screen; comment out next line to run test */
273
continue;
274
275
276
277
break;
case 1:
flags = SDL_WINDOW_FULLSCREEN_DESKTOP;
/* Skip - blanks screen; comment out next line to run test */
278
continue;
279
280
281
break;
case 2:
flags = SDL_WINDOW_OPENGL;
282
break;
283
284
case 3:
flags = SDL_WINDOW_SHOWN;
285
286
break;
case 4:
287
flags = SDL_WINDOW_HIDDEN;
288
break;
289
290
case 5:
flags = SDL_WINDOW_BORDERLESS;
291
break;
292
293
case 6:
flags = SDL_WINDOW_RESIZABLE;
294
break;
295
296
case 7:
flags = SDL_WINDOW_MINIMIZED;
297
break;
298
299
300
case 8:
flags = SDL_WINDOW_MAXIMIZED;
break;
301
case 9:
302
303
flags = SDL_WINDOW_INPUT_GRABBED;
break;
304
case 10:
305
flags = SDL_WINDOW_INPUT_FOCUS;
306
307
break;
case 11:
308
309
flags = SDL_WINDOW_MOUSE_FOCUS;
break;
310
case 12:
311
312
313
flags = SDL_WINDOW_FOREIGN;
break;
}
314
315
316
317
window = SDL_CreateWindow(title, x, y, w, h, flags);
SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d)", x, y, w, h, flags);
SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
318
319
320
/* Clean up */
_destroyVideoSuiteTestWindow(window);
321
322
323
324
325
}
return TEST_COMPLETED;
}
326
327
328
329
330
331
332
333
334
335
336
/**
* @brief Tests the functionality of the SDL_GetWindowFlags function
*/
int
video_getWindowFlags(void *arg)
{
SDL_Window* window;
const char* title = "video_getWindowFlags Test Window";
SDL_WindowFlags flags;
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
344
345
346
if (window != NULL) {
actualFlags = SDL_GetWindowFlags(window);
SDLTest_AssertPass("Call to SDL_GetWindowFlags");
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
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
return TEST_COMPLETED;
}
/**
* @brief Tests the functionality of the SDL_GetNumDisplayModes function
*/
int
video_getNumDisplayModes(void *arg)
{
int result;
int displayNum;
int i;
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays();
SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");
369
/* Make call for each display */
370
371
372
373
for (i=0; i<displayNum; i++) {
result = SDL_GetNumDisplayModes(i);
SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d)", i);
SDLTest_AssertCheck(result >= 1, "Validate returned value from function; expected: >=1; got: %d", result);
374
375
376
377
378
}
return TEST_COMPLETED;
}
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
/**
* @brief Tests negative call to SDL_GetNumDisplayModes function
*/
int
video_getNumDisplayModesNegative(void *arg)
{
int result;
int displayNum;
int displayIndex;
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays();
SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");
/* Invalid boundary values */
displayIndex = SDLTest_RandomSint32BoundaryValue(0, displayNum, SDL_FALSE);
result = SDL_GetNumDisplayModes(displayIndex);
SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/boundary)", displayIndex);
397
398
SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result);
399
400
401
402
/* Large (out-of-bounds) display index */
displayIndex = SDLTest_RandomIntegerInRange(-2000, -1000);
result = SDL_GetNumDisplayModes(displayIndex);
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
406
407
displayIndex = SDLTest_RandomIntegerInRange(1000, 2000);
result = SDL_GetNumDisplayModes(displayIndex);
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
411
412
413
414
415
416
417
418
419
return TEST_COMPLETED;
}
/**
* @brief Tests the functionality of the SDL_GetClosestDisplayMode function against current resolution
*/
int
video_getClosestDisplayModeCurrentResolution(void *arg)
{
int result;
420
421
SDL_DisplayMode current;
SDL_DisplayMode target;
422
423
424
425
426
427
428
429
430
431
SDL_DisplayMode closest;
SDL_DisplayMode* dResult;
int displayNum;
int i;
int variation;
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays();
SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");
432
/* Make calls for each display */
433
434
for (i=0; i<displayNum; i++) {
SDLTest_Log("Testing against display: %d", i);
435
436
437
438
439
440
441
442
/* Get first display mode to get a sane resolution; this should always work */
result = SDL_GetDisplayMode(i, 0, ¤t);
SDLTest_AssertPass("Call to SDL_GetDisplayMode");
SDLTest_AssertCheck(result == 0, "Verify return value, expected: 0, got: %d", result);
if (result != 0) {
return TEST_ABORTED;
}
443
444
445
/* Set the desired resolution equals to current resolution */
target.w = current.w;
446
target.h = current.h;
447
448
449
450
451
for (variation = 0; variation < 8; variation ++) {
/* Vary constraints on other query parameters */
target.format = (variation & 1) ? current.format : 0;
target.refresh_rate = (variation & 2) ? current.refresh_rate : 0;
target.driverdata = (variation & 4) ? current.driverdata : 0;
452
453
454
455
456
/* Make call */
dResult = SDL_GetClosestDisplayMode(i, &target, &closest);
SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=current/variation%d)", variation);
SDLTest_AssertCheck(dResult != NULL, "Verify returned value is not NULL");
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
/* Check that one gets the current resolution back again */
SDLTest_AssertCheck(closest.w == current.w, "Verify returned width matches current width; expected: %d, got: %d", current.w, closest.w);
SDLTest_AssertCheck(closest.h == current.h, "Verify returned height matches current height; expected: %d, got: %d", current.h, closest.h);
SDLTest_AssertCheck(closest.w == dResult->w, "Verify return value matches assigned value; expected: %d, got: %d", closest.w, dResult->w);
SDLTest_AssertCheck(closest.h == dResult->h, "Verify return value matches assigned value; expected: %d, got: %d", closest.h, dResult->h);
}
}
return TEST_COMPLETED;
}
/**
* @brief Tests the functionality of the SDL_GetClosestDisplayMode function against random resolution
*/
int
video_getClosestDisplayModeRandomResolution(void *arg)
{
475
SDL_DisplayMode target;
476
477
478
479
480
481
482
483
484
485
SDL_DisplayMode closest;
SDL_DisplayMode* dResult;
int displayNum;
int i;
int variation;
/* Get number of displays */
displayNum = SDL_GetNumVideoDisplays();
SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");
486
/* Make calls for each display */
487
488
for (i=0; i<displayNum; i++) {
SDLTest_Log("Testing against display: %d", i);
489
490
for (variation = 0; variation < 16; variation ++) {
491
492
493
/* Set random constraints */
target.w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;
494
target.h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;
495
496
497
target.format = (variation & 4) ? SDLTest_RandomIntegerInRange(1, 10) : 0;
target.refresh_rate = (variation & 8) ? SDLTest_RandomIntegerInRange(25, 120) : 0;
target.driverdata = 0;
498
499
500
/* Make call; may or may not find anything, so don't validate any further */
dResult = SDL_GetClosestDisplayMode(i, &target, &closest);
501
SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=random/variation%d)", variation);
502
503
504
505
506
507
508
509
}
}
return TEST_COMPLETED;
}
/**
* @brief Tests call to SDL_GetWindowBrightness
510
511
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowBrightness
512
513
514
515
516
517
518
519
*/
int
video_getWindowBrightness(void *arg)
{
SDL_Window* window;
const char* title = "video_getWindowBrightness Test Window";
float result;
520
/* Call against new test window */
521
522
523
524
525
526
527
window = _createVideoSuiteTestWindow(title);
if (window != NULL) {
result = SDL_GetWindowBrightness(window);
SDLTest_AssertPass("Call to SDL_GetWindowBrightness");
SDLTest_AssertCheck(result >= 0.0 && result <= 1.0, "Validate range of result value; expected: [0.0, 1.0], got: %f", result);
}
528
/* Clean up */
529
_destroyVideoSuiteTestWindow(window);
530
531
532
533
return TEST_COMPLETED;
}
534
535
536
537
538
539
540
541
542
543
544
545
546
/**
* @brief Tests call to SDL_GetWindowBrightness with invalid input
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowBrightness
*/
int
video_getWindowBrightnessNegative(void *arg)
{
const char *invalidWindowError = "Invalid window";
char *lastError;
const char* title = "video_getWindowBrightnessNegative Test Window";
float result;
547
/* Call against invalid window */
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
result = SDL_GetWindowBrightness(NULL);
SDLTest_AssertPass("Call to SDL_GetWindowBrightness(window=NULL)");
SDLTest_AssertCheck(result == 1.0, "Validate result value; expected: 1.0, got: %f", result);
lastError = (char *)SDL_GetError();
SDLTest_AssertPass("SDL_GetError()");
SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
if (lastError != NULL) {
SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0,
"SDL_GetError(): expected message '%s', was message: '%s'",
invalidWindowError,
lastError);
}
return TEST_COMPLETED;
}
/**
* @brief Tests call to SDL_GetWindowDisplayMode
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode
*/
int
video_getWindowDisplayMode(void *arg)
{
SDL_Window* window;
const char* title = "video_getWindowDisplayMode Test Window";
SDL_DisplayMode mode;
int result;
/* Invalidate part of the mode content so we can check values later */
mode.w = -1;
mode.h = -1;
mode.refresh_rate = -1;
582
/* Call against new test window */
583
584
585
586
587
588
589
590
591
592
window = _createVideoSuiteTestWindow(title);
if (window != NULL) {
result = SDL_GetWindowDisplayMode(window, &mode);
SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
SDLTest_AssertCheck(mode.w > 0, "Validate mode.w content; expected: >0, got: %d", mode.w);
SDLTest_AssertCheck(mode.h > 0, "Validate mode.h content; expected: >0, got: %d", mode.h);
SDLTest_AssertCheck(mode.refresh_rate > 0, "Validate mode.refresh_rate content; expected: >0, got: %d", mode.refresh_rate);
}
593
/* Clean up */
594
_destroyVideoSuiteTestWindow(window);
595
596
597
598
return TEST_COMPLETED;
}
599
600
601
602
603
604
/* Helper function that checks for an 'Invalid window' error */
void _checkInvalidWindowError()
{
const char *invalidWindowError = "Invalid window";
char *lastError;
605
lastError = (char *)SDL_GetError();
606
607
608
609
610
611
612
613
SDLTest_AssertPass("SDL_GetError()");
SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
if (lastError != NULL) {
SDLTest_AssertCheck(SDL_strcmp(lastError, invalidWindowError) == 0,
"SDL_GetError(): expected message '%s', was message: '%s'",
invalidWindowError,
lastError);
SDL_ClearError();
614
SDLTest_AssertPass("Call to SDL_ClearError()");
615
616
617
}
}
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
/**
* @brief Tests call to SDL_GetWindowDisplayMode with invalid input
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowDisplayMode
*/
int
video_getWindowDisplayModeNegative(void *arg)
{
const char *expectedError = "Parameter 'mode' is invalid";
char *lastError;
SDL_Window* window;
const char* title = "video_getWindowDisplayModeNegative Test Window";
SDL_DisplayMode mode;
int result;
633
/* Call against new test window */
634
635
636
637
638
639
640
641
642
window = _createVideoSuiteTestWindow(title);
if (window != NULL) {
result = SDL_GetWindowDisplayMode(window, NULL);
SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(...,mode=NULL)");
SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result);
lastError = (char *)SDL_GetError();
SDLTest_AssertPass("SDL_GetError()");
SDLTest_AssertCheck(lastError != NULL, "Verify error message is not NULL");
if (lastError != NULL) {
643
SDLTest_AssertCheck(SDL_strcmp(lastError, expectedError) == 0,
644
645
646
647
648
649
"SDL_GetError(): expected message '%s', was message: '%s'",
expectedError,
lastError);
}
}
650
/* Clean up */
651
_destroyVideoSuiteTestWindow(window);
652
653
654
655
656
/* Call against invalid window */
result = SDL_GetWindowDisplayMode(NULL, &mode);
SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(window=NULL,...)");
SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result);
657
658
_checkInvalidWindowError();
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
return TEST_COMPLETED;
}
/**
* @brief Tests call to SDL_GetWindowGammaRamp
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp
*/
int
video_getWindowGammaRamp(void *arg)
{
SDL_Window* window;
const char* title = "video_getWindowGammaRamp Test Window";
Uint16 red[256];
Uint16 green[256];
Uint16 blue[256];
int result;
677
/* Call against new test window */
678
window = _createVideoSuiteTestWindow(title);
679
if (window == NULL) return TEST_ABORTED;
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
/* Retrieve no channel */
result = SDL_GetWindowGammaRamp(window, NULL, NULL, NULL);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(all NULL)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
/* Retrieve single channel */
result = SDL_GetWindowGammaRamp(window, red, NULL, NULL);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
result = SDL_GetWindowGammaRamp(window, NULL, green, NULL);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(g)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
result = SDL_GetWindowGammaRamp(window, NULL, NULL, blue);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(b)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
/* Retrieve two channels */
result = SDL_GetWindowGammaRamp(window, red, green, NULL);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r, g)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
result = SDL_GetWindowGammaRamp(window, NULL, green, blue);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(g,b)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
result = SDL_GetWindowGammaRamp(window, red, NULL, blue);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r,b)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
/* Retrieve all channels */
result = SDL_GetWindowGammaRamp(window, red, green, blue);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(r,g,b)");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
716
717
/* Clean up */
718
_destroyVideoSuiteTestWindow(window);
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
return TEST_COMPLETED;
}
/**
* @brief Tests call to SDL_GetWindowGammaRamp with invalid input
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGammaRamp
*/
int
video_getWindowGammaRampNegative(void *arg)
{
const char* title = "video_getWindowGammaRampNegative Test Window";
Uint16 red[256];
Uint16 green[256];
Uint16 blue[256];
int result;
737
738
739
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
740
/* Call against invalid window */
741
742
743
result = SDL_GetWindowGammaRamp(NULL, red, green, blue);
SDLTest_AssertPass("Call to SDL_GetWindowGammaRamp(window=NULL,r,g,b)");
SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %f", result);
744
_checkInvalidWindowError();
745
746
747
748
return TEST_COMPLETED;
}
749
/* Helper for setting and checking the window grab state */
750
void
751
752
753
_setAndCheckWindowGrabState(SDL_Window* window, SDL_bool desiredState)
{
SDL_bool currentState;
754
755
756
757
758
759
760
761
762
/* Set state */
SDL_SetWindowGrab(window, desiredState);
SDLTest_AssertPass("Call to SDL_SetWindowGrab(%s)", (desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
/* Get and check state */
currentState = SDL_GetWindowGrab(window);
SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
SDLTest_AssertCheck(
763
764
currentState == desiredState,
"Validate returned state; expected: %s, got: %s",
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
(desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
(currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
}
/**
* @brief Tests call to SDL_GetWindowGrab and SDL_SetWindowGrab
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowGrab
* @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowGrab
*/
int
video_getSetWindowGrab(void *arg)
{
const char* title = "video_getSetWindowGrab Test Window";
SDL_Window* window;
SDL_bool originalState, dummyState, currentState, desiredState;
782
/* Call against new test window */
783
784
785
window = _createVideoSuiteTestWindow(title);
if (window == NULL) return TEST_ABORTED;
786
/* Get state */
787
788
789
790
791
792
793
794
originalState = SDL_GetWindowGrab(window);
SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
/* F */
_setAndCheckWindowGrabState(window, SDL_FALSE);
/* F --> F */
_setAndCheckWindowGrabState(window, SDL_FALSE);
795
796
797
798
799
800
801
802
803
/* F --> T */
_setAndCheckWindowGrabState(window, SDL_TRUE);
/* T --> T */
_setAndCheckWindowGrabState(window, SDL_TRUE);
/* T --> F */
_setAndCheckWindowGrabState(window, SDL_FALSE);
804
805
806
807
/* Negative tests */
dummyState = SDL_GetWindowGrab(NULL);
SDLTest_AssertPass("Call to SDL_GetWindowGrab(window=NULL)");
808
_checkInvalidWindowError();
809
810
811
SDL_SetWindowGrab(NULL, SDL_FALSE);
SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
812
_checkInvalidWindowError();
813
814
815
SDL_SetWindowGrab(NULL, SDL_TRUE);
SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
816
_checkInvalidWindowError();
817
818
819
820
821
822
/* State should still be F */
desiredState = SDL_FALSE;
currentState = SDL_GetWindowGrab(window);
SDLTest_AssertPass("Call to SDL_GetWindowGrab()");
SDLTest_AssertCheck(
823
824
currentState == desiredState,
"Validate returned state; expected: %s, got: %s",
825
826
(desiredState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE",
(currentState == SDL_FALSE) ? "SDL_FALSE" : "SDL_TRUE");
827
828
/* Restore state */
829
830
_setAndCheckWindowGrabState(window, originalState);
831
/* Clean up */
832
833
834
835
836
_destroyVideoSuiteTestWindow(window);
return TEST_COMPLETED;
}
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
/**
* @brief Tests call to SDL_GetWindowID and SDL_GetWindowFromID
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowID
* @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowFromID
*/
int
video_getWindowId(void *arg)
{
const char* title = "video_getWindowId Test Window";
SDL_Window* window;
SDL_Window* result;
Uint32 id, randomId;
852
/* Call against new test window */
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
window = _createVideoSuiteTestWindow(title);
if (window == NULL) return TEST_ABORTED;
/* Get ID */
id = SDL_GetWindowID(window);
SDLTest_AssertPass("Call to SDL_GetWindowID()");
/* Get window from ID */
result = SDL_GetWindowFromID(id);
SDLTest_AssertPass("Call to SDL_GetWindowID(%d)", id);
SDLTest_AssertCheck(result == window, "Verify result matches window pointer");
/* Get window from random large ID, no result check */
randomId = SDLTest_RandomIntegerInRange(UINT8_MAX,UINT16_MAX);
result = SDL_GetWindowFromID(randomId);
SDLTest_AssertPass("Call to SDL_GetWindowID(%d/random_large)", randomId);
/* Get window from 0 and Uint32 max ID, no result check */
result = SDL_GetWindowFromID(0);
SDLTest_AssertPass("Call to SDL_GetWindowID(0)");
result = SDL_GetWindowFromID(UINT32_MAX);
SDLTest_AssertPass("Call to SDL_GetWindowID(UINT32_MAX)");
876
/* Clean up */
877
_destroyVideoSuiteTestWindow(window);
878
879
880
881
882
883
884
/* Get window from ID for closed window*/
result = SDL_GetWindowFromID(id);
SDLTest_AssertPass("Call to SDL_GetWindowID(%d/closed_window)", id);
SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
/* Negative test */
885
886
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
887
888
id = SDL_GetWindowID(NULL);
SDLTest_AssertPass("Call to SDL_GetWindowID(window=NULL)");
889
_checkInvalidWindowError();
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
return TEST_COMPLETED;
}
/**
* @brief Tests call to SDL_GetWindowPixelFormat
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPixelFormat
*/
int
video_getWindowPixelFormat(void *arg)
{
const char* title = "video_getWindowPixelFormat Test Window";
SDL_Window* window;
Uint32 format;
906
/* Call against new test window */
907
908
909
910
911
912
913
window = _createVideoSuiteTestWindow(title);
if (window == NULL) return TEST_ABORTED;
/* Get format */
format = SDL_GetWindowPixelFormat(window);
SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat()");
SDLTest_AssertCheck(format != SDL_PIXELFORMAT_UNKNOWN, "Verify that returned format is valid; expected: != %d, got: %d", SDL_PIXELFORMAT_UNKNOWN, format);
914
915
/* Clean up */
916
_destroyVideoSuiteTestWindow(window);
917
918
/* Negative test */
919
920
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
921
922
format = SDL_GetWindowPixelFormat(NULL);
SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat(window=NULL)");
923
_checkInvalidWindowError();
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
return TEST_COMPLETED;
}
/**
* @brief Tests call to SDL_GetWindowPosition and SDL_SetWindowPosition
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetWindowPosition
* @sa http://wiki.libsdl.org/moin.fcg/SDL_SetWindowPosition
*/
int
video_getSetWindowPosition(void *arg)
{
const char* title = "video_getSetWindowPosition Test Window";
SDL_Window* window;
int xVariation, yVariation;
int referenceX, referenceY;
int currentX, currentY;
int desiredX, desiredY;
944
/* Call against new test window */
945
946
window = _createVideoSuiteTestWindow(title);
if (window == NULL) return TEST_ABORTED;
947
948
949
950
951
for (xVariation = 0; xVariation < 4; xVariation++) {
for (yVariation = 0; yVariation < 4; yVariation++) {
switch(xVariation) {
case 0:
952
/* Zero X Position */
953
954
955
desiredX = 0;
break;
case 1:
956
/* Random X position inside screen */
957
958
959
desiredX = SDLTest_RandomIntegerInRange(1, 100);
break;
case 2:
960
/* Random X position outside screen (positive) */
961
962
963
desiredX = SDLTest_RandomIntegerInRange(10000, 11000);
break;
case 3:
964
/* Random X position outside screen (negative) */
965
966
967
968
969
970
desiredX = SDLTest_RandomIntegerInRange(-1000, -100);
break;
}
switch(yVariation) {
case 0:
971
/* Zero X Position */
972
973
974
desiredY = 0;
break;
case 1:
975
/* Random X position inside screen */
976
977
978
desiredY = SDLTest_RandomIntegerInRange(1, 100);
break;
case 2:
979
/* Random X position outside screen (positive) */
980
981
982
desiredY = SDLTest_RandomIntegerInRange(10000, 11000);
break;
case 3:
983
/* Random Y position outside screen (negative) */
984
985
986
987
988
989
990
desiredY = SDLTest_RandomIntegerInRange(-1000, -100);
break;
}
/* Set position */
SDL_SetWindowPosition(window, desiredX, desiredY);
SDLTest_AssertPass("Call to SDL_SetWindowPosition(...,%d,%d)", desiredX, desiredY);
991
992
993
994
995
996
997
998
999
1000
/* Get position */
currentX = desiredX + 1;
currentY = desiredY + 1;
SDL_GetWindowPosition(window, ¤tX, ¤tY);
SDLTest_AssertPass("Call to SDL_GetWindowPosition()");
SDLTest_AssertCheck(desiredX == currentX, "Verify returned X position; expected: %d, got: %d", desiredX, currentX);
SDLTest_AssertCheck(desiredY == currentY, "Verify returned Y position; expected: %d, got: %d", desiredY, currentY);
/* Get position X */