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
sdltest_generateRunSeed(void * arg)34 sdltest_generateRunSeed(void *arg)
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
sdltest_getFuzzerInvocationCount(void * arg)65 sdltest_getFuzzerInvocationCount(void *arg)
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
sdltest_randomNumber(void * arg)89 sdltest_randomNumber(void *arg)
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
sdltest_randomBoundaryNumberUint8(void * arg)158 sdltest_randomBoundaryNumberUint8(void *arg)
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 */
169   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 10, SDL_TRUE);
170   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
171   SDLTest_AssertCheck(
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 */
176   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 11, SDL_TRUE);
177   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
178   SDLTest_AssertCheck(
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 */
183   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 12, SDL_TRUE);
184   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
185   SDLTest_AssertCheck(
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 */
190   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 13, SDL_TRUE);
191   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
192   SDLTest_AssertCheck(
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 */
197   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 20, SDL_TRUE);
198   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
199   SDLTest_AssertCheck(
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 */
204   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(20, 10, SDL_TRUE);
205   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
206   SDLTest_AssertCheck(
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 */
211   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(1, 20, SDL_FALSE);
212   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
213   SDLTest_AssertCheck(
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 */
218   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(0, 99, SDL_FALSE);
219   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
220   SDLTest_AssertCheck(
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) */
225   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(1, 255, SDL_FALSE);
226   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
227   SDLTest_AssertCheck(
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) */
235   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(0, 254, SDL_FALSE);
236   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
237   SDLTest_AssertCheck(
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) */
245   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(0, 255, SDL_FALSE);
246   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
247   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberUint16(void * arg)268 sdltest_randomBoundaryNumberUint16(void *arg)
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 */
279   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 10, SDL_TRUE);
280   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
281   SDLTest_AssertCheck(
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 */
286   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 11, SDL_TRUE);
287   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
288   SDLTest_AssertCheck(
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 */
293   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 12, SDL_TRUE);
294   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
295   SDLTest_AssertCheck(
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 */
300   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 13, SDL_TRUE);
301   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
302   SDLTest_AssertCheck(
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 */
307   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 20, SDL_TRUE);
308   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
309   SDLTest_AssertCheck(
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 */
314   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(20, 10, SDL_TRUE);
315   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
316   SDLTest_AssertCheck(
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 */
321   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(1, 20, SDL_FALSE);
322   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
323   SDLTest_AssertCheck(
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 */
328   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(0, 99, SDL_FALSE);
329   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
330   SDLTest_AssertCheck(
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");
337   SDLTest_AssertCheck(
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");
347   SDLTest_AssertCheck(
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");
357   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberUint32(void * arg)378 sdltest_randomBoundaryNumberUint32(void *arg)
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 */
389   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 10, SDL_TRUE);
390   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
391   SDLTest_AssertCheck(
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 */
396   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 11, SDL_TRUE);
397   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
398   SDLTest_AssertCheck(
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 */
403   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 12, SDL_TRUE);
404   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
405   SDLTest_AssertCheck(
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 */
410   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 13, SDL_TRUE);
411   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
412   SDLTest_AssertCheck(
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 */
417   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 20, SDL_TRUE);
418   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
419   SDLTest_AssertCheck(
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 */
424   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(20, 10, SDL_TRUE);
425   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
426   SDLTest_AssertCheck(
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 */
431   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(1, 20, SDL_FALSE);
432   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
433   SDLTest_AssertCheck(
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 */
438   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(0, 99, SDL_FALSE);
439   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
440   SDLTest_AssertCheck(
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");
447   SDLTest_AssertCheck(
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");
457   SDLTest_AssertCheck(
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");
467   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberUint64(void * arg)488 sdltest_randomBoundaryNumberUint64(void *arg)
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 */
499   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 10, SDL_TRUE);
500   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
501   SDLTest_AssertCheck(
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 */
506   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 11, SDL_TRUE);
507   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
508   SDLTest_AssertCheck(
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 */
513   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 12, SDL_TRUE);
514   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
515   SDLTest_AssertCheck(
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 */
520   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 13, SDL_TRUE);
521   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
522   SDLTest_AssertCheck(
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 */
527   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 20, SDL_TRUE);
528   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
529   SDLTest_AssertCheck(
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 */
534   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(20, 10, SDL_TRUE);
535   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
536   SDLTest_AssertCheck(
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 */
541   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(1, 20, SDL_FALSE);
542   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
543   SDLTest_AssertCheck(
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 */
548   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(0, 99, SDL_FALSE);
549   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
550   SDLTest_AssertCheck(
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");
557   SDLTest_AssertCheck(
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");
567   SDLTest_AssertCheck(
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");
577   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberSint8(void * arg)598 sdltest_randomBoundaryNumberSint8(void *arg)
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 */
609   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 10, SDL_TRUE);
610   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
611   SDLTest_AssertCheck(
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 */
616   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 11, SDL_TRUE);
617   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
618   SDLTest_AssertCheck(
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 */
623   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 12, SDL_TRUE);
624   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
625   SDLTest_AssertCheck(
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 */
630   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 13, SDL_TRUE);
631   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
632   SDLTest_AssertCheck(
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 */
637   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 20, SDL_TRUE);
638   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
639   SDLTest_AssertCheck(
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 */
644   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(20, 10, SDL_TRUE);
645   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
646   SDLTest_AssertCheck(
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 */
651   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(1, 20, SDL_FALSE);
652   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
653   SDLTest_AssertCheck(
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");
660   SDLTest_AssertCheck(
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");
667   SDLTest_AssertCheck(
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");
677   SDLTest_AssertCheck(
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");
687   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberSint16(void * arg)708 sdltest_randomBoundaryNumberSint16(void *arg)
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 */
719   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 10, SDL_TRUE);
720   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
721   SDLTest_AssertCheck(
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 */
726   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 11, SDL_TRUE);
727   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
728   SDLTest_AssertCheck(
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 */
733   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 12, SDL_TRUE);
734   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
735   SDLTest_AssertCheck(
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 */
740   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 13, SDL_TRUE);
741   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
742   SDLTest_AssertCheck(
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 */
747   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 20, SDL_TRUE);
748   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
749   SDLTest_AssertCheck(
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 */
754   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(20, 10, SDL_TRUE);
755   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
756   SDLTest_AssertCheck(
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 */
761   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(1, 20, SDL_FALSE);
762   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
763   SDLTest_AssertCheck(
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");
770   SDLTest_AssertCheck(
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");
777   SDLTest_AssertCheck(
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");
787   SDLTest_AssertCheck(
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");
797   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberSint32(void * arg)818 sdltest_randomBoundaryNumberSint32(void *arg)
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 */
836   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 10, SDL_TRUE);
837   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
838   SDLTest_AssertCheck(
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 */
843   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 11, SDL_TRUE);
844   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
845   SDLTest_AssertCheck(
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 */
850   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 12, SDL_TRUE);
851   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
852   SDLTest_AssertCheck(
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 */
857   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 13, SDL_TRUE);
858   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
859   SDLTest_AssertCheck(
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 */
864   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 20, SDL_TRUE);
865   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
866   SDLTest_AssertCheck(
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 */
871   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(20, 10, SDL_TRUE);
872   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
873   SDLTest_AssertCheck(
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 */
878   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(1, 20, SDL_FALSE);
879   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
880   SDLTest_AssertCheck(
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");
887   SDLTest_AssertCheck(
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");
894   SDLTest_AssertCheck(
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");
904   SDLTest_AssertCheck(
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");
914   SDLTest_AssertCheck(
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
sdltest_randomBoundaryNumberSint64(void * arg)935 sdltest_randomBoundaryNumberSint64(void *arg)
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 */
946   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 10, SDL_TRUE);
947   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
948   SDLTest_AssertCheck(
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 */
953   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 11, SDL_TRUE);
954   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
955   SDLTest_AssertCheck(
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 */
960   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 12, SDL_TRUE);
961   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
962   SDLTest_AssertCheck(
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 */
967   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 13, SDL_TRUE);
968   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
969   SDLTest_AssertCheck(
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 */
974   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 20, SDL_TRUE);
975   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
976   SDLTest_AssertCheck(
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 */
981   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(20, 10, SDL_TRUE);
982   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
983   SDLTest_AssertCheck(
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 */
988   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(1, 20, SDL_FALSE);
989   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
990   SDLTest_AssertCheck(
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");
997   SDLTest_AssertCheck(
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");
1004   SDLTest_AssertCheck(
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");
1014   SDLTest_AssertCheck(
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");
1024   SDLTest_AssertCheck(
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
sdltest_randomIntegerInRange(void * arg)1045 sdltest_randomIntegerInRange(void *arg)
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
sdltest_randomAsciiString(void * arg)1120 sdltest_randomAsciiString(void *arg)
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
sdltest_randomAsciiStringWithMaximumLength(void * arg)1154 sdltest_randomAsciiStringWithMaximumLength(void *arg)
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)", (int) 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)", (int) 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
sdltest_randomAsciiStringOfSize(void * arg)1207 sdltest_randomAsciiStringOfSize(void *arg)
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)", (int) 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)", (int) 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 */
1261 static const SDLTest_TestCaseReference sdltestTest1 =
1262         { (SDLTest_TestCaseFp)sdltest_getFuzzerInvocationCount, "sdltest_getFuzzerInvocationCount", "Call to sdltest_GetFuzzerInvocationCount", TEST_ENABLED };
1263 
1264 static const SDLTest_TestCaseReference sdltestTest2 =
1265         { (SDLTest_TestCaseFp)sdltest_randomNumber, "sdltest_randomNumber", "Calls to random number generators", TEST_ENABLED };
1266 
1267 static const SDLTest_TestCaseReference sdltestTest3 =
1268         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint8, "sdltest_randomBoundaryNumberUint8", "Calls to random boundary number generators for Uint8", TEST_ENABLED };
1269 
1270 static const SDLTest_TestCaseReference sdltestTest4 =
1271         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint16, "sdltest_randomBoundaryNumberUint16", "Calls to random boundary number generators for Uint16", TEST_ENABLED };
1272 
1273 static const SDLTest_TestCaseReference sdltestTest5 =
1274         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint32, "sdltest_randomBoundaryNumberUint32", "Calls to random boundary number generators for Uint32", TEST_ENABLED };
1275 
1276 static const SDLTest_TestCaseReference sdltestTest6 =
1277         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint64, "sdltest_randomBoundaryNumberUint64", "Calls to random boundary number generators for Uint64", TEST_ENABLED };
1278 
1279 static const SDLTest_TestCaseReference sdltestTest7 =
1280         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint8, "sdltest_randomBoundaryNumberSint8", "Calls to random boundary number generators for Sint8", TEST_ENABLED };
1281 
1282 static const SDLTest_TestCaseReference sdltestTest8 =
1283         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint16, "sdltest_randomBoundaryNumberSint16", "Calls to random boundary number generators for Sint16", TEST_ENABLED };
1284 
1285 static const SDLTest_TestCaseReference sdltestTest9 =
1286         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint32, "sdltest_randomBoundaryNumberSint32", "Calls to random boundary number generators for Sint32", TEST_ENABLED };
1287 
1288 static const SDLTest_TestCaseReference sdltestTest10 =
1289         { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint64, "sdltest_randomBoundaryNumberSint64", "Calls to random boundary number generators for Sint64", TEST_ENABLED };
1290 
1291 static const SDLTest_TestCaseReference sdltestTest11 =
1292         { (SDLTest_TestCaseFp)sdltest_randomIntegerInRange, "sdltest_randomIntegerInRange", "Calls to ranged random number generator", TEST_ENABLED };
1293 
1294 static const SDLTest_TestCaseReference sdltestTest12 =
1295         { (SDLTest_TestCaseFp)sdltest_randomAsciiString, "sdltest_randomAsciiString", "Calls to default ASCII string generator", TEST_ENABLED };
1296 
1297 static const SDLTest_TestCaseReference sdltestTest13 =
1298         { (SDLTest_TestCaseFp)sdltest_randomAsciiStringWithMaximumLength, "sdltest_randomAsciiStringWithMaximumLength", "Calls to random maximum length ASCII string generator", TEST_ENABLED };
1299 
1300 static const SDLTest_TestCaseReference sdltestTest14 =
1301         { (SDLTest_TestCaseFp)sdltest_randomAsciiStringOfSize, "sdltest_randomAsciiStringOfSize", "Calls to fixed size ASCII string generator", TEST_ENABLED };
1302 
1303 static const SDLTest_TestCaseReference sdltestTest15 =
1304         { (SDLTest_TestCaseFp)sdltest_generateRunSeed, "sdltest_generateRunSeed", "Checks internal harness function SDLTest_GenerateRunSeed", TEST_ENABLED };
1305 
1306 /* Sequence of SDL_test test cases */
1307 static const SDLTest_TestCaseReference *sdltestTests[] =  {
1308     &sdltestTest1, &sdltestTest2, &sdltestTest3, &sdltestTest4, &sdltestTest5, &sdltestTest6,
1309     &sdltestTest7, &sdltestTest8, &sdltestTest9, &sdltestTest10, &sdltestTest11, &sdltestTest12,
1310     &sdltestTest13, &sdltestTest14, &sdltestTest15, NULL
1311 };
1312 
1313 /* SDL_test test suite (global) */
1314 SDLTest_TestSuiteReference sdltestTestSuite = {
1315     "SDLtest",
1316     NULL,
1317     sdltestTests,
1318     NULL
1319 };
1320