Home | History | Annotate | Download | only in test
      1 
      2 /**
      3  * Automated SDL_RWops test.
      4  *
      5  * Original code written by Edgar Simo "bobbens"
      6  * Ported by Markus Kauppila (markus.kauppila (at) 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 };
    749