From 6aaedb813fa11ba0679c3051bc2eb28646b9506c Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 30 Aug 2025 16:53:58 -0700 Subject: Update to SDL3 --- .../SDL-3.2.20/test/testautomation_platform.c | 557 +++++++++++++++++++++ 1 file changed, 557 insertions(+) create mode 100644 src/contrib/SDL-3.2.20/test/testautomation_platform.c (limited to 'src/contrib/SDL-3.2.20/test/testautomation_platform.c') 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 +#include +#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 +}; -- cgit v1.2.3