Port clipboard and rwops test suites from GSOC code; minor updates to harness and fuzzer in test lib

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';

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("Runtime of %i iterations: %.1f sec", testIterations, runtime);
-	        		SDLTest_Log("Test runtime: %.5f sec", (testEndSeconds - testStartSeconds) / (float)testIterations);
+	        		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;

test/tests/testclipboard.c

@@ -0,0 +1,182 @@
+/**
+ * New/updated tests: aschiffler at ferzkopp dot net
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#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
+};

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 <stdio.h>
+
+#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
+};

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,