/**

* Automated SDL platform test.

*

* Based off of testplatform.c.

*

* Written by Edgar Simo "bobbens"

*

* Released under Public Domain.

*/

#include "SDL.h"

#include "SDL_at.h"

#include "SDL_endian.h"

#include "SDL_cpuinfo.h"

/*

* Prototypes.

*/

static int plat_testSize( size_t sizeoftype, size_t hardcodetype );

static void plat_testTypes (void);

/**

* @brief Test size.

*

* @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 plat_testSize( size_t sizeoftype, size_t hardcodetype )

{

return sizeoftype != hardcodetype;

}

/**

* @brief Tests type size.

*/

static void plat_testTypes (void)

{

int ret;

SDL_ATbegin( "Type size" );

ret = plat_testSize( sizeof(Uint8), 1 );

if (SDL_ATvassert( ret == 0, "sizeof(Uint8) = %ul instead of 1", sizeof(Uint8) ))

return;

ret = plat_testSize( sizeof(Uint16), 2 );

if (SDL_ATvassert( ret == 0, "sizeof(Uint16) = %ul instead of 2", sizeof(Uint16) ))

return;

ret = plat_testSize( sizeof(Uint32), 4 );

if (SDL_ATvassert( ret == 0, "sizeof(Uint32) = %ul instead of 4", sizeof(Uint32) ))

return;

#ifdef SDL_HAS_64BIT_TYPE

ret = plat_testSize( sizeof(Uint64), 8 );

if (SDL_ATvassert( ret == 0, "sizeof(Uint64) = %ul instead of 8", sizeof(Uint64) ))

return;

#endif /* SDL_HAS_64BIT_TYPE */

SDL_ATend();

}

/**

* @brief Tests platform endianness.

*/

static void plat_testEndian (void)

{

Uint16 value = 0x1234;

int real_byteorder;

Uint16 value16 = 0xCDAB;

Uint16 swapped16 = 0xABCD;

Uint32 value32 = 0xEFBEADDE;

Uint32 swapped32 = 0xDEADBEEF;

#ifdef SDL_HAS_64BIT_TYPE

Uint64 value64, swapped64;

value64 = 0xEFBEADDE;

value64 <<= 32;

value64 |= 0xCDAB3412;

swapped64 = 0x1234ABCD;

swapped64 <<= 32;

swapped64 |= 0xDEADBEEF;

#endif

SDL_ATbegin( "Endianness" );

/* Test endianness. */

if ((*((char *) &value) >> 4) == 0x1) {

real_byteorder = SDL_BIG_ENDIAN;

} else {

real_byteorder = SDL_LIL_ENDIAN;

}

if (SDL_ATvassert( real_byteorder == SDL_BYTEORDER,

"Machine detected as %s endian but appears to be %s endian.",

(SDL_BYTEORDER == SDL_LIL_ENDIAN) ? "little" : "big",

(real_byteorder == SDL_LIL_ENDIAN) ? "little" : "big" ))

return;

/* Test 16 swap. */

if (SDL_ATvassert( SDL_Swap16(value16) == swapped16,

"16 bit swapped incorrectly: 0x%X => 0x%X",

value16, SDL_Swap16(value16) ))

return;

/* Test 32 swap. */

if (SDL_ATvassert( SDL_Swap32(value32) == swapped32,

"32 bit swapped incorrectly: 0x%X => 0x%X",

value32, SDL_Swap32(value32) ))

return;

#ifdef SDL_HAS_64BIT_TYPE

/* Test 64 swap. */

if (SDL_ATvassert( SDL_Swap64(value64) == swapped64,

#ifdef _MSC_VER

"64 bit swapped incorrectly: 0x%I64X => 0x%I64X",

#else

"64 bit swapped incorrectly: 0x%llX => 0x%llX",

#endif

value64, SDL_Swap64(value64) ))

return;

#endif

SDL_ATend();

}

/**

* @brief Gets the name of the platform.

*/

const char *platform_getPlatform (void)

{

return

#if __AIX__

"AIX"

#elif __HAIKU__

/* Haiku must appear here before BeOS, since it also defines __BEOS__ */

"Haiku"

#elif __BEOS__

"BeOS"

#elif __BSDI__

"BSDI"

#elif __DREAMCAST__

"Dreamcast"

#elif __FREEBSD__

"FreeBSD"

#elif __HPUX__

"HP-UX"

#elif __IRIX__

"Irix"

#elif __LINUX__

"Linux"

#elif __MINT__

"Atari MiNT"

#elif __MACOS__

"MacOS Classic"

#elif __MACOSX__

"Mac OS X"

#elif __NETBSD__

"NetBSD"

#elif __OPENBSD__

"OpenBSD"

#elif __OS2__

"OS/2"

#elif __OSF__

"OSF/1"

#elif __QNXNTO__

"QNX Neutrino"

#elif __RISCOS__

"RISC OS"

#elif __SOLARIS__

"Solaris"

#elif __WIN32__

#ifdef _WIN32_WCE

"Windows CE"

#else

"Windows"

#endif

#elif __IPHONEOS__

"iPhone OS"

#else

"an unknown operating system! (see SDL_platform.h)"

#endif

;

}

/**

* @brief Platform test entrypoint.

*/

#ifdef TEST_STANDALONE

int main( int argc, const char *argv[] )

{

(void) argc;

(void) argv;

#else /* TEST_STANDALONE */

int test_platform (void)

{

#endif /* TEST_STANDALONE */

SDL_ATinit( "Platform" );

/* Debug information. */

SDL_ATprintVerbose( 1, "%s System detected\n", platform_getPlatform() );

SDL_ATprintVerbose( 1, "System is %s endian\n",

#ifdef SDL_LIL_ENDIAN

"little"

#else

"big"

#endif

);

SDL_ATprintVerbose( 1, "Available extensions:\n" );

SDL_ATprintVerbose( 1, " RDTSC %s\n", SDL_HasRDTSC()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " MMX %s\n", SDL_HasMMX()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " MMX Ext %s\n", SDL_HasMMXExt()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " 3DNow %s\n", SDL_Has3DNow()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " 3DNow Ext %s\n",

SDL_Has3DNowExt()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " SSE %s\n", SDL_HasSSE()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " SSE2 %s\n", SDL_HasSSE2()? "detected" : "not detected" );

SDL_ATprintVerbose( 1, " AltiVec %s\n", SDL_HasAltiVec()? "detected" : "not detected" );

plat_testTypes();

plat_testEndian();

return SDL_ATfinish();

}