mirrors/SDL
0
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2024-11-23 10:53:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

testautomation: remove SDLTest_TestCaseFp casts

Browse Source
This commit is contained in:
Anonymous Maarten 2024-09-04 23:54:56 +02:00
parent abd2ac5992
commit ff1e252413
20 changed files with 274 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
test/testautomation_blit.c
View File

@ -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[] = {

6
test/testautomation_clipboard.c
View File

@ -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 */

4
test/testautomation_guid.c
View File

@ -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 */

4
test/testautomation_hints.c
View File

@ -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 */

20
test/testautomation_intrinsics.c
View File

@ -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 */

18
test/testautomation_iostream.c
View File

@ -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 */

2
test/testautomation_joystick.c
View File

@ -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 */

26
test/testautomation_keyboard.c
View File

@ -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 */

2
test/testautomation_log.c
View File

@ -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 */

8
test/testautomation_main.c
View File

@ -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 */

232
test/testautomation_math.c
View File

@ -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
};

24
test/testautomation_mouse.c
View File

@ -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 */

6
test/testautomation_pixels.c
View File

@ -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 */

20
test/testautomation_platform.c
View File

@ -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 */

8
test/testautomation_properties.c
View File

@ -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 */

70
test/testautomation_rect.c
View File

@ -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
};
/**

24
test/testautomation_render.c
View File

@ -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 */

30
test/testautomation_sdltest.c
View File

@ -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 */

32
test/testautomation_surface.c
View File

@ -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 = {

6
test/testautomation_time.c
View File

@ -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 */