SDL: Test: Add Fmod tests to math suite.

From 75b9aab6c1bfbf378e9b82a32b044d74ca7f5049 Mon Sep 17 00:00:00 2001
From: Pierre Wendling <[EMAIL REDACTED]>
Date: Wed, 11 May 2022 22:04:28 -0400
Subject: [PATCH] Test: Add Fmod tests to math suite.

---
 test/testautomation_math.c | 226 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 225 insertions(+), 1 deletion(-)

diff --git a/test/testautomation_math.c b/test/testautomation_math.c
index 44d21ce434d..b0d65d842a1 100644
--- a/test/testautomation_math.c
+++ b/test/testautomation_math.c
@@ -673,6 +673,195 @@ copysign_rangeTest(void *args)
     return TEST_COMPLETED;
 }
 
+/* SDL_fmod tests functions */
+
+/**
+ * \brief Checks division of positive and negative inifnity.
+ */
+static int
+fmod_divOfInfCases(void *args)
+{
+    double result;
+
+    result = SDL_fmod(INFINITY, -1.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(%f,%.1f), expected %f, got %f",
+                        INFINITY, -1.0, NAN, result);
+
+    result = SDL_fmod(INFINITY, 1.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(%f,%.1f), expected %f, got %f",
+                        INFINITY, 1.0, NAN, result);
+
+    result = SDL_fmod(-INFINITY, -1.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(%f,%.1f), expected %f, got %f",
+                        -INFINITY, -1.0, NAN, result);
+
+    result = SDL_fmod(-INFINITY, 1.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(%f,%.1f), expected %f, got %f",
+                        -INFINITY, 1.0, NAN, result);
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks division by positive and negative inifnity.
+ */
+static int
+fmod_divByInfCases(void *args)
+{
+    double result;
+
+    result = SDL_fmod(1.0, INFINITY);
+    SDLTest_AssertCheck(1.0 == result,
+                        "Fmod(%.1f,%f), expected %f, got %f",
+                        1.0, INFINITY, 1.0, result);
+
+    result = SDL_fmod(-1.0, INFINITY);
+    SDLTest_AssertCheck(-1.0 == result,
+                        "Fmod(%.1f,%f), expected %f, got %f",
+                        -1.0, INFINITY, -1.0, result);
+
+    result = SDL_fmod(1.0, -INFINITY);
+    SDLTest_AssertCheck(1.0 == result,
+                        "Fmod(%.1f,%f), expected %f, got %f",
+                        1.0, -INFINITY, 1.0, result);
+
+    result = SDL_fmod(-1.0, -INFINITY);
+    SDLTest_AssertCheck(-1.0 == result,
+                        "Fmod(%.1f,%f), expected %f, got %f",
+                        -1.0, -INFINITY, -1.0, result);
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks division of positive and negative zero.
+ */
+static int
+fmod_divOfZeroCases(void *args)
+{
+    const dd_to_d zero_cases[] = {
+        { 0.0, 1.0, 0.0 },
+        { 0.0, -1.0, 0.0 },
+        { -0.0, 1.0, -0.0 },
+        { -0.0, -1.0, -0.0 }
+    };
+    return helper_ddtod("Fmod", SDL_fmod, zero_cases, SDL_arraysize(zero_cases));
+}
+
+/**
+ * \brief Checks division by positive and negative zero.
+ */
+static int
+fmod_divByZeroCases(void *args)
+{
+    double result;
+
+    result = SDL_fmod(1.0, 0.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(1.0,0.0), expected nan, got %f",
+                        result);
+
+    result = SDL_fmod(-1.0, 0.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(-1.0,0.0), expected nan, got %f",
+                        result);
+
+    result = SDL_fmod(1.0, -0.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(1.0,-0.0), expected nan, got %f",
+                        result);
+
+    result = SDL_fmod(-1.0, -0.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(-1.0,-0.0), expected nan, got %f",
+                        result);
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks the NaN cases.
+ */
+static int
+fmod_nanCases(void *args)
+{
+    double result;
+
+    result = SDL_fmod(NAN, 1.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(nan,1.0), expected nan, got %f",
+                        result);
+
+    result = SDL_fmod(NAN, -1.0);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(nan,-1.0), expected nan, got %f",
+                        result);
+
+    result = SDL_fmod(1.0, NAN);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(1.0,nan), expected nan, got %f",
+                        result);
+
+    result = SDL_fmod(-1.0, NAN);
+    SDLTest_AssertCheck(isnan(result),
+                        "Fmod(-1.0,nan), expected nan, got %f",
+                        result);
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks a set of regular values.
+ */
+static int
+fmod_regularCases(void *args)
+{
+    const dd_to_d regular_cases[] = {
+        { 3.5, 2.0, 1.5 },
+        { -6.25, 3.0, -0.25 },
+        { 7.5, 2.5, 0.0 },
+        { 2.0 / 3.0, -1.0 / 3.0, 0.0 }
+    };
+    return helper_ddtod("Fmod", SDL_fmod, regular_cases, SDL_arraysize(regular_cases));
+}
+
+/**
+ * \brief Checks a range of values between 0 and UINT32_MAX
+ */
+static int
+fmod_rangeTest(void *args)
+{
+    const Uint32 ITERATIONS = 10000000;
+    const Uint32 STEP = SDL_MAX_UINT32 / ITERATIONS;
+    Uint32 i;
+    double test_value = 0.0;
+
+    SDLTest_AssertPass("Fabs: Testing a range of %u values with %u steps",
+                       ITERATIONS, STEP);
+
+    for (i = 0; i < ITERATIONS; i++, test_value += STEP) {
+        double result;
+        /* These are tested elsewhere */
+        if (isnan(test_value) || isinf(test_value)) {
+            continue;
+        }
+
+        /* Only log failures to save performances */
+        result = SDL_fmod(test_value, 1.0);
+        if (0.0 != result) {
+            SDLTest_AssertPass("Fmod(%.1f,%.1f), expected %.1f, got %.1f",
+                               test_value, 1.0,
+                               0.0, result);
+            return TEST_ABORTED;
+        }
+    }
+    return TEST_COMPLETED;
+}
+
 /* ================= Test References ================== */
 
 /* SDL_floor test cases */
@@ -813,7 +1002,7 @@ static const SDLTest_TestCaseReference copysignTestZero = {
     "Check positive and negative zero", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference copysignTestNan = {
-    (SDLTest_TestCaseFp) copysign_nanCases, "copysign_nanCase",
+    (SDLTest_TestCaseFp) copysign_nanCases, "copysign_nanCases",
     "Check the NaN special cases", TEST_ENABLED
 };
 static const SDLTest_TestCaseReference copysignTestRange = {
@@ -821,6 +1010,37 @@ static const SDLTest_TestCaseReference copysignTestRange = {
     "Check a range of positive integer", TEST_ENABLED
 };
 
+/* SDL_fmod test cases */
+
+static const SDLTest_TestCaseReference fmodTestDivOfInf = {
+    (SDLTest_TestCaseFp) fmod_divOfInfCases, "fmod_divOfInfCases",
+    "Check division of positive and negative infinity", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference fmodTestDivByInf = {
+    (SDLTest_TestCaseFp) fmod_divByInfCases, "fmod_divByInfCases",
+    "Check division by positive and negative infinity", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference fmodTestDivOfZero = {
+    (SDLTest_TestCaseFp) fmod_divOfZeroCases, "fmod_divOfZeroCases",
+    "Check division of positive and negative zero", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference fmodTestDivByZero = {
+    (SDLTest_TestCaseFp) fmod_divByZeroCases, "fmod_divByZeroCases",
+    "Check division by positive and negative zero", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference fmodTestNan = {
+    (SDLTest_TestCaseFp) fmod_nanCases, "fmod_nanCases",
+    "Check the NaN special cases", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference fmodTestRegular = {
+    (SDLTest_TestCaseFp) fmod_regularCases, "fmod_regularCases",
+    "Check a set of regular values", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference fmodTestRange = {
+    (SDLTest_TestCaseFp) fmod_rangeTest, "fmod_rangeTest",
+    "Check a range of positive integer", TEST_ENABLED
+};
+
 static const SDLTest_TestCaseReference *mathTests[] = {
     &floorTestInf, &floorTestZero, &floorTestNan,
     &floorTestRound, &floorTestFraction, &floorTestRange,
@@ -837,6 +1057,10 @@ static const SDLTest_TestCaseReference *mathTests[] = {
     &fabsTestInf, &fabsTestZero, &fabsTestNan, &fabsTestRange,
 
     &copysignTestInf, &copysignTestZero, &copysignTestNan, &copysignTestRange,
+
+    &fmodTestDivOfInf, &fmodTestDivByInf, &fmodTestDivOfZero, &fmodTestDivByZero,
+    &fmodTestNan, &fmodTestRegular, &fmodTestRange,
+
     NULL
 };