testautomation: remove SDLTest_TestCaseFp casts

test/testautomation_blit.c

@@ -192,15 +192,15 @@ int blit_testRandomToRandomSVGAMultipleIterations(void *arg) {
 }
 
 static const SDLTest_TestCaseReference blitTest1 = {
-        (SDLTest_TestCaseFp)blit_testExampleApplicationRender, "blit_testExampleApplicationRender",
+        blit_testExampleApplicationRender, "blit_testExampleApplicationRender",
         "Test example application render.", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference blitTest2 = {
-        (SDLTest_TestCaseFp)blit_testRandomToRandomSVGA, "blit_testRandomToRandomSVGA",
+        blit_testRandomToRandomSVGA, "blit_testRandomToRandomSVGA",
         "Test SVGA noise render.", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference blitTest3 = {
-        (SDLTest_TestCaseFp)blit_testRandomToRandomSVGAMultipleIterations, "blit_testRandomToRandomSVGAMultipleIterations",
+        blit_testRandomToRandomSVGAMultipleIterations, "blit_testRandomToRandomSVGAMultipleIterations",
         "Test SVGA noise render (250k iterations).", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference *blitTests[] = {

test/testautomation_clipboard.c

@@ -564,15 +564,15 @@ static int clipboard_testPrimarySelectionTextFunctions(void *arg)
 /* ================= Test References ================== */
 
 static const SDLTest_TestCaseReference clipboardTest1 = {
-    (SDLTest_TestCaseFp)clipboard_testClipboardDataFunctions, "clipboard_testClipboardDataFunctions", "End-to-end test of SDL_xyzClipboardData functions", TEST_ENABLED
+    clipboard_testClipboardDataFunctions, "clipboard_testClipboardDataFunctions", "End-to-end test of SDL_xyzClipboardData functions", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference clipboardTest2 = {
-    (SDLTest_TestCaseFp)clipboard_testClipboardTextFunctions, "clipboard_testClipboardTextFunctions", "End-to-end test of SDL_xyzClipboardText functions", TEST_ENABLED
+    clipboard_testClipboardTextFunctions, "clipboard_testClipboardTextFunctions", "End-to-end test of SDL_xyzClipboardText functions", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference clipboardTest3 = {
-    (SDLTest_TestCaseFp)clipboard_testPrimarySelectionTextFunctions, "clipboard_testPrimarySelectionTextFunctions", "End-to-end test of SDL_xyzPrimarySelectionText functions", TEST_ENABLED
+    clipboard_testPrimarySelectionTextFunctions, "clipboard_testPrimarySelectionTextFunctions", "End-to-end test of SDL_xyzPrimarySelectionText functions", TEST_ENABLED
 };
 
 /* Sequence of Clipboard test cases */

test/testautomation_guid.c

@@ -123,11 +123,11 @@ TestGUIDToString(void *arg)
 
 /* GUID routine test cases */
 static const SDLTest_TestCaseReference guidTest1 = {
-    (SDLTest_TestCaseFp)TestStringToGUID, "TestStringToGUID", "Call to SDL_StringToGUID", TEST_ENABLED
+    TestStringToGUID, "TestStringToGUID", "Call to SDL_StringToGUID", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference guidTest2 = {
-    (SDLTest_TestCaseFp)TestGUIDToString, "TestGUIDToString", "Call to SDL_GUIDToString", TEST_ENABLED
+    TestGUIDToString, "TestGUIDToString", "Call to SDL_GUIDToString", TEST_ENABLED
 };
 
 /* Sequence of GUID routine test cases */

test/testautomation_hints.c

@@ -229,11 +229,11 @@ static int hints_setHint(void *arg)
 
 /* Hints test cases */
 static const SDLTest_TestCaseReference hintsTest1 = {
-    (SDLTest_TestCaseFp)hints_getHint, "hints_getHint", "Call to SDL_GetHint", TEST_ENABLED
+    hints_getHint, "hints_getHint", "Call to SDL_GetHint", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference hintsTest2 = {
-    (SDLTest_TestCaseFp)hints_setHint, "hints_setHint", "Call to SDL_SetHint", TEST_ENABLED
+    hints_setHint, "hints_setHint", "Call to SDL_SetHint", TEST_ENABLED
 };
 
 /* Sequence of Hints test cases */

test/testautomation_intrinsics.c

@@ -627,43 +627,43 @@ static int intrinsics_testAVX512F(void *arg)
 /* Intrinsics test cases */
 
 static const SDLTest_TestCaseReference intrinsicsTest1 = {
-    (SDLTest_TestCaseFp)intrinsics_selftest, "intrinsics_selftest", "Intrinsics testautomation selftest", TEST_ENABLED
+    intrinsics_selftest, "intrinsics_selftest", "Intrinsics testautomation selftest", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest2 = {
-    (SDLTest_TestCaseFp)intrinsics_testMMX, "intrinsics_testMMX", "Tests MMX intrinsics", TEST_ENABLED
+    intrinsics_testMMX, "intrinsics_testMMX", "Tests MMX intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest3 = {
-    (SDLTest_TestCaseFp)intrinsics_testSSE, "intrinsics_testSSE", "Tests SSE intrinsics", TEST_ENABLED
+    intrinsics_testSSE, "intrinsics_testSSE", "Tests SSE intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest4 = {
-    (SDLTest_TestCaseFp)intrinsics_testSSE2, "intrinsics_testSSE2", "Tests SSE2 intrinsics", TEST_ENABLED
+    intrinsics_testSSE2, "intrinsics_testSSE2", "Tests SSE2 intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest5 = {
-    (SDLTest_TestCaseFp)intrinsics_testSSE3, "intrinsics_testSSE3", "Tests SSE3 intrinsics", TEST_ENABLED
+    intrinsics_testSSE3, "intrinsics_testSSE3", "Tests SSE3 intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest6 = {
-    (SDLTest_TestCaseFp)intrinsics_testSSE4_1, "intrinsics_testSSE4.1", "Tests SSE4.1 intrinsics", TEST_ENABLED
+    intrinsics_testSSE4_1, "intrinsics_testSSE4.1", "Tests SSE4.1 intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest7 = {
-    (SDLTest_TestCaseFp)intrinsics_testSSE4_2, "intrinsics_testSSE4.2", "Tests SSE4.2 intrinsics", TEST_ENABLED
+    intrinsics_testSSE4_2, "intrinsics_testSSE4.2", "Tests SSE4.2 intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest8 = {
-    (SDLTest_TestCaseFp)intrinsics_testAVX, "intrinsics_testAVX", "Tests AVX intrinsics", TEST_ENABLED
+    intrinsics_testAVX, "intrinsics_testAVX", "Tests AVX intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest9 = {
-    (SDLTest_TestCaseFp)intrinsics_testAVX2, "intrinsics_testAVX2", "Tests AVX2 intrinsics", TEST_ENABLED
+    intrinsics_testAVX2, "intrinsics_testAVX2", "Tests AVX2 intrinsics", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference intrinsicsTest10 = {
-    (SDLTest_TestCaseFp)intrinsics_testAVX512F, "intrinsics_testAVX512F", "Tests AVX512F intrinsics", TEST_ENABLED
+    intrinsics_testAVX512F, "intrinsics_testAVX512F", "Tests AVX512F intrinsics", TEST_ENABLED
 };
 
 /* Sequence of Platform test cases */

test/testautomation_iostream.c

@@ -651,39 +651,39 @@ static int iostrm_testFileWriteReadEndian(void *arg)
 
 /* IOStream test cases */
 static const SDLTest_TestCaseReference iostrmTest1 = {
-    (SDLTest_TestCaseFp)iostrm_testParamNegative, "iostrm_testParamNegative", "Negative test for SDL_IOFromFile parameters", TEST_ENABLED
+    iostrm_testParamNegative, "iostrm_testParamNegative", "Negative test for SDL_IOFromFile parameters", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest2 = {
-    (SDLTest_TestCaseFp)iostrm_testMem, "iostrm_testMem", "Tests opening from memory", TEST_ENABLED
+    iostrm_testMem, "iostrm_testMem", "Tests opening from memory", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest3 = {
-    (SDLTest_TestCaseFp)iostrm_testConstMem, "iostrm_testConstMem", "Tests opening from (const) memory", TEST_ENABLED
+    iostrm_testConstMem, "iostrm_testConstMem", "Tests opening from (const) memory", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest4 = {
-    (SDLTest_TestCaseFp)iostrm_testDynamicMem, "iostrm_testDynamicMem", "Tests opening dynamic memory", TEST_ENABLED
+    iostrm_testDynamicMem, "iostrm_testDynamicMem", "Tests opening dynamic memory", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest5 = {
-    (SDLTest_TestCaseFp)iostrm_testFileRead, "iostrm_testFileRead", "Tests reading from a file", TEST_ENABLED
+    iostrm_testFileRead, "iostrm_testFileRead", "Tests reading from a file", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest6 = {
-    (SDLTest_TestCaseFp)iostrm_testFileWrite, "iostrm_testFileWrite", "Test writing to a file", TEST_ENABLED
+    iostrm_testFileWrite, "iostrm_testFileWrite", "Test writing to a file", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest7 = {
-    (SDLTest_TestCaseFp)iostrm_testAllocFree, "iostrm_testAllocFree", "Test alloc and free of RW context", TEST_ENABLED
+    iostrm_testAllocFree, "iostrm_testAllocFree", "Test alloc and free of RW context", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest8 = {
-    (SDLTest_TestCaseFp)iostrm_testFileWriteReadEndian, "iostrm_testFileWriteReadEndian", "Test writing and reading via the Endian aware functions", TEST_ENABLED
+    iostrm_testFileWriteReadEndian, "iostrm_testFileWriteReadEndian", "Test writing and reading via the Endian aware functions", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference iostrmTest9 = {
-    (SDLTest_TestCaseFp)iostrm_testCompareRWFromMemWithRWFromFile, "iostrm_testCompareRWFromMemWithRWFromFile", "Compare RWFromMem and RWFromFile IOStream for read and seek", TEST_ENABLED
+    iostrm_testCompareRWFromMemWithRWFromFile, "iostrm_testCompareRWFromMemWithRWFromFile", "Compare RWFromMem and RWFromFile IOStream for read and seek", TEST_ENABLED
 };
 
 /* Sequence of IOStream test cases */

test/testautomation_joystick.c

@@ -186,7 +186,7 @@ static int TestVirtualJoystick(void *arg)
 
 /* Joystick routine test cases */
 static const SDLTest_TestCaseReference joystickTest1 = {
-    (SDLTest_TestCaseFp)TestVirtualJoystick, "TestVirtualJoystick", "Test virtual joystick functionality", TEST_ENABLED
+    TestVirtualJoystick, "TestVirtualJoystick", "Test virtual joystick functionality", TEST_ENABLED
 };
 
 /* Sequence of Joystick routine test cases */

test/testautomation_keyboard.c

@@ -612,55 +612,55 @@ static int keyboard_getScancodeFromNameNegative(void *arg)
 
 /* Keyboard test cases */
 static const SDLTest_TestCaseReference keyboardTestGetKeyboardState = {
-    (SDLTest_TestCaseFp)keyboard_getKeyboardState, "keyboard_getKeyboardState", "Check call to SDL_GetKeyboardState with and without numkeys reference", TEST_ENABLED
+    keyboard_getKeyboardState, "keyboard_getKeyboardState", "Check call to SDL_GetKeyboardState with and without numkeys reference", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetKeyboardFocus = {
-    (SDLTest_TestCaseFp)keyboard_getKeyboardFocus, "keyboard_getKeyboardFocus", "Check call to SDL_GetKeyboardFocus", TEST_ENABLED
+    keyboard_getKeyboardFocus, "keyboard_getKeyboardFocus", "Check call to SDL_GetKeyboardFocus", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetKeyFromName = {
-    (SDLTest_TestCaseFp)keyboard_getKeyFromName, "keyboard_getKeyFromName", "Check call to SDL_GetKeyFromName for known, unknown and invalid name", TEST_ENABLED
+    keyboard_getKeyFromName, "keyboard_getKeyFromName", "Check call to SDL_GetKeyFromName for known, unknown and invalid name", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetKeyFromScancode = {
-    (SDLTest_TestCaseFp)keyboard_getKeyFromScancode, "keyboard_getKeyFromScancode", "Check call to SDL_GetKeyFromScancode", TEST_ENABLED
+    keyboard_getKeyFromScancode, "keyboard_getKeyFromScancode", "Check call to SDL_GetKeyFromScancode", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetKeyName = {
-    (SDLTest_TestCaseFp)keyboard_getKeyName, "keyboard_getKeyName", "Check call to SDL_GetKeyName", TEST_ENABLED
+    keyboard_getKeyName, "keyboard_getKeyName", "Check call to SDL_GetKeyName", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetSetModState = {
-    (SDLTest_TestCaseFp)keyboard_getSetModState, "keyboard_getSetModState", "Check call to SDL_GetModState and SDL_SetModState", TEST_ENABLED
+    keyboard_getSetModState, "keyboard_getSetModState", "Check call to SDL_GetModState and SDL_SetModState", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestStartStopTextInput = {
-    (SDLTest_TestCaseFp)keyboard_startStopTextInput, "keyboard_startStopTextInput", "Check call to SDL_StartTextInput and SDL_StopTextInput", TEST_ENABLED
+    keyboard_startStopTextInput, "keyboard_startStopTextInput", "Check call to SDL_StartTextInput and SDL_StopTextInput", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestSetTextInputArea = {
-    (SDLTest_TestCaseFp)keyboard_setTextInputArea, "keyboard_setTextInputArea", "Check call to SDL_SetTextInputArea", TEST_ENABLED
+    keyboard_setTextInputArea, "keyboard_setTextInputArea", "Check call to SDL_SetTextInputArea", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestSetTextInputAreaNegative = {
-    (SDLTest_TestCaseFp)keyboard_setTextInputAreaNegative, "keyboard_setTextInputAreaNegative", "Check call to SDL_SetTextInputArea with invalid data", TEST_ENABLED
+    keyboard_setTextInputAreaNegative, "keyboard_setTextInputAreaNegative", "Check call to SDL_SetTextInputArea with invalid data", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetScancodeFromName = {
-    (SDLTest_TestCaseFp)keyboard_getScancodeFromName, "keyboard_getScancodeFromName", "Check call to SDL_GetScancodeFromName", TEST_ENABLED
+    keyboard_getScancodeFromName, "keyboard_getScancodeFromName", "Check call to SDL_GetScancodeFromName", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetScancodeFromNameNegative = {
-    (SDLTest_TestCaseFp)keyboard_getScancodeFromNameNegative, "keyboard_getScancodeFromNameNegative", "Check call to SDL_GetScancodeFromName with invalid data", TEST_ENABLED
+    keyboard_getScancodeFromNameNegative, "keyboard_getScancodeFromNameNegative", "Check call to SDL_GetScancodeFromName with invalid data", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetKeyNameNegative = {
-    (SDLTest_TestCaseFp)keyboard_getKeyNameNegative, "keyboard_getKeyNameNegative", "Check call to SDL_GetKeyName with invalid data", TEST_ENABLED
+    keyboard_getKeyNameNegative, "keyboard_getKeyNameNegative", "Check call to SDL_GetKeyName with invalid data", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference keyboardTestGetScancodeNameNegative = {
-    (SDLTest_TestCaseFp)keyboard_getScancodeNameNegative, "keyboard_getScancodeNameNegative", "Check call to SDL_GetScancodeName with invalid data", TEST_ENABLED
+    keyboard_getScancodeNameNegative, "keyboard_getScancodeNameNegative", "Check call to SDL_GetScancodeName with invalid data", TEST_ENABLED
 };
 
 /* Sequence of Keyboard test cases */

test/testautomation_log.c

@@ -192,7 +192,7 @@ static int log_testHint(void *arg)
 
 /* Log test cases */
 static const SDLTest_TestCaseReference logTestHint = {
-    (SDLTest_TestCaseFp)log_testHint, "log_testHint", "Check SDL_HINT_LOGGING functionality", TEST_ENABLED
+    log_testHint, "log_testHint", "Check SDL_HINT_LOGGING functionality", TEST_ENABLED
 };
 
 /* Sequence of Log test cases */

test/testautomation_main.c

@@ -137,19 +137,19 @@ main_testSetError(void *arg)
 #endif
 
 static const SDLTest_TestCaseReference mainTest1 = {
-    (SDLTest_TestCaseFp)main_testInitQuitSubSystem, "main_testInitQuitSubSystem", "Tests SDL_InitSubSystem/QuitSubSystem", TEST_ENABLED
+    main_testInitQuitSubSystem, "main_testInitQuitSubSystem", "Tests SDL_InitSubSystem/QuitSubSystem", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mainTest2 = {
-    (SDLTest_TestCaseFp)main_testImpliedJoystickInit, "main_testImpliedJoystickInit", "Tests that init for gamecontroller properly implies joystick", TEST_ENABLED
+    main_testImpliedJoystickInit, "main_testImpliedJoystickInit", "Tests that init for gamecontroller properly implies joystick", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mainTest3 = {
-    (SDLTest_TestCaseFp)main_testImpliedJoystickQuit, "main_testImpliedJoystickQuit", "Tests that quit for gamecontroller doesn't quit joystick if you inited it explicitly", TEST_ENABLED
+    main_testImpliedJoystickQuit, "main_testImpliedJoystickQuit", "Tests that quit for gamecontroller doesn't quit joystick if you inited it explicitly", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mainTest4 = {
-    (SDLTest_TestCaseFp)main_testSetError, "main_testSetError", "Tests that SDL_SetError() handles arbitrarily large strings", TEST_ENABLED
+    main_testSetError, "main_testSetError", "Tests that SDL_SetError() handles arbitrarily large strings", TEST_ENABLED
 };
 
 /* Sequence of Main test cases */

test/testautomation_math.c

@@ -2805,527 +2805,527 @@ atan2_bottomLeftQuadrantTest(void *args)
 /* SDL_floor test cases */
 
 static const SDLTest_TestCaseReference floorTestInf = {
-    (SDLTest_TestCaseFp)floor_infCases, "floor_infCases",
+    floor_infCases, "floor_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference floorTestZero = {
-    (SDLTest_TestCaseFp)floor_zeroCases, "floor_zeroCases",
+    floor_zeroCases, "floor_zeroCases",
     "Checks positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference floorTestNan = {
-    (SDLTest_TestCaseFp)floor_nanCase, "floor_nanCase",
+    floor_nanCase, "floor_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference floorTestRound = {
-    (SDLTest_TestCaseFp)floor_roundNumbersCases, "floor_roundNumberCases",
+    floor_roundNumbersCases, "floor_roundNumberCases",
     "Checks a set of integral values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference floorTestFraction = {
-    (SDLTest_TestCaseFp)floor_fractionCases, "floor_fractionCases",
+    floor_fractionCases, "floor_fractionCases",
     "Checks a set of fractions", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference floorTestRange = {
-    (SDLTest_TestCaseFp)floor_rangeTest, "floor_rangeTest",
+    floor_rangeTest, "floor_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_ceil test cases */
 
 static const SDLTest_TestCaseReference ceilTestInf = {
-    (SDLTest_TestCaseFp)ceil_infCases, "ceil_infCases",
+    ceil_infCases, "ceil_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference ceilTestZero = {
-    (SDLTest_TestCaseFp)ceil_zeroCases, "ceil_zeroCases",
+    ceil_zeroCases, "ceil_zeroCases",
     "Checks positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference ceilTestNan = {
-    (SDLTest_TestCaseFp)ceil_nanCase, "ceil_nanCase",
+    ceil_nanCase, "ceil_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference ceilTestRound = {
-    (SDLTest_TestCaseFp)ceil_roundNumbersCases, "ceil_roundNumberCases",
+    ceil_roundNumbersCases, "ceil_roundNumberCases",
     "Checks a set of integral values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference ceilTestFraction = {
-    (SDLTest_TestCaseFp)ceil_fractionCases, "ceil_fractionCases",
+    ceil_fractionCases, "ceil_fractionCases",
     "Checks a set of fractions", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference ceilTestRange = {
-    (SDLTest_TestCaseFp)ceil_rangeTest, "ceil_rangeTest",
+    ceil_rangeTest, "ceil_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_trunc test cases */
 
 static const SDLTest_TestCaseReference truncTestInf = {
-    (SDLTest_TestCaseFp)trunc_infCases, "trunc_infCases",
+    trunc_infCases, "trunc_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference truncTestZero = {
-    (SDLTest_TestCaseFp)trunc_zeroCases, "trunc_zeroCases",
+    trunc_zeroCases, "trunc_zeroCases",
     "Checks positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference truncTestNan = {
-    (SDLTest_TestCaseFp)trunc_nanCase, "trunc_nanCase",
+    trunc_nanCase, "trunc_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference truncTestRound = {
-    (SDLTest_TestCaseFp)trunc_roundNumbersCases, "trunc_roundNumberCases",
+    trunc_roundNumbersCases, "trunc_roundNumberCases",
     "Checks a set of integral values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference truncTestFraction = {
-    (SDLTest_TestCaseFp)trunc_fractionCases, "trunc_fractionCases",
+    trunc_fractionCases, "trunc_fractionCases",
     "Checks a set of fractions", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference truncTestRange = {
-    (SDLTest_TestCaseFp)trunc_rangeTest, "trunc_rangeTest",
+    trunc_rangeTest, "trunc_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_round test cases */
 
 static const SDLTest_TestCaseReference roundTestInf = {
-    (SDLTest_TestCaseFp)round_infCases, "round_infCases",
+    round_infCases, "round_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference roundTestZero = {
-    (SDLTest_TestCaseFp)round_zeroCases, "round_zeroCases",
+    round_zeroCases, "round_zeroCases",
     "Checks positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference roundTestNan = {
-    (SDLTest_TestCaseFp)round_nanCase, "round_nanCase",
+    round_nanCase, "round_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference roundTestRound = {
-    (SDLTest_TestCaseFp)round_roundNumbersCases, "round_roundNumberCases",
+    round_roundNumbersCases, "round_roundNumberCases",
     "Checks a set of integral values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference roundTestFraction = {
-    (SDLTest_TestCaseFp)round_fractionCases, "round_fractionCases",
+    round_fractionCases, "round_fractionCases",
     "Checks a set of fractions", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference roundTestRange = {
-    (SDLTest_TestCaseFp)round_rangeTest, "round_rangeTest",
+    round_rangeTest, "round_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_fabs test cases */
 
 static const SDLTest_TestCaseReference fabsTestInf = {
-    (SDLTest_TestCaseFp)fabs_infCases, "fabs_infCases",
+    fabs_infCases, "fabs_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fabsTestZero = {
-    (SDLTest_TestCaseFp)fabs_zeroCases, "fabs_zeroCases",
+    fabs_zeroCases, "fabs_zeroCases",
     "Checks positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fabsTestNan = {
-    (SDLTest_TestCaseFp)fabs_nanCase, "fabs_nanCase",
+    fabs_nanCase, "fabs_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fabsTestRange = {
-    (SDLTest_TestCaseFp)fabs_rangeTest, "fabs_rangeTest",
+    fabs_rangeTest, "fabs_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_copysign test cases */
 
 static const SDLTest_TestCaseReference copysignTestInf = {
-    (SDLTest_TestCaseFp)copysign_infCases, "copysign_infCases",
+    copysign_infCases, "copysign_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference copysignTestZero = {
-    (SDLTest_TestCaseFp)copysign_zeroCases, "copysign_zeroCases",
+    copysign_zeroCases, "copysign_zeroCases",
     "Checks positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference copysignTestNan = {
-    (SDLTest_TestCaseFp)copysign_nanCases, "copysign_nanCases",
+    copysign_nanCases, "copysign_nanCases",
     "Checks NANs", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference copysignTestRange = {
-    (SDLTest_TestCaseFp)copysign_rangeTest, "copysign_rangeTest",
+    copysign_rangeTest, "copysign_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_fmod test cases */
 
 static const SDLTest_TestCaseReference fmodTestDivOfInf = {
-    (SDLTest_TestCaseFp)fmod_divOfInfCases, "fmod_divOfInfCases",
+    fmod_divOfInfCases, "fmod_divOfInfCases",
     "Checks division of positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fmodTestDivByInf = {
-    (SDLTest_TestCaseFp)fmod_divByInfCases, "fmod_divByInfCases",
+    fmod_divByInfCases, "fmod_divByInfCases",
     "Checks division by positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fmodTestDivOfZero = {
-    (SDLTest_TestCaseFp)fmod_divOfZeroCases, "fmod_divOfZeroCases",
+    fmod_divOfZeroCases, "fmod_divOfZeroCases",
     "Checks division of positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fmodTestDivByZero = {
-    (SDLTest_TestCaseFp)fmod_divByZeroCases, "fmod_divByZeroCases",
+    fmod_divByZeroCases, "fmod_divByZeroCases",
     "Checks division by positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fmodTestNan = {
-    (SDLTest_TestCaseFp)fmod_nanCases, "fmod_nanCases",
+    fmod_nanCases, "fmod_nanCases",
     "Checks NANs", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fmodTestRegular = {
-    (SDLTest_TestCaseFp)fmod_regularCases, "fmod_regularCases",
+    fmod_regularCases, "fmod_regularCases",
     "Checks a set of regular values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference fmodTestRange = {
-    (SDLTest_TestCaseFp)fmod_rangeTest, "fmod_rangeTest",
+    fmod_rangeTest, "fmod_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_exp test cases */
 
 static const SDLTest_TestCaseReference expTestInf = {
-    (SDLTest_TestCaseFp)exp_infCases, "exp_infCases",
+    exp_infCases, "exp_infCases",
     "Checks positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference expTestZero = {
-    (SDLTest_TestCaseFp)exp_zeroCases, "exp_zeroCases",
+    exp_zeroCases, "exp_zeroCases",
     "Checks for positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference expTestOverflow = {
-    (SDLTest_TestCaseFp)exp_overflowCase, "exp_overflowCase",
+    exp_overflowCase, "exp_overflowCase",
     "Checks for overflow", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference expTestBase = {
-    (SDLTest_TestCaseFp)exp_baseCase, "exp_baseCase",
+    exp_baseCase, "exp_baseCase",
     "Checks the base case", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference expTestRegular = {
-    (SDLTest_TestCaseFp)exp_regularCases, "exp_regularCases",
+    exp_regularCases, "exp_regularCases",
     "Checks a set of regular values", TEST_ENABLED
 };
 
 /* SDL_log test cases */
 
 static const SDLTest_TestCaseReference logTestLimit = {
-    (SDLTest_TestCaseFp)log_limitCases, "log_limitCases",
+    log_limitCases, "log_limitCases",
     "Checks the domain limits", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference logTestNan = {
-    (SDLTest_TestCaseFp)log_nanCases, "log_nanCases",
+    log_nanCases, "log_nanCases",
     "Checks NAN and negative values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference logTestBase = {
-    (SDLTest_TestCaseFp)log_baseCases, "log_baseCases",
+    log_baseCases, "log_baseCases",
     "Checks the base cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference logTestRegular = {
-    (SDLTest_TestCaseFp)log_regularCases, "log_regularCases",
+    log_regularCases, "log_regularCases",
     "Checks a set of regular values", TEST_ENABLED
 };
 
 /* SDL_log10 test cases */
 
 static const SDLTest_TestCaseReference log10TestLimit = {
-    (SDLTest_TestCaseFp)log10_limitCases, "log10_limitCases",
+    log10_limitCases, "log10_limitCases",
     "Checks the domain limits", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference log10TestNan = {
-    (SDLTest_TestCaseFp)log10_nanCases, "log10_nanCases",
+    log10_nanCases, "log10_nanCases",
     "Checks NAN and negative values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference log10TestBase = {
-    (SDLTest_TestCaseFp)log10_baseCases, "log10_baseCases",
+    log10_baseCases, "log10_baseCases",
     "Checks the base cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference log10TestRegular = {
-    (SDLTest_TestCaseFp)log10_regularCases, "log10_regularCases",
+    log10_regularCases, "log10_regularCases",
     "Checks a set of regular values", TEST_ENABLED
 };
 
 /* SDL_modf test cases */
 
 static const SDLTest_TestCaseReference modfTestBase = {
-    (SDLTest_TestCaseFp)modf_baseCases, "modf_baseCases",
+    modf_baseCases, "modf_baseCases",
     "Checks the base cases", TEST_ENABLED
 };
 
 /* SDL_pow test cases */
 
 static const SDLTest_TestCaseReference powTestExpInf1 = {
-    (SDLTest_TestCaseFp)pow_baseNOneExpInfCases, "pow_baseNOneExpInfCases",
+    pow_baseNOneExpInfCases, "pow_baseNOneExpInfCases",
     "Checks for pow(-1, +/-inf)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestExpInf2 = {
-    (SDLTest_TestCaseFp)pow_baseZeroExpNInfCases, "pow_baseZeroExpNInfCases",
+    pow_baseZeroExpNInfCases, "pow_baseZeroExpNInfCases",
     "Checks for pow(+/-0, -inf)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestExpInf3 = {
-    (SDLTest_TestCaseFp)pow_expInfCases, "pow_expInfCases",
+    pow_expInfCases, "pow_expInfCases",
     "Checks for pow(x, +/-inf)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestBaseInf1 = {
-    (SDLTest_TestCaseFp)pow_basePInfCases, "pow_basePInfCases",
+    pow_basePInfCases, "pow_basePInfCases",
     "Checks for pow(inf, x)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestBaseInf2 = {
-    (SDLTest_TestCaseFp)pow_baseNInfCases, "pow_baseNInfCases",
+    pow_baseNInfCases, "pow_baseNInfCases",
     "Checks for pow(-inf, x)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestNan1 = {
-    (SDLTest_TestCaseFp)pow_badOperationCase, "pow_badOperationCase",
+    pow_badOperationCase, "pow_badOperationCase",
     "Checks for negative finite base and non-integer finite exponent", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestNan2 = {
-    (SDLTest_TestCaseFp)pow_base1ExpNanCase, "pow_base1ExpNanCase",
+    pow_base1ExpNanCase, "pow_base1ExpNanCase",
     "Checks for pow(1.0, NAN)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestNan3 = {
-    (SDLTest_TestCaseFp)pow_baseNanExp0Cases, "pow_baseNanExp0Cases",
+    pow_baseNanExp0Cases, "pow_baseNanExp0Cases",
     "Checks for pow(NAN, +/-0)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestNan4 = {
-    (SDLTest_TestCaseFp)pow_nanArgsCases, "pow_nanArgsCases",
+    pow_nanArgsCases, "pow_nanArgsCases",
     "Checks for pow(x, y) with either x or y being NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestZero1 = {
-    (SDLTest_TestCaseFp)pow_baseNZeroExpOddCases, "pow_baseNZeroExpOddCases",
+    pow_baseNZeroExpOddCases, "pow_baseNZeroExpOddCases",
     "Checks for pow(-0.0, y), with y an odd integer.", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestZero2 = {
-    (SDLTest_TestCaseFp)pow_basePZeroExpOddCases, "pow_basePZeroExpOddCases",
+    pow_basePZeroExpOddCases, "pow_basePZeroExpOddCases",
     "Checks for pow(0.0, y), with y an odd integer.", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestZero3 = {
-    (SDLTest_TestCaseFp)pow_baseNZeroCases, "pow_baseNZeroCases",
+    pow_baseNZeroCases, "pow_baseNZeroCases",
     "Checks for pow(-0.0, y), with y finite and even or non-integer number", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestZero4 = {
-    (SDLTest_TestCaseFp)pow_basePZeroCases, "pow_basePZeroCases",
+    pow_basePZeroCases, "pow_basePZeroCases",
     "Checks for pow(0.0, y), with y finite and even or non-integer number", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestRegular = {
-    (SDLTest_TestCaseFp)pow_regularCases, "pow_regularCases",
+    pow_regularCases, "pow_regularCases",
     "Checks a set of regular values", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestPowOf2 = {
-    (SDLTest_TestCaseFp)pow_powerOfTwo, "pow_powerOfTwo",
+    pow_powerOfTwo, "pow_powerOfTwo",
     "Checks the powers of two from 1 to 8", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference powTestRange = {
-    (SDLTest_TestCaseFp)pow_rangeTest, "pow_rangeTest",
+    pow_rangeTest, "pow_rangeTest",
     "Checks a range of positive integer to the power of 0", TEST_ENABLED
 };
 
 /* SDL_sqrt test cases */
 
 static const SDLTest_TestCaseReference sqrtTestInf = {
-    (SDLTest_TestCaseFp)sqrt_infCase, "sqrt_infCase",
+    sqrt_infCase, "sqrt_infCase",
     "Checks positive infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sqrtTestNan = {
-    (SDLTest_TestCaseFp)sqrt_nanCase, "sqrt_nanCase",
+    sqrt_nanCase, "sqrt_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sqrtTestDomain = {
-    (SDLTest_TestCaseFp)sqrt_outOfDomainCases, "sqrt_outOfDomainCases",
+    sqrt_outOfDomainCases, "sqrt_outOfDomainCases",
     "Checks for values out of the domain", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sqrtTestBase = {
-    (SDLTest_TestCaseFp)sqrt_baseCases, "sqrt_baseCases",
+    sqrt_baseCases, "sqrt_baseCases",
     "Checks the base cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sqrtTestRegular = {
-    (SDLTest_TestCaseFp)sqrt_regularCases, "sqrt_regularCases",
+    sqrt_regularCases, "sqrt_regularCases",
     "Checks a set of regular values", TEST_ENABLED
 };
 
 /* SDL_scalbn test cases */
 
 static const SDLTest_TestCaseReference scalbnTestInf = {
-    (SDLTest_TestCaseFp)scalbn_infCases, "scalbn_infCases",
+    scalbn_infCases, "scalbn_infCases",
     "Checks positive and negative infinity arg", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference scalbnTestBaseZero = {
-    (SDLTest_TestCaseFp)scalbn_baseZeroCases, "scalbn_baseZeroCases",
+    scalbn_baseZeroCases, "scalbn_baseZeroCases",
     "Checks for positive and negative zero arg", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference scalbnTestExpZero = {
-    (SDLTest_TestCaseFp)scalbn_expZeroCase, "scalbn_expZeroCase",
+    scalbn_expZeroCase, "scalbn_expZeroCase",
     "Checks for zero exp", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference scalbnTestNan = {
-    (SDLTest_TestCaseFp)scalbn_nanCase, "scalbn_nanCase",
+    scalbn_nanCase, "scalbn_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference scalbnTestRegular = {
-    (SDLTest_TestCaseFp)scalbn_regularCases, "scalbn_regularCases",
+    scalbn_regularCases, "scalbn_regularCases",
     "Checks a set of regular cases", TEST_ENABLED
 };
 
 /* SDL_cos test cases */
 
 static const SDLTest_TestCaseReference cosTestInf = {
-    (SDLTest_TestCaseFp)cos_infCases, "cos_infCases",
+    cos_infCases, "cos_infCases",
     "Checks for positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference cosTestNan = {
-    (SDLTest_TestCaseFp)cos_nanCase, "cos_nanCase",
+    cos_nanCase, "cos_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference cosTestRegular = {
-    (SDLTest_TestCaseFp)cos_regularCases, "cos_regularCases",
+    cos_regularCases, "cos_regularCases",
     "Checks a set of regular cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference cosTestPrecision = {
-    (SDLTest_TestCaseFp)cos_precisionTest, "cos_precisionTest",
+    cos_precisionTest, "cos_precisionTest",
     "Checks cosine precision", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference cosTestRange = {
-    (SDLTest_TestCaseFp)cos_rangeTest, "cos_rangeTest",
+    cos_rangeTest, "cos_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_sin test cases */
 
 static const SDLTest_TestCaseReference sinTestInf = {
-    (SDLTest_TestCaseFp)sin_infCases, "sin_infCases",
+    sin_infCases, "sin_infCases",
     "Checks for positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sinTestNan = {
-    (SDLTest_TestCaseFp)sin_nanCase, "sin_nanCase",
+    sin_nanCase, "sin_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sinTestRegular = {
-    (SDLTest_TestCaseFp)sin_regularCases, "sin_regularCases",
+    sin_regularCases, "sin_regularCases",
     "Checks a set of regular cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sinTestPrecision = {
-    (SDLTest_TestCaseFp)sin_precisionTest, "sin_precisionTest",
+    sin_precisionTest, "sin_precisionTest",
     "Checks sine precision", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference sinTestRange = {
-    (SDLTest_TestCaseFp)sin_rangeTest, "sin_rangeTest",
+    sin_rangeTest, "sin_rangeTest",
     "Checks a range of positive integer", TEST_ENABLED
 };
 
 /* SDL_tan test cases */
 
 static const SDLTest_TestCaseReference tanTestInf = {
-    (SDLTest_TestCaseFp)tan_infCases, "tan_infCases",
+    tan_infCases, "tan_infCases",
     "Checks for positive and negative infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference tanTestNan = {
-    (SDLTest_TestCaseFp)tan_nanCase, "tan_nanCase",
+    tan_nanCase, "tan_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference tanTestZero = {
-    (SDLTest_TestCaseFp)tan_zeroCases, "tan_zeroCases",
+    tan_zeroCases, "tan_zeroCases",
     "Checks a set of regular cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference tanTestPrecision = {
-    (SDLTest_TestCaseFp)tan_precisionTest, "tan_precisionTest",
+    tan_precisionTest, "tan_precisionTest",
     "Checks tangent precision", TEST_ENABLED
 };
 
 /* SDL_acos test cases */
 
 static const SDLTest_TestCaseReference acosTestLimit = {
-    (SDLTest_TestCaseFp)acos_limitCases, "acos_limitCases",
+    acos_limitCases, "acos_limitCases",
     "Checks the edge of the domain (+/-1)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference acosTestOutOfDomain = {
-    (SDLTest_TestCaseFp)acos_outOfDomainCases, "acos_outOfDomainCases",
+    acos_outOfDomainCases, "acos_outOfDomainCases",
     "Checks values outside the domain", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference acosTestNan = {
-    (SDLTest_TestCaseFp)acos_nanCase, "acos_nanCase",
+    acos_nanCase, "acos_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference acosTestPrecision = {
-    (SDLTest_TestCaseFp)acos_precisionTest, "acos_precisionTest",
+    acos_precisionTest, "acos_precisionTest",
     "Checks acos precision", TEST_ENABLED
 };
 
 /* SDL_asin test cases */
 
 static const SDLTest_TestCaseReference asinTestLimit = {
-    (SDLTest_TestCaseFp)asin_limitCases, "asin_limitCases",
+    asin_limitCases, "asin_limitCases",
     "Checks the edge of the domain (+/-1)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference asinTestOutOfDomain = {
-    (SDLTest_TestCaseFp)asin_outOfDomainCases, "asin_outOfDomainCases",
+    asin_outOfDomainCases, "asin_outOfDomainCases",
     "Checks values outside the domain", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference asinTestNan = {
-    (SDLTest_TestCaseFp)asin_nanCase, "asin_nanCase",
+    asin_nanCase, "asin_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference asinTestPrecision = {
-    (SDLTest_TestCaseFp)asin_precisionTest, "asin_precisionTest",
+    asin_precisionTest, "asin_precisionTest",
     "Checks asin precision", TEST_ENABLED
 };
 
 /* SDL_atan test cases */
 
 static const SDLTest_TestCaseReference atanTestLimit = {
-    (SDLTest_TestCaseFp)atan_limitCases, "atan_limitCases",
+    atan_limitCases, "atan_limitCases",
     "Checks the edge of the domain (+/-Infinity)", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atanTestZero = {
-    (SDLTest_TestCaseFp)atan_zeroCases, "atan_zeroCases",
+    atan_zeroCases, "atan_zeroCases",
     "Checks for positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atanTestNan = {
-    (SDLTest_TestCaseFp)atan_nanCase, "atan_nanCase",
+    atan_nanCase, "atan_nanCase",
     "Checks NAN", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atanTestPrecision = {
-    (SDLTest_TestCaseFp)atan_precisionTest, "atan_precisionTest",
+    atan_precisionTest, "atan_precisionTest",
     "Checks atan precision", TEST_ENABLED
 };
 
 /* SDL_atan2 test cases */
 
 static const SDLTest_TestCaseReference atan2TestZero1 = {
-    (SDLTest_TestCaseFp)atan2_bothZeroCases, "atan2_bothZeroCases",
+    atan2_bothZeroCases, "atan2_bothZeroCases",
     "Checks for both arguments being zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestZero2 = {
-    (SDLTest_TestCaseFp)atan2_yZeroCases, "atan2_yZeroCases",
+    atan2_yZeroCases, "atan2_yZeroCases",
     "Checks for y=0", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestZero3 = {
-    (SDLTest_TestCaseFp)atan2_xZeroCases, "atan2_xZeroCases",
+    atan2_xZeroCases, "atan2_xZeroCases",
     "Checks for x=0", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestInf1 = {
-    (SDLTest_TestCaseFp)atan2_bothInfCases, "atan2_bothInfCases",
+    atan2_bothInfCases, "atan2_bothInfCases",
     "Checks for both arguments being infinity", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestInf2 = {
-    (SDLTest_TestCaseFp)atan2_yInfCases, "atan2_yInfCases",
+    atan2_yInfCases, "atan2_yInfCases",
     "Checks for y=0", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestInf3 = {
-    (SDLTest_TestCaseFp)atan2_xInfCases, "atan2_xInfCases",
+    atan2_xInfCases, "atan2_xInfCases",
     "Checks for x=0", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestNan = {
-    (SDLTest_TestCaseFp)atan2_nanCases, "atan2_nanCases",
+    atan2_nanCases, "atan2_nanCases",
     "Checks NANs", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestQuadrantTopRight = {
-    (SDLTest_TestCaseFp)atan2_topRightQuadrantTest, "atan2_topRightQuadrantTest",
+    atan2_topRightQuadrantTest, "atan2_topRightQuadrantTest",
     "Checks values in the top right quadrant", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestQuadrantTopLeft = {
-    (SDLTest_TestCaseFp)atan2_topLeftQuadrantTest, "atan2_topLeftQuadrantTest",
+    atan2_topLeftQuadrantTest, "atan2_topLeftQuadrantTest",
     "Checks values in the top left quadrant", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestQuadrantBottomRight = {
-    (SDLTest_TestCaseFp)atan2_bottomRightQuadrantTest, "atan2_bottomRightQuadrantTest",
+    atan2_bottomRightQuadrantTest, "atan2_bottomRightQuadrantTest",
     "Checks values in the bottom right quadrant", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference atan2TestQuadrantBottomLeft = {
-    (SDLTest_TestCaseFp)atan2_bottomLeftQuadrantTest, "atan2_bottomLeftQuadrantTest",
+    atan2_bottomLeftQuadrantTest, "atan2_bottomLeftQuadrantTest",
     "Checks values in the bottom left quadrant", TEST_ENABLED
 };
 

test/testautomation_mouse.c

@@ -612,51 +612,51 @@ static int mouse_getGlobalMouseState(void *arg)
 
 /* Mouse test cases */
 static const SDLTest_TestCaseReference mouseTestGetMouseState = {
-    (SDLTest_TestCaseFp)mouse_getMouseState, "mouse_getMouseState", "Check call to SDL_GetMouseState", TEST_ENABLED
+    mouse_getMouseState, "mouse_getMouseState", "Check call to SDL_GetMouseState", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestGetRelativeMouseState = {
-    (SDLTest_TestCaseFp)mouse_getRelativeMouseState, "mouse_getRelativeMouseState", "Check call to SDL_GetRelativeMouseState", TEST_ENABLED
+    mouse_getRelativeMouseState, "mouse_getRelativeMouseState", "Check call to SDL_GetRelativeMouseState", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestCreateFreeCursor = {
-    (SDLTest_TestCaseFp)mouse_createFreeCursor, "mouse_createFreeCursor", "Check call to SDL_CreateCursor and SDL_DestroyCursor", TEST_ENABLED
+    mouse_createFreeCursor, "mouse_createFreeCursor", "Check call to SDL_CreateCursor and SDL_DestroyCursor", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestShowCursor = {
-    (SDLTest_TestCaseFp)mouse_showCursor, "mouse_showCursor", "Check call to SDL_ShowCursor", TEST_ENABLED
+    mouse_showCursor, "mouse_showCursor", "Check call to SDL_ShowCursor", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestSetCursor = {
-    (SDLTest_TestCaseFp)mouse_setCursor, "mouse_setCursor", "Check call to SDL_SetCursor", TEST_ENABLED
+    mouse_setCursor, "mouse_setCursor", "Check call to SDL_SetCursor", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestGetCursor = {
-    (SDLTest_TestCaseFp)mouse_getCursor, "mouse_getCursor", "Check call to SDL_GetCursor", TEST_ENABLED
+    mouse_getCursor, "mouse_getCursor", "Check call to SDL_GetCursor", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestWarpMouseInWindow = {
-    (SDLTest_TestCaseFp)mouse_warpMouseInWindow, "mouse_warpMouseInWindow", "Check call to SDL_WarpMouseInWindow", TEST_ENABLED
+    mouse_warpMouseInWindow, "mouse_warpMouseInWindow", "Check call to SDL_WarpMouseInWindow", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestGetMouseFocus = {
-    (SDLTest_TestCaseFp)mouse_getMouseFocus, "mouse_getMouseFocus", "Check call to SDL_GetMouseFocus", TEST_ENABLED
+    mouse_getMouseFocus, "mouse_getMouseFocus", "Check call to SDL_GetMouseFocus", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestCreateFreeColorCursor = {
-    (SDLTest_TestCaseFp)mouse_createFreeColorCursor, "mouse_createFreeColorCursor", "Check call to SDL_CreateColorCursor and SDL_DestroyCursor", TEST_ENABLED
+    mouse_createFreeColorCursor, "mouse_createFreeColorCursor", "Check call to SDL_CreateColorCursor and SDL_DestroyCursor", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestGetSetRelativeMouseMode = {
-    (SDLTest_TestCaseFp)mouse_getSetRelativeMouseMode, "mouse_getSetRelativeMouseMode", "Check call to SDL_GetWindowRelativeMouseMode and SDL_SetWindowRelativeMouseMode", TEST_ENABLED
+    mouse_getSetRelativeMouseMode, "mouse_getSetRelativeMouseMode", "Check call to SDL_GetWindowRelativeMouseMode and SDL_SetWindowRelativeMouseMode", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestGetDefaultCursor = {
-    (SDLTest_TestCaseFp)mouse_getDefaultCursor, "mouse_getDefaultCursor", "Check call to SDL_GetDefaultCursor", TEST_ENABLED
+    mouse_getDefaultCursor, "mouse_getDefaultCursor", "Check call to SDL_GetDefaultCursor", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference mouseTestGetGlobalMouseState = {
-    (SDLTest_TestCaseFp)mouse_getGlobalMouseState, "mouse_getGlobalMouseState", "Check call to SDL_GetGlobalMouseState", TEST_ENABLED
+    mouse_getGlobalMouseState, "mouse_getGlobalMouseState", "Check call to SDL_GetGlobalMouseState", TEST_ENABLED
 };
 
 /* Sequence of Mouse test cases */

test/testautomation_pixels.c

@@ -500,15 +500,15 @@ static int pixels_allocFreePalette(void *arg)
 
 /* Pixels test cases */
 static const SDLTest_TestCaseReference pixelsTest1 = {
-    (SDLTest_TestCaseFp)pixels_getPixelFormatDetails, "pixels_allocFreeFormat", "Call to SDL_GetPixelFormatDetails", TEST_ENABLED
+    pixels_getPixelFormatDetails, "pixels_allocFreeFormat", "Call to SDL_GetPixelFormatDetails", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference pixelsTest2 = {
-    (SDLTest_TestCaseFp)pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_CreatePalette and SDL_DestroyPalette", TEST_ENABLED
+    pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_CreatePalette and SDL_DestroyPalette", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference pixelsTest3 = {
-    (SDLTest_TestCaseFp)pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED
+    pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED
 };
 
 /* Sequence of Pixels test cases */

test/testautomation_platform.c

@@ -494,43 +494,43 @@ static int platform_testGetPowerInfo(void *arg)
 
 /* Platform test cases */
 static const SDLTest_TestCaseReference platformTest1 = {
-    (SDLTest_TestCaseFp)platform_testTypes, "platform_testTypes", "Tests predefined types", TEST_ENABLED
+    platform_testTypes, "platform_testTypes", "Tests predefined types", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest2 = {
-    (SDLTest_TestCaseFp)platform_testEndianessAndSwap, "platform_testEndianessAndSwap", "Tests endianness and swap functions", TEST_ENABLED
+    platform_testEndianessAndSwap, "platform_testEndianessAndSwap", "Tests endianness and swap functions", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest3 = {
-    (SDLTest_TestCaseFp)platform_testGetFunctions, "platform_testGetFunctions", "Tests various SDL_GetXYZ functions", TEST_ENABLED
+    platform_testGetFunctions, "platform_testGetFunctions", "Tests various SDL_GetXYZ functions", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest4 = {
-    (SDLTest_TestCaseFp)platform_testHasFunctions, "platform_testHasFunctions", "Tests various SDL_HasXYZ functions", TEST_ENABLED
+    platform_testHasFunctions, "platform_testHasFunctions", "Tests various SDL_HasXYZ functions", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest5 = {
-    (SDLTest_TestCaseFp)platform_testGetVersion, "platform_testGetVersion", "Tests SDL_GetVersion function", TEST_ENABLED
+    platform_testGetVersion, "platform_testGetVersion", "Tests SDL_GetVersion function", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest6 = {
-    (SDLTest_TestCaseFp)platform_testDefaultInit, "platform_testDefaultInit", "Tests default SDL_Init", TEST_ENABLED
+    platform_testDefaultInit, "platform_testDefaultInit", "Tests default SDL_Init", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest7 = {
-    (SDLTest_TestCaseFp)platform_testGetSetClearError, "platform_testGetSetClearError", "Tests SDL_Get/Set/ClearError", TEST_ENABLED
+    platform_testGetSetClearError, "platform_testGetSetClearError", "Tests SDL_Get/Set/ClearError", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest8 = {
-    (SDLTest_TestCaseFp)platform_testSetErrorEmptyInput, "platform_testSetErrorEmptyInput", "Tests SDL_SetError with empty input", TEST_ENABLED
+    platform_testSetErrorEmptyInput, "platform_testSetErrorEmptyInput", "Tests SDL_SetError with empty input", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest9 = {
-    (SDLTest_TestCaseFp)platform_testSetErrorInvalidInput, "platform_testSetErrorInvalidInput", "Tests SDL_SetError with invalid input", TEST_ENABLED
+    platform_testSetErrorInvalidInput, "platform_testSetErrorInvalidInput", "Tests SDL_SetError with invalid input", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference platformTest10 = {
-    (SDLTest_TestCaseFp)platform_testGetPowerInfo, "platform_testGetPowerInfo", "Tests SDL_GetPowerInfo function", TEST_ENABLED
+    platform_testGetPowerInfo, "platform_testGetPowerInfo", "Tests SDL_GetPowerInfo function", TEST_ENABLED
 };
 
 /* Sequence of Platform test cases */

test/testautomation_properties.c

@@ -386,19 +386,19 @@ static int properties_testLocking(void *arg)
 
 /* Properties test cases */
 static const SDLTest_TestCaseReference propertiesTestBasic = {
-    (SDLTest_TestCaseFp)properties_testBasic, "properties_testBasic", "Test basic property functionality", TEST_ENABLED
+    properties_testBasic, "properties_testBasic", "Test basic property functionality", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference propertiesTestCopy = {
-    (SDLTest_TestCaseFp)properties_testCopy, "properties_testCopy", "Test property copy functionality", TEST_ENABLED
+    properties_testCopy, "properties_testCopy", "Test property copy functionality", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference propertiesTestCleanup = {
-    (SDLTest_TestCaseFp)properties_testCleanup, "properties_testCleanup", "Test property cleanup functionality", TEST_ENABLED
+    properties_testCleanup, "properties_testCleanup", "Test property cleanup functionality", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference propertiesTestLocking = {
-    (SDLTest_TestCaseFp)properties_testLocking, "properties_testLocking", "Test property locking functionality", TEST_ENABLED
+    properties_testLocking, "properties_testLocking", "Test property locking functionality", TEST_ENABLED
 };
 
 /* Sequence of Properties test cases */

test/testautomation_rect.c

@@ -1936,154 +1936,154 @@ static int rect_testFRectEqualsParam(void *arg)
 
 /* SDL_GetRectAndLineIntersectionFloat */
 static const SDLTest_TestCaseReference rectTestIntersectRectAndLineFloat = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectAndLineFloat, "rect_testIntersectRectAndLineFloat", "Tests SDL_GetRectAndLineIntersectionFloat", TEST_ENABLED
+    rect_testIntersectRectAndLineFloat, "rect_testIntersectRectAndLineFloat", "Tests SDL_GetRectAndLineIntersectionFloat", TEST_ENABLED
 };
 
 /* SDL_GetRectAndLineIntersection */
 static const SDLTest_TestCaseReference rectTestIntersectRectAndLine = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectAndLine, "rect_testIntersectRectAndLine", "Tests SDL_GetRectAndLineIntersection clipping cases", TEST_ENABLED
+    rect_testIntersectRectAndLine, "rect_testIntersectRectAndLine", "Tests SDL_GetRectAndLineIntersection clipping cases", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectAndLineInside = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectAndLineInside, "rect_testIntersectRectAndLineInside", "Tests SDL_GetRectAndLineIntersection with line fully contained in rect", TEST_ENABLED
+    rect_testIntersectRectAndLineInside, "rect_testIntersectRectAndLineInside", "Tests SDL_GetRectAndLineIntersection with line fully contained in rect", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectAndLineOutside = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectAndLineOutside, "rect_testIntersectRectAndLineOutside", "Tests SDL_GetRectAndLineIntersection with line fully outside of rect", TEST_ENABLED
+    rect_testIntersectRectAndLineOutside, "rect_testIntersectRectAndLineOutside", "Tests SDL_GetRectAndLineIntersection with line fully outside of rect", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectAndLineEmpty = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectAndLineEmpty, "rect_testIntersectRectAndLineEmpty", "Tests SDL_GetRectAndLineIntersection with empty rectangle ", TEST_ENABLED
+    rect_testIntersectRectAndLineEmpty, "rect_testIntersectRectAndLineEmpty", "Tests SDL_GetRectAndLineIntersection with empty rectangle ", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectAndLineParam = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectAndLineParam, "rect_testIntersectRectAndLineParam", "Negative tests against SDL_GetRectAndLineIntersection with invalid parameters", TEST_ENABLED
+    rect_testIntersectRectAndLineParam, "rect_testIntersectRectAndLineParam", "Negative tests against SDL_GetRectAndLineIntersection with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_GetRectIntersectionFloat */
 static const SDLTest_TestCaseReference rectTestIntersectRectFloat = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectFloat, "rect_testIntersectRectFloat", "Tests SDL_GetRectIntersectionFloat", TEST_ENABLED
+    rect_testIntersectRectFloat, "rect_testIntersectRectFloat", "Tests SDL_GetRectIntersectionFloat", TEST_ENABLED
 };
 
 /* SDL_GetRectIntersection */
 static const SDLTest_TestCaseReference rectTestIntersectRectInside = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectInside, "rect_testIntersectRectInside", "Tests SDL_GetRectIntersection with B fully contained in A", TEST_ENABLED
+    rect_testIntersectRectInside, "rect_testIntersectRectInside", "Tests SDL_GetRectIntersection with B fully contained in A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectOutside = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectOutside, "rect_testIntersectRectOutside", "Tests SDL_GetRectIntersection with B fully outside of A", TEST_ENABLED
+    rect_testIntersectRectOutside, "rect_testIntersectRectOutside", "Tests SDL_GetRectIntersection with B fully outside of A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectPartial = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectPartial, "rect_testIntersectRectPartial", "Tests SDL_GetRectIntersection with B partially intersecting A", TEST_ENABLED
+    rect_testIntersectRectPartial, "rect_testIntersectRectPartial", "Tests SDL_GetRectIntersection with B partially intersecting A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectPoint = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectPoint, "rect_testIntersectRectPoint", "Tests SDL_GetRectIntersection with 1x1 sized rectangles", TEST_ENABLED
+    rect_testIntersectRectPoint, "rect_testIntersectRectPoint", "Tests SDL_GetRectIntersection with 1x1 sized rectangles", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectEmpty = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectEmpty, "rect_testIntersectRectEmpty", "Tests SDL_GetRectIntersection with empty rectangles", TEST_ENABLED
+    rect_testIntersectRectEmpty, "rect_testIntersectRectEmpty", "Tests SDL_GetRectIntersection with empty rectangles", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestIntersectRectParam = {
-    (SDLTest_TestCaseFp)rect_testIntersectRectParam, "rect_testIntersectRectParam", "Negative tests against SDL_GetRectIntersection with invalid parameters", TEST_ENABLED
+    rect_testIntersectRectParam, "rect_testIntersectRectParam", "Negative tests against SDL_GetRectIntersection with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_HasRectIntersection */
 static const SDLTest_TestCaseReference rectTestHasIntersectionInside = {
-    (SDLTest_TestCaseFp)rect_testHasIntersectionInside, "rect_testHasIntersectionInside", "Tests SDL_HasRectIntersection with B fully contained in A", TEST_ENABLED
+    rect_testHasIntersectionInside, "rect_testHasIntersectionInside", "Tests SDL_HasRectIntersection with B fully contained in A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestHasIntersectionOutside = {
-    (SDLTest_TestCaseFp)rect_testHasIntersectionOutside, "rect_testHasIntersectionOutside", "Tests SDL_HasRectIntersection with B fully outside of A", TEST_ENABLED
+    rect_testHasIntersectionOutside, "rect_testHasIntersectionOutside", "Tests SDL_HasRectIntersection with B fully outside of A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestHasIntersectionPartial = {
-    (SDLTest_TestCaseFp)rect_testHasIntersectionPartial, "rect_testHasIntersectionPartial", "Tests SDL_HasRectIntersection with B partially intersecting A", TEST_ENABLED
+    rect_testHasIntersectionPartial, "rect_testHasIntersectionPartial", "Tests SDL_HasRectIntersection with B partially intersecting A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestHasIntersectionPoint = {
-    (SDLTest_TestCaseFp)rect_testHasIntersectionPoint, "rect_testHasIntersectionPoint", "Tests SDL_HasRectIntersection with 1x1 sized rectangles", TEST_ENABLED
+    rect_testHasIntersectionPoint, "rect_testHasIntersectionPoint", "Tests SDL_HasRectIntersection with 1x1 sized rectangles", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestHasIntersectionEmpty = {
-    (SDLTest_TestCaseFp)rect_testHasIntersectionEmpty, "rect_testHasIntersectionEmpty", "Tests SDL_HasRectIntersection with empty rectangles", TEST_ENABLED
+    rect_testHasIntersectionEmpty, "rect_testHasIntersectionEmpty", "Tests SDL_HasRectIntersection with empty rectangles", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestHasIntersectionParam = {
-    (SDLTest_TestCaseFp)rect_testHasIntersectionParam, "rect_testHasIntersectionParam", "Negative tests against SDL_HasRectIntersection with invalid parameters", TEST_ENABLED
+    rect_testHasIntersectionParam, "rect_testHasIntersectionParam", "Negative tests against SDL_HasRectIntersection with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_GetRectEnclosingPointsFloat */
 static const SDLTest_TestCaseReference rectTestEnclosePointsFloat = {
-    (SDLTest_TestCaseFp)rect_testEnclosePointsFloat, "rect_testEnclosePointsFloat", "Tests SDL_GetRectEnclosingPointsFloat", TEST_ENABLED
+    rect_testEnclosePointsFloat, "rect_testEnclosePointsFloat", "Tests SDL_GetRectEnclosingPointsFloat", TEST_ENABLED
 };
 
 /* SDL_GetRectEnclosingPoints */
 static const SDLTest_TestCaseReference rectTestEnclosePoints = {
-    (SDLTest_TestCaseFp)rect_testEnclosePoints, "rect_testEnclosePoints", "Tests SDL_GetRectEnclosingPoints without clipping", TEST_ENABLED
+    rect_testEnclosePoints, "rect_testEnclosePoints", "Tests SDL_GetRectEnclosingPoints without clipping", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestEnclosePointsWithClipping = {
-    (SDLTest_TestCaseFp)rect_testEnclosePointsWithClipping, "rect_testEnclosePointsWithClipping", "Tests SDL_GetRectEnclosingPoints with clipping", TEST_ENABLED
+    rect_testEnclosePointsWithClipping, "rect_testEnclosePointsWithClipping", "Tests SDL_GetRectEnclosingPoints with clipping", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestEnclosePointsRepeatedInput = {
-    (SDLTest_TestCaseFp)rect_testEnclosePointsRepeatedInput, "rect_testEnclosePointsRepeatedInput", "Tests SDL_GetRectEnclosingPoints with repeated input", TEST_ENABLED
+    rect_testEnclosePointsRepeatedInput, "rect_testEnclosePointsRepeatedInput", "Tests SDL_GetRectEnclosingPoints with repeated input", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestEnclosePointsParam = {
-    (SDLTest_TestCaseFp)rect_testEnclosePointsParam, "rect_testEnclosePointsParam", "Negative tests against SDL_GetRectEnclosingPoints with invalid parameters", TEST_ENABLED
+    rect_testEnclosePointsParam, "rect_testEnclosePointsParam", "Negative tests against SDL_GetRectEnclosingPoints with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_GetRectUnion */
 static const SDLTest_TestCaseReference rectTestUnionRectInside = {
-    (SDLTest_TestCaseFp)rect_testUnionRectInside, "rect_testUnionRectInside", "Tests SDL_GetRectUnion where rect B is inside rect A", TEST_ENABLED
+    rect_testUnionRectInside, "rect_testUnionRectInside", "Tests SDL_GetRectUnion where rect B is inside rect A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestUnionRectOutside = {
-    (SDLTest_TestCaseFp)rect_testUnionRectOutside, "rect_testUnionRectOutside", "Tests SDL_GetRectUnion where rect B is outside rect A", TEST_ENABLED
+    rect_testUnionRectOutside, "rect_testUnionRectOutside", "Tests SDL_GetRectUnion where rect B is outside rect A", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestUnionRectEmpty = {
-    (SDLTest_TestCaseFp)rect_testUnionRectEmpty, "rect_testUnionRectEmpty", "Tests SDL_GetRectUnion where rect A or rect B are empty", TEST_ENABLED
+    rect_testUnionRectEmpty, "rect_testUnionRectEmpty", "Tests SDL_GetRectUnion where rect A or rect B are empty", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestUnionRectParam = {
-    (SDLTest_TestCaseFp)rect_testUnionRectParam, "rect_testUnionRectParam", "Negative tests against SDL_GetRectUnion with invalid parameters", TEST_ENABLED
+    rect_testUnionRectParam, "rect_testUnionRectParam", "Negative tests against SDL_GetRectUnion with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_RectEmptyFloat */
 static const SDLTest_TestCaseReference rectTestRectEmptyFloat = {
-    (SDLTest_TestCaseFp)rect_testRectEmptyFloat, "rect_testRectEmptyFloat", "Tests SDL_RectEmptyFloat with various inputs", TEST_ENABLED
+    rect_testRectEmptyFloat, "rect_testRectEmptyFloat", "Tests SDL_RectEmptyFloat with various inputs", TEST_ENABLED
 };
 
 /* SDL_RectEmpty */
 static const SDLTest_TestCaseReference rectTestRectEmpty = {
-    (SDLTest_TestCaseFp)rect_testRectEmpty, "rect_testRectEmpty", "Tests SDL_RectEmpty with various inputs", TEST_ENABLED
+    rect_testRectEmpty, "rect_testRectEmpty", "Tests SDL_RectEmpty with various inputs", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestRectEmptyParam = {
-    (SDLTest_TestCaseFp)rect_testRectEmptyParam, "rect_testRectEmptyParam", "Negative tests against SDL_RectEmpty with invalid parameters", TEST_ENABLED
+    rect_testRectEmptyParam, "rect_testRectEmptyParam", "Negative tests against SDL_RectEmpty with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_RectsEqual */
 static const SDLTest_TestCaseReference rectTestRectEquals = {
-    (SDLTest_TestCaseFp)rect_testRectEquals, "rect_testRectEquals", "Tests SDL_RectsEqual with various inputs", TEST_ENABLED
+    rect_testRectEquals, "rect_testRectEquals", "Tests SDL_RectsEqual with various inputs", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestRectEqualsParam = {
-    (SDLTest_TestCaseFp)rect_testRectEqualsParam, "rect_testRectEqualsParam", "Negative tests against SDL_RectsEqual with invalid parameters", TEST_ENABLED
+    rect_testRectEqualsParam, "rect_testRectEqualsParam", "Negative tests against SDL_RectsEqual with invalid parameters", TEST_ENABLED
 };
 
 /* SDL_RectsEqualFloat */
 static const SDLTest_TestCaseReference rectTestFRectEquals = {
-    (SDLTest_TestCaseFp)rect_testFRectEquals, "rect_testFRectEquals", "Tests SDL_RectsEqualFloat with various inputs", TEST_ENABLED
+    rect_testFRectEquals, "rect_testFRectEquals", "Tests SDL_RectsEqualFloat with various inputs", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference rectTestFRectEqualsParam = {
-    (SDLTest_TestCaseFp)rect_testFRectEqualsParam, "rect_testFRectEqualsParam", "Negative tests against SDL_RectsEqualFloat with invalid parameters", TEST_ENABLED
+    rect_testFRectEqualsParam, "rect_testFRectEqualsParam", "Negative tests against SDL_RectsEqualFloat with invalid parameters", TEST_ENABLED
 };
 
 /**

test/testautomation_render.c

@@ -1538,51 +1538,51 @@ static int render_testUVWrapping(void *arg)
 
 /* Render test cases */
 static const SDLTest_TestCaseReference renderTestGetNumRenderDrivers = {
-    (SDLTest_TestCaseFp)render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED
+    render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestPrimitives = {
-    (SDLTest_TestCaseFp)render_testPrimitives, "render_testPrimitives", "Tests rendering primitives", TEST_ENABLED
+    render_testPrimitives, "render_testPrimitives", "Tests rendering primitives", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestPrimitivesWithViewport = {
-    (SDLTest_TestCaseFp)render_testPrimitivesWithViewport, "render_testPrimitivesWithViewport", "Tests rendering primitives within a viewport", TEST_ENABLED
+    render_testPrimitivesWithViewport, "render_testPrimitivesWithViewport", "Tests rendering primitives within a viewport", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestBlit = {
-    (SDLTest_TestCaseFp)render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED
+    render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestBlitTiled = {
-    (SDLTest_TestCaseFp)render_testBlitTiled, "render_testBlitTiled", "Tests tiled blitting", TEST_ENABLED
+    render_testBlitTiled, "render_testBlitTiled", "Tests tiled blitting", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestBlit9Grid = {
-    (SDLTest_TestCaseFp)render_testBlit9Grid, "render_testBlit9Grid", "Tests 9-grid blitting", TEST_ENABLED
+    render_testBlit9Grid, "render_testBlit9Grid", "Tests 9-grid blitting", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestBlitColor = {
-    (SDLTest_TestCaseFp)render_testBlitColor, "render_testBlitColor", "Tests blitting with color", TEST_ENABLED
+    render_testBlitColor, "render_testBlitColor", "Tests blitting with color", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestBlendModes = {
-    (SDLTest_TestCaseFp)render_testBlendModes, "render_testBlendModes", "Tests rendering blend modes", TEST_ENABLED
+    render_testBlendModes, "render_testBlendModes", "Tests rendering blend modes", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestViewport = {
-    (SDLTest_TestCaseFp)render_testViewport, "render_testViewport", "Tests viewport", TEST_ENABLED
+    render_testViewport, "render_testViewport", "Tests viewport", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestClipRect = {
-    (SDLTest_TestCaseFp)render_testClipRect, "render_testClipRect", "Tests clip rect", TEST_ENABLED
+    render_testClipRect, "render_testClipRect", "Tests clip rect", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestLogicalSize = {
-    (SDLTest_TestCaseFp)render_testLogicalSize, "render_testLogicalSize", "Tests logical size", TEST_ENABLED
+    render_testLogicalSize, "render_testLogicalSize", "Tests logical size", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference renderTestUVWrapping = {
-    (SDLTest_TestCaseFp)render_testUVWrapping, "render_testUVWrapping", "Tests geometry UV wrapping", TEST_ENABLED
+    render_testUVWrapping, "render_testUVWrapping", "Tests geometry UV wrapping", TEST_ENABLED
 };
 
 /* Sequence of Render test cases */

test/testautomation_sdltest.c

@@ -1226,63 +1226,63 @@ static int sdltest_randomAsciiStringOfSize(void *arg)
 
 /* SDL_test test cases */
 static const SDLTest_TestCaseReference sdltestTest1 = {
-    (SDLTest_TestCaseFp)sdltest_getFuzzerInvocationCount, "sdltest_getFuzzerInvocationCount", "Call to sdltest_GetFuzzerInvocationCount", TEST_ENABLED
+    sdltest_getFuzzerInvocationCount, "sdltest_getFuzzerInvocationCount", "Call to sdltest_GetFuzzerInvocationCount", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest2 = {
-    (SDLTest_TestCaseFp)sdltest_randomNumber, "sdltest_randomNumber", "Calls to random number generators", TEST_ENABLED
+    sdltest_randomNumber, "sdltest_randomNumber", "Calls to random number generators", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest3 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint8, "sdltest_randomBoundaryNumberUint8", "Calls to random boundary number generators for Uint8", TEST_ENABLED
+    sdltest_randomBoundaryNumberUint8, "sdltest_randomBoundaryNumberUint8", "Calls to random boundary number generators for Uint8", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest4 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint16, "sdltest_randomBoundaryNumberUint16", "Calls to random boundary number generators for Uint16", TEST_ENABLED
+    sdltest_randomBoundaryNumberUint16, "sdltest_randomBoundaryNumberUint16", "Calls to random boundary number generators for Uint16", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest5 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint32, "sdltest_randomBoundaryNumberUint32", "Calls to random boundary number generators for Uint32", TEST_ENABLED
+    sdltest_randomBoundaryNumberUint32, "sdltest_randomBoundaryNumberUint32", "Calls to random boundary number generators for Uint32", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest6 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberUint64, "sdltest_randomBoundaryNumberUint64", "Calls to random boundary number generators for Uint64", TEST_ENABLED
+    sdltest_randomBoundaryNumberUint64, "sdltest_randomBoundaryNumberUint64", "Calls to random boundary number generators for Uint64", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest7 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint8, "sdltest_randomBoundaryNumberSint8", "Calls to random boundary number generators for Sint8", TEST_ENABLED
+    sdltest_randomBoundaryNumberSint8, "sdltest_randomBoundaryNumberSint8", "Calls to random boundary number generators for Sint8", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest8 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint16, "sdltest_randomBoundaryNumberSint16", "Calls to random boundary number generators for Sint16", TEST_ENABLED
+    sdltest_randomBoundaryNumberSint16, "sdltest_randomBoundaryNumberSint16", "Calls to random boundary number generators for Sint16", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest9 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint32, "sdltest_randomBoundaryNumberSint32", "Calls to random boundary number generators for Sint32", TEST_ENABLED
+    sdltest_randomBoundaryNumberSint32, "sdltest_randomBoundaryNumberSint32", "Calls to random boundary number generators for Sint32", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest10 = {
-    (SDLTest_TestCaseFp)sdltest_randomBoundaryNumberSint64, "sdltest_randomBoundaryNumberSint64", "Calls to random boundary number generators for Sint64", TEST_ENABLED
+    sdltest_randomBoundaryNumberSint64, "sdltest_randomBoundaryNumberSint64", "Calls to random boundary number generators for Sint64", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest11 = {
-    (SDLTest_TestCaseFp)sdltest_randomIntegerInRange, "sdltest_randomIntegerInRange", "Calls to ranged random number generator", TEST_ENABLED
+    sdltest_randomIntegerInRange, "sdltest_randomIntegerInRange", "Calls to ranged random number generator", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest12 = {
-    (SDLTest_TestCaseFp)sdltest_randomAsciiString, "sdltest_randomAsciiString", "Calls to default ASCII string generator", TEST_ENABLED
+    sdltest_randomAsciiString, "sdltest_randomAsciiString", "Calls to default ASCII string generator", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest13 = {
-    (SDLTest_TestCaseFp)sdltest_randomAsciiStringWithMaximumLength, "sdltest_randomAsciiStringWithMaximumLength", "Calls to random maximum length ASCII string generator", TEST_ENABLED
+    sdltest_randomAsciiStringWithMaximumLength, "sdltest_randomAsciiStringWithMaximumLength", "Calls to random maximum length ASCII string generator", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest14 = {
-    (SDLTest_TestCaseFp)sdltest_randomAsciiStringOfSize, "sdltest_randomAsciiStringOfSize", "Calls to fixed size ASCII string generator", TEST_ENABLED
+    sdltest_randomAsciiStringOfSize, "sdltest_randomAsciiStringOfSize", "Calls to fixed size ASCII string generator", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference sdltestTest15 = {
-    (SDLTest_TestCaseFp)sdltest_generateRunSeed, "sdltest_generateRunSeed", "Checks internal harness function SDLTest_GenerateRunSeed", TEST_ENABLED
+    sdltest_generateRunSeed, "sdltest_generateRunSeed", "Checks internal harness function SDLTest_GenerateRunSeed", TEST_ENABLED
 };
 
 /* Sequence of SDL_test test cases */

test/testautomation_surface.c

@@ -1462,67 +1462,67 @@ static int surface_testPremultiplyAlpha(void *arg)
 
 /* Surface test cases */
 static const SDLTest_TestCaseReference surfaceTestSaveLoadBitmap = {
-    (SDLTest_TestCaseFp)surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED
+    surface_testSaveLoadBitmap, "surface_testSaveLoadBitmap", "Tests sprite saving and loading.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlit = {
-    (SDLTest_TestCaseFp)surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED
+    surface_testBlit, "surface_testBlit", "Tests basic blitting.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitTiled = {
-    (SDLTest_TestCaseFp)surface_testBlitTiled, "surface_testBlitTiled", "Tests tiled blitting.", TEST_ENABLED
+    surface_testBlitTiled, "surface_testBlitTiled", "Tests tiled blitting.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlit9Grid = {
-    (SDLTest_TestCaseFp)surface_testBlit9Grid, "surface_testBlit9Grid", "Tests 9-grid blitting.", TEST_ENABLED
+    surface_testBlit9Grid, "surface_testBlit9Grid", "Tests 9-grid blitting.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitMultiple = {
-    (SDLTest_TestCaseFp)surface_testBlitMultiple, "surface_testBlitMultiple", "Tests blitting between multiple surfaces of the same format.", TEST_ENABLED
+    surface_testBlitMultiple, "surface_testBlitMultiple", "Tests blitting between multiple surfaces of the same format.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestLoadFailure = {
-    (SDLTest_TestCaseFp)surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED
+    surface_testLoadFailure, "surface_testLoadFailure", "Tests sprite loading. A failure case.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestSurfaceConversion = {
-    (SDLTest_TestCaseFp)surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED
+    surface_testSurfaceConversion, "surface_testSurfaceConversion", "Tests surface conversion.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestCompleteSurfaceConversion = {
-    (SDLTest_TestCaseFp)surface_testCompleteSurfaceConversion, "surface_testCompleteSurfaceConversion", "Tests surface conversion across all pixel formats", TEST_ENABLED
+    surface_testCompleteSurfaceConversion, "surface_testCompleteSurfaceConversion", "Tests surface conversion across all pixel formats", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitColorMod = {
-    (SDLTest_TestCaseFp)surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED
+    surface_testBlitColorMod, "surface_testBlitColorMod", "Tests some blitting routines with color mod.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitAlphaMod = {
-    (SDLTest_TestCaseFp)surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED
+    surface_testBlitAlphaMod, "surface_testBlitAlphaMod", "Tests some blitting routines with alpha mod.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitBlendBlend = {
-    (SDLTest_TestCaseFp)surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_ENABLED
+    surface_testBlitBlendBlend, "surface_testBlitBlendBlend", "Tests blitting routines with blend blending mode.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitBlendPremultiplied = {
-    (SDLTest_TestCaseFp)surface_testBlitBlendPremultiplied, "surface_testBlitBlendPremultiplied", "Tests blitting routines with premultiplied blending mode.", TEST_ENABLED
+    surface_testBlitBlendPremultiplied, "surface_testBlitBlendPremultiplied", "Tests blitting routines with premultiplied blending mode.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitBlendAdd = {
-    (SDLTest_TestCaseFp)surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_ENABLED
+    surface_testBlitBlendAdd, "surface_testBlitBlendAdd", "Tests blitting routines with add blending mode.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitBlendAddPremultiplied = {
-    (SDLTest_TestCaseFp)surface_testBlitBlendAddPremultiplied, "surface_testBlitBlendAddPremultiplied", "Tests blitting routines with premultiplied add blending mode.", TEST_ENABLED
+    surface_testBlitBlendAddPremultiplied, "surface_testBlitBlendAddPremultiplied", "Tests blitting routines with premultiplied add blending mode.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitBlendMod = {
-    (SDLTest_TestCaseFp)surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED
+    surface_testBlitBlendMod, "surface_testBlitBlendMod", "Tests blitting routines with mod blending mode.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestBlitBlendMul = {
-    (SDLTest_TestCaseFp)surface_testBlitBlendMul, "surface_testBlitBlendMul", "Tests blitting routines with mul blending mode.", TEST_ENABLED
+    surface_testBlitBlendMul, "surface_testBlitBlendMul", "Tests blitting routines with mul blending mode.", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference surfaceTestOverflow = {

test/testautomation_time.c

@@ -196,15 +196,15 @@ static int time_dateTimeUtilities(void *arg)
 
 /* Time test cases */
 static const SDLTest_TestCaseReference timeTest1 = {
-    (SDLTest_TestCaseFp)time_getRealtimeClock, "time_getRealtimeClock", "Call to SDL_GetRealtimeClockTicks", TEST_ENABLED
+    time_getRealtimeClock, "time_getRealtimeClock", "Call to SDL_GetRealtimeClockTicks", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference timeTest2 = {
-    (SDLTest_TestCaseFp)time_dateTimeConversion, "time_dateTimeConversion", "Call to SDL_TimeToDateTime/SDL_DateTimeToTime", TEST_ENABLED
+    time_dateTimeConversion, "time_dateTimeConversion", "Call to SDL_TimeToDateTime/SDL_DateTimeToTime", TEST_ENABLED
 };
 
 static const SDLTest_TestCaseReference timeTest3 = {
-    (SDLTest_TestCaseFp)time_dateTimeUtilities, "time_dateTimeUtilities", "Call to SDL_TimeToDateTime/SDL_DateTimeToTime", TEST_ENABLED
+    time_dateTimeUtilities, "time_dateTimeUtilities", "Call to SDL_TimeToDateTime/SDL_DateTimeToTime", TEST_ENABLED
 };
 
 /* Sequence of Timer test cases */