kc3-lang/SDL/test/testautomation_platform.c

• Show log

  Commit

• Hash : 0e45984f
  Author :
  Date : 2015-06-21T17:33:46
  

  Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().

Download

• test/testautomation_platform.c

• /**
   * 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
  };
  

Download