Atlas - testautomation_sdltest.c
Home / ext / SDL2 / test
Lines: 1 | Size: 60369 bytes
[Download] [Show on GitHub] [Search similar files] [Raw] [Raw (proxy)] 
[FILE BEGIN]
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 */
28extern char *SDLTest_GenerateRunSeed(const int length);
29
30/**
31 * @brief Calls to SDLTest_GenerateRunSeed()
32 */
33int
34sdltest_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 */
64int
65sdltest_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 */
88int
89sdltest_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 */
157int
158sdltest_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 */
267int
268sdltest_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 */
377int
378sdltest_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 */
487int
488sdltest_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 */
597int
598sdltest_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 */
707int
708sdltest_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 */
817int
818sdltest_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 */
934int
935sdltest_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 */
1044int
1045sdltest_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 */
1119int
1120sdltest_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 */
1153int
1154sdltest_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)", 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 */
1206int
1207sdltest_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)", 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 */
1261static const SDLTest_TestCaseReference sdltestTest1 =
1262        { (SDLTest_TestCaseFp)sdltest_getFuzzerInvocationCount, "sdltest_getFuzzerInvocationCount", "Call to sdltest_GetFuzzerInvocationCount", TEST_ENABLED };
1263
1264static const SDLTest_TestCaseReference sdltestTest2 =
1265        { (SDLTest_TestCaseFp)sdltest_randomNumber, "sdltest_randomNumber", "Calls to random number generators", TEST_ENABLED };
1266
1267static const SDLTest_TestCaseReference sdltestTest3 =
1268        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint8, "sdltest_randomBoundaryNumberUint8", "Calls to random boundary number generators for Uint8", TEST_ENABLED };
1269
1270static const SDLTest_TestCaseReference sdltestTest4 =
1271        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint16, "sdltest_randomBoundaryNumberUint16", "Calls to random boundary number generators for Uint16", TEST_ENABLED };
1272
1273static const SDLTest_TestCaseReference sdltestTest5 =
1274        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint32, "sdltest_randomBoundaryNumberUint32", "Calls to random boundary number generators for Uint32", TEST_ENABLED };
1275
1276static const SDLTest_TestCaseReference sdltestTest6 =
1277        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint64, "sdltest_randomBoundaryNumberUint64", "Calls to random boundary number generators for Uint64", TEST_ENABLED };
1278
1279static const SDLTest_TestCaseReference sdltestTest7 =
1280        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint8, "sdltest_randomBoundaryNumberSint8", "Calls to random boundary number generators for Sint8", TEST_ENABLED };
1281
1282static const SDLTest_TestCaseReference sdltestTest8 =
1283        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint16, "sdltest_randomBoundaryNumberSint16", "Calls to random boundary number generators for Sint16", TEST_ENABLED };
1284
1285static const SDLTest_TestCaseReference sdltestTest9 =
1286        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint32, "sdltest_randomBoundaryNumberSint32", "Calls to random boundary number generators for Sint32", TEST_ENABLED };
1287
1288static const SDLTest_TestCaseReference sdltestTest10 =
1289        { (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint64, "sdltest_randomBoundaryNumberSint64", "Calls to random boundary number generators for Sint64", TEST_ENABLED };
1290
1291static const SDLTest_TestCaseReference sdltestTest11 =
1292        { (SDLTest_TestCaseFp)sdltest_randomIntegerInRange, "sdltest_randomIntegerInRange", "Calls to ranged random number generator", TEST_ENABLED };
1293
1294static const SDLTest_TestCaseReference sdltestTest12 =
1295        { (SDLTest_TestCaseFp)sdltest_randomAsciiString, "sdltest_randomAsciiString", "Calls to default ASCII string generator", TEST_ENABLED };
1296
1297static const SDLTest_TestCaseReference sdltestTest13 =
1298        { (SDLTest_TestCaseFp)sdltest_randomAsciiStringWithMaximumLength, "sdltest_randomAsciiStringWithMaximumLength", "Calls to random maximum length ASCII string generator", TEST_ENABLED };
1299
1300static const SDLTest_TestCaseReference sdltestTest14 =
1301        { (SDLTest_TestCaseFp)sdltest_randomAsciiStringOfSize, "sdltest_randomAsciiStringOfSize", "Calls to fixed size ASCII string generator", TEST_ENABLED };
1302
1303static 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 */
1307static 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) */
1314SDLTest_TestSuiteReference sdltestTestSuite = {
1315    "SDLtest",
1316    NULL,
1317    sdltestTests,
1318    NULL
1319};
1320
[FILE END]
(C) 2025 0x4248
(C) 2025 4248 Media and 4248 Systems, All part of 0x4248
See LICENCE files for more information. Not all files are by 0x4248 always check Licencing.