summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/test/testautomation_platform.c
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:28:05 +0100
committer Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:53:49 +0100
commitcf6dc7d370407914020f3e623719f09c8668c692 (patch)
tree46b3416d091b4c09b50fba7ffcbd310aed032cc8 /3rdparty/SDL2/test/testautomation_platform.c
parent64135e73f973d9b95beb0c60b65feb34fbfec64a (diff)
Placed SDL2 source since we need it on some platforms (nw)
Diffstat (limited to '3rdparty/SDL2/test/testautomation_platform.c')
-rw-r--r--3rdparty/SDL2/test/testautomation_platform.c584
1 files changed, 584 insertions, 0 deletions
diff --git a/3rdparty/SDL2/test/testautomation_platform.c b/3rdparty/SDL2/test/testautomation_platform.c
new file mode 100644
index 00000000000..5211a4a70cc
--- /dev/null
+++ b/3rdparty/SDL2/test/testautomation_platform.c
@@ -0,0 +1,584 @@
+/**
+ * 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
+};