Update to SDL3

1 files changed, 557 insertions, 0 deletions

diff --git a/src/contrib/SDL-3.2.20/test/testautomation_platform.c b/src/contrib/SDL-3.2.20/test/testautomation_platform.c
new file mode 100644
index 0000000..2a70e75
--- /dev/null
+++ b/src/contrib/SDL-3.2.20/test/testautomation_platform.c
@@ -0,0 +1,557 @@
+/**
+ * Original code: automated SDL platform test written by Edgar Simo "bobbens"
+ * Extended and updated by aschiffler at ferzkopp dot net
+ */
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_test.h>
+#include "testautomation_suites.h"
+
+/* ================= Test Case Implementation ================== */
+
+/* Helper functions */
+
+/**
+ * Compare sizes of types.
+ *
+ * @note Watcom C flags these as Warning 201: "Unreachable code" if you just
+ *  compare them directly, so we push it through a function to keep the
+ *  compiler quiet.  --ryan.
+ */
+static int compareSizeOfType(size_t sizeoftype, size_t hardcodetype)
+{
+    return sizeoftype != hardcodetype;
+}
+
+/* Test case functions */
+
+/**
+ * Tests type sizes.
+ */
+static int SDLCALL platform_testTypes(void *arg)
+{
+    int ret;
+
+    ret = compareSizeOfType(sizeof(Uint8), 1);
+    SDLTest_AssertCheck(ret == 0, "sizeof(Uint8) = %u, expected  1", (unsigned int)sizeof(Uint8));
+
+    ret = compareSizeOfType(sizeof(Uint16), 2);
+    SDLTest_AssertCheck(ret == 0, "sizeof(Uint16) = %u, expected 2", (unsigned int)sizeof(Uint16));
+
+    ret = compareSizeOfType(sizeof(Uint32), 4);
+    SDLTest_AssertCheck(ret == 0, "sizeof(Uint32) = %u, expected 4", (unsigned int)sizeof(Uint32));
+
+    ret = compareSizeOfType(sizeof(Uint64), 8);
+    SDLTest_AssertCheck(ret == 0, "sizeof(Uint64) = %u, expected 8", (unsigned int)sizeof(Uint64));
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests platform endianness and SDL_SwapXY functions.
+ */
+static int SDLCALL platform_testEndianessAndSwap(void *arg)
+{
+    int real_byteorder;
+    int real_floatwordorder = 0;
+    Uint16 value = 0x1234;
+    Uint16 value16 = 0xCDAB;
+    Uint16 swapped16 = 0xABCD;
+    Uint32 value32 = 0xEFBEADDE;
+    Uint32 swapped32 = 0xDEADBEEF;
+
+    union
+    {
+        double d;
+        Uint32 ui32[2];
+    } value_double;
+
+    Uint64 value64, swapped64;
+    value64 = 0xEFBEADDE;
+    value64 <<= 32;
+    value64 |= 0xCDAB3412;
+    swapped64 = 0x1234ABCD;
+    swapped64 <<= 32;
+    swapped64 |= 0xDEADBEEF;
+    value_double.d = 3.141593;
+
+    if ((*((char *)&value) >> 4) == 0x1) {
+        real_byteorder = SDL_BIG_ENDIAN;
+    } else {
+        real_byteorder = SDL_LIL_ENDIAN;
+    }
+
+    /* Test endianness. */
+    SDLTest_AssertCheck(real_byteorder == SDL_BYTEORDER,
+                        "Machine detected as %s endian, appears to be %s endian.",
+                        (SDL_BYTEORDER == SDL_LIL_ENDIAN) ? "little" : "big",
+                        (real_byteorder == SDL_LIL_ENDIAN) ? "little" : "big");
+
+    if (value_double.ui32[0] == 0x82c2bd7f && value_double.ui32[1] == 0x400921fb) {
+        real_floatwordorder = SDL_LIL_ENDIAN;
+    } else if (value_double.ui32[0] == 0x400921fb && value_double.ui32[1] == 0x82c2bd7f) {
+        real_floatwordorder = SDL_BIG_ENDIAN;
+    }
+
+    /* Test endianness. */
+    SDLTest_AssertCheck(real_floatwordorder == SDL_FLOATWORDORDER,
+                        "Machine detected as having %s endian float word order, appears to be %s endian.",
+                        (SDL_FLOATWORDORDER == SDL_LIL_ENDIAN) ? "little" : "big",
+                        (real_floatwordorder == SDL_LIL_ENDIAN) ? "little" : (real_floatwordorder == SDL_BIG_ENDIAN) ? "big"
+                                                                                                                     : "unknown");
+
+    /* Test 16 swap. */
+    SDLTest_AssertCheck(SDL_Swap16(value16) == swapped16,
+                        "SDL_Swap16(): 16 bit swapped: 0x%X => 0x%X",
+                        value16, SDL_Swap16(value16));
+
+    /* Test 32 swap. */
+    SDLTest_AssertCheck(SDL_Swap32(value32) == swapped32,
+                        "SDL_Swap32(): 32 bit swapped: 0x%" SDL_PRIX32 " => 0x%" SDL_PRIX32,
+                        value32, SDL_Swap32(value32));
+
+    /* Test 64 swap. */
+    SDLTest_AssertCheck(SDL_Swap64(value64) == swapped64,
+                        "SDL_Swap64(): 64 bit swapped: 0x%" SDL_PRIX64 " => 0x%" SDL_PRIX64,
+                        value64, SDL_Swap64(value64));
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests SDL_GetXYZ() functions
+ * \sa SDL_GetPlatform
+ * \sa SDL_GetNumLogicalCPUCores
+ * \sa SDL_GetRevision
+ * \sa SDL_GetCPUCacheLineSize
+ */
+static int SDLCALL platform_testGetFunctions(void *arg)
+{
+    const char *platform;
+    const char *revision;
+    int ret;
+    size_t len;
+
+    platform = SDL_GetPlatform();
+    SDLTest_AssertPass("SDL_GetPlatform()");
+    SDLTest_AssertCheck(platform != NULL, "SDL_GetPlatform() != NULL");
+    if (platform != NULL) {
+        len = SDL_strlen(platform);
+        SDLTest_AssertCheck(len > 0,
+                            "SDL_GetPlatform(): expected non-empty platform, was platform: '%s', len: %i",
+                            platform,
+                            (int)len);
+    }
+
+    ret = SDL_GetNumLogicalCPUCores();
+    SDLTest_AssertPass("SDL_GetNumLogicalCPUCores()");
+    SDLTest_AssertCheck(ret > 0,
+                        "SDL_GetNumLogicalCPUCores(): expected count > 0, was: %i",
+                        ret);
+
+    ret = SDL_GetCPUCacheLineSize();
+    SDLTest_AssertPass("SDL_GetCPUCacheLineSize()");
+    SDLTest_AssertCheck(ret >= 0,
+                        "SDL_GetCPUCacheLineSize(): expected size >= 0, was: %i",
+                        ret);
+
+    revision = SDL_GetRevision();
+    SDLTest_AssertPass("SDL_GetRevision()");
+    SDLTest_AssertCheck(revision != NULL, "SDL_GetRevision() != NULL");
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests SDL_HasXYZ() functions
+ * \sa SDL_HasAltiVec
+ * \sa SDL_HasMMX
+ * \sa SDL_HasSSE
+ * \sa SDL_HasSSE2
+ * \sa SDL_HasSSE3
+ * \sa SDL_HasSSE41
+ * \sa SDL_HasSSE42
+ * \sa SDL_HasAVX
+ */
+static int SDLCALL platform_testHasFunctions(void *arg)
+{
+    /* TODO: independently determine and compare values as well */
+
+    SDL_HasAltiVec();
+    SDLTest_AssertPass("SDL_HasAltiVec()");
+
+    SDL_HasMMX();
+    SDLTest_AssertPass("SDL_HasMMX()");
+
+    SDL_HasSSE();
+    SDLTest_AssertPass("SDL_HasSSE()");
+
+    SDL_HasSSE2();
+    SDLTest_AssertPass("SDL_HasSSE2()");
+
+    SDL_HasSSE3();
+    SDLTest_AssertPass("SDL_HasSSE3()");
+
+    SDL_HasSSE41();
+    SDLTest_AssertPass("SDL_HasSSE41()");
+
+    SDL_HasSSE42();
+    SDLTest_AssertPass("SDL_HasSSE42()");
+
+    SDL_HasAVX();
+    SDLTest_AssertPass("SDL_HasAVX()");
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests SDL_GetVersion
+ * \sa SDL_GetVersion
+ */
+static int SDLCALL platform_testGetVersion(void *arg)
+{
+    int linked = SDL_GetVersion();
+    SDLTest_AssertCheck(linked >= SDL_VERSION,
+                        "SDL_GetVersion(): returned version %d (>= %d)",
+                        linked,
+                        SDL_VERSION);
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests default SDL_Init
+ */
+static int SDLCALL platform_testDefaultInit(void *arg)
+{
+    bool ret;
+    int subsystem;
+
+    subsystem = SDL_WasInit(0);
+    SDLTest_AssertCheck(subsystem != 0,
+                        "SDL_WasInit(0): returned %i, expected != 0",
+                        subsystem);
+
+    ret = SDL_Init(0);
+    SDLTest_AssertCheck(ret == true,
+                        "SDL_Init(0): returned %i, expected true, error: %s",
+                        ret,
+                        SDL_GetError());
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests SDL_Get/Set/ClearError
+ * \sa SDL_GetError
+ * \sa SDL_SetError
+ * \sa SDL_ClearError
+ */
+static int SDLCALL platform_testGetSetClearError(void *arg)
+{
+    int result;
+    const char *testError = "Testing";
+    const char *lastError;
+    size_t len;
+
+    SDL_ClearError();
+    SDLTest_AssertPass("SDL_ClearError()");
+
+    lastError = SDL_GetError();
+    SDLTest_AssertPass("SDL_GetError()");
+    SDLTest_AssertCheck(lastError != NULL,
+                        "SDL_GetError() != NULL");
+    if (lastError != NULL) {
+        len = SDL_strlen(lastError);
+        SDLTest_AssertCheck(len == 0,
+                            "SDL_GetError(): no message expected, len: %i", (int)len);
+    }
+
+    result = SDL_SetError("%s", testError);
+    SDLTest_AssertPass("SDL_SetError()");
+    SDLTest_AssertCheck(result == false, "SDL_SetError: expected false, got: %i", result);
+    lastError = SDL_GetError();
+    SDLTest_AssertCheck(lastError != NULL,
+                        "SDL_GetError() != NULL");
+    if (lastError != NULL) {
+        len = SDL_strlen(lastError);
+        SDLTest_AssertCheck(len == SDL_strlen(testError),
+                            "SDL_GetError(): expected message len %i, was len: %i",
+                            (int)SDL_strlen(testError),
+                            (int)len);
+        SDLTest_AssertCheck(SDL_strcmp(lastError, testError) == 0,
+                            "SDL_GetError(): expected message %s, was message: %s",
+                            testError,
+                            lastError);
+    }
+
+    /* Clean up */
+    SDL_ClearError();
+    SDLTest_AssertPass("SDL_ClearError()");
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * Tests SDL_SetError with empty input
+ * \sa SDL_SetError
+ */
+static int SDLCALL platform_testSetErrorEmptyInput(void *arg)
+{
+    int result;
+    const char *testError = "";
+    const char *lastError;
+    size_t len;
+
+    result = SDL_SetError("%s", testError);
+    SDLTest_AssertPass("SDL_SetError()");
+    SDLTest_AssertCheck(result == false, "SDL_SetError: expected false, got: %i", result);
+    lastError = SDL_GetError();
+    SDLTest_AssertCheck(lastError != NULL,
+                        "SDL_GetError() != NULL");
+    if (lastError != NULL) {
+        len = SDL_strlen(lastError);
+        SDLTest_AssertCheck(len == SDL_strlen(testError),
+                            "SDL_GetError(): expected message len %i, was len: %i",
+                            (int)SDL_strlen(testError),
+                            (int)len);
+        SDLTest_AssertCheck(SDL_strcmp(lastError, testError) == 0,
+                            "SDL_GetError(): expected message '%s', was message: '%s'",
+                            testError,
+                            lastError);
+    }
+
+    /* Clean up */
+    SDL_ClearError();
+    SDLTest_AssertPass("SDL_ClearError()");
+
+    return TEST_COMPLETED;
+}
+
+#ifdef HAVE_WFORMAT_OVERFLOW
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-overflow"
+#endif
+
+/**
+ * Tests SDL_SetError with invalid input
+ * \sa SDL_SetError
+ */
+static int SDLCALL platform_testSetErrorInvalidInput(void *arg)
+{
+    int result;
+    const char *invalidError = "";
+    const char *probeError = "Testing";
+    const char *lastError;
+    size_t len;
+
+    /* Reset */
+    SDL_ClearError();
+    SDLTest_AssertPass("SDL_ClearError()");
+
+    /* Check for no-op */
+    result = SDL_SetError("%s", invalidError);
+    SDLTest_AssertPass("SDL_SetError()");
+    SDLTest_AssertCheck(result == false, "SDL_SetError: expected false, got: %i", result);
+    lastError = SDL_GetError();
+    SDLTest_AssertCheck(lastError != NULL,
+                        "SDL_GetError() != NULL");
+    if (lastError != NULL) {
+        len = SDL_strlen(lastError);
+        SDLTest_AssertCheck(len == 0 || SDL_strcmp(lastError, "(null)") == 0,
+                            "SDL_GetError(): expected message len 0, was len: %i",
+                            (int)len);
+    }
+
+    /* Set */
+    result = SDL_SetError("%s", probeError);
+    SDLTest_AssertPass("SDL_SetError('%s')", probeError);
+    SDLTest_AssertCheck(result == false, "SDL_SetError: expected false, got: %i", result);
+
+    /* Check for no-op */
+    result = SDL_SetError("%s", invalidError);
+    SDLTest_AssertPass("SDL_SetError(NULL)");
+    SDLTest_AssertCheck(result == false, "SDL_SetError: expected false, got: %i", result);
+    lastError = SDL_GetError();
+    SDLTest_AssertCheck(lastError != NULL,
+                        "SDL_GetError() != NULL");
+    if (lastError != NULL) {
+        len = SDL_strlen(lastError);
+        SDLTest_AssertCheck(len == 0 || SDL_strcmp(lastError, "(null)") == 0,
+                            "SDL_GetError(): expected message len 0, was len: %i",
+                            (int)len);
+    }
+
+    /* Reset */
+    SDL_ClearError();
+    SDLTest_AssertPass("SDL_ClearError()");
+
+    /* Set and check */
+    result = SDL_SetError("%s", probeError);
+    SDLTest_AssertPass("SDL_SetError()");
+    SDLTest_AssertCheck(result == false, "SDL_SetError: expected false, got: %i", result);
+    lastError = SDL_GetError();
+    SDLTest_AssertCheck(lastError != NULL,
+                        "SDL_GetError() != NULL");
+    if (lastError != NULL) {
+        len = SDL_strlen(lastError);
+        SDLTest_AssertCheck(len == SDL_strlen(probeError),
+                            "SDL_GetError(): expected message len %i, was len: %i",
+                            (int)SDL_strlen(probeError),
+                            (int)len);
+        SDLTest_AssertCheck(SDL_strcmp(lastError, probeError) == 0,
+                            "SDL_GetError(): expected message '%s', was message: '%s'",
+                            probeError,
+                            lastError);
+    }
+
+    /* Clean up */
+    SDL_ClearError();
+    SDLTest_AssertPass("SDL_ClearError()");
+
+    return TEST_COMPLETED;
+}
+
+#ifdef HAVE_WFORMAT_OVERFLOW
+#pragma GCC diagnostic pop
+#endif
+
+/**
+ * Tests SDL_GetPowerInfo
+ * \sa SDL_GetPowerInfo
+ */
+static int SDLCALL platform_testGetPowerInfo(void *arg)
+{
+    SDL_PowerState state;
+    SDL_PowerState stateAgain;
+    int secs;
+    int secsAgain;
+    int pct;
+    int pctAgain;
+
+    state = SDL_GetPowerInfo(&secs, &pct);
+    SDLTest_AssertPass("SDL_GetPowerInfo()");
+    SDLTest_AssertCheck(
+        state == SDL_POWERSTATE_UNKNOWN ||
+            state == SDL_POWERSTATE_ON_BATTERY ||
+            state == SDL_POWERSTATE_NO_BATTERY ||
+            state == SDL_POWERSTATE_CHARGING ||
+            state == SDL_POWERSTATE_CHARGED,
+        "SDL_GetPowerInfo(): state %i is one of the expected values",
+        (int)state);
+
+    if (state == SDL_POWERSTATE_ON_BATTERY) {
+        SDLTest_AssertCheck(
+            secs >= 0,
+            "SDL_GetPowerInfo(): on battery, secs >= 0, was: %i",
+            secs);
+        SDLTest_AssertCheck(
+            (pct >= 0) && (pct <= 100),
+            "SDL_GetPowerInfo(): on battery, pct=[0,100], was: %i",
+            pct);
+    }
+
+    if (state == SDL_POWERSTATE_UNKNOWN ||
+        state == SDL_POWERSTATE_NO_BATTERY) {
+        SDLTest_AssertCheck(
+            secs == -1,
+            "SDL_GetPowerInfo(): no battery, secs == -1, was: %i",
+            secs);
+        SDLTest_AssertCheck(
+            pct == -1,
+            "SDL_GetPowerInfo(): no battery, pct == -1, was: %i",
+            pct);
+    }
+
+    /* Partial return value variations */
+    stateAgain = SDL_GetPowerInfo(&secsAgain, NULL);
+    SDLTest_AssertCheck(
+        state == stateAgain,
+        "State %i returned when only 'secs' requested",
+        stateAgain);
+    SDLTest_AssertCheck(
+        secs == secsAgain,
+        "Value %i matches when only 'secs' requested",
+        secsAgain);
+    stateAgain = SDL_GetPowerInfo(NULL, &pctAgain);
+    SDLTest_AssertCheck(
+        state == stateAgain,
+        "State %i returned when only 'pct' requested",
+        stateAgain);
+    SDLTest_AssertCheck(
+        pct == pctAgain,
+        "Value %i matches when only 'pct' requested",
+        pctAgain);
+    stateAgain = SDL_GetPowerInfo(NULL, NULL);
+    SDLTest_AssertCheck(
+        state == stateAgain,
+        "State %i returned when no value requested",
+        stateAgain);
+
+    return TEST_COMPLETED;
+}
+
+/* ================= Test References ================== */
+
+/* Platform test cases */
+static const SDLTest_TestCaseReference platformTest1 = {
+    platform_testTypes, "platform_testTypes", "Tests predefined types", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest2 = {
+    platform_testEndianessAndSwap, "platform_testEndianessAndSwap", "Tests endianness and swap functions", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest3 = {
+    platform_testGetFunctions, "platform_testGetFunctions", "Tests various SDL_GetXYZ functions", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest4 = {
+    platform_testHasFunctions, "platform_testHasFunctions", "Tests various SDL_HasXYZ functions", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest5 = {
+    platform_testGetVersion, "platform_testGetVersion", "Tests SDL_GetVersion function", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest6 = {
+    platform_testDefaultInit, "platform_testDefaultInit", "Tests default SDL_Init", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest7 = {
+    platform_testGetSetClearError, "platform_testGetSetClearError", "Tests SDL_Get/Set/ClearError", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest8 = {
+    platform_testSetErrorEmptyInput, "platform_testSetErrorEmptyInput", "Tests SDL_SetError with empty input", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest9 = {
+    platform_testSetErrorInvalidInput, "platform_testSetErrorInvalidInput", "Tests SDL_SetError with invalid input", TEST_ENABLED
+};
+
+static const SDLTest_TestCaseReference platformTest10 = {
+    platform_testGetPowerInfo, "platform_testGetPowerInfo", "Tests SDL_GetPowerInfo function", TEST_ENABLED
+};
+
+/* Sequence of Platform test cases */
+static const SDLTest_TestCaseReference *platformTests[] = {
+    &platformTest1,
+    &platformTest2,
+    &platformTest3,
+    &platformTest4,
+    &platformTest5,
+    &platformTest6,
+    &platformTest7,
+    &platformTest8,
+    &platformTest9,
+    &platformTest10,
+    NULL
+};
+
+/* Platform test suite (global) */
+SDLTest_TestSuiteReference platformTestSuite = {
+    "Platform",
+    NULL,
+    platformTests,
+    NULL
+};