From 73daadb74e74189aa196dd1df93d35870a731566 Mon Sep 17 00:00:00 2001
From: Edward Rudd <urkle@outoforder.cc>
Date: Wed, 3 Dec 2014 12:23:17 -0500
Subject: [PATCH] switch to use SDL_PRI* macros for long long formatting
 everywhere.

---
 include/SDL_stdinc.h           |  18 ++++
 src/test/SDL_test_common.c     |   4 +-
 test/testautomation.c          |   2 +-
 test/testautomation_platform.c |   6 +-
 test/testautomation_rwops.c    |  20 ++--
 test/testautomation_sdltest.c  | 188 ++++++++++++++++-----------------
 test/testautomation_timer.c    |   4 +-
 test/testplatform.c            |   8 +-
 test/testtimer.c               |   2 +-
 9 files changed, 130 insertions(+), 122 deletions(-)

diff --git a/include/SDL_stdinc.h b/include/SDL_stdinc.h
index 78d3402e72c8d..c82fcdd833c2f 100644
--- a/include/SDL_stdinc.h
+++ b/include/SDL_stdinc.h
@@ -186,6 +186,24 @@ typedef uint64_t Uint64;
 #define SDL_PRIu64 "llu"
 #endif
 #endif
+#ifndef SDL_PRIx64
+#ifdef PRIx64
+#define SDL_PRIx64 PRIx64
+#elif defined(__WIN32__)
+#define SDL_PRIx64 "I64x"
+#else
+#define SDL_PRIx64 "llx"
+#endif
+#endif
+#ifndef SDL_PRIX64
+#ifdef PRIX64
+#define SDL_PRIX64 PRIX64
+#elif defined(__WIN32__)
+#define SDL_PRIX64 "I64X"
+#else
+#define SDL_PRIX64 "llX"
+#endif
+#endif
 
 /* Annotations to help code analysis tools */
 #ifdef SDL_DISABLE_ANALYZE_MACROS
diff --git a/src/test/SDL_test_common.c b/src/test/SDL_test_common.c
index 58e74cc5191dd..c95f8142a1e7d 100644
--- a/src/test/SDL_test_common.c
+++ b/src/test/SDL_test_common.c
@@ -1204,10 +1204,10 @@ SDLTest_PrintEvent(SDL_Event * event)
                 event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
         break;
     case SDL_DOLLARGESTURE:
-        SDL_Log("SDL_EVENT: Dollar gesture detect: %lld", event->dgesture.gestureId);
+        SDL_Log("SDL_EVENT: Dollar gesture detect: %"SDL_PRIs64, event->dgesture.gestureId);
         break;
     case SDL_DOLLARRECORD:
-        SDL_Log("SDL_EVENT: Dollar gesture record: %lld", event->dgesture.gestureId);
+        SDL_Log("SDL_EVENT: Dollar gesture record: %"SDL_PRIs64, event->dgesture.gestureId);
         break;
     case SDL_MULTIGESTURE:
         SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
diff --git a/test/testautomation.c b/test/testautomation.c
index 8eab76e9cac1b..ceb352ab77e61 100644
--- a/test/testautomation.c
+++ b/test/testautomation.c
@@ -62,7 +62,7 @@ main(int argc, char *argv[])
             }
             else if (SDL_strcasecmp(argv[i], "--execKey") == 0) {
                 if (argv[i + 1]) {
-                    SDL_sscanf(argv[i + 1], "%llu", (long long unsigned int *)&userExecKey);
+                    SDL_sscanf(argv[i + 1], "%"SDL_PRIu64, (long long unsigned int *)&userExecKey);
                     consumed = 2;
                 }
             }
diff --git a/test/testautomation_platform.c b/test/testautomation_platform.c
index 5228bfdc7b658..5211a4a70ccaa 100644
--- a/test/testautomation_platform.c
+++ b/test/testautomation_platform.c
@@ -92,11 +92,7 @@ int platform_testEndianessAndSwap(void *arg)
 
     /* Test 64 swap. */
     SDLTest_AssertCheck( SDL_Swap64(value64) == swapped64,
-#ifdef _MSC_VER
-             "SDL_Swap64(): 64 bit swapped: 0x%I64X => 0x%I64X",
-#else
-             "SDL_Swap64(): 64 bit swapped: 0x%llX => 0x%llX",
-#endif
+             "SDL_Swap64(): 64 bit swapped: 0x%"SDL_PRIX64" => 0x%"SDL_PRIX64,
              value64, SDL_Swap64(value64) );
 
    return TEST_COMPLETED;
diff --git a/test/testautomation_rwops.c b/test/testautomation_rwops.c
index 3a1f682f23c55..16f2161fec3c6 100644
--- a/test/testautomation_rwops.c
+++ b/test/testautomation_rwops.c
@@ -105,7 +105,7 @@ _testGenericRWopsValidations(SDL_RWops *rw, int write)
    /* Set to start. */
    i = SDL_RWseek(rw, 0, RW_SEEK_SET );
    SDLTest_AssertPass("Call to SDL_RWseek succeeded");
-   SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %lli", i);
+   SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %"SDL_PRIs64, i);
 
    /* Test write. */
    s = SDL_RWwrite(rw, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString)-1, 1);
@@ -120,12 +120,12 @@ _testGenericRWopsValidations(SDL_RWops *rw, int write)
    /* Test seek to random position */
    i = SDL_RWseek( rw, seekPos, RW_SEEK_SET );
    SDLTest_AssertPass("Call to SDL_RWseek succeeded");
-   SDLTest_AssertCheck(i == (Sint64)seekPos, "Verify seek to %i with SDL_RWseek (RW_SEEK_SET), expected %i, got %lli", seekPos, seekPos, i);
+   SDLTest_AssertCheck(i == (Sint64)seekPos, "Verify seek to %i with SDL_RWseek (RW_SEEK_SET), expected %i, got %"SDL_PRIs64, seekPos, seekPos, i);
 
    /* Test seek back to start */
    i = SDL_RWseek(rw, 0, RW_SEEK_SET );
    SDLTest_AssertPass("Call to SDL_RWseek succeeded");
-   SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %lli", i);
+   SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %"SDL_PRIs64, i);
 
    /* Test read */
    s = SDL_RWread( rw, buf, 1, sizeof(RWopsHelloWorldTestString)-1 );
@@ -144,7 +144,7 @@ _testGenericRWopsValidations(SDL_RWops *rw, int write)
    SDLTest_AssertPass("Call to SDL_RWseek(...,-4,RW_SEEK_CUR) succeeded");
    SDLTest_AssertCheck(
        i == (Sint64)(sizeof(RWopsHelloWorldTestString)-5),
-       "Verify seek to -4 with SDL_RWseek (RW_SEEK_CUR), expected %i, got %lli",
+       "Verify seek to -4 with SDL_RWseek (RW_SEEK_CUR), expected %i, got %"SDL_PRIs64,
        sizeof(RWopsHelloWorldTestString)-5,
        i);
 
@@ -152,7 +152,7 @@ _testGenericRWopsValidations(SDL_RWops *rw, int write)
    SDLTest_AssertPass("Call to SDL_RWseek(...,-1,RW_SEEK_END) succeeded");
    SDLTest_AssertCheck(
        i == (Sint64)(sizeof(RWopsHelloWorldTestString)-2),
-       "Verify seek to -1 with SDL_RWseek (RW_SEEK_END), expected %i, got %lli",
+       "Verify seek to -1 with SDL_RWseek (RW_SEEK_END), expected %i, got %"SDL_PRIs64,
        sizeof(RWopsHelloWorldTestString)-2,
        i);
 
@@ -161,7 +161,7 @@ _testGenericRWopsValidations(SDL_RWops *rw, int write)
    SDLTest_AssertPass("Call to SDL_RWseek(...,0,invalid_whence) succeeded");
    SDLTest_AssertCheck(
        i == (Sint64)(-1),
-       "Verify seek with SDL_RWseek (invalid_whence); expected: -1, got %lli",
+       "Verify seek with SDL_RWseek (invalid_whence); expected: -1, got %"SDL_PRIs64,
        i);
 }
 
@@ -560,7 +560,7 @@ rwops_testCompareRWFromMemWithRWFromFile(void)
 
      /* Compare */
      SDLTest_AssertCheck(rv_mem == rv_file, "Verify returned read blocks matches for mem and file reads; got: rv_mem=%d rv_file=%d", rv_mem, rv_file);
-     SDLTest_AssertCheck(sv_mem == sv_file, "Verify SEEK_END position matches for mem and file seeks; got: sv_mem=%llu sv_file=%llu", sv_mem, sv_file);
+     SDLTest_AssertCheck(sv_mem == sv_file, "Verify SEEK_END position matches for mem and file seeks; got: sv_mem=%"SDL_PRIu64" sv_file=%"SDL_PRIu64, sv_mem, sv_file);
      SDLTest_AssertCheck(buffer_mem[slen] == 0, "Verify mem buffer termination; expected: 0, got: %d", buffer_mem[slen]);
      SDLTest_AssertCheck(buffer_file[slen] == 0, "Verify file buffer termination; expected: 0, got: %d", buffer_file[slen]);
      SDLTest_AssertCheck(
@@ -668,7 +668,7 @@ rwops_testFileWriteReadEndian(void)
      /* Test seek to start */
      result = SDL_RWseek( rw, 0, RW_SEEK_SET );
      SDLTest_AssertPass("Call to SDL_RWseek succeeded");
-     SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_RWseek, expected 0, got %lli", result);
+     SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_RWseek, expected 0, got %"SDL_PRIs64, result);
 
      /* Read test data */
      BE16test = SDL_ReadBE16(rw);
@@ -679,7 +679,7 @@ rwops_testFileWriteReadEndian(void)
      SDLTest_AssertCheck(BE32test == BE32value, "Validate return value from SDL_ReadBE32, expected: %u, got: %u", BE32value, BE32test);
      BE64test = SDL_ReadBE64(rw);
      SDLTest_AssertPass("Call to SDL_ReadBE64()");
-     SDLTest_AssertCheck(BE64test == BE64value, "Validate return value from SDL_ReadBE64, expected: %llu, got: %llu", BE64value, BE64test);
+     SDLTest_AssertCheck(BE64test == BE64value, "Validate return value from SDL_ReadBE64, expected: %"SDL_PRIu64", got: %"SDL_PRIu64, BE64value, BE64test);
      LE16test = SDL_ReadLE16(rw);
      SDLTest_AssertPass("Call to SDL_ReadLE16()");
      SDLTest_AssertCheck(LE16test == LE16value, "Validate return value from SDL_ReadLE16, expected: %hu, got: %hu", LE16value, LE16test);
@@ -688,7 +688,7 @@ rwops_testFileWriteReadEndian(void)
      SDLTest_AssertCheck(LE32test == LE32value, "Validate return value from SDL_ReadLE32, expected: %u, got: %u", LE32value, LE32test);
      LE64test = SDL_ReadLE64(rw);
      SDLTest_AssertPass("Call to SDL_ReadLE64()");
-     SDLTest_AssertCheck(LE64test == LE64value, "Validate return value from SDL_ReadLE64, expected: %llu, got: %llu", LE64value, LE64test);
+     SDLTest_AssertCheck(LE64test == LE64value, "Validate return value from SDL_ReadLE64, expected: %"SDL_PRIu64", got: %"SDL_PRIu64, LE64value, LE64test);
 
      /* Close handle */
      cresult = SDL_RWclose(rw);
diff --git a/test/testautomation_sdltest.c b/test/testautomation_sdltest.c
index 2238ba4f0edaf..ec1da8a50ea19 100644
--- a/test/testautomation_sdltest.c
+++ b/test/testautomation_sdltest.c
@@ -93,35 +93,35 @@ sdltest_randomNumber(void *arg)
   result = (Sint64)SDLTest_RandomUint8();
   umax = (1 << 8) - 1;
   SDLTest_AssertPass("Call to SDLTest_RandomUint8");
-  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%llu], got: %lld", umax, result);
+  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%"SDL_PRIu64"], got: %"SDL_PRIs64, umax, result);
 
   result = (Sint64)SDLTest_RandomSint8();
   min = 0 - (1 << 7);
   max =     (1 << 7) - 1;
   SDLTest_AssertPass("Call to SDLTest_RandomSint8");
-  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%lld,%lld], got: %lld", min, max, result);
+  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
 
   result = (Sint64)SDLTest_RandomUint16();
   umax = (1 << 16) - 1;
   SDLTest_AssertPass("Call to SDLTest_RandomUint16");
-  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%llu], got: %lld", umax, result);
+  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%"SDL_PRIu64"], got: %"SDL_PRIs64, umax, result);
 
   result = (Sint64)SDLTest_RandomSint16();
   min = 0 - (1 << 15);
   max =     (1 << 15) - 1;
   SDLTest_AssertPass("Call to SDLTest_RandomSint16");
-  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%lld,%lld], got: %lld", min, max, result);
+  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
 
   result = (Sint64)SDLTest_RandomUint32();
   umax = ((Uint64)1 << 32) - 1;
   SDLTest_AssertPass("Call to SDLTest_RandomUint32");
-  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%llu], got: %lld", umax, result);
+  SDLTest_AssertCheck(result >= 0 && result <= (Sint64)umax, "Verify result value, expected: [0,%"SDL_PRIu64"], got: %"SDL_PRIs64, umax, result);
 
   result = (Sint64)SDLTest_RandomSint32();
   min = 0 - ((Sint64)1 << 31);
   max =     ((Sint64)1 << 31) - 1;
   SDLTest_AssertPass("Call to SDLTest_RandomSint32");
-  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%lld,%lld], got: %lld", min, max, result);
+  SDLTest_AssertCheck(result >= min && result <= max, "Verify result value, expected: [%"SDL_PRIs64",%"SDL_PRIs64"], got: %"SDL_PRIs64, min, max, result);
 
   uresult = SDLTest_RandomUint64();
   SDLTest_AssertPass("Call to SDLTest_RandomUint64");
@@ -166,63 +166,63 @@ sdltest_randomBoundaryNumberUint8(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", uresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", uresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", uresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", uresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0 || uresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", uresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(0, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 100,
-    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %lld", uresult);
+    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 0xff, SDL_FALSE) returns 0 (no error) */
   uresult = (Uint64)SDLTest_RandomUint8BoundaryValue(1, 255, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters (1,255,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters (1,255,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -232,7 +232,7 @@ sdltest_randomBoundaryNumberUint8(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0xff,
-    "Validate result value for parameters (0,254,SDL_FALSE); expected: 0xff, got: %lld", uresult);
+    "Validate result value for parameters (0,254,SDL_FALSE); expected: 0xff, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -242,7 +242,7 @@ sdltest_randomBoundaryNumberUint8(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint8BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters(0,255,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters(0,255,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -276,63 +276,63 @@ sdltest_randomBoundaryNumberUint16(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", uresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", uresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", uresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", uresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0 || uresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", uresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(0, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 100,
-    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %lld", uresult);
+    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 0xffff, SDL_FALSE) returns 0 (no error) */
   uresult = (Uint64)SDLTest_RandomUint16BoundaryValue(1, 0xffff, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters (1,0xffff,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters (1,0xffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -342,7 +342,7 @@ sdltest_randomBoundaryNumberUint16(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0xffff,
-    "Validate result value for parameters (0,0xfffe,SDL_FALSE); expected: 0xffff, got: %lld", uresult);
+    "Validate result value for parameters (0,0xfffe,SDL_FALSE); expected: 0xffff, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -352,7 +352,7 @@ sdltest_randomBoundaryNumberUint16(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint16BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters(0,0xffff,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters(0,0xffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -386,63 +386,63 @@ sdltest_randomBoundaryNumberUint32(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", uresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", uresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", uresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", uresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0 || uresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", uresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(0, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 100,
-    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %lld", uresult);
+    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 0xffffffff, SDL_FALSE) returns 0 (no error) */
   uresult = (Uint64)SDLTest_RandomUint32BoundaryValue(1, 0xffffffff, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters (1,0xffffffff,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters (1,0xffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -452,7 +452,7 @@ sdltest_randomBoundaryNumberUint32(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0xffffffff,
-    "Validate result value for parameters (0,0xfffffffe,SDL_FALSE); expected: 0xffffffff, got: %lld", uresult);
+    "Validate result value for parameters (0,0xfffffffe,SDL_FALSE); expected: 0xffffffff, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -462,7 +462,7 @@ sdltest_randomBoundaryNumberUint32(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint32BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters(0,0xffffffff,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters(0,0xffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -496,63 +496,63 @@ sdltest_randomBoundaryNumberUint64(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", uresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", uresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", uresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 12 || uresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", uresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 10 || uresult == 11 || uresult == 19 || uresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", uresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0 || uresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", uresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(0, 99, SDL_FALSE) returns 100 */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(0, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 100,
-    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %lld", uresult);
+    "Validate result value for parameters (0,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, uresult);
 
   /* RandomUintXBoundaryValue(1, 0xffffffffffffffff, SDL_FALSE) returns 0 (no error) */
   uresult = (Uint64)SDLTest_RandomUint64BoundaryValue(1, (Uint64)0xffffffffffffffffULL, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters (1,0xffffffffffffffff,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters (1,0xffffffffffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -562,7 +562,7 @@ sdltest_randomBoundaryNumberUint64(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == (Uint64)0xffffffffffffffffULL,
-    "Validate result value for parameters (0,0xfffffffffffffffe,SDL_FALSE); expected: 0xffffffffffffffff, got: %lld", uresult);
+    "Validate result value for parameters (0,0xfffffffffffffffe,SDL_FALSE); expected: 0xffffffffffffffff, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -572,7 +572,7 @@ sdltest_randomBoundaryNumberUint64(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomUint64BoundaryValue");
   SDLTest_AssertCheck(
     uresult == 0,
-    "Validate result value for parameters(0,0xffffffffffffffff,SDL_FALSE); expected: 0, got: %lld", uresult);
+    "Validate result value for parameters(0,0xffffffffffffffff,SDL_FALSE); expected: 0, got: %"SDL_PRIs64, uresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -606,63 +606,63 @@ sdltest_randomBoundaryNumberSint8(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", sresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", sresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", sresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", sresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 0 || sresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", sresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(SCHAR_MIN, 99, SDL_FALSE) returns 100 */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(SCHAR_MIN, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 100,
-    "Validate result value for parameters (SCHAR_MIN,99,SDL_FALSE); expected: 100, got: %lld", sresult);
+    "Validate result value for parameters (SCHAR_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(SCHAR_MIN + 1, SCHAR_MAX, SDL_FALSE) returns SCHAR_MIN (no error) */
   sresult = (Sint64)SDLTest_RandomSint8BoundaryValue(SCHAR_MIN + 1, SCHAR_MAX, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == SCHAR_MIN,
-    "Validate result value for parameters (SCHAR_MIN + 1,SCHAR_MAX,SDL_FALSE); expected: %d, got: %lld", SCHAR_MIN, sresult);
+    "Validate result value for parameters (SCHAR_MIN + 1,SCHAR_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SCHAR_MIN, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -672,7 +672,7 @@ sdltest_randomBoundaryNumberSint8(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == SCHAR_MAX,
-    "Validate result value for parameters (SCHAR_MIN,SCHAR_MAX - 1,SDL_FALSE); expected: %d, got: %lld", SCHAR_MAX, sresult);
+    "Validate result value for parameters (SCHAR_MIN,SCHAR_MAX - 1,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SCHAR_MAX, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -682,7 +682,7 @@ sdltest_randomBoundaryNumberSint8(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint8BoundaryValue");
   SDLTest_AssertCheck(
     sresult == SCHAR_MIN,
-    "Validate result value for parameters(SCHAR_MIN,SCHAR_MAX,SDL_FALSE); expected: %d, got: %lld", SCHAR_MIN, sresult);
+    "Validate result value for parameters(SCHAR_MIN,SCHAR_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SCHAR_MIN, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -716,63 +716,63 @@ sdltest_randomBoundaryNumberSint16(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", sresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", sresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", sresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", sresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 0 || sresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", sresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(SHRT_MIN, 99, SDL_FALSE) returns 100 */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(SHRT_MIN, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 100,
-    "Validate result value for parameters (SHRT_MIN,99,SDL_FALSE); expected: 100, got: %lld", sresult);
+    "Validate result value for parameters (SHRT_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(SHRT_MIN + 1, SHRT_MAX, SDL_FALSE) returns SHRT_MIN (no error) */
   sresult = (Sint64)SDLTest_RandomSint16BoundaryValue(SHRT_MIN + 1, SHRT_MAX, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == SHRT_MIN,
-    "Validate result value for parameters (SHRT_MIN+1,SHRT_MAX,SDL_FALSE); expected: %d, got: %lld", SHRT_MIN, sresult);
+    "Validate result value for parameters (SHRT_MIN+1,SHRT_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SHRT_MIN, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -782,7 +782,7 @@ sdltest_randomBoundaryNumberSint16(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == SHRT_MAX,
-    "Validate result value for parameters (SHRT_MIN,SHRT_MAX - 1,SDL_FALSE); expected: %d, got: %lld", SHRT_MAX, sresult);
+    "Validate result value for parameters (SHRT_MIN,SHRT_MAX - 1,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SHRT_MAX, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -792,7 +792,7 @@ sdltest_randomBoundaryNumberSint16(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint16BoundaryValue");
   SDLTest_AssertCheck(
     sresult == SHRT_MIN,
-    "Validate result value for parameters(SHRT_MIN,SHRT_MAX,SDL_FALSE); expected: %d, got: %lld", SHRT_MIN, sresult);
+    "Validate result value for parameters(SHRT_MIN,SHRT_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, SHRT_MIN, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -833,63 +833,63 @@ sdltest_randomBoundaryNumberSint32(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", sresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", sresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", sresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", sresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 0 || sresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", sresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(LONG_MIN, 99, SDL_FALSE) returns 100 */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(long_min, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 100,
-    "Validate result value for parameters (LONG_MIN,99,SDL_FALSE); expected: 100, got: %lld", sresult);
+    "Validate result value for parameters (LONG_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(LONG_MIN + 1, LONG_MAX, SDL_FALSE) returns LONG_MIN (no error) */
   sresult = (Sint64)SDLTest_RandomSint32BoundaryValue(long_min + 1, long_max, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == long_min,
-    "Validate result value for parameters (LONG_MIN+1,LONG_MAX,SDL_FALSE); expected: %d, got: %lld", long_min, sresult);
+    "Validate result value for parameters (LONG_MIN+1,LONG_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, long_min, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -899,7 +899,7 @@ sdltest_randomBoundaryNumberSint32(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == long_max,
-    "Validate result value for parameters (LONG_MIN,LONG_MAX - 1,SDL_FALSE); expected: %d, got: %lld", long_max, sresult);
+    "Validate result value for parameters (LONG_MIN,LONG_MAX - 1,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, long_max, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -909,7 +909,7 @@ sdltest_randomBoundaryNumberSint32(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint32BoundaryValue");
   SDLTest_AssertCheck(
     sresult == long_min,
-    "Validate result value for parameters(LONG_MIN,LONG_MAX,SDL_FALSE); expected: %d, got: %lld", long_min, sresult);
+    "Validate result value for parameters(LONG_MIN,LONG_MAX,SDL_FALSE); expected: %d, got: %"SDL_PRIs64, long_min, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
@@ -943,63 +943,63 @@ sdltest_randomBoundaryNumberSint64(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10,
-    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %lld", sresult);
+    "Validate result value for parameters (10,10,SDL_TRUE); expected: 10, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 11, SDL_TRUE) returns 10, 11 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 11, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11,
-    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %lld", sresult);
+    "Validate result value for parameters (10,11,SDL_TRUE); expected: 10|11, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 12, SDL_TRUE) returns 10, 11, 12 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 12, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12,
-    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %lld", sresult);
+    "Validate result value for parameters (10,12,SDL_TRUE); expected: 10|11|12, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 13, SDL_TRUE) returns 10, 11, 12, 13 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 13, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 12 || sresult == 13,
-    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %lld", sresult);
+    "Validate result value for parameters (10,13,SDL_TRUE); expected: 10|11|12|13, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(10, 20, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(10, 20, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (10,20,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(20, 10, SDL_TRUE) returns 10, 11, 19 or 20 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(20, 10, SDL_TRUE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 10 || sresult == 11 || sresult == 19 || sresult == 20,
-    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %lld", sresult);
+    "Validate result value for parameters (20,10,SDL_TRUE); expected: 10|11|19|20, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(1, 20, SDL_FALSE) returns 0, 21 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(1, 20, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 0 || sresult == 21,
-    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %lld", sresult);
+    "Validate result value for parameters (1,20,SDL_FALSE); expected: 0|21, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(LLONG_MIN, 99, SDL_FALSE) returns 100 */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(LLONG_MIN, 99, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == 100,
-    "Validate result value for parameters (LLONG_MIN,99,SDL_FALSE); expected: 100, got: %lld", sresult);
+    "Validate result value for parameters (LLONG_MIN,99,SDL_FALSE); expected: 100, got: %"SDL_PRIs64, sresult);
 
   /* RandomSintXBoundaryValue(LLONG_MIN + 1, LLONG_MAX, SDL_FALSE) returns LLONG_MIN (no error) */
   sresult = (Sint64)SDLTest_RandomSint64BoundaryValue(LLONG_MIN + 1, LLONG_MAX, SDL_FALSE);
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == LLONG_MIN,
-    "Validate result value for parameters (LLONG_MIN+1,LLONG_MAX,SDL_FALSE); expected: %lld, got: %lld", LLONG_MIN, sresult);
+    "Validate result value for parameters (LLONG_MIN+1,LLONG_MAX,SDL_FALSE); expected: %"SDL_PRIs64", got: %"SDL_PRIs64, LLONG_MIN, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -1009,7 +1009,7 @@ sdltest_randomBoundaryNumberSint64(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == LLONG_MAX,
-    "Validate result value for parameters (LLONG_MIN,LLONG_MAX - 1,SDL_FALSE); expected: %lld, got: %lld", LLONG_MAX, sresult);
+    "Validate result value for parameters (LLONG_MIN,LLONG_MAX - 1,SDL_FALSE); expected: %"SDL_PRIs64", got: %"SDL_PRIs64, LLONG_MAX, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError == NULL || lastError[0] == '\0', "Validate no error message was set");
@@ -1019,7 +1019,7 @@ sdltest_randomBoundaryNumberSint64(void *arg)
   SDLTest_AssertPass("Call to SDLTest_RandomSint64BoundaryValue");
   SDLTest_AssertCheck(
     sresult == LLONG_MIN,
-    "Validate result value for parameters(LLONG_MIN,LLONG_MAX,SDL_FALSE); expected: %lld, got: %lld", LLONG_MIN, sresult);
+    "Validate result value for parameters(LLONG_MIN,LLONG_MAX,SDL_FALSE); expected: %"SDL_PRIs64", got: %"SDL_PRIs64, LLONG_MIN, sresult);
   lastError = (char *)SDL_GetError();
   SDLTest_AssertPass("SDL_GetError()");
   SDLTest_AssertCheck(lastError != NULL && SDL_strcmp(lastError, expectedError) == 0,
diff --git a/test/testautomation_timer.c b/test/testautomation_timer.c
index 0e836455058c1..6d73856ee2fc8 100644
--- a/test/testautomation_timer.c
+++ b/test/testautomation_timer.c
@@ -42,7 +42,7 @@ timer_getPerformanceCounter(void *arg)
 
   result = SDL_GetPerformanceCounter();
   SDLTest_AssertPass("Call to SDL_GetPerformanceCounter()");
-  SDLTest_AssertCheck(result > 0, "Check result value, expected: >0, got: %llu", result);
+  SDLTest_AssertCheck(result > 0, "Check result value, expected: >0, got: %"SDL_PRIu64, result);
 
   return TEST_COMPLETED;
 }
@@ -57,7 +57,7 @@ timer_getPerformanceFrequency(void *arg)
 
   result = SDL_GetPerformanceFrequency();
   SDLTest_AssertPass("Call to SDL_GetPerformanceFrequency()");
-  SDLTest_AssertCheck(result > 0, "Check result value, expected: >0, got: %llu", result);
+  SDLTest_AssertCheck(result > 0, "Check result value, expected: >0, got: %"SDL_PRIu64, result);
 
   return TEST_COMPLETED;
 }
diff --git a/test/testplatform.c b/test/testplatform.c
index ae367ff4b34de..e0dc29e7cfb4d 100644
--- a/test/testplatform.c
+++ b/test/testplatform.c
@@ -119,14 +119,8 @@ TestEndian(SDL_bool verbose)
         ++error;
     }
     if (verbose) {
-#ifdef _MSC_VER
-        SDL_Log("Value 64 = 0x%I64X, swapped = 0x%I64X\n", value64,
+        SDL_Log("Value 64 = 0x%"SDL_PRIX64", swapped = 0x%"SDL_PRIX64"\n", value64,
                SDL_Swap64(value64));
-#else
-        SDL_Log("Value 64 = 0x%llX, swapped = 0x%llX\n",
-               (unsigned long long) value64,
-               (unsigned long long) SDL_Swap64(value64));
-#endif
     }
     if (SDL_Swap64(value64) != swapped64) {
         if (verbose) {
diff --git a/test/testtimer.c b/test/testtimer.c
index ef6bcb6a8bc3e..f02364cd25d15 100644
--- a/test/testtimer.c
+++ b/test/testtimer.c
@@ -107,7 +107,7 @@ main(int argc, char *argv[])
     now = SDL_GetPerformanceCounter();
     SDL_Log("1 million iterations of ticktock took %f ms\n", (double)((now - start)*1000) / SDL_GetPerformanceFrequency());
 
-    SDL_Log("Performance counter frequency: %llu\n", (unsigned long long) SDL_GetPerformanceFrequency());
+    SDL_Log("Performance counter frequency: %"PRIu64"\n", (unsigned long long) SDL_GetPerformanceFrequency());
     start32 = SDL_GetTicks();
     start = SDL_GetPerformanceCounter();
     SDL_Delay(1000);