From b6c7d8a9880bfa5192eee86e0aed6b9f08f45d21 Mon Sep 17 00:00:00 2001 From: Andreas Schiffler Date: Sun, 16 Dec 2012 21:59:29 -0800 Subject: [PATCH] Port clipboard and rwops test suites from GSOC code; minor updates to harness and fuzzer in test lib --- src/test/SDL_test_fuzzer.c | 2 +- src/test/SDL_test_harness.c | 17 +- test/tests/testclipboard.c | 182 +++++++++++++++ test/tests/testrwops.c | 427 ++++++++++++++++++++++++++++++++++++ test/tests/testsuites.h | 8 +- 5 files changed, 626 insertions(+), 10 deletions(-) create mode 100644 test/tests/testclipboard.c create mode 100644 test/tests/testrwops.c diff --git a/src/test/SDL_test_fuzzer.c b/src/test/SDL_test_fuzzer.c index 23b6d8413..3ef546da3 100644 --- a/src/test/SDL_test_fuzzer.c +++ b/src/test/SDL_test_fuzzer.c @@ -630,7 +630,7 @@ SDLTest_RandomAsciiStringWithMaximumLength(int maxSize) } for(counter = 0; counter < size; ++counter) { - string[counter] = (char)SDLTest_RandomIntegerInRange(1, 127); + string[counter] = (char)SDLTest_RandomIntegerInRange(32, 126); } string[counter] = '\0'; diff --git a/src/test/SDL_test_harness.c b/src/test/SDL_test_harness.c index 31cf239d0..50ff47563 100644 --- a/src/test/SDL_test_harness.c +++ b/src/test/SDL_test_harness.c @@ -342,6 +342,7 @@ SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], char *userRunSeed, U float runEndSeconds; float suiteEndSeconds; float testEndSeconds; + float runtime; int testResult = 0; int runResult = 0; Uint32 totalTestFailedCount = 0; @@ -450,14 +451,16 @@ SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], char *userRunSeed, U // Take time - test end testEndSeconds = GetClock(); + runtime = testEndSeconds - testStartSeconds; + if (runtime < 0.0f) runtime = 0.0f; if (testIterations > 1) { // Log test runtime - SDLTest_Log("Runtime of %i iterations: %.1f sec", testIterations, testEndSeconds - testStartSeconds); - SDLTest_Log("Test runtime: %.5f sec", (testEndSeconds - testStartSeconds) / (float)testIterations); + SDLTest_Log("Runtime of %i iterations: %.1f sec", testIterations, runtime); + SDLTest_Log("Test runtime: %.5f sec", runtime / (float)testIterations); } else { // Log test runtime - SDLTest_Log("Test runtime: %.1f sec", testEndSeconds - testStartSeconds); + SDLTest_Log("Test runtime: %.1f sec", runtime); } // Log final test result @@ -476,9 +479,11 @@ SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], char *userRunSeed, U // Take time - suite end suiteEndSeconds = GetClock(); + runtime = suiteEndSeconds - suiteStartSeconds; + if (runtime < 0.0f) runtime = 0.0f; // Log suite runtime - SDLTest_Log("Suite runtime: %.1f sec", suiteEndSeconds - suiteStartSeconds); + SDLTest_Log("Suite runtime: %.1f sec", runtime); // Log summary and final Suite result countSum = testPassedCount + testFailedCount + testSkippedCount; @@ -496,9 +501,11 @@ SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], char *userRunSeed, U // Take time - run end runEndSeconds = GetClock(); + runtime = runEndSeconds - runStartSeconds; + if (runtime < 0.0f) runtime = 0.0f; // Log total runtime - SDLTest_Log("Total runtime: %.1f sec", runEndSeconds - runStartSeconds); + SDLTest_Log("Total runtime: %.1f sec", runtime); // Log summary and final run result countSum = totalTestPassedCount + totalTestFailedCount + totalTestSkippedCount; diff --git a/test/tests/testclipboard.c b/test/tests/testclipboard.c new file mode 100644 index 000000000..2dc9dbdee --- /dev/null +++ b/test/tests/testclipboard.c @@ -0,0 +1,182 @@ +/** + * New/updated tests: aschiffler at ferzkopp dot net + */ + +#include +#include + +#include "SDL.h" +#include "SDL_test.h" + +/* ================= Test Case Implementation ================== */ + +/* Test case functions */ + +/** + * \brief Check call to SDL_HasClipboardText + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_HasClipboardText + */ +int +clipboard_testHasClipboardText(void *arg) +{ + SDL_bool result; + result = SDL_HasClipboardText(); + SDLTest_AssertPass("Call to SDL_HasClipboardText succeeded"); + + return TEST_COMPLETED; +} + +/** + * \brief Check call to SDL_GetClipboardText + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_GetClipboardText + */ +int +clipboard_testGetClipboardText(void *arg) +{ + char *charResult; + charResult = SDL_GetClipboardText(); + SDLTest_AssertPass("Call to SDL_GetClipboardText succeeded"); + + if (charResult) SDL_free(charResult); + + return TEST_COMPLETED; +} + +/** + * \brief Check call to SDL_SetClipboardText + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_SetClipboardText + */ +int +clipboard_testSetClipboardText(void *arg) +{ + char *textRef = SDLTest_RandomAsciiString(); + char *text = SDL_strdup(textRef); + int result; + result = SDL_SetClipboardText((const char *)text); + SDLTest_AssertPass("Call to SDL_SetClipboardText succeeded"); + SDLTest_AssertCheck( + result == 0, + "Validate SDL_SetClipboardText result, expected 0, got %i", + result); + SDLTest_AssertCheck( + SDL_strcmp(textRef, text) == 0, + "Verify SDL_SetClipboardText did not modify input string, expected '%s', got '%s'", + textRef, text); + + /* Cleanup */ + if (textRef) SDL_free(textRef); + if (text) SDL_free(text); + + return TEST_COMPLETED; +} + +/** + * \brief End-to-end test of SDL_xyzClipboardText functions + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_HasClipboardText + * http://wiki.libsdl.org/moin.cgi/SDL_GetClipboardText + * http://wiki.libsdl.org/moin.cgi/SDL_SetClipboardText + */ +int +clipboard_testClipboardTextFunctions(void *arg) +{ + char *textRef = SDLTest_RandomAsciiString(); + char *text = SDL_strdup(textRef); + SDL_bool boolResult; + int intResult; + char *charResult; + + /* Clear clipboard text state */ + boolResult = SDL_HasClipboardText(); + SDLTest_AssertPass("Call to SDL_HasClipboardText succeeded"); + if (boolResult == SDL_TRUE) { + intResult = SDL_SetClipboardText((const char *)NULL); + SDLTest_AssertPass("Call to DL_SetClipboardText(NULL) succeeded"); + SDLTest_AssertCheck( + intResult == 0, + "Verify result from SDL_SetClipboardText(NULL), expected 0, got %i", + intResult); + charResult = SDL_GetClipboardText(); + SDLTest_AssertPass("Call to SDL_GetClipboardText succeeded"); + boolResult = SDL_HasClipboardText(); + SDLTest_AssertPass("Call to SDL_HasClipboardText succeeded"); + SDLTest_AssertCheck( + boolResult == SDL_FALSE, + "Verify SDL_HasClipboardText returned SDL_FALSE, got %s", + (boolResult) ? "SDL_TRUE" : "SDL_FALSE"); + } + + /* Empty clipboard */ + charResult = SDL_GetClipboardText(); + SDLTest_AssertPass("Call to SDL_GetClipboardText succeeded"); + SDLTest_AssertCheck( + charResult != NULL, + "Verify SDL_GetClipboardText did not return NULL"); + SDLTest_AssertCheck( + strlen(charResult) == 0, + "Verify SDL_GetClipboardText returned string with length 0, got length %i", + strlen(charResult)); + intResult = SDL_SetClipboardText((const char *)text); + SDLTest_AssertPass("Call to SDL_SetClipboardText succeeded"); + SDLTest_AssertCheck( + intResult == 0, + "Verify result from SDL_SetClipboardText(NULL), expected 0, got %i", + intResult); + SDLTest_AssertCheck( + strcmp(textRef, text) == 0, + "Verify SDL_SetClipboardText did not modify input string, expected '%s', got '%s'", + textRef, text); + boolResult = SDL_HasClipboardText(); + SDLTest_AssertPass("Call to SDL_HasClipboardText succeeded"); + SDLTest_AssertCheck( + boolResult == SDL_TRUE, + "Verify SDL_HasClipboardText returned SDL_TRUE, got %s", + (boolResult) ? "SDL_TRUE" : "SDL_FALSE"); + charResult = SDL_GetClipboardText(); + SDLTest_AssertPass("Call to SDL_GetClipboardText succeeded"); + SDLTest_AssertCheck( + strcmp(textRef, charResult) == 0, + "Verify SDL_GetClipboardText returned correct string, expected '%s', got '%s'", + textRef, charResult); + + /* Cleanup */ + if (textRef) SDL_free(textRef); + if (text) SDL_free(text); + if (charResult) SDL_free(charResult); + + return TEST_COMPLETED; +} + + +/* ================= Test References ================== */ + +/* Clipboard test cases */ +static const SDLTest_TestCaseReference clipboardTest1 = + { (SDLTest_TestCaseFp)clipboard_testHasClipboardText, "clipboard_testHasClipboardText", "Check call to SDL_HasClipboardText", TEST_ENABLED }; + +static const SDLTest_TestCaseReference clipboardTest2 = + { (SDLTest_TestCaseFp)clipboard_testGetClipboardText, "clipboard_testGetClipboardText", "Check call to SDL_GetClipboardText", TEST_ENABLED }; + +static const SDLTest_TestCaseReference clipboardTest3 = + { (SDLTest_TestCaseFp)clipboard_testSetClipboardText, "clipboard_testSetClipboardText", "Check call to SDL_SetClipboardText", TEST_ENABLED }; + +static const SDLTest_TestCaseReference clipboardTest4 = + { (SDLTest_TestCaseFp)clipboard_testClipboardTextFunctions, "clipboard_testClipboardTextFunctions", "End-to-end test of SDL_xyzClipboardText functions", TEST_ENABLED }; + +/* Sequence of Clipboard test cases */ +static const SDLTest_TestCaseReference *clipboardTests[] = { + &clipboardTest1, &clipboardTest2, &clipboardTest3, &clipboardTest4, NULL +}; + +/* Clipboard test suite (global) */ +SDLTest_TestSuiteReference clipboardTestSuite = { + "Clipboard", + NULL, + clipboardTests, + NULL +}; diff --git a/test/tests/testrwops.c b/test/tests/testrwops.c new file mode 100644 index 000000000..ff8053dcb --- /dev/null +++ b/test/tests/testrwops.c @@ -0,0 +1,427 @@ +/** + * Automated SDL_RWops test. + * + * Original code written by Edgar Simo "bobbens" + * Ported by Markus Kauppila (markus.kauppila@gmail.com) + * Updated for SDL_test by aschiffler at ferzkopp dot net + * + * Released under Public Domain. + */ + +/* quiet windows compiler warnings */ +#define _CRT_SECURE_NO_WARNINGS + +#include + +#include "SDL.h" +#include "SDL_test.h" + +/* ================= Test Case Implementation ================== */ + +const char* RWopsReadTestFilename = "rwops_read"; +const char* RWopsWriteTestFilename = "rwops_write"; + +static const char RWopsHelloWorldTestString[] = "Hello World!"; +static const char RWopsHelloWorldCompString[] = "Hello World!"; + +/* Fixture */ + +void +RWopsSetUp(void *arg) +{ + int fileLen = SDL_strlen(RWopsHelloWorldTestString); + FILE *handle; + int writtenLen; + int result; + + /* Clean up from previous runs (if any); ignore errors */ + remove(RWopsReadTestFilename); + remove(RWopsWriteTestFilename); + + /* Create a test file */ + handle = fopen(RWopsReadTestFilename, "w"); + SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", RWopsReadTestFilename); + if (handle == NULL) return; + + /* Write some known test into it */ + writtenLen = (int)fwrite(RWopsHelloWorldTestString, 1, fileLen, handle); + SDLTest_AssertCheck(fileLen == writtenLen, "Verify number of written bytes, expected %i, got %i", fileLen, writtenLen); + result = fclose(handle); + SDLTest_AssertCheck(result == 0, "Verify result from fclose, expected 0, got %i", result); + + SDLTest_AssertPass("Creation of test file completed"); +} + +void +RWopsTearDown(void *arg) +{ + int result; + + /* Remove the created files to clean up; ignore errors for write filename */ + result = remove(RWopsReadTestFilename); + SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", RWopsReadTestFilename, result); + remove(RWopsWriteTestFilename); + + SDLTest_AssertPass("Cleanup of test files completed"); +} + +/** + * @brief Makes sure parameters work properly. Local helper function. + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_RWseek + * http://wiki.libsdl.org/moin.cgi/SDL_RWread + */ +void +_testGenericRWopsValidations(SDL_RWops *rw, int write) +{ + char buf[sizeof(RWopsHelloWorldTestString)]; + int i; + int seekPos = SDLTest_RandomIntegerInRange(4, 8); + + /* Clear buffer */ + SDL_zero(buf); + + /* Set to start. */ + i = SDL_RWseek(rw, 0, RW_SEEK_SET ); + SDLTest_AssertPass("Call to SDL_RWseek succeeded"); + SDLTest_AssertCheck(i == 0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %i", i); + + /* Test write. */ + i = SDL_RWwrite(rw, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString)-1, 1); + SDLTest_AssertPass("Call to SDL_RWwrite succeeded"); + if (write) { + SDLTest_AssertCheck(i == 1, "Verify result of writing one byte with SDL_RWwrite, expected 1, got %i", i); + } + else { + SDLTest_AssertCheck(i <= 0, "Verify result of writing with SDL_RWwrite, expected <=0, got %i", i); + } + + /* Test seek to random position */ + i = SDL_RWseek( rw, seekPos, RW_SEEK_SET ); + SDLTest_AssertPass("Call to SDL_RWseek succeeded"); + SDLTest_AssertCheck(i == seekPos, "Verify seek to %i with SDL_RWseek (RW_SEEK_SET), expected %i, got %i", seekPos, seekPos, i); + + /* Test seek back to start */ + i = SDL_RWseek(rw, 0, RW_SEEK_SET ); + SDLTest_AssertPass("Call to SDL_RWseek succeeded"); + SDLTest_AssertCheck(i == 0, "Verify seek to 0 with SDL_RWseek (RW_SEEK_SET), expected 0, got %i", i); + + /* Test read */ + i = SDL_RWread( rw, buf, 1, sizeof(RWopsHelloWorldTestString)-1 ); + SDLTest_AssertPass("Call to SDL_RWread succeeded"); + SDLTest_AssertCheck( + i == (sizeof(RWopsHelloWorldTestString)-1), + "Verify result from SDL_RWread, expected %i, got %i", + sizeof(RWopsHelloWorldTestString)-1, + i); + SDLTest_AssertCheck( + SDL_memcmp(buf, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString)-1 ) == 0, + "Verify read bytes match expected string, expected '%s', got '%s'", RWopsHelloWorldTestString, buf); + + /* More seek tests. */ + i = SDL_RWseek( rw, -4, RW_SEEK_CUR ); + SDLTest_AssertPass("Call to SDL_RWseek(...,-4,RW_SEEK_CUR) succeeded"); + SDLTest_AssertCheck( + i == (sizeof(RWopsHelloWorldTestString)-5), + "Verify seek to -4 with SDL_RWseek (RW_SEEK_CUR), expected %i, got %i", + sizeof(RWopsHelloWorldTestString)-5, + i); + + i = SDL_RWseek( rw, -1, RW_SEEK_END ); + SDLTest_AssertPass("Call to SDL_RWseek(...,-1,RW_SEEK_END) succeeded"); + SDLTest_AssertCheck( + i == (sizeof(RWopsHelloWorldTestString)-2), + "Verify seek to -1 with SDL_RWseek (RW_SEEK_END), expected %i, got %i", + sizeof(RWopsHelloWorldTestString)-2, + i); +} + +/*! + * Negative test for SDL_RWFromFile parameters + * + * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile + * + */ +int +rwops_testParamNegative (void) +{ + SDL_RWops *rwops; + + /* These should all fail. */ + rwops = SDL_RWFromFile(NULL, NULL); + SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, NULL) succeeded"); + SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, NULL) returns NULL"); + + rwops = SDL_RWFromFile(NULL, "ab+"); + SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, \"ab+\") succeeded"); + SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, \"ab+\") returns NULL"); + + rwops = SDL_RWFromFile(NULL, "sldfkjsldkfj"); + SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, \"sldfkjsldkfj\") succeeded"); + SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, \"sldfkjsldkfj\") returns NULL"); + + rwops = SDL_RWFromFile("something", ""); + SDLTest_AssertPass("Call to SDL_RWFromFile(\"something\", \"\") succeeded"); + SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(\"something\", \"\") returns NULL"); + + rwops = SDL_RWFromFile("something", NULL); + SDLTest_AssertPass("Call to SDL_RWFromFile(\"something\", NULL) succeeded"); + SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(\"something\", NULL) returns NULL"); + + return TEST_COMPLETED; +} + +/** + * @brief Tests opening from memory. + * + * \sa http://wiki.libsdl.org/moin.cgi/SDL_RWFromMem + */ +int +rwops_testMem (void) +{ + char mem[sizeof(RWopsHelloWorldTestString)]; + SDL_RWops *rw; + + /* Clear buffer */ + SDL_zero(mem); + + /* Open */ + rw = SDL_RWFromMem(mem, sizeof(RWopsHelloWorldTestString)-1); + SDLTest_AssertPass("Call to SDL_RWFromMem() succeeded"); + SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_RWFromMem does not return NULL"); + + /* Bail out if NULL */ + if (rw == NULL) return TEST_ABORTED; + + /* Run generic tests */ + _testGenericRWopsValidations(rw, 1); + + /* Close */ + SDL_RWclose(rw); + SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); + SDL_FreeRW(rw); + SDLTest_AssertPass("Call to SDL_FreeRW() succeeded"); + + return TEST_COMPLETED; +} + + +/** + * @brief Tests opening from memory. + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_RWFromConstMem + */ +int +rwops_testConstMem (void) +{ + SDL_RWops *rw; + + /* Open handle */ + rw = SDL_RWFromConstMem( RWopsHelloWorldCompString, sizeof(RWopsHelloWorldCompString)-1 ); + SDLTest_AssertPass("Call to SDL_RWFromConstMem() succeeded"); + SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_RWFromConstMem does not return NULL"); + + /* Bail out if NULL */ + if (rw == NULL) return TEST_ABORTED; + + /* Run generic tests */ + _testGenericRWopsValidations( rw, 0 ); + + /* Close handle */ + SDL_RWclose(rw); + SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); + SDL_FreeRW( rw ); + SDLTest_AssertPass("Call to SDL_FreeRW() succeeded"); + + return TEST_COMPLETED; +} + + +/** + * @brief Tests reading from file. + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile + * http://wiki.libsdl.org/moin.cgi/SDL_FreeRW + */ +int +rwops_testFileRead(void) +{ + SDL_RWops *rw; + + /* Read test. */ + rw = SDL_RWFromFile(RWopsReadTestFilename, "r"); + SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"r\") succeeded"); + SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in read mode does not return NULL"); + + // Bail out if NULL + if (rw == NULL) return TEST_ABORTED; + + /* Run generic tests */ + _testGenericRWopsValidations( rw, 0 ); + + /* Close handle */ + SDL_RWclose(rw); + SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); + SDL_FreeRW( rw ); + SDLTest_AssertPass("Call to SDL_FreeRW() succeeded"); + + return TEST_COMPLETED; +} + +/** + * @brief Tests writing from memory. + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile + * http://wiki.libsdl.org/moin.cgi/SDL_FreeRW + */ +int +rwops_testFileWrite(void) +{ + SDL_RWops *rw; + + /* Write test. */ + rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+"); + SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\") succeeded"); + SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL"); + + // Bail out if NULL + if (rw == NULL) return TEST_ABORTED; + + /* Run generic tests */ + _testGenericRWopsValidations( rw, 1 ); + + /* Close handle */ + SDL_RWclose(rw); + SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); + SDL_FreeRW( rw ); + SDLTest_AssertPass("Call to SDL_FreeRW() succeeded"); + + return TEST_COMPLETED; +} + + +/** + * @brief Tests reading from file handle + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFP + * http://wiki.libsdl.org/moin.cgi/SDL_FreeRW + * + */ +int +rwops_testFPRead(void) +{ + FILE *fp; + SDL_RWops *rw; + + /* Run read tests. */ + fp = fopen(RWopsReadTestFilename, "r"); + SDLTest_AssertCheck(fp != NULL, "Verify handle from opening file '%s' in read mode is not NULL", RWopsReadTestFilename); + + /* Bail out if NULL */ + if (fp == NULL) return TEST_ABORTED; + + /* Open */ + rw = SDL_RWFromFP( fp, 1 ); + SDLTest_AssertPass("Call to SDL_RWFromFP() succeeded"); + SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFP in read mode does not return NULL"); + + /* Bail out if NULL */ + if (rw == NULL) return TEST_ABORTED; + + /* Run generic tests */ + _testGenericRWopsValidations( rw, 0 ); + + /* Close handle */ + SDL_RWclose(rw); + SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); + SDL_FreeRW( rw ); + SDLTest_AssertPass("Call to SDL_FreeRW() succeeded"); + fclose(fp); + + return TEST_COMPLETED; +} + + +/** + * @brief Tests writing to file handle + * + * \sa + * http://wiki.libsdl.org/moin.cgi/SDL_RWFromFP + * http://wiki.libsdl.org/moin.cgi/SDL_FreeRW + * + */ +int +rwops_testFPWrite(void) +{ + FILE *fp; + SDL_RWops *rw; + + /* Run write tests. */ + fp = fopen(RWopsWriteTestFilename, "w+"); + SDLTest_AssertCheck(fp != NULL, "Verify handle from opening file '%s' in write mode is not NULL", RWopsWriteTestFilename); + + /* Bail out if NULL */ + if (fp == NULL) return TEST_ABORTED; + + /* Open */ + rw = SDL_RWFromFP( fp, 1 ); + SDLTest_AssertPass("Call to SDL_RWFromFP() succeeded"); + SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFP in write mode does not return NULL"); + + /* Bail out if NULL */ + if (rw == NULL) return TEST_ABORTED; + + /* Run generic tests */ + _testGenericRWopsValidations( rw, 1 ); + + /* Close handle */ + SDL_RWclose(rw); + SDLTest_AssertPass("Call to SDL_RWclose() succeeded"); + SDL_FreeRW( rw ); + SDLTest_AssertPass("Call to SDL_FreeRW() succeeded"); + fclose(fp); + + return TEST_COMPLETED; +} + +/* ================= Test References ================== */ + +/* RWops test cases */ +static const SDLTest_TestCaseReference rwopsTest1 = + { (SDLTest_TestCaseFp)rwops_testParamNegative, "rwops_testParamNegative", "Negative test for SDL_RWFromFile parameters", TEST_ENABLED }; + +static const SDLTest_TestCaseReference rwopsTest2 = + { (SDLTest_TestCaseFp)rwops_testMem, "rwops_testMem", "Tests opening from memory", TEST_ENABLED }; + +static const SDLTest_TestCaseReference rwopsTest3 = + { (SDLTest_TestCaseFp)rwops_testConstMem, "rwops_testConstMem", "Tests opening from (const) memory", TEST_ENABLED }; + +static const SDLTest_TestCaseReference rwopsTest4 = + { (SDLTest_TestCaseFp)rwops_testFileRead, "rwops_testFileRead", "Tests reading from a file", TEST_ENABLED }; + +static const SDLTest_TestCaseReference rwopsTest5 = + { (SDLTest_TestCaseFp)rwops_testFileWrite, "rwops_testFileWrite", "Test writing to a file", TEST_ENABLED }; + +static const SDLTest_TestCaseReference rwopsTest6 = + { (SDLTest_TestCaseFp)rwops_testFPRead, "rwops_testFPRead", "Test reading from file pointer", TEST_ENABLED }; + +static const SDLTest_TestCaseReference rwopsTest7 = + { (SDLTest_TestCaseFp)rwops_testFPWrite, "rwops_testFPWrite", "Test writing to file pointer", TEST_ENABLED }; + +/* Sequence of RWops test cases */ +static const SDLTest_TestCaseReference *rwopsTests[] = { + &rwopsTest1, &rwopsTest2, &rwopsTest3, &rwopsTest4, &rwopsTest5, &rwopsTest6, &rwopsTest7, NULL +}; + +/* RWops test suite (global) */ +SDLTest_TestSuiteReference rwopsTestSuite = { + "RWops", + RWopsSetUp, + rwopsTests, + RWopsTearDown +}; diff --git a/test/tests/testsuites.h b/test/tests/testsuites.h index 456adbab2..40f4b5fcc 100644 --- a/test/tests/testsuites.h +++ b/test/tests/testsuites.h @@ -10,13 +10,13 @@ // Test collections //extern SDLTest_TestSuiteReference audioTestSuite; -//extern SDLTest_TestSuiteReference clipboardTestSuite; +extern SDLTest_TestSuiteReference clipboardTestSuite; //extern SDLTest_TestSuiteReference eventsTestSuite; //extern SDLTest_TestSuiteReference keyboardTestSuite; extern SDLTest_TestSuiteReference platformTestSuite; extern SDLTest_TestSuiteReference rectTestSuite; //extern SDLTest_TestSuiteReference renderTestSuite; -//extern SDLTest_TestSuiteReference rwopsTestSuite; +extern SDLTest_TestSuiteReference rwopsTestSuite; //extern SDLTest_TestSuiteReference surfaceTestSuite; //extern SDLTest_TestSuiteReference syswmTestSuite; //extern SDLTest_TestSuiteReference videoTestSuite; @@ -24,13 +24,13 @@ extern SDLTest_TestSuiteReference rectTestSuite; // All test suites SDLTest_TestSuiteReference *testSuites[] = { // &audioTestSuite, -// &clipboardTestSuite, + &clipboardTestSuite, // &eventsTestSuite, // &keyboardTestSuite, &platformTestSuite, &rectTestSuite, // &renderTestSuite, -// &rwopsTestSuite, + &rwopsTestSuite, // &surfaceTestSuite, // &syswmTestSuite, // &videoTestSuite,