test/testautomation_sdltest.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 07 Jul 2019 09:10:56 -0700
changeset 12928 3c4a4b1077cd
parent 11420 f1dcaee3479b
permissions -rw-r--r--
Fixed bug 4710 - audio/alsa: avoid configuring hardware parameters with only a single period

Anthony Pesch

The previous code first configured the period size using snd_pcm_hw_par-
ams_set_period_size_near. Then, it further narrowed the configuration
space by calling snd_pcm_hw_params_set_buffer_size_near using a buffer
size of 2 times the _requested_ period size in order to try and get a
configuration with only 2 periods. If the configured period size was
larger than the requested size, the second call could inadvertently
narrow the configuration space to contain only a single period.

Rather than fixing the call to snd_pcm_hw_params_set_buffer_size_near
to use a size of 2 times the configured period size, the code has been
changed to use snd_pcm_hw_params_set_periods_min in order to more
clearly explain the intent.
     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
    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
    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
    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
   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
   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
   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
   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
   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
   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
   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
   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
  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
  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
  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)", targetLen);
  1167   SDLTest_AssertCheck(result != NULL, "Validate that result is not NULL");
  1168   if (result != NULL) {
  1169      len = SDL_strlen(result);
  1170      SDLTest_AssertCheck(len >= 1 && len <= targetLen, "Validate that result length; expected: len=[1,%d], got: %d", (int) targetLen, (int) len);
  1171      nonAsciiCharacters = 0;
  1172      for (i=0; i<len; i++) {
  1173        if (iscntrl(result[i])) {
  1174          nonAsciiCharacters++;
  1175        }
  1176      }
  1177      SDLTest_AssertCheck(nonAsciiCharacters == 0, "Validate that result does not contain non-Ascii characters, got: %d", nonAsciiCharacters);
  1178      if (nonAsciiCharacters) {
  1179         SDLTest_LogError("Invalid result from generator: '%s'", result);
  1180      }
  1181      SDL_free(result);
  1182   }
  1183 
  1184   /* Negative test */
  1185   targetLen = 0;
  1186   result = SDLTest_RandomAsciiStringWithMaximumLength((int) targetLen);
  1187   SDLTest_AssertPass("Call to SDLTest_RandomAsciiStringWithMaximumLength(%d)", targetLen);
  1188   SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
  1189   lastError = (char *)SDL_GetError();
  1190   SDLTest_AssertPass("SDL_GetError()");
  1191   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
  1192              "SDL_GetError(): expected message '%s', was message: '%s'",
  1193              expectedError,
  1194              lastError);
  1195 
  1196   /* Clear error messages */
  1197   SDL_ClearError();
  1198   SDLTest_AssertPass("SDL_ClearError()");
  1199 
  1200   return TEST_COMPLETED;
  1201 }
  1202 
  1203 /**
  1204  * @brief Calls to SDLTest_RandomAsciiStringOfSize
  1205  */
  1206 int
  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)", 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 */
  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 };