SDL  2.0
testautomation_sdltest.c
Go to the documentation of this file.
1 /**
2  * SDL_test test suite
3  */
4 
5 #include <limits.h>
6 /* Visual Studio 2008 doesn't have stdint.h */
7 #if defined(_MSC_VER) && _MSC_VER <= 1500
8 #define UINT8_MAX _UI8_MAX
9 #define UINT16_MAX _UI16_MAX
10 #define UINT32_MAX _UI32_MAX
11 #define INT64_MIN _I64_MIN
12 #define INT64_MAX _I64_MAX
13 #define UINT64_MAX _UI64_MAX
14 #else
15 #include <stdint.h>
16 #endif
17 
18 #include <stdio.h>
19 #include <float.h>
20 #include <ctype.h>
21 
22 #include "SDL.h"
23 #include "SDL_test.h"
24 
25 /* Test case functions */
26 
27 /* Forward declarations for internal harness functions */
28 extern char *SDLTest_GenerateRunSeed(const int length);
29 
30 /**
31  * @brief Calls to SDLTest_GenerateRunSeed()
32  */
33 int
35 {
36  char* result;
37  size_t i, l;
38  int j;
39 
40  for (i = 1; i <= 10; i += 3) {
41  result = SDLTest_GenerateRunSeed((const int)i);
42  SDLTest_AssertPass("Call to SDLTest_GenerateRunSeed()");
43  SDLTest_AssertCheck(result != NULL, "Verify returned value is not NULL");
44  if (result != NULL) {
45  l = SDL_strlen(result);
46  SDLTest_AssertCheck(l == i, "Verify length of returned value is %d, got: %d", (int) i, (int) l);
47  SDL_free(result);
48  }
49  }
50 
51  /* Negative cases */
52  for (j = -2; j <= 0; j++) {
53  result = SDLTest_GenerateRunSeed((const int)j);
54  SDLTest_AssertPass("Call to SDLTest_GenerateRunSeed()");
55  SDLTest_AssertCheck(result == NULL, "Verify returned value is not NULL");
56  }
57 
58  return TEST_COMPLETED;
59 }
60 
61 /**
62  * @brief Calls to SDLTest_GetFuzzerInvocationCount()
63  */
64 int
66 {
67  Uint8 result;
68  int fuzzerCount1, fuzzerCount2;
69 
70  fuzzerCount1 = SDLTest_GetFuzzerInvocationCount();
71  SDLTest_AssertPass("Call to SDLTest_GetFuzzerInvocationCount()");
72  SDLTest_AssertCheck(fuzzerCount1 >= 0, "Verify returned value, expected: >=0, got: %d", fuzzerCount1);
73 
74  result = SDLTest_RandomUint8();
75  SDLTest_AssertPass("Call to SDLTest_RandomUint8(), returned %d", result);
76 
77  fuzzerCount2 = SDLTest_GetFuzzerInvocationCount();
78  SDLTest_AssertPass("Call to SDLTest_GetFuzzerInvocationCount()");
79  SDLTest_AssertCheck(fuzzerCount2 > fuzzerCount1, "Verify returned value, expected: >%d, got: %d", fuzzerCount1, fuzzerCount2);
80 
81  return TEST_COMPLETED;
82 }
83 
84 
85 /**
86  * @brief Calls to random number generators
87  */
88 int
90 {
91  Sint64 result;
92  Uint64 uresult;
93  double dresult;
94  Uint64 umax;
95  Sint64 min, max;
96 
97  result = (Sint64)SDLTest_RandomUint8();
98  umax = (1 << 8) - 1;
99  SDLTest_AssertPass("Call to SDLTest_RandomUint8");
100  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%"SDL_PRIu64"], got: %"SDL_PRIs64, umax, result);
101 
102  result = (Sint64)SDLTest_RandomSint8();
103  min = 0 - (1 << 7);
104  max = (1 << 7) - 1;
105  SDLTest_AssertPass("Call to SDLTest_RandomSint8");
106  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
107 
108  result = (Sint64)SDLTest_RandomUint16();
109  umax = (1 << 16) - 1;
110  SDLTest_AssertPass("Call to SDLTest_RandomUint16");
111  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%"SDL_PRIu64"], got: %"SDL_PRIs64, umax, result);
112 
113  result = (Sint64)SDLTest_RandomSint16();
114  min = 0 - (1 << 15);
115  max = (1 << 15) - 1;
116  SDLTest_AssertPass("Call to SDLTest_RandomSint16");
117  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
118 
119  result = (Sint64)SDLTest_RandomUint32();
120  umax = ((Uint64)1 << 32) - 1;
121  SDLTest_AssertPass("Call to SDLTest_RandomUint32");
122  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%"SDL_PRIu64"], got: %"SDL_PRIs64, umax, result);
123 
124  result = (Sint64)SDLTest_RandomSint32();
125  min = 0 - ((Sint64)1 << 31);
126  max = ((Sint64)1 << 31) - 1;
127  SDLTest_AssertPass("Call to SDLTest_RandomSint32");
128  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
129 
130  uresult = SDLTest_RandomUint64();
131  SDLTest_AssertPass("Call to SDLTest_RandomUint64");
132 
133  result = SDLTest_RandomSint64();
134  SDLTest_AssertPass("Call to SDLTest_RandomSint64");
135 
136  dresult = (double)SDLTest_RandomUnitFloat();
137  SDLTest_AssertPass("Call to SDLTest_RandomUnitFloat");
138  SDLTest_AssertCheck(dresult >= 0.0 && dresult < 1.0, "Verify result value, expected: [0.0,1.0[, got: %e", dresult);
139 
140  dresult = (double)SDLTest_RandomFloat();
141  SDLTest_AssertPass("Call to SDLTest_RandomFloat");
142  SDLTest_AssertCheck(dresult >= (double)(-FLT_MAX) && dresult <= (double)FLT_MAX, "Verify result value, expected: [%e,%e], got: %e", (double)(-FLT_MAX), (double)FLT_MAX, dresult);
143 
144  dresult = (double)SDLTest_RandomUnitDouble();
145  SDLTest_AssertPass("Call to SDLTest_RandomUnitDouble");
146  SDLTest_AssertCheck(dresult >= 0.0 && dresult < 1.0, "Verify result value, expected: [0.0,1.0[, got: %e", dresult);
147 
148  dresult = SDLTest_RandomDouble();
149  SDLTest_AssertPass("Call to SDLTest_RandomDouble");
150 
151  return TEST_COMPLETED;
152 }
153 
154 /*
155  * @brief Calls to random boundary number generators for Uint8
156  */
157 int
159 {
160  const char *expectedError = "That operation is not supported";
161  char *lastError;
162  Uint64 uresult;
163 
164  /* Clean error messages */
165  SDL_ClearError();
166  SDLTest_AssertPass("SDL_ClearError()");
167 
168  /* RandomUintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
170  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
172  uresult == 10,
173  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
174 
175  /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
177  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
179  uresult == 10 || uresult == 11,
180  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
181 
182  /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
184  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
186  uresult == 10 || uresult == 11 || uresult == 12,
187  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
188 
189  /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
191  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
193  uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
194  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
195 
196  /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
198  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
200  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
201  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
202 
203  /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
205  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
207  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
208  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
209 
210  /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
212  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
214  uresult == 0 || uresult == 21,
215  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
216 
217  /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
219  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
221  uresult == 100,
222  "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
223 
224  /* RandomUintXBoundaryValue(1, 0xff, SDL_FALSE) returns 0 (no error) */
226  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
228  uresult == 0,
229  "Validate result value for parameters (1,255,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
230  lastError = (char *)SDL_GetError();
231  SDLTest_AssertPass("SDL_GetError()");
232  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
233 
234  /* RandomUintXBoundaryValue(0, 0xfe, SDL_FALSE) returns 0xff (no error) */
236  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
238  uresult == 0xff,
239  "Validate result value for parameters (0,254,SDL_FALSE); expected: 0xff, got: %"SDL_PRIs64, uresult);
240  lastError = (char *)SDL_GetError();
241  SDLTest_AssertPass("SDL_GetError()");
242  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
243 
244  /* RandomUintXBoundaryValue(0, 0xff, SDL_FALSE) returns 0 (sets error) */
246  SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
248  uresult == 0,
249  "Validate result value for parameters(0,255,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
250  lastError = (char *)SDL_GetError();
251  SDLTest_AssertPass("SDL_GetError()");
252  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
253  "SDL_GetError(): expected message '%s', was message: '%s'",
254  expectedError,
255  lastError);
256 
257  /* Clear error messages */
258  SDL_ClearError();
259  SDLTest_AssertPass("SDL_ClearError()");
260 
261  return TEST_COMPLETED;
262 }
263 
264 /*
265  * @brief Calls to random boundary number generators for Uint16
266  */
267 int
269 {
270  const char *expectedError = "That operation is not supported";
271  char *lastError;
272  Uint64 uresult;
273 
274  /* Clean error messages */
275  SDL_ClearError();
276  SDLTest_AssertPass("SDL_ClearError()");
277 
278  /* RandomUintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
280  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
282  uresult == 10,
283  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
284 
285  /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
287  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
289  uresult == 10 || uresult == 11,
290  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
291 
292  /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
294  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
296  uresult == 10 || uresult == 11 || uresult == 12,
297  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
298 
299  /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
301  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
303  uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
304  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
305 
306  /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
308  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
310  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
311  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
312 
313  /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
315  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
317  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
318  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
319 
320  /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
322  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
324  uresult == 0 || uresult == 21,
325  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
326 
327  /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
329  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
331  uresult == 100,
332  "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
333 
334  /* RandomUintXBoundaryValue(1, 0xffff, SDL_FALSE) returns 0 (no error) */
335  uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(1, 0xffff, SDL_FALSE);
336  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
338  uresult == 0,
339  "Validate result value for parameters (1,0xffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
340  lastError = (char *)SDL_GetError();
341  SDLTest_AssertPass("SDL_GetError()");
342  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
343 
344  /* RandomUintXBoundaryValue(0, 0xfffe, SDL_FALSE) returns 0xffff (no error) */
345  uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(0, 0xfffe, SDL_FALSE);
346  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
348  uresult == 0xffff,
349  "Validate result value for parameters (0,0xfffe,SDL_FALSE); expected: 0xffff, got: %"SDL_PRIs64, uresult);
350  lastError = (char *)SDL_GetError();
351  SDLTest_AssertPass("SDL_GetError()");
352  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
353 
354  /* RandomUintXBoundaryValue(0, 0xffff, SDL_FALSE) returns 0 (sets error) */
355  uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(0, 0xffff, SDL_FALSE);
356  SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
358  uresult == 0,
359  "Validate result value for parameters(0,0xffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
360  lastError = (char *)SDL_GetError();
361  SDLTest_AssertPass("SDL_GetError()");
362  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
363  "SDL_GetError(): expected message '%s', was message: '%s'",
364  expectedError,
365  lastError);
366 
367  /* Clear error messages */
368  SDL_ClearError();
369  SDLTest_AssertPass("SDL_ClearError()");
370 
371  return TEST_COMPLETED;
372 }
373 
374 /*
375  * @brief Calls to random boundary number generators for Uint32
376  */
377 int
379 {
380  const char *expectedError = "That operation is not supported";
381  char *lastError;
382  Uint64 uresult;
383 
384  /* Clean error messages */
385  SDL_ClearError();
386  SDLTest_AssertPass("SDL_ClearError()");
387 
388  /* RandomUintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
390  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
392  uresult == 10,
393  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
394 
395  /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
397  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
399  uresult == 10 || uresult == 11,
400  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
401 
402  /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
404  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
406  uresult == 10 || uresult == 11 || uresult == 12,
407  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
408 
409  /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
411  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
413  uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
414  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
415 
416  /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
418  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
420  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
421  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
422 
423  /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
425  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
427  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
428  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
429 
430  /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
432  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
434  uresult == 0 || uresult == 21,
435  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
436 
437  /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
439  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
441  uresult == 100,
442  "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
443 
444  /* RandomUintXBoundaryValue(1, 0xffffffff, SDL_FALSE) returns 0 (no error) */
445  uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(1, 0xffffffff, SDL_FALSE);
446  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
448  uresult == 0,
449  "Validate result value for parameters (1,0xffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
450  lastError = (char *)SDL_GetError();
451  SDLTest_AssertPass("SDL_GetError()");
452  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
453 
454  /* RandomUintXBoundaryValue(0, 0xfffffffe, SDL_FALSE) returns 0xffffffff (no error) */
455  uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(0, 0xfffffffe, SDL_FALSE);
456  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
458  uresult == 0xffffffff,
459  "Validate result value for parameters (0,0xfffffffe,SDL_FALSE); expected: 0xffffffff, got: %"SDL_PRIs64, uresult);
460  lastError = (char *)SDL_GetError();
461  SDLTest_AssertPass("SDL_GetError()");
462  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
463 
464  /* RandomUintXBoundaryValue(0, 0xffffffff, SDL_FALSE) returns 0 (sets error) */
465  uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(0, 0xffffffff, SDL_FALSE);
466  SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
468  uresult == 0,
469  "Validate result value for parameters(0,0xffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
470  lastError = (char *)SDL_GetError();
471  SDLTest_AssertPass("SDL_GetError()");
472  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
473  "SDL_GetError(): expected message '%s', was message: '%s'",
474  expectedError,
475  lastError);
476 
477  /* Clear error messages */
478  SDL_ClearError();
479  SDLTest_AssertPass("SDL_ClearError()");
480 
481  return TEST_COMPLETED;
482 }
483 
484 /*
485  * @brief Calls to random boundary number generators for Uint64
486  */
487 int
489 {
490  const char *expectedError = "That operation is not supported";
491  char *lastError;
492  Uint64 uresult;
493 
494  /* Clean error messages */
495  SDL_ClearError();
496  SDLTest_AssertPass("SDL_ClearError()");
497 
498  /* RandomUintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
500  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
502  uresult == 10,
503  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
504 
505  /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
507  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
509  uresult == 10 || uresult == 11,
510  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
511 
512  /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
514  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
516  uresult == 10 || uresult == 11 || uresult == 12,
517  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
518 
519  /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
521  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
523  uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
524  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
525 
526  /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
528  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
530  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
531  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
532 
533  /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
535  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
537  uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
538  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
539 
540  /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
542  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
544  uresult == 0 || uresult == 21,
545  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
546 
547  /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
549  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
551  uresult == 100,
552  "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
553 
554  /* RandomUintXBoundaryValue(1, 0xffffffffffffffff, SDL_FALSE) returns 0 (no error) */
555  uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(1, (Uint64)0xffffffffffffffffULL, SDL_FALSE);
556  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
558  uresult == 0,
559  "Validate result value for parameters (1,0xffffffffffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
560  lastError = (char *)SDL_GetError();
561  SDLTest_AssertPass("SDL_GetError()");
562  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
563 
564  /* RandomUintXBoundaryValue(0, 0xfffffffffffffffe, SDL_FALSE) returns 0xffffffffffffffff (no error) */
565  uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(0, (Uint64)0xfffffffffffffffeULL, SDL_FALSE);
566  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
568  uresult == (Uint64)0xffffffffffffffffULL,
569  "Validate result value for parameters (0,0xfffffffffffffffe,SDL_FALSE); expected: 0xffffffffffffffff, got: %"SDL_PRIs64, uresult);
570  lastError = (char *)SDL_GetError();
571  SDLTest_AssertPass("SDL_GetError()");
572  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
573 
574  /* RandomUintXBoundaryValue(0, 0xffffffffffffffff, SDL_FALSE) returns 0 (sets error) */
575  uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(0, (Uint64)0xffffffffffffffffULL, SDL_FALSE);
576  SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
578  uresult == 0,
579  "Validate result value for parameters(0,0xffffffffffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
580  lastError = (char *)SDL_GetError();
581  SDLTest_AssertPass("SDL_GetError()");
582  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
583  "SDL_GetError(): expected message '%s', was message: '%s'",
584  expectedError,
585  lastError);
586 
587  /* Clear error messages */
588  SDL_ClearError();
589  SDLTest_AssertPass("SDL_ClearError()");
590 
591  return TEST_COMPLETED;
592 }
593 
594 /*
595  * @brief Calls to random boundary number generators for Sint8
596  */
597 int
599 {
600  const char *expectedError = "That operation is not supported";
601  char *lastError;
602  Sint64 sresult;
603 
604  /* Clean error messages */
605  SDL_ClearError();
606  SDLTest_AssertPass("SDL_ClearError()");
607 
608  /* RandomSintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
610  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
612  sresult == 10,
613  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
614 
615  /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
617  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
619  sresult == 10 || sresult == 11,
620  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
621 
622  /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
624  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
626  sresult == 10 || sresult == 11 || sresult == 12,
627  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
628 
629  /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
631  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
633  sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
634  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
635 
636  /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
638  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
640  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
641  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
642 
643  /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
645  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
647  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
648  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
649 
650  /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
652  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
654  sresult == 0 || sresult == 21,
655  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
656 
657  /* RandomSintXBoundaryValue(SCHAR_MIN, 99, SDL_FALSE) returns 100 */
658  sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(SCHAR_MIN, 99, SDL_FALSE);
659  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
661  sresult == 100,
662  "Validate result value for parameters (SCHAR_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
663 
664  /* RandomSintXBoundaryValue(SCHAR_MIN + 1, SCHAR_MAX, SDL_FALSE) returns SCHAR_MIN (no error) */
665  sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(SCHAR_MIN + 1, SCHAR_MAX, SDL_FALSE);
666  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
668  sresult == SCHAR_MIN,
669  "Validate result value for parameters (SCHAR_MIN + 1,SCHAR_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SCHAR_MIN, sresult);
670  lastError = (char *)SDL_GetError();
671  SDLTest_AssertPass("SDL_GetError()");
672  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
673 
674  /* RandomSintXBoundaryValue(SCHAR_MIN, SCHAR_MAX - 1, SDL_FALSE) returns SCHAR_MAX (no error) */
675  sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(SCHAR_MIN, SCHAR_MAX -1, SDL_FALSE);
676  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
678  sresult == SCHAR_MAX,
679  "Validate result value for parameters (SCHAR_MIN,SCHAR_MAX - 1,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SCHAR_MAX, sresult);
680  lastError = (char *)SDL_GetError();
681  SDLTest_AssertPass("SDL_GetError()");
682  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
683 
684  /* RandomSintXBoundaryValue(SCHAR_MIN, SCHAR_MAX, SDL_FALSE) returns SCHAR_MIN (sets error) */
685  sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(SCHAR_MIN, SCHAR_MAX, SDL_FALSE);
686  SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
688  sresult == SCHAR_MIN,
689  "Validate result value for parameters(SCHAR_MIN,SCHAR_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SCHAR_MIN, sresult);
690  lastError = (char *)SDL_GetError();
691  SDLTest_AssertPass("SDL_GetError()");
692  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
693  "SDL_GetError(): expected message '%s', was message: '%s'",
694  expectedError,
695  lastError);
696 
697  /* Clear error messages */
698  SDL_ClearError();
699  SDLTest_AssertPass("SDL_ClearError()");
700 
701  return TEST_COMPLETED;
702 }
703 
704 /*
705  * @brief Calls to random boundary number generators for Sint16
706  */
707 int
709 {
710  const char *expectedError = "That operation is not supported";
711  char *lastError;
712  Sint64 sresult;
713 
714  /* Clean error messages */
715  SDL_ClearError();
716  SDLTest_AssertPass("SDL_ClearError()");
717 
718  /* RandomSintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
720  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
722  sresult == 10,
723  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
724 
725  /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
727  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
729  sresult == 10 || sresult == 11,
730  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
731 
732  /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
734  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
736  sresult == 10 || sresult == 11 || sresult == 12,
737  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
738 
739  /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
741  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
743  sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
744  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
745 
746  /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
748  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
750  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
751  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
752 
753  /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
755  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
757  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
758  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
759 
760  /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
762  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
764  sresult == 0 || sresult == 21,
765  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
766 
767  /* RandomSintXBoundaryValue(SHRT_MIN, 99, SDL_FALSE) returns 100 */
768  sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(SHRT_MIN, 99, SDL_FALSE);
769  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
771  sresult == 100,
772  "Validate result value for parameters (SHRT_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
773 
774  /* RandomSintXBoundaryValue(SHRT_MIN + 1, SHRT_MAX, SDL_FALSE) returns SHRT_MIN (no error) */
775  sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(SHRT_MIN + 1, SHRT_MAX, SDL_FALSE);
776  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
778  sresult == SHRT_MIN,
779  "Validate result value for parameters (SHRT_MIN+1,SHRT_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SHRT_MIN, sresult);
780  lastError = (char *)SDL_GetError();
781  SDLTest_AssertPass("SDL_GetError()");
782  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
783 
784  /* RandomSintXBoundaryValue(SHRT_MIN, SHRT_MAX - 1, SDL_FALSE) returns SHRT_MAX (no error) */
785  sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(SHRT_MIN, SHRT_MAX - 1, SDL_FALSE);
786  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
788  sresult == SHRT_MAX,
789  "Validate result value for parameters (SHRT_MIN,SHRT_MAX - 1,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SHRT_MAX, sresult);
790  lastError = (char *)SDL_GetError();
791  SDLTest_AssertPass("SDL_GetError()");
792  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
793 
794  /* RandomSintXBoundaryValue(SHRT_MIN, SHRT_MAX, SDL_FALSE) returns 0 (sets error) */
795  sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(SHRT_MIN, SHRT_MAX, SDL_FALSE);
796  SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
798  sresult == SHRT_MIN,
799  "Validate result value for parameters(SHRT_MIN,SHRT_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SHRT_MIN, sresult);
800  lastError = (char *)SDL_GetError();
801  SDLTest_AssertPass("SDL_GetError()");
802  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
803  "SDL_GetError(): expected message '%s', was message: '%s'",
804  expectedError,
805  lastError);
806 
807  /* Clear error messages */
808  SDL_ClearError();
809  SDLTest_AssertPass("SDL_ClearError()");
810 
811  return TEST_COMPLETED;
812 }
813 
814 /*
815  * @brief Calls to random boundary number generators for Sint32
816  */
817 int
819 {
820  const char *expectedError = "That operation is not supported";
821  char *lastError;
822  Sint64 sresult;
823 #if ((ULONG_MAX) == (UINT_MAX))
824  Sint32 long_min = LONG_MIN;
825  Sint32 long_max = LONG_MAX;
826 #else
827  Sint32 long_min = INT_MIN;
828  Sint32 long_max = INT_MAX;
829 #endif
830 
831  /* Clean error messages */
832  SDL_ClearError();
833  SDLTest_AssertPass("SDL_ClearError()");
834 
835  /* RandomSintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
837  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
839  sresult == 10,
840  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
841 
842  /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
844  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
846  sresult == 10 || sresult == 11,
847  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
848 
849  /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
851  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
853  sresult == 10 || sresult == 11 || sresult == 12,
854  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
855 
856  /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
858  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
860  sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
861  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
862 
863  /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
865  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
867  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
868  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
869 
870  /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
872  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
874  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
875  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
876 
877  /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
879  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
881  sresult == 0 || sresult == 21,
882  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
883 
884  /* RandomSintXBoundaryValue(LONG_MIN, 99, SDL_FALSE) returns 100 */
885  sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(long_min, 99, SDL_FALSE);
886  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
888  sresult == 100,
889  "Validate result value for parameters (LONG_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
890 
891  /* RandomSintXBoundaryValue(LONG_MIN + 1, LONG_MAX, SDL_FALSE) returns LONG_MIN (no error) */
892  sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(long_min + 1, long_max, SDL_FALSE);
893  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
895  sresult == long_min,
896  "Validate result value for parameters (LONG_MIN+1,LONG_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, long_min, sresult);
897  lastError = (char *)SDL_GetError();
898  SDLTest_AssertPass("SDL_GetError()");
899  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
900 
901  /* RandomSintXBoundaryValue(LONG_MIN, LONG_MAX - 1, SDL_FALSE) returns LONG_MAX (no error) */
902  sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(long_min, long_max - 1, SDL_FALSE);
903  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
905  sresult == long_max,
906  "Validate result value for parameters (LONG_MIN,LONG_MAX - 1,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, long_max, sresult);
907  lastError = (char *)SDL_GetError();
908  SDLTest_AssertPass("SDL_GetError()");
909  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
910 
911  /* RandomSintXBoundaryValue(LONG_MIN, LONG_MAX, SDL_FALSE) returns 0 (sets error) */
912  sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(long_min, long_max, SDL_FALSE);
913  SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
915  sresult == long_min,
916  "Validate result value for parameters(LONG_MIN,LONG_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, long_min, sresult);
917  lastError = (char *)SDL_GetError();
918  SDLTest_AssertPass("SDL_GetError()");
919  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
920  "SDL_GetError(): expected message '%s', was message: '%s'",
921  expectedError,
922  lastError);
923 
924  /* Clear error messages */
925  SDL_ClearError();
926  SDLTest_AssertPass("SDL_ClearError()");
927 
928  return TEST_COMPLETED;
929 }
930 
931 /*
932  * @brief Calls to random boundary number generators for Sint64
933  */
934 int
936 {
937  const char *expectedError = "That operation is not supported";
938  char *lastError;
939  Sint64 sresult;
940 
941  /* Clean error messages */
942  SDL_ClearError();
943  SDLTest_AssertPass("SDL_ClearError()");
944 
945  /* RandomSintXBoundaryValue(10, 10, SDL_TRUE) returns 10 */
947  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
949  sresult == 10,
950  "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
951 
952  /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
954  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
956  sresult == 10 || sresult == 11,
957  "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
958 
959  /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
961  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
963  sresult == 10 || sresult == 11 || sresult == 12,
964  "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
965 
966  /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
968  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
970  sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
971  "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
972 
973  /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
975  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
977  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
978  "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
979 
980  /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
982  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
984  sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
985  "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
986 
987  /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
989  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
991  sresult == 0 || sresult == 21,
992  "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
993 
994  /* RandomSintXBoundaryValue(LLONG_MIN, 99, SDL_FALSE) returns 100 */
995  sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(INT64_MIN, 99, SDL_FALSE);
996  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
998  sresult == 100,
999  "Validate result value for parameters (LLONG_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
1000 
1001  /* RandomSintXBoundaryValue(LLONG_MIN + 1, LLONG_MAX, SDL_FALSE) returns LLONG_MIN (no error) */
1002  sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(INT64_MIN + 1, INT64_MAX, SDL_FALSE);
1003  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
1005  sresult == INT64_MIN,
1006  "Validate result value for parameters (LLONG_MIN+1,LLONG_MAX,SDL_FALSE); expected: %"SDL_PRIs64", got: %"SDL_PRIs64, INT64_MIN, sresult);
1007  lastError = (char *)SDL_GetError();
1008  SDLTest_AssertPass("SDL_GetError()");
1009  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
1010 
1011  /* RandomSintXBoundaryValue(LLONG_MIN, LLONG_MAX - 1, SDL_FALSE) returns LLONG_MAX (no error) */
1012  sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(INT64_MIN, INT64_MAX - 1, SDL_FALSE);
1013  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
1015  sresult == INT64_MAX,
1016  "Validate result value for parameters (LLONG_MIN,LLONG_MAX - 1,SDL_FALSE); expected: %"SDL_PRIs64", got: %"SDL_PRIs64, INT64_MAX, sresult);
1017  lastError = (char *)SDL_GetError();
1018  SDLTest_AssertPass("SDL_GetError()");
1019  SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
1020 
1021  /* RandomSintXBoundaryValue(LLONG_MIN, LLONG_MAX, SDL_FALSE) returns 0 (sets error) */
1022  sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(INT64_MIN, INT64_MAX, SDL_FALSE);
1023  SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
1025  sresult == INT64_MIN,
1026  "Validate result value for parameters(LLONG_MIN,LLONG_MAX,SDL_FALSE); expected: %"SDL_PRIs64", got: %"SDL_PRIs64, INT64_MIN, sresult);
1027  lastError = (char *)SDL_GetError();
1028  SDLTest_AssertPass("SDL_GetError()");
1029  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
1030  "SDL_GetError(): expected message '%s', was message: '%s'",
1031  expectedError,
1032  lastError);
1033 
1034  /* Clear error messages */
1035  SDL_ClearError();
1036  SDLTest_AssertPass("SDL_ClearError()");
1037 
1038  return TEST_COMPLETED;
1039 }
1040 
1041 /**
1042  * @brief Calls to SDLTest_RandomIntegerInRange
1043  */
1044 int
1046 {
1047  Sint32 min, max;
1048  Sint32 result;
1049 #if ((ULONG_MAX) == (UINT_MAX))
1050  Sint32 long_min = LONG_MIN;
1051  Sint32 long_max = LONG_MAX;
1052 #else
1053  Sint32 long_min = INT_MIN;
1054  Sint32 long_max = INT_MAX;
1055 #endif
1056 
1057  /* Standard range */
1058  min = (Sint32)SDLTest_RandomSint16();
1059  max = min + (Sint32)SDLTest_RandomUint8() + 2;
1060  result = SDLTest_RandomIntegerInRange(min, max);
1061  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(min,max)");
1062  SDLTest_AssertCheck(min <= result && result <= max, "Validated returned value; expected: [%d,%d], got: %d", min, max, result);
1063 
1064  /* One Range */
1065  min = (Sint32)SDLTest_RandomSint16();
1066  max = min + 1;
1067  result = SDLTest_RandomIntegerInRange(min, max);
1068  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(min,min+1)");
1069  SDLTest_AssertCheck(min <= result && result <= max, "Validated returned value; expected: [%d,%d], got: %d", min, max, result);
1070 
1071  /* Zero range */
1072  min = (Sint32)SDLTest_RandomSint16();
1073  max = min;
1074  result = SDLTest_RandomIntegerInRange(min, max);
1075  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(min,min)");
1076  SDLTest_AssertCheck(min == result, "Validated returned value; expected: %d, got: %d", min, result);
1077 
1078  /* Zero range at zero */
1079  min = 0;
1080  max = 0;
1081  result = SDLTest_RandomIntegerInRange(min, max);
1082  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(0,0)");
1083  SDLTest_AssertCheck(result == 0, "Validated returned value; expected: 0, got: %d", result);
1084 
1085  /* Swapped min-max */
1086  min = (Sint32)SDLTest_RandomSint16();
1087  max = min + (Sint32)SDLTest_RandomUint8() + 2;
1088  result = SDLTest_RandomIntegerInRange(max, min);
1089  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(max,min)");
1090  SDLTest_AssertCheck(min <= result && result <= max, "Validated returned value; expected: [%d,%d], got: %d", min, max, result);
1091 
1092  /* Range with min at integer limit */
1093  min = long_min;
1094  max = long_max + (Sint32)SDLTest_RandomSint16();
1095  result = SDLTest_RandomIntegerInRange(min, max);
1096  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(SINT32_MIN,...)");
1097  SDLTest_AssertCheck(min <= result && result <= max, "Validated returned value; expected: [%d,%d], got: %d", min, max, result);
1098 
1099  /* Range with max at integer limit */
1100  min = long_min - (Sint32)SDLTest_RandomSint16();
1101  max = long_max;
1102  result = SDLTest_RandomIntegerInRange(min, max);
1103  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(...,SINT32_MAX)");
1104  SDLTest_AssertCheck(min <= result && result <= max, "Validated returned value; expected: [%d,%d], got: %d", min, max, result);
1105 
1106  /* Full integer range */
1107  min = long_min;
1108  max = long_max;
1109  result = SDLTest_RandomIntegerInRange(min, max);
1110  SDLTest_AssertPass("Call to SDLTest_RandomIntegerInRange(SINT32_MIN,SINT32_MAX)");
1111  SDLTest_AssertCheck(min <= result && result <= max, "Validated returned value; expected: [%d,%d], got: %d", min, max, result);
1112 
1113  return TEST_COMPLETED;
1114 }
1115 
1116 /**
1117  * @brief Calls to SDLTest_RandomAsciiString
1118  */
1119 int
1121 {
1122  char* result;
1123  size_t len;
1124  int nonAsciiCharacters;
1125  size_t i;
1126 
1127  result = SDLTest_RandomAsciiString();
1128  SDLTest_AssertPass("Call to SDLTest_RandomAsciiString()");
1129  SDLTest_AssertCheck(result != NULL, "Validate that result is not NULL");
1130  if (result != NULL) {
1131  len = SDL_strlen(result);
1132  SDLTest_AssertCheck(len >= 1 && len <= 255, "Validate that result length; expected: len=[1,255], got: %d", (int) len);
1133  nonAsciiCharacters = 0;
1134  for (i=0; i<len; i++) {
1135  if (iscntrl(result[i])) {
1136  nonAsciiCharacters++;
1137  }
1138  }
1139  SDLTest_AssertCheck(nonAsciiCharacters == 0, "Validate that result does not contain non-Ascii characters, got: %d", nonAsciiCharacters);
1140  if (nonAsciiCharacters) {
1141  SDLTest_LogError("Invalid result from generator: '%s'", result);
1142  }
1143  SDL_free(result);
1144  }
1145 
1146  return TEST_COMPLETED;
1147 }
1148 
1149 
1150 /**
1151  * @brief Calls to SDLTest_RandomAsciiStringWithMaximumLength
1152  */
1153 int
1155 {
1156  const char* expectedError = "Parameter 'maxLength' is invalid";
1157  char* lastError;
1158  char* result;
1159  size_t targetLen;
1160  size_t len;
1161  int nonAsciiCharacters;
1162  size_t i;
1163 
1164  targetLen = 16 + SDLTest_RandomUint8();
1165  result = SDLTest_RandomAsciiStringWithMaximumLength((int) targetLen);
1166  SDLTest_AssertPass("Call to SDLTest_RandomAsciiStringWithMaximumLength(%d)", targetLen);
1167  SDLTest_AssertCheck(result != NULL, "Validate that result is not NULL");
1168  if (result != NULL) {
1169  len = SDL_strlen(result);
1170  SDLTest_AssertCheck(len >= 1 && len <= targetLen, "Validate that result length; expected: len=[1,%d], got: %d", (int) targetLen, (int) len);
1171  nonAsciiCharacters = 0;
1172  for (i=0; i<len; i++) {
1173  if (iscntrl(result[i])) {
1174  nonAsciiCharacters++;
1175  }
1176  }
1177  SDLTest_AssertCheck(nonAsciiCharacters == 0, "Validate that result does not contain non-Ascii characters, got: %d", nonAsciiCharacters);
1178  if (nonAsciiCharacters) {
1179  SDLTest_LogError("Invalid result from generator: '%s'", result);
1180  }
1181  SDL_free(result);
1182  }
1183 
1184  /* Negative test */
1185  targetLen = 0;
1186  result = SDLTest_RandomAsciiStringWithMaximumLength((int) targetLen);
1187  SDLTest_AssertPass("Call to SDLTest_RandomAsciiStringWithMaximumLength(%d)", targetLen);
1188  SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
1189  lastError = (char *)SDL_GetError();
1190  SDLTest_AssertPass("SDL_GetError()");
1191  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
1192  "SDL_GetError(): expected message '%s', was message: '%s'",
1193  expectedError,
1194  lastError);
1195 
1196  /* Clear error messages */
1197  SDL_ClearError();
1198  SDLTest_AssertPass("SDL_ClearError()");
1199 
1200  return TEST_COMPLETED;
1201 }
1202 
1203 /**
1204  * @brief Calls to SDLTest_RandomAsciiStringOfSize
1205  */
1206 int
1208 {
1209  const char* expectedError = "Parameter 'size' is invalid";
1210  char* lastError;
1211  char* result;
1212  size_t targetLen;
1213  size_t len;
1214  int nonAsciiCharacters;
1215  size_t i;
1216 
1217  /* Positive test */
1218  targetLen = 16 + SDLTest_RandomUint8();
1219  result = SDLTest_RandomAsciiStringOfSize((int) targetLen);
1220  SDLTest_AssertPass("Call to SDLTest_RandomAsciiStringOfSize(%d)", targetLen);
1221  SDLTest_AssertCheck(result != NULL, "Validate that result is not NULL");
1222  if (result != NULL) {
1223  len = SDL_strlen(result);
1224  SDLTest_AssertCheck(len == targetLen, "Validate that result length; expected: len=%d, got: %d", (int) targetLen, (int) len);
1225  nonAsciiCharacters = 0;
1226  for (i=0; i<len; i++) {
1227  if (iscntrl(result[i])) {
1228  nonAsciiCharacters++;
1229  }
1230  }
1231  SDLTest_AssertCheck(nonAsciiCharacters == 0, "Validate that result does not contain non-ASCII characters, got: %d", nonAsciiCharacters);
1232  if (nonAsciiCharacters) {
1233  SDLTest_LogError("Invalid result from generator: '%s'", result);
1234  }
1235  SDL_free(result);
1236  }
1237 
1238  /* Negative test */
1239  targetLen = 0;
1240  result = SDLTest_RandomAsciiStringOfSize((int) targetLen);
1241  SDLTest_AssertPass("Call to SDLTest_RandomAsciiStringOfSize(%d)", targetLen);
1242  SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
1243  lastError = (char *)SDL_GetError();
1244  SDLTest_AssertPass("SDL_GetError()");
1245  SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
1246  "SDL_GetError(): expected message '%s', was message: '%s'",
1247  expectedError,
1248  lastError);
1249 
1250  /* Clear error messages */
1251  SDL_ClearError();
1252  SDLTest_AssertPass("SDL_ClearError()");
1253 
1254  return TEST_COMPLETED;
1255 }
1256 
1257 
1258 /* ================= Test References ================== */
1259 
1260 /* SDL_test test cases */
1262  { (SDLTest_TestCaseFp)sdltest_getFuzzerInvocationCount, "sdltest_getFuzzerInvocationCount", "Call to sdltest_GetFuzzerInvocationCount", TEST_ENABLED };
1263 
1265  { (SDLTest_TestCaseFp)sdltest_randomNumber, "sdltest_randomNumber", "Calls to random number generators", TEST_ENABLED };
1266 
1268  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint8, "sdltest_randomBoundaryNumberUint8", "Calls to random boundary number generators for Uint8", TEST_ENABLED };
1269 
1271  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint16, "sdltest_randomBoundaryNumberUint16", "Calls to random boundary number generators for Uint16", TEST_ENABLED };
1272 
1274  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint32, "sdltest_randomBoundaryNumberUint32", "Calls to random boundary number generators for Uint32", TEST_ENABLED };
1275 
1277  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint64, "sdltest_randomBoundaryNumberUint64", "Calls to random boundary number generators for Uint64", TEST_ENABLED };
1278 
1280  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint8, "sdltest_randomBoundaryNumberSint8", "Calls to random boundary number generators for Sint8", TEST_ENABLED };
1281 
1283  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint16, "sdltest_randomBoundaryNumberSint16", "Calls to random boundary number generators for Sint16", TEST_ENABLED };
1284 
1286  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint32, "sdltest_randomBoundaryNumberSint32", "Calls to random boundary number generators for Sint32", TEST_ENABLED };
1287 
1289  { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint64, "sdltest_randomBoundaryNumberSint64", "Calls to random boundary number generators for Sint64", TEST_ENABLED };
1290 
1292  { (SDLTest_TestCaseFp)sdltest_randomIntegerInRange, "sdltest_randomIntegerInRange", "Calls to ranged random number generator", TEST_ENABLED };
1293 
1295  { (SDLTest_TestCaseFp)sdltest_randomAsciiString, "sdltest_randomAsciiString", "Calls to default ASCII string generator", TEST_ENABLED };
1296 
1298  { (SDLTest_TestCaseFp)sdltest_randomAsciiStringWithMaximumLength, "sdltest_randomAsciiStringWithMaximumLength", "Calls to random maximum length ASCII string generator", TEST_ENABLED };
1299 
1301  { (SDLTest_TestCaseFp)sdltest_randomAsciiStringOfSize, "sdltest_randomAsciiStringOfSize", "Calls to fixed size ASCII string generator", TEST_ENABLED };
1302 
1304  { (SDLTest_TestCaseFp)sdltest_generateRunSeed, "sdltest_generateRunSeed", "Checks internal harness function SDLTest_GenerateRunSeed", TEST_ENABLED };
1305 
1306 /* Sequence of SDL_test test cases */
1311 };
1312 
1313 /* SDL_test test suite (global) */
1315  "SDLtest",
1316  NULL,
1317  sdltestTests,
1318  NULL
1319 };
static const SDLTest_TestCaseReference sdltestTest2
#define SDL_ClearError
Sint8 SDLTest_RandomSint8(void)
Uint64 SDLTest_RandomUint64BoundaryValue(Uint64 boundary1, Uint64 boundary2, SDL_bool validDomain)
int sdltest_getFuzzerInvocationCount(void *arg)
Calls to SDLTest_GetFuzzerInvocationCount()
#define SDL_GetError
static const SDLTest_TestCaseReference sdltestTest9
static const SDLTest_TestCaseReference sdltestTest1
GLuint64EXT * result
int sdltest_randomAsciiStringOfSize(void *arg)
Calls to SDLTest_RandomAsciiStringOfSize.
int sdltest_randomAsciiStringWithMaximumLength(void *arg)
Calls to SDLTest_RandomAsciiStringWithMaximumLength.
Sint32 SDLTest_RandomIntegerInRange(Sint32 min, Sint32 max)
int sdltest_randomNumber(void *arg)
Calls to random number generators.
Sint32 SDLTest_RandomSint32(void)
void SDLTest_AssertPass(SDL_PRINTF_FORMAT_STRING const char *assertDescription,...) SDL_PRINTF_VARARG_FUNC(1)
Explicitly pass without checking an assertion condition. Updates assertion counter.
static const SDLTest_TestCaseReference sdltestTest11
Uint8 SDLTest_RandomUint8(void)
Uint32 SDLTest_RandomUint32BoundaryValue(Uint32 boundary1, Uint32 boundary2, SDL_bool validDomain)
int sdltest_randomBoundaryNumberUint8(void *arg)
Uint32 SDLTest_RandomUint32(void)
static const SDLTest_TestCaseReference sdltestTest14
static const SDLTest_TestCaseReference sdltestTest10
uint64_t Uint64
Definition: SDL_stdinc.h:194
int sdltest_randomBoundaryNumberSint16(void *arg)
GLenum GLsizei len
static const SDLTest_TestCaseReference sdltestTest7
int sdltest_randomIntegerInRange(void *arg)
Calls to SDLTest_RandomIntegerInRange.
static const SDLTest_TestCaseReference sdltestTest4
static const SDLTest_TestCaseReference sdltestTest12
float SDLTest_RandomFloat(void)
int SDLTest_GetFuzzerInvocationCount(void)
int(* SDLTest_TestCaseFp)(void *arg)
SDLTest_TestSuiteReference sdltestTestSuite
static const SDLTest_TestCaseReference sdltestTest6
void SDLTest_LogError(SDL_PRINTF_FORMAT_STRING const char *fmt,...) SDL_PRINTF_VARARG_FUNC(1)
Prints given message with a timestamp in the TEST category and the ERROR priority.
Definition: SDL_test_log.c:103
static const SDLTest_TestCaseReference sdltestTest3
char * SDLTest_RandomAsciiStringOfSize(int size)
#define SDL_PRIs64
Definition: SDL_stdinc.h:205
char * SDLTest_RandomAsciiString(void)
char * SDLTest_RandomAsciiStringWithMaximumLength(int maxLength)
Uint16 SDLTest_RandomUint16BoundaryValue(Uint16 boundary1, Uint16 boundary2, SDL_bool validDomain)
int SDLTest_AssertCheck(int assertCondition, SDL_PRINTF_FORMAT_STRING const char *assertDescription,...) SDL_PRINTF_VARARG_FUNC(2)
Assert for test cases that logs but does not break execution flow on failures. Updates assertion coun...
uint8_t Uint8
Definition: SDL_stdinc.h:157
#define SDL_free
Sint32 SDLTest_RandomSint32BoundaryValue(Sint32 boundary1, Sint32 boundary2, SDL_bool validDomain)
Uint64 SDLTest_RandomUint64(void)
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int in j)
Definition: SDL_x11sym.h:50
static const SDLTest_TestCaseReference sdltestTest5
Sint16 SDLTest_RandomSint16(void)
Sint16 SDLTest_RandomSint16BoundaryValue(Sint16 boundary1, Sint16 boundary2, SDL_bool validDomain)
int32_t Sint32
Definition: SDL_stdinc.h:175
#define TEST_COMPLETED
static const SDLTest_TestCaseReference sdltestTest15
#define TEST_ENABLED
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
static const SDLTest_TestCaseReference * sdltestTests[]
Sint64 SDLTest_RandomSint64(void)
#define NULL
Definition: begin_code.h:164
Sint8 SDLTest_RandomSint8BoundaryValue(Sint8 boundary1, Sint8 boundary2, SDL_bool validDomain)
int sdltest_randomBoundaryNumberSint64(void *arg)
int sdltest_randomBoundaryNumberUint64(void *arg)
Sint64 SDLTest_RandomSint64BoundaryValue(Sint64 boundary1, Sint64 boundary2, SDL_bool validDomain)
#define SDL_strlen
Uint16 SDLTest_RandomUint16(void)
int sdltest_randomBoundaryNumberSint8(void *arg)
#define SDL_PRIu64
Definition: SDL_stdinc.h:216
float SDLTest_RandomUnitFloat(void)
static const SDLTest_TestCaseReference sdltestTest13
#define SDL_strcmp
int sdltest_randomAsciiString(void *arg)
Calls to SDLTest_RandomAsciiString.
int64_t Sint64
Definition: SDL_stdinc.h:188
int sdltest_randomBoundaryNumberUint16(void *arg)
Uint8 SDLTest_RandomUint8BoundaryValue(Uint8 boundary1, Uint8 boundary2, SDL_bool validDomain)
GLuint GLsizei GLsizei * length
double SDLTest_RandomDouble(void)
static const SDLTest_TestCaseReference sdltestTest8
char * SDLTest_GenerateRunSeed(const int length)
Generates a random run seed string for the harness. The generated seed will contain alphanumeric char...
int sdltest_randomBoundaryNumberSint32(void *arg)
int sdltest_randomBoundaryNumberUint32(void *arg)
int sdltest_generateRunSeed(void *arg)
Calls to SDLTest_GenerateRunSeed()
double SDLTest_RandomUnitDouble(void)