(M_PI_6l, M_E2l, M_E3l, M_2_SQRT_PIl, M_SQRT_PIl): Increase precision.
[kopensolaris-gnu/glibc.git] / math / libm-test.inc
index 3e31b44..f4df889 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Andreas Jaeger <aj@arthur.rhein-neckar.de>, 1997.
 
@@ -77,7 +77,7 @@
    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
    is also tested.  Correct handling of exceptions is checked
    against.  These implemented tests should check all cases that are
-   specified in ISO C 9X.
+   specified in ISO C99.
 
    Exception testing: At the moment only divide-by-zero and invalid
    exceptions are tested.  Overflow/underflow and inexact exceptions
 #include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <argp.h>
 
 /* Possible exceptions */
 #define IGNORE_ZERO_INF_SIGN           0x10
 
 /* Various constants (we must supply them precalculated for accuracy).  */
-#define M_PI_6l                        .52359877559829887308L
-#define M_E2l                  7.389056098930650227230L
-#define M_E3l                  20.08553692318766774093L
-#define M_2_SQRT_PIl           3.5449077018110320545963L       /* 2 sqrt (M_PIl)  */
-#define M_SQRT_PIl             1.77245385090551602729817L      /* sqrt (M_PIl)  */
+#define M_PI_6l                        .52359877559829887307710723054658383L
+#define M_E2l                  7.389056098930650227230427460575008L
+#define M_E3l                  20.085536923187667740928529654581719L
+#define M_2_SQRT_PIl           3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
+#define M_SQRT_PIl             1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
 #define M_LOG_SQRT_PIl         0.572364942924700087072L        /* log(sqrt(M_PIl))  */
 #define M_LOG_2_SQRT_PIl       1.265512123484645396489L        /* log(2*sqrt(M_PIl))  */
 #define M_PI_34l               (M_PIl - M_PI_4l)               /* 3*pi/4 */
@@ -158,6 +159,7 @@ static int noXPasses;       /* number of unexpected passes.  */
 static int verbose;
 static int output_max_error;   /* Should the maximal errors printed?  */
 static int output_points;      /* Should the single function results printed?  */
+static int ignore_max_ulp;     /* Should we ignore max_ulp?  */
 
 static FLOAT minus_zero, plus_zero;
 static FLOAT plus_infty, minus_infty, nan_value;
@@ -187,6 +189,7 @@ init_max_error (void)
   max_error = 0;
   real_max_error = 0;
   imag_max_error = 0;
+  feclearexcept (FE_ALL_EXCEPT);
 }
 
 static void
@@ -204,7 +207,7 @@ print_screen (int ok, int xfail)
 {
   if (output_points
       && (verbose > 1
-         || ((verbose == 1) && (ok == xfail))))
+         || (verbose == 1 && ok == xfail)))
     return 1;
   return 0;
 }
@@ -280,8 +283,8 @@ print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
                   CHOOSE("ldouble", "double", "float",
                          "ildouble", "idouble", "ifloat"), imag_ulp);
        }
-      
-         
+
+
     }
 }
 
@@ -315,7 +318,7 @@ print_max_error (const char *func_name, FLOAT allowed, int xfail)
 {
   int ok = 0;
 
-  if (max_error <= allowed)
+  if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
     {
       ok = 1;
     }
@@ -476,11 +479,8 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
       if (((exceptions & IGNORE_ZERO_INF_SIGN) == 0)
          && (computed == 0.0 && expected == 0.0
              && signbit(computed) != signbit (expected)))
-       {
-         ok = 0;
-         print_ulps (test_name, ulp);
-       }
-      else if (ulp <= max_ulp)
+       ok = 0;
+      else if (ulp == 0.0 || (ulp <= max_ulp && !ignore_max_ulp))
        ok = 1;
       else
        {
@@ -537,7 +537,7 @@ check_complex (const char *test_name, __complex__ FLOAT computed,
   part_exp = __real__ expected;
   part_max_ulp = __real__ max_ulp;
   part_xfail = __real__ xfail;
-  
+
   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
                        exception, &real_max_error);
 
@@ -546,7 +546,7 @@ check_complex (const char *test_name, __complex__ FLOAT computed,
   part_exp = __imag__ expected;
   part_max_ulp = __imag__ max_ulp;
   part_xfail = __imag__ xfail;
-  
+
   /* Don't check again for exceptions, just pass through the
      zero/inf sign test.  */
   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
@@ -694,6 +694,12 @@ matherr (struct exception *x __attribute__ ((unused)))
 static void
 acos_test (void)
 {
+  errno = 0;
+  FUNC(acos) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (acos);
 
   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
@@ -718,6 +724,12 @@ acos_test (void)
 static void
 acosh_test (void)
 {
+  errno = 0;
+  FUNC(acosh) (7);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (acosh);
 
   TEST_f_f (acosh, plus_infty, plus_infty);
@@ -735,6 +747,11 @@ acosh_test (void)
 static void
 asin_test (void)
 {
+  errno = 0;
+  FUNC(asin) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (asin);
 
@@ -760,12 +777,21 @@ asin_test (void)
 static void
 asinh_test (void)
 {
+  errno = 0;
+  FUNC(asinh) (0.7);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (asinh);
 
   TEST_f_f (asinh, 0, 0);
   TEST_f_f (asinh, minus_zero, minus_zero);
+#ifndef TEST_INLINE
   TEST_f_f (asinh, plus_infty, plus_infty);
   TEST_f_f (asinh, minus_infty, minus_infty);
+#endif
+  TEST_f_f (asinh, nan_value, nan_value);
   TEST_f_f (asinh, 0.7, 0.652666566082355786L);
 
   END (asinh);
@@ -774,6 +800,11 @@ asinh_test (void)
 static void
 atan_test (void)
 {
+  errno = 0;
+  FUNC(atan) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (atan);
 
@@ -782,6 +813,7 @@ atan_test (void)
 
   TEST_f_f (atan, plus_infty, M_PI_2l);
   TEST_f_f (atan, minus_infty, -M_PI_2l);
+  TEST_f_f (atan, nan_value, nan_value);
 
   TEST_f_f (atan, 1, M_PI_4l);
   TEST_f_f (atan, -1, -M_PI_4l);
@@ -796,6 +828,11 @@ atan_test (void)
 static void
 atanh_test (void)
 {
+  errno = 0;
+  FUNC(atanh) (0.7);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (atanh);
 
@@ -805,6 +842,7 @@ atanh_test (void)
 
   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
+  TEST_f_f (atanh, nan_value, nan_value);
 
   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
   TEST_f_f (atanh, 1.1, nan_value, INVALID_EXCEPTION);
@@ -818,6 +856,12 @@ atanh_test (void)
 static void
 atan2_test (void)
 {
+  errno = 0;
+  FUNC(atan2) (-0, 1);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (atan2);
 
   /* atan2 (0,x) == 0 for x > 0.  */
@@ -872,6 +916,7 @@ atan2_test (void)
   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
+  TEST_ff_f (atan2, nan_value, nan_value, nan_value);
 
   TEST_ff_f (atan2, 0.7, 1, 0.6107259643892086165L);
   TEST_ff_f (atan2, 0.4, 0.0003, 1.5700463269355215718L);
@@ -883,6 +928,12 @@ atan2_test (void)
 static void
 cabs_test (void)
 {
+  errno = 0;
+  FUNC(cabs) (BUILD_COMPLEX (0.7, 12.4));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cabs);
 
   /* cabs (x + iy) is specified as hypot (x,y) */
@@ -923,6 +974,12 @@ cabs_test (void)
 static void
 cacos_test (void)
 {
+  errno = 0;
+  FUNC(cacos) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cacos);
 
 
@@ -981,6 +1038,12 @@ cacos_test (void)
 static void
 cacosh_test (void)
 {
+  errno = 0;
+  FUNC(cacosh) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cacosh);
 
 
@@ -1096,12 +1159,20 @@ carg_test (void)
 
   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
 
+  TEST_c_f (carg, nan_value, nan_value, nan_value);
+
   END (carg);
 }
 
 static void
 casin_test (void)
 {
+  errno = 0;
+  FUNC(casin) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (casin);
 
   TEST_c_c (casin, 0, 0, 0.0, 0.0);
@@ -1160,6 +1231,12 @@ casin_test (void)
 static void
 casinh_test (void)
 {
+  errno = 0;
+  FUNC(casinh) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (casinh);
 
   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
@@ -1218,6 +1295,12 @@ casinh_test (void)
 static void
 catan_test (void)
 {
+  errno = 0;
+  FUNC(catan) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (catan);
 
   TEST_c_c (catan, 0, 0, 0, 0);
@@ -1280,6 +1363,12 @@ catan_test (void)
 static void
 catanh_test (void)
 {
+  errno = 0;
+  FUNC(catanh) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (catanh);
 
   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
@@ -1340,6 +1429,12 @@ catanh_test (void)
 static void
 cbrt_test (void)
 {
+  errno = 0;
+  FUNC(cbrt) (8);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cbrt);
 
   TEST_f_f (cbrt, 0.0, 0.0);
@@ -1349,10 +1444,10 @@ cbrt_test (void)
   TEST_f_f (cbrt, minus_infty, minus_infty);
   TEST_f_f (cbrt, nan_value, nan_value);
 
-  TEST_f_f (cbrt, -0.001, -0.1);
+  TEST_f_f (cbrt, -0.001, -0.1L);
   TEST_f_f (cbrt, 8, 2);
   TEST_f_f (cbrt, -27.0, -3.0);
-  TEST_f_f (cbrt, 0.970299, 0.99);
+  TEST_f_f (cbrt, 0.970299, 0.99L);
   TEST_f_f (cbrt, 0.7, 0.8879040017426007084L);
 
   END (cbrt);
@@ -1361,6 +1456,11 @@ cbrt_test (void)
 static void
 ccos_test (void)
 {
+  errno = 0;
+  FUNC(ccos) (BUILD_COMPLEX (0, 0));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (ccos);
 
@@ -1425,6 +1525,11 @@ ccos_test (void)
 static void
 ccosh_test (void)
 {
+  errno = 0;
+  FUNC(ccosh) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (ccosh);
 
@@ -1495,6 +1600,7 @@ ceil_test (void)
   TEST_f_f (ceil, minus_zero, minus_zero);
   TEST_f_f (ceil, plus_infty, plus_infty);
   TEST_f_f (ceil, minus_infty, minus_infty);
+  TEST_f_f (ceil, nan_value, nan_value);
 
   TEST_f_f (ceil, M_PIl, 4.0);
   TEST_f_f (ceil, -M_PIl, -3.0);
@@ -1506,6 +1612,12 @@ ceil_test (void)
 static void
 cexp_test (void)
 {
+  errno = 0;
+  FUNC(cexp) (BUILD_COMPLEX (0, 0));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cexp);
 
   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
@@ -1578,6 +1690,12 @@ cimag_test (void)
 static void
 clog_test (void)
 {
+  errno = 0;
+  FUNC(clog) (BUILD_COMPLEX (-2, -3));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (clog);
 
   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
@@ -1637,6 +1755,12 @@ clog_test (void)
 static void
 clog10_test (void)
 {
+  errno = 0;
+  FUNC(clog10) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (clog10);
 
   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
@@ -1741,12 +1865,19 @@ copysign_test (void)
 static void
 cos_test (void)
 {
+  errno = 0;
+  FUNC(cos) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cos);
 
   TEST_f_f (cos, 0, 1);
   TEST_f_f (cos, minus_zero, 1);
   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (cos, nan_value, nan_value);
 
   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
@@ -1760,12 +1891,21 @@ cos_test (void)
 static void
 cosh_test (void)
 {
+  errno = 0;
+  FUNC(cosh) (0.7);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cosh);
   TEST_f_f (cosh, 0, 1);
   TEST_f_f (cosh, minus_zero, 1);
 
+#ifndef TEST_INLINE
   TEST_f_f (cosh, plus_infty, plus_infty);
   TEST_f_f (cosh, minus_infty, plus_infty);
+#endif
+  TEST_f_f (cosh, nan_value, nan_value);
 
   TEST_f_f (cosh, 0.7, 1.255169005630943018L);
   END (cosh);
@@ -1775,6 +1915,12 @@ cosh_test (void)
 static void
 cpow_test (void)
 {
+  errno = 0;
+  FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (cpow);
 
   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
@@ -1783,6 +1929,8 @@ cpow_test (void)
   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
 
+  TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
+
   END (cpow, complex);
 }
 
@@ -1826,6 +1974,11 @@ creal_test (void)
 static void
 csin_test (void)
 {
+  errno = 0;
+  FUNC(csin) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (csin);
 
@@ -1890,6 +2043,11 @@ csin_test (void)
 static void
 csinh_test (void)
 {
+  errno = 0;
+  FUNC(csinh) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (csinh);
 
@@ -1952,6 +2110,12 @@ csinh_test (void)
 static void
 csqrt_test (void)
 {
+  errno = 0;
+  FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (csqrt);
 
   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
@@ -2012,6 +2176,12 @@ csqrt_test (void)
 static void
 ctan_test (void)
 {
+  errno = 0;
+  FUNC(ctan) (BUILD_COMPLEX (0.7, 1.2));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (ctan);
 
   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
@@ -2064,6 +2234,12 @@ ctan_test (void)
 static void
 ctanh_test (void)
 {
+  errno = 0;
+  FUNC(ctanh) (BUILD_COMPLEX (0, 0));
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (ctanh);
 
   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
@@ -2128,6 +2304,7 @@ erf_test (void)
   TEST_f_f (erf, minus_zero, minus_zero);
   TEST_f_f (erf, plus_infty, 1);
   TEST_f_f (erf, minus_infty, -1);
+  TEST_f_f (erf, nan_value, nan_value);
 
   TEST_f_f (erf, 0.7, 0.67780119383741847297L);
 
@@ -2155,6 +2332,7 @@ erfc_test (void)
   TEST_f_f (erfc, minus_infty, 2.0);
   TEST_f_f (erfc, 0.0, 1.0);
   TEST_f_f (erfc, minus_zero, 1.0);
+  TEST_f_f (erfc, nan_value, nan_value);
 
   TEST_f_f (erfc, 0.7, 0.32219880616258152702L);
 
@@ -2169,13 +2347,22 @@ erfc_test (void)
 static void
 exp_test (void)
 {
+  errno = 0;
+  FUNC(exp) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (exp);
 
   TEST_f_f (exp, 0, 1);
   TEST_f_f (exp, minus_zero, 1);
 
+#ifndef TEST_INLINE
   TEST_f_f (exp, plus_infty, plus_infty);
   TEST_f_f (exp, minus_infty, 0);
+#endif
+  TEST_f_f (exp, nan_value, nan_value);
   TEST_f_f (exp, 1, M_El);
 
   TEST_f_f (exp, 2, M_E2l);
@@ -2202,8 +2389,9 @@ exp10_test (void)
 
   TEST_f_f (exp10, plus_infty, plus_infty);
   TEST_f_f (exp10, minus_infty, 0);
+  TEST_f_f (exp10, nan_value, nan_value);
   TEST_f_f (exp10, 3, 1000);
-  TEST_f_f (exp10, -1, 0.1);
+  TEST_f_f (exp10, -1, 0.1L);
   TEST_f_f (exp10, 1e6, plus_infty);
   TEST_f_f (exp10, -1e6, 0);
   TEST_f_f (exp10, 0.7, 5.0118723362727228500L);
@@ -2226,6 +2414,8 @@ exp2_test (void)
   TEST_f_f (exp2, minus_zero, 1);
   TEST_f_f (exp2, plus_infty, plus_infty);
   TEST_f_f (exp2, minus_infty, 0);
+  TEST_f_f (exp2, nan_value, nan_value);
+
   TEST_f_f (exp2, 10, 1024);
   TEST_f_f (exp2, -1, 0.5);
   TEST_f_f (exp2, 1e6, plus_infty);
@@ -2238,13 +2428,22 @@ exp2_test (void)
 static void
 expm1_test (void)
 {
+  errno = 0;
+  FUNC(expm1) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (expm1);
 
   TEST_f_f (expm1, 0, 0);
   TEST_f_f (expm1, minus_zero, minus_zero);
 
+#ifndef TEST_INLINE
   TEST_f_f (expm1, plus_infty, plus_infty);
   TEST_f_f (expm1, minus_infty, -1);
+#endif
+  TEST_f_f (expm1, nan_value, nan_value);
 
   TEST_f_f (expm1, 1, M_El - 1.0);
   TEST_f_f (expm1, 0.7, 1.0137527074704765216L);
@@ -2262,6 +2461,7 @@ fabs_test (void)
 
   TEST_f_f (fabs, plus_infty, plus_infty);
   TEST_f_f (fabs, minus_infty, plus_infty);
+  TEST_f_f (fabs, nan_value, nan_value);
 
   TEST_f_f (fabs, 38.0, 38.0);
   TEST_f_f (fabs, -M_El, M_El);
@@ -2312,6 +2512,7 @@ floor_test (void)
   TEST_f_f (floor, minus_zero, minus_zero);
   TEST_f_f (floor, plus_infty, plus_infty);
   TEST_f_f (floor, minus_infty, minus_infty);
+  TEST_f_f (floor, nan_value, nan_value);
 
   TEST_f_f (floor, M_PIl, 3.0);
   TEST_f_f (floor, -M_PIl, -4.0);
@@ -2424,6 +2625,11 @@ fmin_test (void)
 static void
 fmod_test (void)
 {
+  errno = 0;
+  FUNC(fmod) (6.5, 2.3);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (fmod);
 
@@ -2447,10 +2653,12 @@ fmod_test (void)
   /* fmod (x, -inf) == x for x not infinite.  */
   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
 
-  TEST_ff_f (fmod, 6.5, 2.3, 1.9);
-  TEST_ff_f (fmod, -6.5, 2.3, -1.9);
-  TEST_ff_f (fmod, 6.5, -2.3, 1.9);
-  TEST_ff_f (fmod, -6.5, -2.3, -1.9);
+  TEST_ff_f (fmod, nan_value, nan_value, nan_value);
+
+  TEST_ff_f (fmod, 6.5, 2.3, 1.9L);
+  TEST_ff_f (fmod, -6.5, 2.3, -1.9L);
+  TEST_ff_f (fmod, 6.5, -2.3, 1.9L);
+  TEST_ff_f (fmod, -6.5, -2.3, -1.9L);
 
   END (fmod);
 }
@@ -2485,8 +2693,8 @@ frexp_test (void)
   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
 
-  TEST_fI_f1 (frexp, 12.8, 0.8, 4);
-  TEST_fI_f1 (frexp, -27.34, -0.854375, 5);
+  TEST_fI_f1 (frexp, 12.8, 0.8L, 4);
+  TEST_fI_f1 (frexp, -27.34, -0.854375L, 5);
 
   END (frexp);
 }
@@ -2509,6 +2717,7 @@ gamma_test (void)
   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
   TEST_f_f (gamma, minus_infty, plus_infty);
+  TEST_f_f (gamma, nan_value, nan_value);
 
   TEST_f_f1 (gamma, 1, 0, 1);
   TEST_f_f1 (gamma, 3, M_LN2l, 1);
@@ -2522,15 +2731,23 @@ gamma_test (void)
 static void
 hypot_test (void)
 {
+  errno = 0;
+  FUNC(hypot) (0.7, 12.4);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (hypot);
 
   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
 
+#ifndef TEST_INLINE
   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
+#endif
 
   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
 
@@ -2545,9 +2762,9 @@ hypot_test (void)
   TEST_ff_f (hypot, -12.4, -0.7, 12.41974234837422060118L);
 
   /*  hypot (x,0) == fabs (x)  */
-  TEST_ff_f (hypot, 0.7, 0, 0.7);
-  TEST_ff_f (hypot, -0.7, 0, 0.7);
-  TEST_ff_f (hypot, -5.7e7, 0, 5.7e7);
+  TEST_ff_f (hypot, 0.7, 0, 0.7L);
+  TEST_ff_f (hypot, -0.7, 0, 0.7L);
+  TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
 
   TEST_ff_f (hypot, 0.7, 1.2, 1.3892443989449804508L);
 
@@ -2759,6 +2976,7 @@ lgamma_test (void)
 
   TEST_f_f (lgamma, plus_infty, plus_infty);
   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
+  TEST_f_f (lgamma, nan_value, nan_value);
 
   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
@@ -2847,6 +3065,11 @@ llrint_test (void)
 static void
 log_test (void)
 {
+  errno = 0;
+  FUNC(log) (1);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
   START (log);
 
   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
@@ -2870,6 +3093,12 @@ log_test (void)
 static void
 log10_test (void)
 {
+  errno = 0;
+  FUNC(log10) (1);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (log10);
 
   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
@@ -2881,6 +3110,7 @@ log10_test (void)
   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
 
   TEST_f_f (log10, plus_infty, plus_infty);
+  TEST_f_f (log10, nan_value, nan_value);
 
   TEST_f_f (log10, 0.1L, -1);
   TEST_f_f (log10, 10.0, 1);
@@ -2896,6 +3126,12 @@ log10_test (void)
 static void
 log1p_test (void)
 {
+  errno = 0;
+  FUNC(log1p) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (log1p);
 
   TEST_f_f (log1p, 0, 0);
@@ -2905,6 +3141,7 @@ log1p_test (void)
   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
 
   TEST_f_f (log1p, plus_infty, plus_infty);
+  TEST_f_f (log1p, nan_value, nan_value);
 
   TEST_f_f (log1p, M_El - 1.0, 1);
 
@@ -2917,6 +3154,12 @@ log1p_test (void)
 static void
 log2_test (void)
 {
+  errno = 0;
+  FUNC(log2) (1);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (log2);
 
   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
@@ -2927,6 +3170,7 @@ log2_test (void)
   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
 
   TEST_f_f (log2, plus_infty, plus_infty);
+  TEST_f_f (log2, nan_value, nan_value);
 
   TEST_f_f (log2, M_El, M_LOG2El);
   TEST_f_f (log2, 2.0, 1);
@@ -2949,6 +3193,7 @@ logb_test (void)
   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 
   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
+  TEST_f_f (logb, nan_value, nan_value);
 
   TEST_f_f (logb, 1, 0);
   TEST_f_f (logb, M_El, 1);
@@ -3063,6 +3308,13 @@ nearbyint_test (void)
   TEST_f_f (nearbyint, minus_zero, minus_zero);
   TEST_f_f (nearbyint, plus_infty, plus_infty);
   TEST_f_f (nearbyint, minus_infty, minus_infty);
+  TEST_f_f (nearbyint, nan_value, nan_value);
+
+  /* Default rounding mode is round to nearest.  */
+  TEST_f_f (nearbyint, 0.5, 0.0);
+  TEST_f_f (nearbyint, 1.5, 2.0);
+  TEST_f_f (nearbyint, -0.5, minus_zero);
+  TEST_f_f (nearbyint, -1.5, -2.0);
 
   END (nearbyint);
 }
@@ -3123,6 +3375,12 @@ static void
 pow_test (void)
 {
 
+  errno = 0;
+  FUNC(pow) (0, 0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (pow);
 
   TEST_ff_f (pow, 0, 0, 1);
@@ -3139,6 +3397,7 @@ pow_test (void)
   TEST_ff_f (pow, nan_value, minus_zero, 1);
 
 
+#ifndef TEST_INLINE
   TEST_ff_f (pow, 1.1, plus_infty, plus_infty);
   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
   TEST_ff_f (pow, -1.1, plus_infty, plus_infty);
@@ -3190,6 +3449,7 @@ pow_test (void)
   TEST_ff_f (pow, minus_infty, -1.1, 0);
   TEST_ff_f (pow, minus_infty, -11.1, 0);
   TEST_ff_f (pow, minus_infty, -1001.1, 0);
+#endif
 
   TEST_ff_f (pow, nan_value, nan_value, nan_value);
   TEST_ff_f (pow, 0, nan_value, nan_value);
@@ -3236,6 +3496,7 @@ pow_test (void)
   TEST_ff_f (pow, minus_zero, 2, 0);
   TEST_ff_f (pow, minus_zero, 11.1, 0);
 
+#ifndef TEST_INLINE
   /* pow (x, +inf) == +inf for |x| > 1.  */
   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
 
@@ -3247,6 +3508,7 @@ pow_test (void)
 
   /* pow (x, -inf) == +inf for |x| < 1.  */
   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
+#endif
 
   /* pow (+inf, y) == +inf for y > 0.  */
   TEST_ff_f (pow, plus_infty, 2, plus_infty);
@@ -3289,6 +3551,11 @@ pow_test (void)
 static void
 remainder_test (void)
 {
+  errno = 0;
+  FUNC(remainder) (1.625, 1.0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
   START (remainder);
 
@@ -3296,6 +3563,7 @@ remainder_test (void)
   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
+  TEST_ff_f (remainder, nan_value, nan_value, nan_value);
 
   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
@@ -3313,12 +3581,19 @@ remquo_test (void)
   /* x is needed.  */
   int x;
 
+  errno = 0;
+  FUNC(remquo) (1.625, 1.0, &x);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (remquo);
 
   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
+  TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
 
   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
@@ -3341,6 +3616,12 @@ rint_test (void)
   TEST_f_f (rint, plus_infty, plus_infty);
   TEST_f_f (rint, minus_infty, minus_infty);
 
+  /* Default rounding mode is round to nearest.  */
+  TEST_f_f (rint, 0.5, 0.0);
+  TEST_f_f (rint, 1.5, 2.0);
+  TEST_f_f (rint, -0.5, -0.0);
+  TEST_f_f (rint, -1.5, -2.0);
+
   END (rint);
 }
 
@@ -3490,12 +3771,19 @@ signbit_test (void)
 static void
 sin_test (void)
 {
+  errno = 0;
+  FUNC(sin) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (sin);
 
   TEST_f_f (sin, 0, 0);
   TEST_f_f (sin, minus_zero, minus_zero);
   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (sin, nan_value, nan_value);
 
   TEST_f_f (sin, M_PI_6l, 0.5);
   TEST_f_f (sin, -M_PI_6l, -0.5);
@@ -3512,6 +3800,12 @@ sincos_test (void)
 {
   FLOAT sin_res, cos_res;
 
+  errno = 0;
+  FUNC(sincos) (0, &sin_res, &cos_res);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (sincos);
 
   /* sincos is treated differently because it returns void.  */
@@ -3520,6 +3814,7 @@ sincos_test (void)
   TEST_extra (sincos, minus_zero, minus_zero, 1);
   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
+  TEST_extra (sincos, nan_value, nan_value, nan_value);
 
   TEST_extra (sincos, M_PI_2l, 1, 0);
   TEST_extra (sincos, M_PI_6l, 0.5, 0.866025403784438646764L);
@@ -3532,12 +3827,21 @@ sincos_test (void)
 static void
 sinh_test (void)
 {
+  errno = 0;
+  FUNC(sinh) (0.7);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (sinh);
   TEST_f_f (sinh, 0, 0);
   TEST_f_f (sinh, minus_zero, minus_zero);
 
+#ifndef TEST_INLINE
   TEST_f_f (sinh, plus_infty, plus_infty);
   TEST_f_f (sinh, minus_infty, minus_infty);
+#endif
+  TEST_f_f (sinh, nan_value, nan_value);
 
   TEST_f_f (sinh, 0.7, 0.75858370183953350346L);
 
@@ -3547,6 +3851,12 @@ sinh_test (void)
 static void
 sqrt_test (void)
 {
+  errno = 0;
+  FUNC(sqrt) (1);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (sqrt);
 
   TEST_f_f (sqrt, 0, 0);
@@ -3558,13 +3868,14 @@ sqrt_test (void)
   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (sqrt, nan_value, nan_value);
 
   TEST_f_f (sqrt, 2209, 47);
   TEST_f_f (sqrt, 4, 2);
   TEST_f_f (sqrt, 2, M_SQRT2l);
   TEST_f_f (sqrt, 0.25, 0.5);
   TEST_f_f (sqrt, 6642.25, 81.5);
-  TEST_f_f (sqrt, 15239.9025, 123.45);
+  TEST_f_f (sqrt, 15239.9025, 123.45L);
   TEST_f_f (sqrt, 0.7, 0.83666002653407554798L);
 
   END (sqrt);
@@ -3573,12 +3884,19 @@ sqrt_test (void)
 static void
 tan_test (void)
 {
+  errno = 0;
+  FUNC(tan) (0);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (tan);
 
   TEST_f_f (tan, 0, 0);
   TEST_f_f (tan, minus_zero, minus_zero);
   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (tan, nan_value, nan_value);
 
   TEST_f_f (tan, M_PI_4l, 1);
   TEST_f_f (tan, 0.7, 0.84228838046307944813L);
@@ -3589,13 +3907,22 @@ tan_test (void)
 static void
 tanh_test (void)
 {
+  errno = 0;
+  FUNC(tanh) (0.7);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
   START (tanh);
 
   TEST_f_f (tanh, 0, 0);
   TEST_f_f (tanh, minus_zero, minus_zero);
 
+#ifndef TEST_INLINE
   TEST_f_f (tanh, plus_infty, 1);
   TEST_f_f (tanh, minus_infty, -1);
+#endif
+  TEST_f_f (tanh, nan_value, nan_value);
 
   TEST_f_f (tanh, 0.7, 0.60436777711716349631L);
 
@@ -3620,6 +3947,7 @@ tgamma_test (void)
   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (tgamma, nan_value, nan_value);
 
   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
@@ -3822,6 +4150,8 @@ static const struct argp_option options[] =
     "Don't output maximal errors of functions"},
   { "no-points", 'p', NULL, 0,
     "Don't output results of functions invocations"},
+  { "ignore-max-ulp", 'i', "yes/no", 0,
+    "Ignore given maximal errors"},
   { NULL, 0, NULL, 0, NULL }
 };
 
@@ -3847,6 +4177,12 @@ parse_opt (int key, char *arg, struct argp_state *state)
     case 'f':
       output_max_error = 0;
       break;
+    case 'i':
+      if (strcmp (arg, "yes") == 0)
+       ignore_max_ulp = 1;
+      else if (strcmp (arg, "no") == 0)
+       ignore_max_ulp = 0;
+      break;
     case 'p':
       output_points = 0;
       break;
@@ -3901,6 +4237,8 @@ main (int argc, char **argv)
   output_ulps = 0;
   output_max_error = 1;
   output_points = 1;
+  /* XXX set to 0 for releases.  */
+  ignore_max_ulp = 0;
 
   /* Parse and process arguments.  */
   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
@@ -3930,7 +4268,7 @@ main (int argc, char **argv)
   check_ulp ();
 #endif
 
-  /* Keep the tests a wee bit ordered (according to ISO 9X).  */
+  /* Keep the tests a wee bit ordered (according to ISO C99).  */
   /* Classification macros:  */
   fpclassify_test ();
   isfinite_test ();