test/testautomation_rwops.c
author Alex Baines <alex@abaines.me.uk>
Tue, 19 Aug 2014 23:31:50 +0100
changeset 9097 56d712662a82
parent 8761 bce4122e6e87
child 9219 c65108ddbeb0
permissions -rw-r--r--
Add a SDL_IM_INTERNAL_EDITING event to make IMs like iBus render editing text in its own UI instead of sending TEXTEDITING events.
This is useful for applications that handle TEXTINPUT events but not TEXTEDITING events.
     1 
     2 /**
     3  * Automated SDL_RWops test.
     4  *
     5  * Original code written by Edgar Simo "bobbens"
     6  * Ported by Markus Kauppila (markus.kauppila@gmail.com)
     7  * Updated and extended for SDL_test by aschiffler at ferzkopp dot net
     8  *
     9  * Released under Public Domain.
    10  */
    11 
    12 /* quiet windows compiler warnings */
    13 #define _CRT_SECURE_NO_WARNINGS
    14 
    15 #include <stdio.h>
    16 
    17 #include "SDL.h"
    18 #include "SDL_test.h"
    19 
    20 /* ================= Test Case Implementation ================== */
    21 
    22 const char* RWopsReadTestFilename = "rwops_read";
    23 const char* RWopsWriteTestFilename = "rwops_write";
    24 const char* RWopsAlphabetFilename = "rwops_alphabet";
    25 
    26 static const char RWopsHelloWorldTestString[] = "Hello World!";
    27 static const char RWopsHelloWorldCompString[] = "Hello World!";
    28 static const char RWopsAlphabetString[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    29 
    30 /* Fixture */
    31 
    32 void
    33 RWopsSetUp(void *arg)
    34 {
    35     int fileLen;
    36     FILE *handle;
    37     int writtenLen;
    38     int result;
    39 
    40     /* Clean up from previous runs (if any); ignore errors */
    41     remove(RWopsReadTestFilename);
    42     remove(RWopsWriteTestFilename);
    43     remove(RWopsAlphabetFilename);
    44 
    45     /* Create a test file */
    46     handle = fopen(RWopsReadTestFilename, "w");
    47     SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", RWopsReadTestFilename);
    48         if (handle == NULL) return;
    49 
    50     /* Write some known text into it */
    51     fileLen = SDL_strlen(RWopsHelloWorldTestString);
    52     writtenLen = (int)fwrite(RWopsHelloWorldTestString, 1, fileLen, handle);
    53     SDLTest_AssertCheck(fileLen == writtenLen, "Verify number of written bytes, expected %i, got %i", fileLen, writtenLen);
    54     result = fclose(handle);
    55     SDLTest_AssertCheck(result == 0, "Verify result from fclose, expected 0, got %i", result);
    56 
    57     /* Create a second test file */
    58     handle = fopen(RWopsAlphabetFilename, "w");
    59     SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", RWopsAlphabetFilename);
    60         if (handle == NULL) return;
    61 
    62     /* Write alphabet text into it */
    63     fileLen = SDL_strlen(RWopsAlphabetString);
    64     writtenLen = (int)fwrite(RWopsAlphabetString, 1, fileLen, handle);
    65     SDLTest_AssertCheck(fileLen == writtenLen, "Verify number of written bytes, expected %i, got %i", fileLen, writtenLen);
    66     result = fclose(handle);
    67     SDLTest_AssertCheck(result == 0, "Verify result from fclose, expected 0, got %i", result);
    68 
    69     SDLTest_AssertPass("Creation of test file completed");
    70 }
    71 
    72 void
    73 RWopsTearDown(void *arg)
    74 {
    75     int result;
    76 
    77     /* Remove the created files to clean up; ignore errors for write filename */
    78     result = remove(RWopsReadTestFilename);
    79     SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", RWopsReadTestFilename, result);
    80     remove(RWopsWriteTestFilename);
    81     result = remove(RWopsAlphabetFilename);
    82     SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", RWopsAlphabetFilename, result);
    83 
    84     SDLTest_AssertPass("Cleanup of test files completed");
    85 }
    86 
    87 /**
    88  * @brief Makes sure parameters work properly. Local helper function.
    89  *
    90  * \sa
    91  * http://wiki.libsdl.org/moin.cgi/SDL_RWseek
    92  * http://wiki.libsdl.org/moin.cgi/SDL_RWread
    93  */
    94 void
    95 _testGenericRWopsValidations(SDL_RWops *rw, int write)
    96 {
    97    char buf[sizeof(RWopsHelloWorldTestString)];
    98    Sint64 i;
    99    size_t s;
   100    int seekPos = SDLTest_RandomIntegerInRange(4, 8);
   101 
   102    /* Clear buffer */
   103    SDL_zero(buf);
   104 
   105    /* Set to start. */
   106    i = SDL_RWseek(rw, 0, RW_SEEK_SET );
   107    SDLTest_AssertPass("Call to SDL_RWseek succeeded");
   108    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %i", i);
   109 
   110    /* Test write. */
   111    s = SDL_RWwrite(rw, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString)-1, 1);
   112    SDLTest_AssertPass("Call to SDL_RWwrite succeeded");
   113    if (write) {
   114         SDLTest_AssertCheck(s == (size_t)1, "Verify result of writing one byte with SDL_RWwrite, expected 1, got %i", s);
   115    }
   116    else {
   117         SDLTest_AssertCheck(s == (size_t)0, "Verify result of writing with SDL_RWwrite, expected: 0, got %i", s);
   118    }
   119 
   120    /* Test seek to random position */
   121    i = SDL_RWseek( rw, seekPos, RW_SEEK_SET );
   122    SDLTest_AssertPass("Call to SDL_RWseek succeeded");
   123    SDLTest_AssertCheck(i == (Sint64)seekPos, "Verify seek to %i with SDL_RWseek (RW_SEEK_SET), expected %i, got %i", seekPos, seekPos, i);
   124 
   125    /* Test seek back to start */
   126    i = SDL_RWseek(rw, 0, RW_SEEK_SET );
   127    SDLTest_AssertPass("Call to SDL_RWseek succeeded");
   128    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %i", i);
   129 
   130    /* Test read */
   131    s = SDL_RWread( rw, buf, 1, sizeof(RWopsHelloWorldTestString)-1 );
   132    SDLTest_AssertPass("Call to SDL_RWread succeeded");
   133    SDLTest_AssertCheck(
   134        s == (size_t)(sizeof(RWopsHelloWorldTestString)-1),
   135        "Verify result from SDL_RWread, expected %i, got %i",
   136        sizeof(RWopsHelloWorldTestString)-1,
   137        s);
   138    SDLTest_AssertCheck(
   139        SDL_memcmp(buf, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString)-1 ) == 0,
   140        "Verify read bytes match expected string, expected '%s', got '%s'", RWopsHelloWorldTestString, buf);
   141 
   142    /* More seek tests. */
   143    i = SDL_RWseek( rw, -4, RW_SEEK_CUR );
   144    SDLTest_AssertPass("Call to SDL_RWseek(...,-4,RW_SEEK_CUR) succeeded");
   145    SDLTest_AssertCheck(
   146        i == (Sint64)(sizeof(RWopsHelloWorldTestString)-5),
   147        "Verify seek to -4 with SDL_RWseek (RW_SEEK_CUR), expected %i, got %i",
   148        sizeof(RWopsHelloWorldTestString)-5,
   149        i);
   150 
   151    i = SDL_RWseek( rw, -1, RW_SEEK_END );
   152    SDLTest_AssertPass("Call to SDL_RWseek(...,-1,RW_SEEK_END) succeeded");
   153    SDLTest_AssertCheck(
   154        i == (Sint64)(sizeof(RWopsHelloWorldTestString)-2),
   155        "Verify seek to -1 with SDL_RWseek (RW_SEEK_END), expected %i, got %i",
   156        sizeof(RWopsHelloWorldTestString)-2,
   157        i);
   158 
   159    /* Invalid whence seek */
   160    i = SDL_RWseek( rw, 0, 999 );
   161    SDLTest_AssertPass("Call to SDL_RWseek(...,0,invalid_whence) succeeded");
   162    SDLTest_AssertCheck(
   163        i == (Sint64)(-1),
   164        "Verify seek with SDL_RWseek (invalid_whence); expected: -1, got %i",
   165        i);
   166 }
   167 
   168 /* !
   169  * Negative test for SDL_RWFromFile parameters
   170  *
   171  * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
   172  *
   173  */
   174 int
   175 rwops_testParamNegative (void)
   176 {
   177    SDL_RWops *rwops;
   178 
   179    /* These should all fail. */
   180    rwops = SDL_RWFromFile(NULL, NULL);
   181    SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, NULL) succeeded");
   182    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, NULL) returns NULL");
   183 
   184    rwops = SDL_RWFromFile(NULL, "ab+");
   185    SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, \"ab+\") succeeded");
   186    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, \"ab+\") returns NULL");
   187 
   188    rwops = SDL_RWFromFile(NULL, "sldfkjsldkfj");
   189    SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, \"sldfkjsldkfj\") succeeded");
   190    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, \"sldfkjsldkfj\") returns NULL");
   191 
   192    rwops = SDL_RWFromFile("something", "");
   193    SDLTest_AssertPass("Call to SDL_RWFromFile(\"something\", \"\") succeeded");
   194    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(\"something\", \"\") returns NULL");
   195 
   196    rwops = SDL_RWFromFile("something", NULL);
   197    SDLTest_AssertPass("Call to SDL_RWFromFile(\"something\", NULL) succeeded");
   198    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(\"something\", NULL) returns NULL");
   199 
   200    rwops = SDL_RWFromMem((void *)NULL, 10);
   201    SDLTest_AssertPass("Call to SDL_RWFromMem(NULL, 10) succeeded");
   202    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromMem(NULL, 10) returns NULL");
   203 
   204    rwops = SDL_RWFromMem((void *)RWopsAlphabetString, 0);
   205    SDLTest_AssertPass("Call to SDL_RWFromMem(data, 0) succeeded");
   206    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromMem(data, 0) returns NULL");
   207 
   208    rwops = SDL_RWFromConstMem((const void *)RWopsAlphabetString, 0);
   209    SDLTest_AssertPass("Call to SDL_RWFromConstMem(data, 0) succeeded");
   210    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromConstMem(data, 0) returns NULL");
   211 
   212    return TEST_COMPLETED;
   213 }
   214 
   215 /**
   216  * @brief Tests opening from memory.
   217  *
   218  * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromMem
   219  * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   220  */
   221 int
   222 rwops_testMem (void)
   223 {
   224    char mem[sizeof(RWopsHelloWorldTestString)];
   225    SDL_RWops *rw;
   226    int result;
   227 
   228    /* Clear buffer */
   229    SDL_zero(mem);
   230 
   231    /* Open */
   232    rw = SDL_RWFromMem(mem, sizeof(RWopsHelloWorldTestString)-1);
   233    SDLTest_AssertPass("Call to SDL_RWFromMem() succeeded");
   234    SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_RWFromMem does not return NULL");
   235 
   236    /* Bail out if NULL */
   237    if (rw == NULL) return TEST_ABORTED;
   238 
   239    /* Check type */
   240    SDLTest_AssertCheck(rw->type == SDL_RWOPS_MEMORY, "Verify RWops type is SDL_RWOPS_MEMORY; expected: %d, got: %d", SDL_RWOPS_MEMORY, rw->type);
   241 
   242    /* Run generic tests */
   243    _testGenericRWopsValidations(rw, 1);
   244 
   245    /* Close */
   246    result = SDL_RWclose(rw);
   247    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   248    SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   249 
   250    return TEST_COMPLETED;
   251 }
   252 
   253 
   254 /**
   255  * @brief Tests opening from memory.
   256  *
   257  * \sa
   258  * http://wiki.libsdl.org/moin.cgi/SDL_RWFromConstMem
   259  * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   260  */
   261 int
   262 rwops_testConstMem (void)
   263 {
   264    SDL_RWops *rw;
   265    int result;
   266 
   267    /* Open handle */
   268    rw = SDL_RWFromConstMem( RWopsHelloWorldCompString, sizeof(RWopsHelloWorldCompString)-1 );
   269    SDLTest_AssertPass("Call to SDL_RWFromConstMem() succeeded");
   270    SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_RWFromConstMem does not return NULL");
   271 
   272    /* Bail out if NULL */
   273    if (rw == NULL) return TEST_ABORTED;
   274 
   275    /* Check type */
   276    SDLTest_AssertCheck(rw->type == SDL_RWOPS_MEMORY_RO, "Verify RWops type is SDL_RWOPS_MEMORY_RO; expected: %d, got: %d", SDL_RWOPS_MEMORY_RO, rw->type);
   277 
   278    /* Run generic tests */
   279    _testGenericRWopsValidations( rw, 0 );
   280 
   281    /* Close handle */
   282    result = SDL_RWclose(rw);
   283    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   284    SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   285 
   286   return TEST_COMPLETED;
   287 }
   288 
   289 
   290 /**
   291  * @brief Tests reading from file.
   292  *
   293  * \sa
   294  * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
   295  * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   296  */
   297 int
   298 rwops_testFileRead(void)
   299 {
   300    SDL_RWops *rw;
   301    int result;
   302 
   303    /* Read test. */
   304    rw = SDL_RWFromFile(RWopsReadTestFilename, "r");
   305    SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"r\") succeeded");
   306    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in read mode does not return NULL");
   307 
   308    /* Bail out if NULL */
   309    if (rw == NULL) return TEST_ABORTED;
   310 
   311    /* Check type */
   312 #if defined(__ANDROID__)
   313    SDLTest_AssertCheck(
   314       rw->type == SDL_RWOPS_STDFILE || rw->type == SDL_RWOPS_JNIFILE,
   315       "Verify RWops type is SDL_RWOPS_STDFILE or SDL_RWOPS_JNIFILE; expected: %d|%d, got: %d", SDL_RWOPS_STDFILE, SDL_RWOPS_JNIFILE, rw->type);
   316 #elif defined(__WIN32__)
   317    SDLTest_AssertCheck(
   318       rw->type == SDL_RWOPS_WINFILE,
   319       "Verify RWops type is SDL_RWOPS_WINFILE; expected: %d, got: %d", SDL_RWOPS_WINFILE, rw->type);
   320 #else
   321    SDLTest_AssertCheck(
   322       rw->type == SDL_RWOPS_STDFILE,
   323       "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %d", SDL_RWOPS_STDFILE, rw->type);
   324 #endif
   325 
   326    /* Run generic tests */
   327    _testGenericRWopsValidations( rw, 0 );
   328 
   329    /* Close handle */
   330    result = SDL_RWclose(rw);
   331    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   332    SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   333 
   334    return TEST_COMPLETED;
   335 }
   336 
   337 /**
   338  * @brief Tests writing from file.
   339  *
   340  * \sa
   341  * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
   342  * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   343  */
   344 int
   345 rwops_testFileWrite(void)
   346 {
   347    SDL_RWops *rw;
   348    int result;
   349 
   350    /* Write test. */
   351    rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+");
   352    SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\") succeeded");
   353    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL");
   354 
   355    /* Bail out if NULL */
   356    if (rw == NULL) return TEST_ABORTED;
   357 
   358    /* Check type */
   359 #if defined(__ANDROID__)
   360    SDLTest_AssertCheck(
   361       rw->type == SDL_RWOPS_STDFILE || rw->type == SDL_RWOPS_JNIFILE,
   362       "Verify RWops type is SDL_RWOPS_STDFILE or SDL_RWOPS_JNIFILE; expected: %d|%d, got: %d", SDL_RWOPS_STDFILE, SDL_RWOPS_JNIFILE, rw->type);
   363 #elif defined(__WIN32__)
   364    SDLTest_AssertCheck(
   365       rw->type == SDL_RWOPS_WINFILE,
   366       "Verify RWops type is SDL_RWOPS_WINFILE; expected: %d, got: %d", SDL_RWOPS_WINFILE, rw->type);
   367 #else
   368    SDLTest_AssertCheck(
   369       rw->type == SDL_RWOPS_STDFILE,
   370       "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %d", SDL_RWOPS_STDFILE, rw->type);
   371 #endif
   372 
   373    /* Run generic tests */
   374    _testGenericRWopsValidations( rw, 1 );
   375 
   376    /* Close handle */
   377    result = SDL_RWclose(rw);
   378    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   379    SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   380 
   381    return TEST_COMPLETED;
   382 }
   383 
   384 
   385 /**
   386  * @brief Tests reading from file handle
   387  *
   388  * \sa
   389  * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFP
   390  * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   391  *
   392  */
   393 int
   394 rwops_testFPRead(void)
   395 {
   396    FILE *fp;
   397    SDL_RWops *rw;
   398    int result;
   399 
   400    /* Run read tests. */
   401    fp = fopen(RWopsReadTestFilename, "r");
   402    SDLTest_AssertCheck(fp != NULL, "Verify handle from opening file '%s' in read mode is not NULL", RWopsReadTestFilename);
   403 
   404    /* Bail out if NULL */
   405    if (fp == NULL) return TEST_ABORTED;
   406 
   407    /* Open */
   408    rw = SDL_RWFromFP( fp, SDL_TRUE );
   409    SDLTest_AssertPass("Call to SDL_RWFromFP() succeeded");
   410    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFP in read mode does not return NULL");
   411 
   412    /* Bail out if NULL */
   413    if (rw == NULL) {
   414      fclose(fp);
   415      return TEST_ABORTED;
   416    }
   417 
   418    /* Check type */
   419    SDLTest_AssertCheck(
   420       rw->type == SDL_RWOPS_STDFILE,
   421       "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %d", SDL_RWOPS_STDFILE, rw->type);
   422 
   423    /* Run generic tests */
   424    _testGenericRWopsValidations( rw, 0 );
   425 
   426    /* Close handle - does fclose() */
   427    result = SDL_RWclose(rw);
   428    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   429    SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   430 
   431    return TEST_COMPLETED;
   432 }
   433 
   434 
   435 /**
   436  * @brief Tests writing to file handle
   437  *
   438  * \sa
   439  * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFP
   440  * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   441  *
   442  */
   443 int
   444 rwops_testFPWrite(void)
   445 {
   446    FILE *fp;
   447    SDL_RWops *rw;
   448    int result;
   449 
   450    /* Run write tests. */
   451    fp = fopen(RWopsWriteTestFilename, "w+");
   452    SDLTest_AssertCheck(fp != NULL, "Verify handle from opening file '%s' in write mode is not NULL", RWopsWriteTestFilename);
   453 
   454    /* Bail out if NULL */
   455    if (fp == NULL) return TEST_ABORTED;
   456 
   457    /* Open */
   458    rw = SDL_RWFromFP( fp, SDL_TRUE );
   459    SDLTest_AssertPass("Call to SDL_RWFromFP() succeeded");
   460    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFP in write mode does not return NULL");
   461 
   462    /* Bail out if NULL */
   463    if (rw == NULL) {
   464      fclose(fp);
   465      return TEST_ABORTED;
   466    }
   467 
   468    /* Check type */
   469    SDLTest_AssertCheck(
   470       rw->type == SDL_RWOPS_STDFILE,
   471       "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %d", SDL_RWOPS_STDFILE, rw->type);
   472 
   473    /* Run generic tests */
   474    _testGenericRWopsValidations( rw, 1 );
   475 
   476    /* Close handle - does fclose() */
   477    result = SDL_RWclose(rw);
   478    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   479    SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   480 
   481    return TEST_COMPLETED;
   482 }
   483 
   484 /**
   485  * @brief Tests alloc and free RW context.
   486  *
   487  * \sa http://wiki.libsdl.org/moin.cgi/SDL_AllocRW
   488  * \sa http://wiki.libsdl.org/moin.cgi/SDL_FreeRW
   489  */
   490 int
   491 rwops_testAllocFree (void)
   492 {
   493    /* Allocate context */
   494    SDL_RWops *rw = SDL_AllocRW();
   495    SDLTest_AssertPass("Call to SDL_AllocRW() succeeded");
   496    SDLTest_AssertCheck(rw != NULL, "Validate result from SDL_AllocRW() is not NULL");
   497    if (rw==NULL) return TEST_ABORTED;
   498 
   499    /* Check type */
   500    SDLTest_AssertCheck(
   501       rw->type == SDL_RWOPS_UNKNOWN,
   502       "Verify RWops type is SDL_RWOPS_UNKNOWN; expected: %d, got: %d", SDL_RWOPS_UNKNOWN, rw->type);
   503 
   504    /* Free context again */
   505    SDL_FreeRW(rw);
   506    SDLTest_AssertPass("Call to SDL_FreeRW() succeeded");
   507 
   508    return TEST_COMPLETED;
   509 }
   510 
   511 /**
   512  * @brief Compare memory and file reads
   513  *
   514  * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromMem
   515  * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
   516  */
   517 int
   518 rwops_testCompareRWFromMemWithRWFromFile(void)
   519 {
   520    int slen = 26;
   521    char buffer_file[27];
   522    char buffer_mem[27];
   523    size_t rv_file;
   524    size_t rv_mem;
   525    Uint64 sv_file;
   526    Uint64 sv_mem;
   527    SDL_RWops* rwops_file;
   528    SDL_RWops* rwops_mem;
   529    int size;
   530    int result;
   531 
   532 
   533    for (size=5; size<10; size++)
   534    {
   535      /* Terminate buffer */
   536      buffer_file[slen] = 0;
   537      buffer_mem[slen] = 0;
   538 
   539      /* Read/seek from memory */
   540      rwops_mem = SDL_RWFromMem((void *)RWopsAlphabetString, slen);
   541      SDLTest_AssertPass("Call to SDL_RWFromMem()");
   542      rv_mem = SDL_RWread(rwops_mem, buffer_mem, size, 6);
   543      SDLTest_AssertPass("Call to SDL_RWread(mem, size=%d)", size);
   544      sv_mem = SDL_RWseek(rwops_mem, 0, SEEK_END);
   545      SDLTest_AssertPass("Call to SDL_RWseek(mem,SEEK_END)");
   546      result = SDL_RWclose(rwops_mem);
   547      SDLTest_AssertPass("Call to SDL_RWclose(mem)");
   548      SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   549 
   550      /* Read/see from file */
   551      rwops_file = SDL_RWFromFile(RWopsAlphabetFilename, "r");
   552      SDLTest_AssertPass("Call to SDL_RWFromFile()");
   553      rv_file = SDL_RWread(rwops_file, buffer_file, size, 6);
   554      SDLTest_AssertPass("Call to SDL_RWread(file, size=%d)", size);
   555      sv_file = SDL_RWseek(rwops_file, 0, SEEK_END);
   556      SDLTest_AssertPass("Call to SDL_RWseek(file,SEEK_END)");
   557      result = SDL_RWclose(rwops_file);
   558      SDLTest_AssertPass("Call to SDL_RWclose(file)");
   559      SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
   560 
   561      /* Compare */
   562      SDLTest_AssertCheck(rv_mem == rv_file, "Verify returned read blocks matches for mem and file reads; got: rv_mem=%d rv_file=%d", rv_mem, rv_file);
   563      SDLTest_AssertCheck(sv_mem == sv_file, "Verify SEEK_END position matches for mem and file seeks; got: sv_mem=%llu sv_file=%llu", sv_mem, sv_file);
   564      SDLTest_AssertCheck(buffer_mem[slen] == 0, "Verify mem buffer termination; expected: 0, got: %d", buffer_mem[slen]);
   565      SDLTest_AssertCheck(buffer_file[slen] == 0, "Verify file buffer termination; expected: 0, got: %d", buffer_file[slen]);
   566      SDLTest_AssertCheck(
   567        SDL_strncmp(buffer_mem, RWopsAlphabetString, slen) == 0,
   568        "Verify mem buffer contain alphabet string; expected: %s, got: %s", RWopsAlphabetString, buffer_mem);
   569      SDLTest_AssertCheck(
   570        SDL_strncmp(buffer_file, RWopsAlphabetString, slen) == 0,
   571        "Verify file buffer contain alphabet string; expected: %s, got: %s", RWopsAlphabetString, buffer_file);
   572    }
   573 
   574    return TEST_COMPLETED;
   575 }
   576 
   577 /**
   578  * @brief Tests writing and reading from file using endian aware functions.
   579  *
   580  * \sa
   581  * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
   582  * http://wiki.libsdl.org/moin.cgi/SDL_RWClose
   583  * http://wiki.libsdl.org/moin.cgi/SDL_ReadBE16
   584  * http://wiki.libsdl.org/moin.cgi/SDL_WriteBE16
   585  */
   586 int
   587 rwops_testFileWriteReadEndian(void)
   588 {
   589    SDL_RWops *rw;
   590    Sint64 result;
   591    int mode;
   592    size_t objectsWritten;
   593    Uint16 BE16value;
   594    Uint32 BE32value;
   595    Uint64 BE64value;
   596    Uint16 LE16value;
   597    Uint32 LE32value;
   598    Uint64 LE64value;
   599    Uint16 BE16test;
   600    Uint32 BE32test;
   601    Uint64 BE64test;
   602    Uint16 LE16test;
   603    Uint32 LE32test;
   604    Uint64 LE64test;
   605    int cresult;
   606 
   607    for (mode = 0; mode < 3; mode++) {
   608 
   609      /* Create test data */
   610      switch (mode) {
   611        case 0:
   612         SDLTest_Log("All 0 values");
   613         BE16value = 0;
   614         BE32value = 0;
   615         BE64value = 0;
   616         LE16value = 0;
   617         LE32value = 0;
   618         LE64value = 0;
   619         break;
   620        case 1:
   621         SDLTest_Log("All 1 values");
   622         BE16value = 1;
   623         BE32value = 1;
   624         BE64value = 1;
   625         LE16value = 1;
   626         LE32value = 1;
   627         LE64value = 1;
   628         break;
   629        case 2:
   630         SDLTest_Log("Random values");
   631         BE16value = SDLTest_RandomUint16();
   632         BE32value = SDLTest_RandomUint32();
   633         BE64value = SDLTest_RandomUint64();
   634         LE16value = SDLTest_RandomUint16();
   635         LE32value = SDLTest_RandomUint32();
   636         LE64value = SDLTest_RandomUint64();
   637         break;
   638      }
   639 
   640      /* Write test. */
   641      rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+");
   642      SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\")");
   643      SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL");
   644 
   645      /* Bail out if NULL */
   646      if (rw == NULL) return TEST_ABORTED;
   647 
   648      /* Write test data */
   649      objectsWritten = SDL_WriteBE16(rw, BE16value);
   650      SDLTest_AssertPass("Call to SDL_WriteBE16");
   651      SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
   652      objectsWritten = SDL_WriteBE32(rw, BE32value);
   653      SDLTest_AssertPass("Call to SDL_WriteBE32");
   654      SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
   655      objectsWritten = SDL_WriteBE64(rw, BE64value);
   656      SDLTest_AssertPass("Call to SDL_WriteBE64");
   657      SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
   658      objectsWritten = SDL_WriteLE16(rw, LE16value);
   659      SDLTest_AssertPass("Call to SDL_WriteLE16");
   660      SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
   661      objectsWritten = SDL_WriteLE32(rw, LE32value);
   662      SDLTest_AssertPass("Call to SDL_WriteLE32");
   663      SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
   664      objectsWritten = SDL_WriteLE64(rw, LE64value);
   665      SDLTest_AssertPass("Call to SDL_WriteLE64");
   666      SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
   667 
   668      /* Test seek to start */
   669      result = SDL_RWseek( rw, 0, RW_SEEK_SET );
   670      SDLTest_AssertPass("Call to SDL_RWseek succeeded");
   671      SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_RWseek, expected 0, got %i", result);
   672 
   673      /* Read test data */
   674      BE16test = SDL_ReadBE16(rw);
   675      SDLTest_AssertPass("Call to SDL_ReadBE16");
   676      SDLTest_AssertCheck(BE16test == BE16value, "Validate return value from SDL_ReadBE16, expected: %hu, got: %hu", BE16value, BE16test);
   677      BE32test = SDL_ReadBE32(rw);
   678      SDLTest_AssertPass("Call to SDL_ReadBE32");
   679      SDLTest_AssertCheck(BE32test == BE32value, "Validate return value from SDL_ReadBE32, expected: %u, got: %u", BE32value, BE32test);
   680      BE64test = SDL_ReadBE64(rw);
   681      SDLTest_AssertPass("Call to SDL_ReadBE64");
   682      SDLTest_AssertCheck(BE64test == BE64value, "Validate return value from SDL_ReadBE64, expected: %llu, got: %llu", BE64value, BE64test);
   683      LE16test = SDL_ReadLE16(rw);
   684      SDLTest_AssertPass("Call to SDL_ReadLE16");
   685      SDLTest_AssertCheck(LE16test == LE16value, "Validate return value from SDL_ReadLE16, expected: %hu, got: %hu", LE16value, LE16test);
   686      LE32test = SDL_ReadLE32(rw);
   687      SDLTest_AssertPass("Call to SDL_ReadLE32");
   688      SDLTest_AssertCheck(LE32test == LE32value, "Validate return value from SDL_ReadLE32, expected: %u, got: %u", LE32value, LE32test);
   689      LE64test = SDL_ReadLE64(rw);
   690      SDLTest_AssertPass("Call to SDL_ReadLE64");
   691      SDLTest_AssertCheck(LE64test == LE64value, "Validate return value from SDL_ReadLE64, expected: %llu, got: %llu", LE64value, LE64test);
   692 
   693      /* Close handle */
   694      cresult = SDL_RWclose(rw);
   695      SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
   696      SDLTest_AssertCheck(cresult == 0, "Verify result value is 0; got: %d", cresult);
   697    }
   698 
   699    return TEST_COMPLETED;
   700 }
   701 
   702 
   703 /* ================= Test References ================== */
   704 
   705 /* RWops test cases */
   706 static const SDLTest_TestCaseReference rwopsTest1 =
   707         { (SDLTest_TestCaseFp)rwops_testParamNegative, "rwops_testParamNegative", "Negative test for SDL_RWFromFile parameters", TEST_ENABLED };
   708 
   709 static const SDLTest_TestCaseReference rwopsTest2 =
   710         { (SDLTest_TestCaseFp)rwops_testMem, "rwops_testMem", "Tests opening from memory", TEST_ENABLED };
   711 
   712 static const SDLTest_TestCaseReference rwopsTest3 =
   713         { (SDLTest_TestCaseFp)rwops_testConstMem, "rwops_testConstMem", "Tests opening from (const) memory", TEST_ENABLED };
   714 
   715 static const SDLTest_TestCaseReference rwopsTest4 =
   716         { (SDLTest_TestCaseFp)rwops_testFileRead, "rwops_testFileRead", "Tests reading from a file", TEST_ENABLED };
   717 
   718 static const SDLTest_TestCaseReference rwopsTest5 =
   719         { (SDLTest_TestCaseFp)rwops_testFileWrite, "rwops_testFileWrite", "Test writing to a file", TEST_ENABLED };
   720 
   721 static const SDLTest_TestCaseReference rwopsTest6 =
   722         { (SDLTest_TestCaseFp)rwops_testFPRead, "rwops_testFPRead", "Test reading from file pointer", TEST_ENABLED };
   723 
   724 static const SDLTest_TestCaseReference rwopsTest7 =
   725         { (SDLTest_TestCaseFp)rwops_testFPWrite, "rwops_testFPWrite", "Test writing to file pointer", TEST_ENABLED };
   726 
   727 static const SDLTest_TestCaseReference rwopsTest8 =
   728         { (SDLTest_TestCaseFp)rwops_testAllocFree, "rwops_testAllocFree", "Test alloc and free of RW context", TEST_ENABLED };
   729 
   730 static const SDLTest_TestCaseReference rwopsTest9 =
   731         { (SDLTest_TestCaseFp)rwops_testFileWriteReadEndian, "rwops_testFileWriteReadEndian", "Test writing and reading via the Endian aware functions", TEST_ENABLED };
   732 
   733 static const SDLTest_TestCaseReference rwopsTest10 =
   734         { (SDLTest_TestCaseFp)rwops_testCompareRWFromMemWithRWFromFile, "rwops_testCompareRWFromMemWithRWFromFile", "Compare RWFromMem and RWFromFile RWops for read and seek", TEST_ENABLED };
   735 
   736 /* Sequence of RWops test cases */
   737 static const SDLTest_TestCaseReference *rwopsTests[] =  {
   738     &rwopsTest1, &rwopsTest2, &rwopsTest3, &rwopsTest4, &rwopsTest5, &rwopsTest6,
   739     &rwopsTest7, &rwopsTest8, &rwopsTest9, &rwopsTest10, NULL
   740 };
   741 
   742 /* RWops test suite (global) */
   743 SDLTest_TestSuiteReference rwopsTestSuite = {
   744     "RWops",
   745     RWopsSetUp,
   746     rwopsTests,
   747     RWopsTearDown
   748 };