gh-102837: Increase test coverage for the math module

Modules/mathmodule.c

@@ -1024,7 +1024,7 @@ math_1a(PyObject *arg, double (*func) (double))
    The last rule is used to catch overflow on platforms which follow
    C89 but for which HUGE_VAL is not an infinity.
 
-   For most two-argument functions (copysign, fmod, hypot, atan2)
+   For most two-argument functions (copysign, remainder, atan2)
    these rules are enough to ensure that Python's functions behave as
    specified in 'Annex F' of the C99 standard, with the 'invalid' and
    'divide-by-zero' floating-point exceptions mapping to Python's
@@ -2196,10 +2196,12 @@ math_modf_impl(PyObject *module, double x)
     double y;
     /* some platforms don't do the right thing for NaNs and
        infinities, so we take care of special cases directly. */
-    if (isinf(x))
-        return Py_BuildValue("(dd)", copysign(0., x), x);
-    else if (isnan(x))
-        return Py_BuildValue("(dd)", x, x);
+    if (!isfinite(x)) {
+        if (isinf(x))
+            return Py_BuildValue("(dd)", copysign(0., x), x);
+        else
+            return Py_BuildValue("(dd)", x, x);
+    }
 
     errno = 0;
     x = modf(x, &y);
@@ -2232,14 +2234,14 @@ loghelper(PyObject* arg, double (*func)(double))
         }
 
         x = PyLong_AsDouble(arg);
-        if (x == -1.0 && PyErr_Occurred()) {
+        if (x == -1.0) {
             if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                 return NULL;
             /* Here the conversion to double overflowed, but it's possible
                to compute the log anyway.  Clear the exception and continue. */
             PyErr_Clear();
             x = _PyLong_Frexp((PyLongObject *)arg, &e);
-            if (x == -1.0 && PyErr_Occurred())
+            if (x == -1.0)
                 return NULL;
             /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
             result = func(x) + func(2.0) * e;
@@ -3019,7 +3021,8 @@ math_pow_impl(PyObject *module, double x, double y)
                (A) (+/-0.)**negative (-> divide-by-zero)
                (B) overflow of x**y with x and y finite
             */
-            else if (isinf(r)) {
+            else {
+                assert(isinf(r));
                 if (x == 0.)
                     errno = EDOM;
                 else