diff --git a/test/testautomation_math.c b/test/testautomation_math.c
index 1843ef09b..4d9a6b1e3 100644
--- a/test/testautomation_math.c
+++ b/test/testautomation_math.c
@@ -151,6 +151,128 @@ floor_rangeTest(void *args)
     return TEST_COMPLETED;
 }
 
+/* SDL_ceil tests functions */
+
+/**
+ * \brief Checks edge cases (0 and infinity) for themselves.
+ */
+static int
+ceil_edgeCases(void *args)
+{
+    double result;
+
+    result = SDL_ceil(INFINITY);
+    SDLTest_AssertCheck(INFINITY == result, "Ceil(%f), expected %f, got %f",
+                        INFINITY, INFINITY, result);
+    result = SDL_ceil(-INFINITY);
+    SDLTest_AssertCheck(-INFINITY == result, "Ceil(%f), expected %f, got %f",
+                        -INFINITY, -INFINITY, result);
+
+    result = SDL_ceil(0.0);
+    SDLTest_AssertCheck(0.0 == result, "Ceil(%.1f), expected %.1f, got %.1f",
+                        0.0, 0.0, result);
+    result = SDL_ceil(-0.0);
+    SDLTest_AssertCheck(-0.0 == result, "Ceil(%.1f), expected %.1f, got %.1f",
+                        -0.0, -0.0, result);
+
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks the NaN case.
+ */
+static int
+ceil_nanCase(void *args)
+{
+    SDLTest_AssertCheck(isnan(SDL_ceil(NAN)), "Ceil(nan), expected nan");
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks round values (x.0) for themselves
+ */
+static int
+ceil_roundNumbersCases(void *args)
+{
+    Uint32 i;
+    const double round_cases[] = {
+        1.0,
+        -1.0,
+        15.0,
+        -15.0,
+        125.0,
+        -125.0,
+        1024.0,
+        -1024.0
+    };
+    for (i = 0; i < SDL_arraysize(round_cases); i++) {
+        const double result = SDL_ceil(round_cases[i]);
+        SDLTest_AssertCheck(result == round_cases[i],
+                            "Ceil(%.1f), expected %.1f, got %.1f", round_cases[i],
+                            round_cases[i], result);
+    }
+    return TEST_COMPLETED;
+}
+
+/**
+ * \brief Checks a set of fractions
+ */
+static int
+ceil_fractionCases(void *args)
+{
+    Uint32 i;
+    const d_to_d frac_cases[] = {
+        { 1.0 / 2.0, 1.0 },
+        { -1.0 / 2.0, -0.0 },
+        { 4.0 / 3.0, 2.0 },
+        { -4.0 / 3.0, -1.0 },
+        { 76.0 / 7.0, 11.0 },
+        { -76.0 / 7.0, -10.0 },
+        { 535.0 / 8.0, 67.0 },
+        { -535.0 / 8.0, -66.0 },
+        { 19357.0 / 53.0, 366.0 },
+        { -19357.0 / 53.0, -365.0 }
+    };
+    for (i = 0; i < SDL_arraysize(frac_cases); i++) {
+        const double result = SDL_ceil(frac_cases[i].input);
+        SDLTest_AssertCheck(result == frac_cases[i].expected,
+                            "Ceil(%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
+ */
+static int
+ceil_rangeTest(void *args)
+{
+    const Uint32 ITERATIONS = 10000000;
+    const Uint32 STEP = SDL_MAX_UINT32 / ITERATIONS;
+    Uint32 i;
+    double test_value = 0.0;
+
+    SDLTest_AssertPass("Ceil: 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;
+        }
+
+        result = SDL_ceil(test_value);
+        if (result != test_value) { /* Only log failures to save performances */
+            SDLTest_AssertPass("Ceil(%.1f), expected %.1f, got %.1f", test_value,
+                               test_value, result);
+            return TEST_ABORTED;
+        }
+    }
+    return TEST_COMPLETED;
+}
+
 /* ================= Test References ================== */
 
 /* SDL_floor test cases */
@@ -176,8 +298,33 @@ static const SDLTest_TestCaseReference floorTest5 = {
     "Check a range of positive integer", TEST_ENABLED
 };
 
+/* SDL_ceil test cases */
+
+static const SDLTest_TestCaseReference ceilTest1 = {
+    (SDLTest_TestCaseFp) ceil_edgeCases, "ceil_edgeCases",
+    "Check positive and negative infinity and 0", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference ceilTest2 = {
+    (SDLTest_TestCaseFp) ceil_nanCase, "ceil_nanCase",
+    "Check the NaN special case", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference ceilTest3 = {
+    (SDLTest_TestCaseFp) ceil_roundNumbersCases, "ceil_roundNumberCases",
+    "Check a set of round numbers", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference ceilTest4 = {
+    (SDLTest_TestCaseFp) ceil_fractionCases, "ceil_fractionCases",
+    "Check a set of fractions", TEST_ENABLED
+};
+static const SDLTest_TestCaseReference ceilTest5 = {
+    (SDLTest_TestCaseFp) ceil_rangeTest, "ceil_rangeTest",
+    "Check a range of positive integer", TEST_ENABLED
+};
+
 static const SDLTest_TestCaseReference *mathTests[] = {
-    &floorTest1, &floorTest2, &floorTest3, &floorTest4, &floorTest5, NULL
+    &floorTest1, &floorTest2, &floorTest3, &floorTest4, &floorTest5,
+    &ceilTest1, &ceilTest2, &ceilTest3, &ceilTest4, &ceilTest5,
+    NULL
 };
 
 SDLTest_TestSuiteReference mathTestSuite = { "Math", NULL, mathTests, NULL };