/** * Original code: automated SDL platform test written by Edgar Simo "bobbens" * Extended and updated by aschiffler at ferzkopp dot net */ #include <stdio.h> #include "SDL.h" #include "SDL_test.h" /* ================= Test Case Implementation ================== */ /* Helper functions */ /** * @brief 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 */ /** * @brief Tests type sizes. */ int platform_testTypes(void *arg) { int ret; ret = _compareSizeOfType( sizeof(Uint8), 1 ); SDLTest_AssertCheck( ret == 0, "sizeof(Uint8) = %lu, expected 1", (unsigned long)sizeof(Uint8) ); ret = _compareSizeOfType( sizeof(Uint16), 2 ); SDLTest_AssertCheck( ret == 0, "sizeof(Uint16) = %lu, expected 2", (unsigned long)sizeof(Uint16) ); ret = _compareSizeOfType( sizeof(Uint32), 4 ); SDLTest_AssertCheck( ret == 0, "sizeof(Uint32) = %lu, expected 4", (unsigned long)sizeof(Uint32) ); ret = _compareSizeOfType( sizeof(Uint64), 8 ); SDLTest_AssertCheck( ret == 0, "sizeof(Uint64) = %lu, expected 8", (unsigned long)sizeof(Uint64) ); return TEST_COMPLETED; } /** * @brief Tests platform endianness and SDL_SwapXY functions. */ int platform_testEndianessAndSwap(void *arg) { int real_byteorder; Uint16 value = 0x1234; Uint16 value16 = 0xCDAB; Uint16 swapped16 = 0xABCD; Uint32 value32 = 0xEFBEADDE; Uint32 swapped32 = 0xDEADBEEF; Uint64 value64, swapped64; value64 = 0xEFBEADDE; value64 <<= 32; value64 |= 0xCDAB3412; swapped64 = 0x1234ABCD; swapped64 <<= 32; swapped64 |= 0xDEADBEEF; 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" ); /* 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%X => 0x%X", 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; } /* ! * \brief Tests SDL_GetXYZ() functions * \sa * http://wiki.libsdl.org/moin.cgi/SDL_GetPlatform * http://wiki.libsdl.org/moin.cgi/SDL_GetCPUCount * http://wiki.libsdl.org/moin.cgi/SDL_GetCPUCacheLineSize * http://wiki.libsdl.org/moin.cgi/SDL_GetRevision * http://wiki.libsdl.org/moin.cgi/SDL_GetRevisionNumber */ int platform_testGetFunctions (void *arg) { char *platform; char *revision; int ret; int len; platform = (char *)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, len); } ret = SDL_GetCPUCount(); SDLTest_AssertPass("SDL_GetCPUCount()"); SDLTest_AssertCheck(ret > 0, "SDL_GetCPUCount(): 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 = (char *)SDL_GetRevision(); SDLTest_AssertPass("SDL_GetRevision()"); SDLTest_AssertCheck(revision != NULL, "SDL_GetRevision() != NULL"); ret = SDL_GetRevisionNumber(); SDLTest_AssertPass("SDL_GetRevisionNumber()"); return TEST_COMPLETED; } /* ! * \brief Tests SDL_HasXYZ() functions * \sa * http://wiki.libsdl.org/moin.cgi/SDL_Has3DNow * http://wiki.libsdl.org/moin.cgi/SDL_HasAltiVec * http://wiki.libsdl.org/moin.cgi/SDL_HasMMX * http://wiki.libsdl.org/moin.cgi/SDL_HasRDTSC * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE2 * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE3 * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE41 * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE42 * http://wiki.libsdl.org/moin.cgi/SDL_HasAVX */ int platform_testHasFunctions (void *arg) { int ret; /* TODO: independently determine and compare values as well */ ret = SDL_HasRDTSC(); SDLTest_AssertPass("SDL_HasRDTSC()"); ret = SDL_HasAltiVec(); SDLTest_AssertPass("SDL_HasAltiVec()"); ret = SDL_HasMMX(); SDLTest_AssertPass("SDL_HasMMX()"); ret = SDL_Has3DNow(); SDLTest_AssertPass("SDL_Has3DNow()"); ret = SDL_HasSSE(); SDLTest_AssertPass("SDL_HasSSE()"); ret = SDL_HasSSE2(); SDLTest_AssertPass("SDL_HasSSE2()"); ret = SDL_HasSSE3(); SDLTest_AssertPass("SDL_HasSSE3()"); ret = SDL_HasSSE41(); SDLTest_AssertPass("SDL_HasSSE41()"); ret = SDL_HasSSE42(); SDLTest_AssertPass("SDL_HasSSE42()"); ret = SDL_HasAVX(); SDLTest_AssertPass("SDL_HasAVX()"); return TEST_COMPLETED; } /* ! * \brief Tests SDL_GetVersion * \sa * http://wiki.libsdl.org/moin.cgi/SDL_GetVersion */ int platform_testGetVersion(void *arg) { SDL_version linked; int major = SDL_MAJOR_VERSION; int minor = SDL_MINOR_VERSION; SDL_GetVersion(&linked); SDLTest_AssertCheck( linked.major >= major, "SDL_GetVersion(): returned major %i (>= %i)", linked.major, major); SDLTest_AssertCheck( linked.minor >= minor, "SDL_GetVersion(): returned minor %i (>= %i)", linked.minor, minor); return TEST_COMPLETED; } /* ! * \brief Tests SDL_VERSION macro */ int platform_testSDLVersion(void *arg) { SDL_version compiled; int major = SDL_MAJOR_VERSION; int minor = SDL_MINOR_VERSION; SDL_VERSION(&compiled); SDLTest_AssertCheck( compiled.major >= major, "SDL_VERSION() returned major %i (>= %i)", compiled.major, major); SDLTest_AssertCheck( compiled.minor >= minor, "SDL_VERSION() returned minor %i (>= %i)", compiled.minor, minor); return TEST_COMPLETED; } /* ! * \brief Tests default SDL_Init */ int platform_testDefaultInit(void *arg) { int ret; int subsystem; subsystem = SDL_WasInit(SDL_INIT_EVERYTHING); SDLTest_AssertCheck( subsystem != 0, "SDL_WasInit(0): returned %i, expected != 0", subsystem); ret = SDL_Init(SDL_WasInit(SDL_INIT_EVERYTHING)); SDLTest_AssertCheck( ret == 0, "SDL_Init(0): returned %i, expected 0, error: %s", ret, SDL_GetError()); return TEST_COMPLETED; } /* ! * \brief Tests SDL_Get/Set/ClearError * \sa * http://wiki.libsdl.org/moin.cgi/SDL_GetError * http://wiki.libsdl.org/moin.cgi/SDL_SetError * http://wiki.libsdl.org/moin.cgi/SDL_ClearError */ int platform_testGetSetClearError(void *arg) { int result; const char *testError = "Testing"; char *lastError; int len; SDL_ClearError(); SDLTest_AssertPass("SDL_ClearError()"); lastError = (char *)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", len); } result = SDL_SetError("%s", testError); SDLTest_AssertPass("SDL_SetError()"); SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result); lastError = (char *)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", SDL_strlen(testError), 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; } /* ! * \brief Tests SDL_SetError with empty input * \sa * http://wiki.libsdl.org/moin.cgi/SDL_SetError */ int platform_testSetErrorEmptyInput(void *arg) { int result; const char *testError = ""; char *lastError; int len; result = SDL_SetError("%s", testError); SDLTest_AssertPass("SDL_SetError()"); SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result); lastError = (char *)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", SDL_strlen(testError), 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; } /* ! * \brief Tests SDL_SetError with invalid input * \sa * http://wiki.libsdl.org/moin.cgi/SDL_SetError */ int platform_testSetErrorInvalidInput(void *arg) { int result; const char *invalidError = NULL; const char *probeError = "Testing"; char *lastError; int len; /* Reset */ SDL_ClearError(); SDLTest_AssertPass("SDL_ClearError()"); /* Check for no-op */ result = SDL_SetError(invalidError); SDLTest_AssertPass("SDL_SetError()"); SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result); lastError = (char *)SDL_GetError(); SDLTest_AssertCheck(lastError != NULL, "SDL_GetError() != NULL"); if (lastError != NULL) { len = SDL_strlen(lastError); SDLTest_AssertCheck(len == 0, "SDL_GetError(): expected message len 0, was len: %i", len); } /* Set */ result = SDL_SetError(probeError); SDLTest_AssertPass("SDL_SetError('%s')", probeError); SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result); /* Check for no-op */ result = SDL_SetError(invalidError); SDLTest_AssertPass("SDL_SetError(NULL)"); SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result); lastError = (char *)SDL_GetError(); SDLTest_AssertCheck(lastError != NULL, "SDL_GetError() != NULL"); if (lastError != NULL) { len = SDL_strlen(lastError); SDLTest_AssertCheck(len == 0, "SDL_GetError(): expected message len 0, was len: %i", len); } /* Reset */ SDL_ClearError(); SDLTest_AssertPass("SDL_ClearError()"); /* Set and check */ result = SDL_SetError(probeError); SDLTest_AssertPass("SDL_SetError()"); SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result); lastError = (char *)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", SDL_strlen(probeError), 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; } /* ! * \brief Tests SDL_GetPowerInfo * \sa * http://wiki.libsdl.org/moin.cgi/SDL_GetPowerInfo */ int 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 = { (SDLTest_TestCaseFp)platform_testTypes, "platform_testTypes", "Tests predefined types", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest2 = { (SDLTest_TestCaseFp)platform_testEndianessAndSwap, "platform_testEndianessAndSwap", "Tests endianess and swap functions", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest3 = { (SDLTest_TestCaseFp)platform_testGetFunctions, "platform_testGetFunctions", "Tests various SDL_GetXYZ functions", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest4 = { (SDLTest_TestCaseFp)platform_testHasFunctions, "platform_testHasFunctions", "Tests various SDL_HasXYZ functions", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest5 = { (SDLTest_TestCaseFp)platform_testGetVersion, "platform_testGetVersion", "Tests SDL_GetVersion function", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest6 = { (SDLTest_TestCaseFp)platform_testSDLVersion, "platform_testSDLVersion", "Tests SDL_VERSION macro", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest7 = { (SDLTest_TestCaseFp)platform_testDefaultInit, "platform_testDefaultInit", "Tests default SDL_Init", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest8 = { (SDLTest_TestCaseFp)platform_testGetSetClearError, "platform_testGetSetClearError", "Tests SDL_Get/Set/ClearError", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest9 = { (SDLTest_TestCaseFp)platform_testSetErrorEmptyInput, "platform_testSetErrorEmptyInput", "Tests SDL_SetError with empty input", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest10 = { (SDLTest_TestCaseFp)platform_testSetErrorInvalidInput, "platform_testSetErrorInvalidInput", "Tests SDL_SetError with invalid input", TEST_ENABLED}; static const SDLTest_TestCaseReference platformTest11 = { (SDLTest_TestCaseFp)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, &platformTest11, NULL }; /* Platform test suite (global) */ SDLTest_TestSuiteReference platformTestSuite = { "Platform", NULL, platformTests, NULL };