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