encounter
/
SDL
mirror of https://github.com/encounter/SDL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Test: Refactored and formatted math test suite.

This commit is contained in:
Pierre Wendling 2022-05-06 13:39:44 -04:00 committed by Sam Lantinga
parent 0f630e9177
commit 9eb09d2392
1 changed files with 129 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
test/testautomation_math.c
View File

@ -7,6 +7,26 @@
#include "SDL.h" #include "SDL.h"
#include "SDL_test.h" #include "SDL_test.h"
/* ================= Test Structs ================== */
/**
* Stores a single input and the expected result
*/
typedef struct
{
double input;
double expected;
} d_to_d;
/**
* Stores a pair of inputs and the expected result
*/
typedef struct
{
double x_input, y_input;
double expected;
} dd_to_d;
/* ================= Test Case Implementation ================== */ /* ================= Test Case Implementation ================== */
/* SDL_floor tests functions */ /* SDL_floor tests functions */
@ -14,96 +34,121 @@
/** /**
* \brief Checks edge cases (0 and infinity) for themselves. * \brief Checks edge cases (0 and infinity) for themselves.
*/ */
static int floor_edgeCases(void* args) { static int
double result; floor_edgeCases(void *args)
{
double result;
result = SDL_floor(INFINITY); result = SDL_floor(INFINITY);
SDLTest_AssertCheck(INFINITY == result, "Floor(%f), expected %f, got %f", SDLTest_AssertCheck(INFINITY == result, "Floor(%f), expected %f, got %f",
INFINITY, INFINITY, result); INFINITY, INFINITY, result);
result = SDL_floor(-INFINITY); result = SDL_floor(-INFINITY);
SDLTest_AssertCheck(-INFINITY == result, "Floor(%f), expected %f, got %f", SDLTest_AssertCheck(-INFINITY == result, "Floor(%f), expected %f, got %f",
-INFINITY, -INFINITY, result); -INFINITY, -INFINITY, result);
result = SDL_floor(0.0); result = SDL_floor(0.0);
SDLTest_AssertCheck(0.0 == result, "Floor(%.1f), expected %.1f, got %.1f", SDLTest_AssertCheck(0.0 == result, "Floor(%.1f), expected %.1f, got %.1f",
0.0, 0.0, result); 0.0, 0.0, result);
result = SDL_floor(-0.0); result = SDL_floor(-0.0);
SDLTest_AssertCheck(-0.0 == result, "Floor(%.1f), expected %.1f, got %.1f", SDLTest_AssertCheck(-0.0 == result, "Floor(%.1f), expected %.1f, got %.1f",
-0.0, -0.0, result); -0.0, -0.0, result);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
/** /**
* \brief Checks the NaN case. * \brief Checks the NaN case.
*/ */
static int floor_nanCase(void* args) { static int
SDLTest_AssertCheck(isnan(SDL_floor(NAN)), "Floor(nan), expected nan"); floor_nanCase(void *args)
return TEST_COMPLETED; {
SDLTest_AssertCheck(isnan(SDL_floor(NAN)), "Floor(nan), expected nan");
return TEST_COMPLETED;
} }
/** /**
* \brief Checks round values (x.0) for themselves * \brief Checks round values (x.0) for themselves
*/ */
static int floor_roundNumbersCases(void* args) { static int
Uint32 i; floor_roundNumbersCases(void *args)
const double round_cases[] = {1.0, -1.0, 15.0, -15.0, {
125.0, -125.0, 1024.0, -1024.0}; Uint32 i;
for (i = 0; i < SDL_arraysize(round_cases); i++) { const double round_cases[] = {
const double result = SDL_floor(round_cases[i]); 1.0,
SDLTest_AssertCheck(result == round_cases[i], -1.0,
"Floor(%.1f), expected %.1f, got %.1f", round_cases[i], 15.0,
round_cases[i], result); -15.0,
} 125.0,
return TEST_COMPLETED; -125.0,
1024.0,
-1024.0
};
for (i = 0; i < SDL_arraysize(round_cases); i++) {
const double result = SDL_floor(round_cases[i]);
SDLTest_AssertCheck(result == round_cases[i],
"Floor(%.1f), expected %.1f, got %.1f", round_cases[i],
round_cases[i], result);
}
return TEST_COMPLETED;
} }
/** /**
* \brief Checks a set of fractions * \brief Checks a set of fractions
*/ */
static int floor_fractionCases(void* args) { static int
Uint32 i; floor_fractionCases(void *args)
const struct { {
double input, expected; Uint32 i;
} frac_cases[] = {{1.0 / 2.0, 0.0}, {-1.0 / 2.0, -1.0}, const d_to_d frac_cases[] = {
{4.0 / 3.0, 1.0}, {-4.0 / 3.0, -2.0}, { 1.0 / 2.0, 0.0 },
{76.0 / 7.0, 10.0}, {-76.0 / 7.0, -11.0}, { -1.0 / 2.0, -1.0 },
{535.0 / 8.0, 66.0}, {-535.0 / 8.0, -67.0}, { 4.0 / 3.0, 1.0 },
{19357.0 / 53.0, 365.0}, {-19357.0 / 53.0, -366.0}}; { -4.0 / 3.0, -2.0 },
for (i = 0; i < SDL_arraysize(frac_cases); i++) { { 76.0 / 7.0, 10.0 },
const double result = SDL_floor(frac_cases[i].input); { -76.0 / 7.0, -11.0 },
SDLTest_AssertCheck(result == frac_cases[i].expected, { 535.0 / 8.0, 66.0 },
"Floor(%f), expected %.1f, got %f", frac_cases[i].input, { -535.0 / 8.0, -67.0 },
frac_cases[i].expected, result); { 19357.0 / 53.0, 365.0 },
} { -19357.0 / 53.0, -366.0 }
return TEST_COMPLETED; };
for (i = 0; i < SDL_arraysize(frac_cases); i++) {
const double result = SDL_floor(frac_cases[i].input);
SDLTest_AssertCheck(result == frac_cases[i].expected,
"Floor(%f), expected %.1f, got %f", frac_cases[i].input,
frac_cases[i].expected, result);
}
return TEST_COMPLETED;
} }
/** /**
* \brief Checks a range of values between 0 and UINT32_MAX * \brief Checks a range of values between 0 and UINT32_MAX
*/ */
static int floor_rangeTest(void* args) { static int
const Uint32 ITERATIONS = 10000000; floor_rangeTest(void *args)
const Uint32 STEP = SDL_MAX_UINT32 / ITERATIONS; {
Uint32 i; const Uint32 ITERATIONS = 10000000;
double test_value = 0.0; const Uint32 STEP = SDL_MAX_UINT32 / ITERATIONS;
SDLTest_AssertPass("Floor: Testing a range of %u values with %u steps", Uint32 i;
ITERATIONS, STEP); double test_value = 0.0;
for (i = 0; i < ITERATIONS; i++, test_value += STEP) {
double result;
/* These are tested elsewhere */
if (isnan(test_value) || isinf(test_value)) {
continue;
}
result = SDL_floor(test_value); SDLTest_AssertPass("Floor: Testing a range of %u values with %u steps",
if (result != test_value) { /* Only log failures to save performances */ ITERATIONS, STEP);
SDLTest_AssertPass("Floor(%.1f), expected %.1f, got %.1f", test_value,
test_value, result); for (i = 0; i < ITERATIONS; i++, test_value += STEP) {
return TEST_ABORTED; double result;
/* These are tested elsewhere */
if (isnan(test_value) || isinf(test_value)) {
continue;
}
result = SDL_floor(test_value);
if (result != test_value) { /* Only log failures to save performances */
SDLTest_AssertPass("Floor(%.1f), expected %.1f, got %.1f", test_value,
test_value, result);
return TEST_ABORTED;
}
} }
} return TEST_COMPLETED;
return TEST_COMPLETED;
} }
/* ================= Test References ================== */ /* ================= Test References ================== */
@ -111,22 +156,28 @@ static int floor_rangeTest(void* args) {
/* SDL_floor test cases */ /* SDL_floor test cases */
static const SDLTest_TestCaseReference floorTest1 = { static const SDLTest_TestCaseReference floorTest1 = {
(SDLTest_TestCaseFp)floor_edgeCases, "floor_edgeCases", (SDLTest_TestCaseFp) floor_edgeCases, "floor_edgeCases",
"Check positive and negative infinity and 0", TEST_ENABLED}; "Check positive and negative infinity and 0", TEST_ENABLED
};
static const SDLTest_TestCaseReference floorTest2 = { static const SDLTest_TestCaseReference floorTest2 = {
(SDLTest_TestCaseFp)floor_nanCase, "floor_nanCase", (SDLTest_TestCaseFp) floor_nanCase, "floor_nanCase",
"Check the NaN special case", TEST_ENABLED}; "Check the NaN special case", TEST_ENABLED
};
static const SDLTest_TestCaseReference floorTest3 = { static const SDLTest_TestCaseReference floorTest3 = {
(SDLTest_TestCaseFp)floor_roundNumbersCases, "floor_roundNumberCases", (SDLTest_TestCaseFp) floor_roundNumbersCases, "floor_roundNumberCases",
"Check a set of round numbers", TEST_ENABLED}; "Check a set of round numbers", TEST_ENABLED
};
static const SDLTest_TestCaseReference floorTest4 = { static const SDLTest_TestCaseReference floorTest4 = {
(SDLTest_TestCaseFp)floor_fractionCases, "floor_fractionCases", (SDLTest_TestCaseFp) floor_fractionCases, "floor_fractionCases",
"Check a set of fractions", TEST_ENABLED}; "Check a set of fractions", TEST_ENABLED
};
static const SDLTest_TestCaseReference floorTest5 = { static const SDLTest_TestCaseReference floorTest5 = {
(SDLTest_TestCaseFp)floor_rangeTest, "floor_rangeTest", (SDLTest_TestCaseFp) floor_rangeTest, "floor_rangeTest",
"Check a range of positive integer", TEST_ENABLED}; "Check a range of positive integer", TEST_ENABLED
};
static const SDLTest_TestCaseReference* mathTests[] = { static const SDLTest_TestCaseReference *mathTests[] = {
&floorTest1, &floorTest2, &floorTest3, &floorTest4, &floorTest5, NULL}; &floorTest1, &floorTest2, &floorTest3, &floorTest4, &floorTest5, NULL
};
SDLTest_TestSuiteReference mathTestSuite = {"Math", NULL, mathTests, NULL}; SDLTest_TestSuiteReference mathTestSuite = { "Math", NULL, mathTests, NULL };