test/testautomation_platform.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:09 -0800
changeset 11730 ac6c607e065c
parent 11416 7e7d8a125d6a
permissions -rw-r--r--
Enable building the Metal renderer by default, and weak link the Metal framework so the SDL library is safe to use on older Macs
Also generate iOS versions of the Metal shaders
     1 /**
     2  * Original code: automated SDL platform test written by Edgar Simo "bobbens"
     3  * Extended and updated by aschiffler at ferzkopp dot net
     4  */
     5 
     6 #include <stdio.h>
     7 
     8 #include "SDL.h"
     9 #include "SDL_test.h"
    10 
    11 /* ================= Test Case Implementation ================== */
    12 
    13 /* Helper functions */
    14 
    15 /**
    16  * @brief Compare sizes of types.
    17  *
    18  * @note Watcom C flags these as Warning 201: "Unreachable code" if you just
    19  *  compare them directly, so we push it through a function to keep the
    20  *  compiler quiet.  --ryan.
    21  */
    22 static int _compareSizeOfType( size_t sizeoftype, size_t hardcodetype )
    23 {
    24     return sizeoftype != hardcodetype;
    25 }
    26 
    27 /* Test case functions */
    28 
    29 /**
    30  * @brief Tests type sizes.
    31  */
    32 int platform_testTypes(void *arg)
    33 {
    34    int ret;
    35 
    36    ret = _compareSizeOfType( sizeof(Uint8), 1 );
    37    SDLTest_AssertCheck( ret == 0, "sizeof(Uint8) = %lu, expected  1", (unsigned long)sizeof(Uint8) );
    38 
    39    ret = _compareSizeOfType( sizeof(Uint16), 2 );
    40    SDLTest_AssertCheck( ret == 0, "sizeof(Uint16) = %lu, expected 2", (unsigned long)sizeof(Uint16) );
    41 
    42    ret = _compareSizeOfType( sizeof(Uint32), 4 );
    43    SDLTest_AssertCheck( ret == 0, "sizeof(Uint32) = %lu, expected 4", (unsigned long)sizeof(Uint32) );
    44 
    45    ret = _compareSizeOfType( sizeof(Uint64), 8 );
    46    SDLTest_AssertCheck( ret == 0, "sizeof(Uint64) = %lu, expected 8", (unsigned long)sizeof(Uint64) );
    47 
    48    return TEST_COMPLETED;
    49 }
    50 
    51 /**
    52  * @brief Tests platform endianness and SDL_SwapXY functions.
    53  */
    54 int platform_testEndianessAndSwap(void *arg)
    55 {
    56     int real_byteorder;
    57     Uint16 value = 0x1234;
    58     Uint16 value16 = 0xCDAB;
    59     Uint16 swapped16 = 0xABCD;
    60     Uint32 value32 = 0xEFBEADDE;
    61     Uint32 swapped32 = 0xDEADBEEF;
    62 
    63     Uint64 value64, swapped64;
    64     value64 = 0xEFBEADDE;
    65     value64 <<= 32;
    66     value64 |= 0xCDAB3412;
    67     swapped64 = 0x1234ABCD;
    68     swapped64 <<= 32;
    69     swapped64 |= 0xDEADBEEF;
    70 
    71     if ((*((char *) &value) >> 4) == 0x1) {
    72         real_byteorder = SDL_BIG_ENDIAN;
    73     } else {
    74         real_byteorder = SDL_LIL_ENDIAN;
    75     }
    76 
    77     /* Test endianness. */
    78     SDLTest_AssertCheck( real_byteorder == SDL_BYTEORDER,
    79              "Machine detected as %s endian, appears to be %s endian.",
    80              (SDL_BYTEORDER == SDL_LIL_ENDIAN) ? "little" : "big",
    81              (real_byteorder == SDL_LIL_ENDIAN) ? "little" : "big" );
    82 
    83     /* Test 16 swap. */
    84     SDLTest_AssertCheck( SDL_Swap16(value16) == swapped16,
    85              "SDL_Swap16(): 16 bit swapped: 0x%X => 0x%X",
    86              value16, SDL_Swap16(value16) );
    87 
    88     /* Test 32 swap. */
    89     SDLTest_AssertCheck( SDL_Swap32(value32) == swapped32,
    90              "SDL_Swap32(): 32 bit swapped: 0x%X => 0x%X",
    91              value32, SDL_Swap32(value32) );
    92 
    93     /* Test 64 swap. */
    94     SDLTest_AssertCheck( SDL_Swap64(value64) == swapped64,
    95              "SDL_Swap64(): 64 bit swapped: 0x%"SDL_PRIX64" => 0x%"SDL_PRIX64,
    96              value64, SDL_Swap64(value64) );
    97 
    98    return TEST_COMPLETED;
    99 }
   100 
   101 /* !
   102  * \brief Tests SDL_GetXYZ() functions
   103  * \sa
   104  * http://wiki.libsdl.org/moin.cgi/SDL_GetPlatform
   105  * http://wiki.libsdl.org/moin.cgi/SDL_GetCPUCount
   106  * http://wiki.libsdl.org/moin.cgi/SDL_GetCPUCacheLineSize
   107  * http://wiki.libsdl.org/moin.cgi/SDL_GetRevision
   108  * http://wiki.libsdl.org/moin.cgi/SDL_GetRevisionNumber
   109  */
   110 int platform_testGetFunctions (void *arg)
   111 {
   112    char *platform;
   113    char *revision;
   114    int ret;
   115    size_t len;
   116 
   117    platform = (char *)SDL_GetPlatform();
   118    SDLTest_AssertPass("SDL_GetPlatform()");
   119    SDLTest_AssertCheck(platform != NULL, "SDL_GetPlatform() != NULL");
   120    if (platform != NULL) {
   121      len = SDL_strlen(platform);
   122      SDLTest_AssertCheck(len > 0,
   123              "SDL_GetPlatform(): expected non-empty platform, was platform: '%s', len: %i",
   124              platform,
   125              (int) len);
   126    }
   127 
   128    ret = SDL_GetCPUCount();
   129    SDLTest_AssertPass("SDL_GetCPUCount()");
   130    SDLTest_AssertCheck(ret > 0,
   131              "SDL_GetCPUCount(): expected count > 0, was: %i",
   132              ret);
   133 
   134    ret = SDL_GetCPUCacheLineSize();
   135    SDLTest_AssertPass("SDL_GetCPUCacheLineSize()");
   136    SDLTest_AssertCheck(ret >= 0,
   137              "SDL_GetCPUCacheLineSize(): expected size >= 0, was: %i",
   138              ret);
   139 
   140    revision = (char *)SDL_GetRevision();
   141    SDLTest_AssertPass("SDL_GetRevision()");
   142    SDLTest_AssertCheck(revision != NULL, "SDL_GetRevision() != NULL");
   143 
   144    ret = SDL_GetRevisionNumber();
   145    SDLTest_AssertPass("SDL_GetRevisionNumber()");
   146 
   147    return TEST_COMPLETED;
   148 }
   149 
   150 /* !
   151  * \brief Tests SDL_HasXYZ() functions
   152  * \sa
   153  * http://wiki.libsdl.org/moin.cgi/SDL_Has3DNow
   154  * http://wiki.libsdl.org/moin.cgi/SDL_HasAltiVec
   155  * http://wiki.libsdl.org/moin.cgi/SDL_HasMMX
   156  * http://wiki.libsdl.org/moin.cgi/SDL_HasRDTSC
   157  * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE
   158  * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE2
   159  * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE3
   160  * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE41
   161  * http://wiki.libsdl.org/moin.cgi/SDL_HasSSE42
   162  * http://wiki.libsdl.org/moin.cgi/SDL_HasAVX
   163  */
   164 int platform_testHasFunctions (void *arg)
   165 {
   166    int ret;
   167 
   168    /* TODO: independently determine and compare values as well */
   169 
   170    ret = SDL_HasRDTSC();
   171    SDLTest_AssertPass("SDL_HasRDTSC()");
   172 
   173    ret = SDL_HasAltiVec();
   174    SDLTest_AssertPass("SDL_HasAltiVec()");
   175 
   176    ret = SDL_HasMMX();
   177    SDLTest_AssertPass("SDL_HasMMX()");
   178 
   179    ret = SDL_Has3DNow();
   180    SDLTest_AssertPass("SDL_Has3DNow()");
   181 
   182    ret = SDL_HasSSE();
   183    SDLTest_AssertPass("SDL_HasSSE()");
   184 
   185    ret = SDL_HasSSE2();
   186    SDLTest_AssertPass("SDL_HasSSE2()");
   187 
   188    ret = SDL_HasSSE3();
   189    SDLTest_AssertPass("SDL_HasSSE3()");
   190 
   191    ret = SDL_HasSSE41();
   192    SDLTest_AssertPass("SDL_HasSSE41()");
   193 
   194    ret = SDL_HasSSE42();
   195    SDLTest_AssertPass("SDL_HasSSE42()");
   196 
   197    ret = SDL_HasAVX();
   198    SDLTest_AssertPass("SDL_HasAVX()");
   199 
   200    return TEST_COMPLETED;
   201 }
   202 
   203 /* !
   204  * \brief Tests SDL_GetVersion
   205  * \sa
   206  * http://wiki.libsdl.org/moin.cgi/SDL_GetVersion
   207  */
   208 int platform_testGetVersion(void *arg)
   209 {
   210    SDL_version linked;
   211    int major = SDL_MAJOR_VERSION;
   212    int minor = SDL_MINOR_VERSION;
   213 
   214    SDL_GetVersion(&linked);
   215    SDLTest_AssertCheck( linked.major >= major,
   216              "SDL_GetVersion(): returned major %i (>= %i)",
   217              linked.major,
   218              major);
   219    SDLTest_AssertCheck( linked.minor >= minor,
   220              "SDL_GetVersion(): returned minor %i (>= %i)",
   221              linked.minor,
   222              minor);
   223 
   224    return TEST_COMPLETED;
   225 }
   226 
   227 
   228 /* !
   229  * \brief Tests SDL_VERSION macro
   230  */
   231 int platform_testSDLVersion(void *arg)
   232 {
   233    SDL_version compiled;
   234    int major = SDL_MAJOR_VERSION;
   235    int minor = SDL_MINOR_VERSION;
   236 
   237    SDL_VERSION(&compiled);
   238    SDLTest_AssertCheck( compiled.major >= major,
   239              "SDL_VERSION() returned major %i (>= %i)",
   240              compiled.major,
   241              major);
   242    SDLTest_AssertCheck( compiled.minor >= minor,
   243              "SDL_VERSION() returned minor %i (>= %i)",
   244              compiled.minor,
   245              minor);
   246 
   247    return TEST_COMPLETED;
   248 }
   249 
   250 
   251 /* !
   252  * \brief Tests default SDL_Init
   253  */
   254 int platform_testDefaultInit(void *arg)
   255 {
   256    int ret;
   257    int subsystem;
   258 
   259    subsystem = SDL_WasInit(SDL_INIT_EVERYTHING);
   260    SDLTest_AssertCheck( subsystem != 0,
   261              "SDL_WasInit(0): returned %i, expected != 0",
   262              subsystem);
   263 
   264    ret = SDL_Init(SDL_WasInit(SDL_INIT_EVERYTHING));
   265    SDLTest_AssertCheck( ret == 0,
   266              "SDL_Init(0): returned %i, expected 0, error: %s",
   267              ret,
   268              SDL_GetError());
   269 
   270    return TEST_COMPLETED;
   271 }
   272 
   273 /* !
   274  * \brief Tests SDL_Get/Set/ClearError
   275  * \sa
   276  * http://wiki.libsdl.org/moin.cgi/SDL_GetError
   277  * http://wiki.libsdl.org/moin.cgi/SDL_SetError
   278  * http://wiki.libsdl.org/moin.cgi/SDL_ClearError
   279  */
   280 int platform_testGetSetClearError(void *arg)
   281 {
   282    int result;
   283    const char *testError = "Testing";
   284    char *lastError;
   285    size_t len;
   286 
   287    SDL_ClearError();
   288    SDLTest_AssertPass("SDL_ClearError()");
   289 
   290    lastError = (char *)SDL_GetError();
   291    SDLTest_AssertPass("SDL_GetError()");
   292    SDLTest_AssertCheck(lastError != NULL,
   293              "SDL_GetError() != NULL");
   294    if (lastError != NULL)
   295    {
   296      len = SDL_strlen(lastError);
   297      SDLTest_AssertCheck(len == 0,
   298              "SDL_GetError(): no message expected, len: %i", (int) len);
   299    }
   300 
   301    result = SDL_SetError("%s", testError);
   302    SDLTest_AssertPass("SDL_SetError()");
   303    SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result);
   304    lastError = (char *)SDL_GetError();
   305    SDLTest_AssertCheck(lastError != NULL,
   306              "SDL_GetError() != NULL");
   307    if (lastError != NULL)
   308    {
   309      len = SDL_strlen(lastError);
   310      SDLTest_AssertCheck(len == SDL_strlen(testError),
   311              "SDL_GetError(): expected message len %i, was len: %i",
   312              (int) SDL_strlen(testError),
   313              (int) len);
   314      SDLTest_AssertCheck(SDL_strcmp(lastError, testError) == 0,
   315              "SDL_GetError(): expected message %s, was message: %s",
   316              testError,
   317              lastError);
   318    }
   319 
   320    /* Clean up */
   321    SDL_ClearError();
   322    SDLTest_AssertPass("SDL_ClearError()");
   323 
   324    return TEST_COMPLETED;
   325 }
   326 
   327 /* !
   328  * \brief Tests SDL_SetError with empty input
   329  * \sa
   330  * http://wiki.libsdl.org/moin.cgi/SDL_SetError
   331  */
   332 int platform_testSetErrorEmptyInput(void *arg)
   333 {
   334    int result;
   335    const char *testError = "";
   336    char *lastError;
   337    size_t len;
   338 
   339    result = SDL_SetError("%s", testError);
   340    SDLTest_AssertPass("SDL_SetError()");
   341    SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result);
   342    lastError = (char *)SDL_GetError();
   343    SDLTest_AssertCheck(lastError != NULL,
   344              "SDL_GetError() != NULL");
   345    if (lastError != NULL)
   346    {
   347      len = SDL_strlen(lastError);
   348      SDLTest_AssertCheck(len == SDL_strlen(testError),
   349              "SDL_GetError(): expected message len %i, was len: %i",
   350              (int) SDL_strlen(testError),
   351              (int) len);
   352      SDLTest_AssertCheck(SDL_strcmp(lastError, testError) == 0,
   353              "SDL_GetError(): expected message '%s', was message: '%s'",
   354              testError,
   355              lastError);
   356    }
   357 
   358    /* Clean up */
   359    SDL_ClearError();
   360    SDLTest_AssertPass("SDL_ClearError()");
   361 
   362    return TEST_COMPLETED;
   363 }
   364 
   365 /* !
   366  * \brief Tests SDL_SetError with invalid input
   367  * \sa
   368  * http://wiki.libsdl.org/moin.cgi/SDL_SetError
   369  */
   370 int platform_testSetErrorInvalidInput(void *arg)
   371 {
   372    int result;
   373    const char *invalidError = NULL;
   374    const char *probeError = "Testing";
   375    char *lastError;
   376    size_t len;
   377 
   378    /* Reset */
   379    SDL_ClearError();
   380    SDLTest_AssertPass("SDL_ClearError()");
   381 
   382    /* Check for no-op */
   383    result = SDL_SetError("%s", invalidError);
   384    SDLTest_AssertPass("SDL_SetError()");
   385    SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result);
   386    lastError = (char *)SDL_GetError();
   387    SDLTest_AssertCheck(lastError != NULL,
   388              "SDL_GetError() != NULL");
   389    if (lastError != NULL)
   390    {
   391      len = SDL_strlen(lastError);
   392      SDLTest_AssertCheck(len == 0,
   393              "SDL_GetError(): expected message len 0, was len: %i",
   394              (int) len);
   395    }
   396 
   397    /* Set */
   398    result = SDL_SetError("%s", probeError);
   399    SDLTest_AssertPass("SDL_SetError('%s')", probeError);
   400    SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result);
   401 
   402    /* Check for no-op */
   403    result = SDL_SetError("%s", invalidError);
   404    SDLTest_AssertPass("SDL_SetError(NULL)");
   405    SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result);
   406    lastError = (char *)SDL_GetError();
   407    SDLTest_AssertCheck(lastError != NULL,
   408              "SDL_GetError() != NULL");
   409    if (lastError != NULL)
   410    {
   411      len = SDL_strlen(lastError);
   412      SDLTest_AssertCheck(len == 0,
   413              "SDL_GetError(): expected message len 0, was len: %i",
   414              (int) len);
   415    }
   416 
   417    /* Reset */
   418    SDL_ClearError();
   419    SDLTest_AssertPass("SDL_ClearError()");
   420 
   421    /* Set and check */
   422    result = SDL_SetError("%s", probeError);
   423    SDLTest_AssertPass("SDL_SetError()");
   424    SDLTest_AssertCheck(result == -1, "SDL_SetError: expected -1, got: %i", result);
   425    lastError = (char *)SDL_GetError();
   426    SDLTest_AssertCheck(lastError != NULL,
   427              "SDL_GetError() != NULL");
   428    if (lastError != NULL)
   429    {
   430      len = SDL_strlen(lastError);
   431      SDLTest_AssertCheck(len == SDL_strlen(probeError),
   432              "SDL_GetError(): expected message len %i, was len: %i",
   433              (int) SDL_strlen(probeError),
   434              (int) len);
   435      SDLTest_AssertCheck(SDL_strcmp(lastError, probeError) == 0,
   436              "SDL_GetError(): expected message '%s', was message: '%s'",
   437              probeError,
   438              lastError);
   439    }
   440    
   441    /* Clean up */
   442    SDL_ClearError();
   443    SDLTest_AssertPass("SDL_ClearError()");
   444 
   445    return TEST_COMPLETED;
   446 }
   447 
   448 /* !
   449  * \brief Tests SDL_GetPowerInfo
   450  * \sa
   451  * http://wiki.libsdl.org/moin.cgi/SDL_GetPowerInfo
   452  */
   453 int platform_testGetPowerInfo(void *arg)
   454 {
   455    SDL_PowerState state;
   456    SDL_PowerState stateAgain;
   457    int secs;
   458    int secsAgain;
   459    int pct;
   460    int pctAgain;
   461 
   462    state = SDL_GetPowerInfo(&secs, &pct);
   463    SDLTest_AssertPass("SDL_GetPowerInfo()");
   464    SDLTest_AssertCheck(
   465        state==SDL_POWERSTATE_UNKNOWN ||
   466        state==SDL_POWERSTATE_ON_BATTERY ||
   467        state==SDL_POWERSTATE_NO_BATTERY ||
   468        state==SDL_POWERSTATE_CHARGING ||
   469        state==SDL_POWERSTATE_CHARGED,
   470        "SDL_GetPowerInfo(): state %i is one of the expected values",
   471        (int)state);
   472 
   473    if (state==SDL_POWERSTATE_ON_BATTERY)
   474    {
   475       SDLTest_AssertCheck(
   476          secs >= 0,
   477          "SDL_GetPowerInfo(): on battery, secs >= 0, was: %i",
   478          secs);
   479       SDLTest_AssertCheck(
   480          (pct >= 0) && (pct <= 100),
   481          "SDL_GetPowerInfo(): on battery, pct=[0,100], was: %i",
   482          pct);
   483    }
   484 
   485    if (state==SDL_POWERSTATE_UNKNOWN ||
   486        state==SDL_POWERSTATE_NO_BATTERY)
   487    {
   488       SDLTest_AssertCheck(
   489          secs == -1,
   490          "SDL_GetPowerInfo(): no battery, secs == -1, was: %i",
   491          secs);
   492       SDLTest_AssertCheck(
   493          pct == -1,
   494          "SDL_GetPowerInfo(): no battery, pct == -1, was: %i",
   495          pct);
   496    }
   497 
   498    /* Partial return value variations */
   499    stateAgain = SDL_GetPowerInfo(&secsAgain, NULL);
   500    SDLTest_AssertCheck(
   501         state==stateAgain,
   502         "State %i returned when only 'secs' requested",
   503         stateAgain);
   504    SDLTest_AssertCheck(
   505         secs==secsAgain,
   506         "Value %i matches when only 'secs' requested",
   507         secsAgain);
   508    stateAgain = SDL_GetPowerInfo(NULL, &pctAgain);
   509    SDLTest_AssertCheck(
   510         state==stateAgain,
   511         "State %i returned when only 'pct' requested",
   512         stateAgain);
   513    SDLTest_AssertCheck(
   514         pct==pctAgain,
   515         "Value %i matches when only 'pct' requested",
   516         pctAgain);
   517    stateAgain = SDL_GetPowerInfo(NULL, NULL);
   518    SDLTest_AssertCheck(
   519         state==stateAgain,
   520         "State %i returned when no value requested",
   521         stateAgain);
   522 
   523    return TEST_COMPLETED;
   524 }
   525 
   526 /* ================= Test References ================== */
   527 
   528 /* Platform test cases */
   529 static const SDLTest_TestCaseReference platformTest1 =
   530         { (SDLTest_TestCaseFp)platform_testTypes, "platform_testTypes", "Tests predefined types", TEST_ENABLED};
   531 
   532 static const SDLTest_TestCaseReference platformTest2 =
   533         { (SDLTest_TestCaseFp)platform_testEndianessAndSwap, "platform_testEndianessAndSwap", "Tests endianess and swap functions", TEST_ENABLED};
   534 
   535 static const SDLTest_TestCaseReference platformTest3 =
   536         { (SDLTest_TestCaseFp)platform_testGetFunctions, "platform_testGetFunctions", "Tests various SDL_GetXYZ functions", TEST_ENABLED};
   537 
   538 static const SDLTest_TestCaseReference platformTest4 =
   539         { (SDLTest_TestCaseFp)platform_testHasFunctions, "platform_testHasFunctions", "Tests various SDL_HasXYZ functions", TEST_ENABLED};
   540 
   541 static const SDLTest_TestCaseReference platformTest5 =
   542         { (SDLTest_TestCaseFp)platform_testGetVersion, "platform_testGetVersion", "Tests SDL_GetVersion function", TEST_ENABLED};
   543 
   544 static const SDLTest_TestCaseReference platformTest6 =
   545         { (SDLTest_TestCaseFp)platform_testSDLVersion, "platform_testSDLVersion", "Tests SDL_VERSION macro", TEST_ENABLED};
   546 
   547 static const SDLTest_TestCaseReference platformTest7 =
   548         { (SDLTest_TestCaseFp)platform_testDefaultInit, "platform_testDefaultInit", "Tests default SDL_Init", TEST_ENABLED};
   549 
   550 static const SDLTest_TestCaseReference platformTest8 =
   551         { (SDLTest_TestCaseFp)platform_testGetSetClearError, "platform_testGetSetClearError", "Tests SDL_Get/Set/ClearError", TEST_ENABLED};
   552 
   553 static const SDLTest_TestCaseReference platformTest9 =
   554         { (SDLTest_TestCaseFp)platform_testSetErrorEmptyInput, "platform_testSetErrorEmptyInput", "Tests SDL_SetError with empty input", TEST_ENABLED};
   555 
   556 static const SDLTest_TestCaseReference platformTest10 =
   557         { (SDLTest_TestCaseFp)platform_testSetErrorInvalidInput, "platform_testSetErrorInvalidInput", "Tests SDL_SetError with invalid input", TEST_ENABLED};
   558 
   559 static const SDLTest_TestCaseReference platformTest11 =
   560         { (SDLTest_TestCaseFp)platform_testGetPowerInfo, "platform_testGetPowerInfo", "Tests SDL_GetPowerInfo function", TEST_ENABLED };
   561 
   562 /* Sequence of Platform test cases */
   563 static const SDLTest_TestCaseReference *platformTests[] =  {
   564     &platformTest1,
   565     &platformTest2,
   566     &platformTest3,
   567     &platformTest4,
   568     &platformTest5,
   569     &platformTest6,
   570     &platformTest7,
   571     &platformTest8,
   572     &platformTest9,
   573     &platformTest10,
   574     &platformTest11,
   575     NULL
   576 };
   577 
   578 /* Platform test suite (global) */
   579 SDLTest_TestSuiteReference platformTestSuite = {
   580     "Platform",
   581     NULL,
   582     platformTests,
   583     NULL
   584 };