Convert TEST_ff_f tests from code to data.

1 files changed, 1011 insertions, 937 deletions

diff --git a/math/libm-test.inc b/math/libm-test.inc
index 2d4006fb84..08527b923d 100644
--- a/math/libm-test.inc
+++ b/math/libm-test.inc
@@ -872,6 +872,23 @@ struct test_f_f_data
   FLOAT max_ulp;
   int exceptions;
 };
+struct test_ff_f_data
+{
+  const char *test_name;
+  FLOAT arg1, arg2;
+  FLOAT expected;
+  FLOAT max_ulp;
+  int exceptions;
+};
+struct test_ff_f_data_nexttoward
+{
+  const char *test_name;
+  FLOAT arg1;
+  long double arg2;
+  FLOAT expected;
+  FLOAT max_ulp;
+  int exceptions;
+};
 
 /* Set the rounding mode, or restore the saved value.  */
 #define IF_ROUND_INIT_	/* Empty.  */
@@ -914,7 +931,15 @@ struct test_f_f_data
 		     MAX_ULP, EXCEPTIONS)				\
   check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG1, ARG2), EXPECTED,	\
 	       MAX_ULP, EXCEPTIONS)
+#define RUN_TEST_LOOP_2_f(FUNC_NAME, ARRAY, ROUNDING_MODE)		\
+  IF_ROUND_INIT_ ## ROUNDING_MODE					\
+    for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++)	\
+      RUN_TEST_2_f ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg1,	\
+		    (ARRAY)[i].arg2, (ARRAY)[i].expected,		\
+		    (ARRAY)[i].max_ulp,	(ARRAY)[i].exceptions);		\
+  ROUND_RESTORE_ ## ROUNDING_MODE
 #define RUN_TEST_ff_f RUN_TEST_2_f
+#define RUN_TEST_LOOP_ff_f RUN_TEST_LOOP_2_f
 #define RUN_TEST_fi_f RUN_TEST_2_f
 #define RUN_TEST_fl_f RUN_TEST_2_f
 #define RUN_TEST_if_f RUN_TEST_2_f
@@ -1504,88 +1529,93 @@ atanh_test (void)
   END (atanh);
 }
 
-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.  */
-  TEST_ff_f (atan2, 0, 1, 0);
+static const struct test_ff_f_data atan2_test_data[] =
+  {
+    START_DATA (atan2),
+    /* atan2 (0,x) == 0 for x > 0.  */
+    TEST_ff_f (atan2, 0, 1, 0),
 
-  /* atan2 (-0,x) == -0 for x > 0.  */
-  TEST_ff_f (atan2, minus_zero, 1, minus_zero);
+    /* atan2 (-0,x) == -0 for x > 0.  */
+    TEST_ff_f (atan2, minus_zero, 1, minus_zero),
 
-  TEST_ff_f (atan2, 0, 0, 0);
-  TEST_ff_f (atan2, minus_zero, 0, minus_zero);
+    TEST_ff_f (atan2, 0, 0, 0),
+    TEST_ff_f (atan2, minus_zero, 0, minus_zero),
 
-  /* atan2 (+0,x) == +pi for x < 0.  */
-  TEST_ff_f (atan2, 0, -1, M_PIl);
+    /* atan2 (+0,x) == +pi for x < 0.  */
+    TEST_ff_f (atan2, 0, -1, M_PIl),
 
-  /* atan2 (-0,x) == -pi for x < 0.  */
-  TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
+    /* atan2 (-0,x) == -pi for x < 0.  */
+    TEST_ff_f (atan2, minus_zero, -1, -M_PIl),
 
-  TEST_ff_f (atan2, 0, minus_zero, M_PIl);
-  TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
+    TEST_ff_f (atan2, 0, minus_zero, M_PIl),
+    TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl),
 
-  /* atan2 (y,+0) == pi/2 for y > 0.  */
-  TEST_ff_f (atan2, 1, 0, M_PI_2l);
+    /* atan2 (y,+0) == pi/2 for y > 0.  */
+    TEST_ff_f (atan2, 1, 0, M_PI_2l),
 
-  /* atan2 (y,-0) == pi/2 for y > 0.  */
-  TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
+    /* atan2 (y,-0) == pi/2 for y > 0.  */
+    TEST_ff_f (atan2, 1, minus_zero, M_PI_2l),
 
-  /* atan2 (y,+0) == -pi/2 for y < 0.  */
-  TEST_ff_f (atan2, -1, 0, -M_PI_2l);
+    /* atan2 (y,+0) == -pi/2 for y < 0.  */
+    TEST_ff_f (atan2, -1, 0, -M_PI_2l),
 
-  /* atan2 (y,-0) == -pi/2 for y < 0.  */
-  TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
+    /* atan2 (y,-0) == -pi/2 for y < 0.  */
+    TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l),
 
-  /* atan2 (y,inf) == +0 for finite y > 0.  */
-  TEST_ff_f (atan2, 1, plus_infty, 0);
+    /* atan2 (y,inf) == +0 for finite y > 0.  */
+    TEST_ff_f (atan2, 1, plus_infty, 0),
 
-  /* atan2 (y,inf) == -0 for finite y < 0.  */
-  TEST_ff_f (atan2, -1, plus_infty, minus_zero);
+    /* atan2 (y,inf) == -0 for finite y < 0.  */
+    TEST_ff_f (atan2, -1, plus_infty, minus_zero),
 
-  /* atan2(+inf, x) == pi/2 for finite x.  */
-  TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
+    /* atan2(+inf, x) == pi/2 for finite x.  */
+    TEST_ff_f (atan2, plus_infty, -1, M_PI_2l),
 
-  /* atan2(-inf, x) == -pi/2 for finite x.  */
-  TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
+    /* atan2(-inf, x) == -pi/2 for finite x.  */
+    TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l),
 
-  /* atan2 (y,-inf) == +pi for finite y > 0.  */
-  TEST_ff_f (atan2, 1, minus_infty, M_PIl);
+    /* atan2 (y,-inf) == +pi for finite y > 0.  */
+    TEST_ff_f (atan2, 1, minus_infty, M_PIl),
 
-  /* atan2 (y,-inf) == -pi for finite y < 0.  */
-  TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
+    /* atan2 (y,-inf) == -pi for finite y < 0.  */
+    TEST_ff_f (atan2, -1, minus_infty, -M_PIl),
 
-  TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
-  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, qnan_value, qnan_value, qnan_value);
+    TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l),
+    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, qnan_value, qnan_value, qnan_value),
 
-  TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
+    TEST_ff_f (atan2, max_value, max_value, M_PI_4l),
 
-  TEST_ff_f (atan2, max_value, min_value, M_PI_2l);
-  TEST_ff_f (atan2, -max_value, -min_value, -M_PI_2l);
+    TEST_ff_f (atan2, max_value, min_value, M_PI_2l),
+    TEST_ff_f (atan2, -max_value, -min_value, -M_PI_2l),
 
-  TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
-  TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
-  TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
-  TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
-  TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
-  TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
+    TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L),
+    TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L),
+    TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L),
+    TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L),
+    TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L),
+    TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L),
 
-  TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
+    TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L),
 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
-  TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l);
+    TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l),
 #endif
+    END_DATA (atan2)
+  };
 
+static void
+atan2_test (void)
+{
+  errno = 0;
+  FUNC(atan2) (-0, 1);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
+
+  START (atan2);
+  RUN_TEST_LOOP_ff_f (atan2, atan2_test_data, );
   END (atan2);
 }
 
@@ -6423,32 +6453,37 @@ conj_test (void)
 }
 
 
+static const struct test_ff_f_data copysign_test_data[] =
+  {
+    START_DATA (copysign),
+    TEST_ff_f (copysign, 0, 4, 0),
+    TEST_ff_f (copysign, 0, -4, minus_zero),
+    TEST_ff_f (copysign, minus_zero, 4, 0),
+    TEST_ff_f (copysign, minus_zero, -4, minus_zero),
+
+    TEST_ff_f (copysign, plus_infty, 0, plus_infty),
+    TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty),
+    TEST_ff_f (copysign, minus_infty, 0, plus_infty),
+    TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty),
+
+    TEST_ff_f (copysign, 0, plus_infty, 0),
+    TEST_ff_f (copysign, 0, minus_zero, minus_zero),
+    TEST_ff_f (copysign, minus_zero, plus_infty, 0),
+    TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero),
+
+    /* XXX More correctly we would have to check the sign of the NaN.  */
+    TEST_ff_f (copysign, qnan_value, 0, qnan_value),
+    TEST_ff_f (copysign, qnan_value, minus_zero, qnan_value),
+    TEST_ff_f (copysign, -qnan_value, 0, qnan_value),
+    TEST_ff_f (copysign, -qnan_value, minus_zero, qnan_value),
+    END_DATA (copysign)
+  };
+
 static void
 copysign_test (void)
 {
   START (copysign);
-
-  TEST_ff_f (copysign, 0, 4, 0);
-  TEST_ff_f (copysign, 0, -4, minus_zero);
-  TEST_ff_f (copysign, minus_zero, 4, 0);
-  TEST_ff_f (copysign, minus_zero, -4, minus_zero);
-
-  TEST_ff_f (copysign, plus_infty, 0, plus_infty);
-  TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
-  TEST_ff_f (copysign, minus_infty, 0, plus_infty);
-  TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
-
-  TEST_ff_f (copysign, 0, plus_infty, 0);
-  TEST_ff_f (copysign, 0, minus_zero, minus_zero);
-  TEST_ff_f (copysign, minus_zero, plus_infty, 0);
-  TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
-
-  /* XXX More correctly we would have to check the sign of the NaN.  */
-  TEST_ff_f (copysign, qnan_value, 0, qnan_value);
-  TEST_ff_f (copysign, qnan_value, minus_zero, qnan_value);
-  TEST_ff_f (copysign, -qnan_value, 0, qnan_value);
-  TEST_ff_f (copysign, -qnan_value, minus_zero, qnan_value);
-
+  RUN_TEST_LOOP_ff_f (copysign, copysign_test_data, );
   END (copysign);
 }
 
@@ -8031,39 +8066,44 @@ fabs_test (void)
 }
 
 
+static const struct test_ff_f_data fdim_test_data[] =
+  {
+    START_DATA (fdim),
+    TEST_ff_f (fdim, 0, 0, 0),
+    TEST_ff_f (fdim, 9, 0, 9),
+    TEST_ff_f (fdim, 0, 9, 0),
+    TEST_ff_f (fdim, -9, 0, 0),
+    TEST_ff_f (fdim, 0, -9, 9),
+
+    TEST_ff_f (fdim, plus_infty, 9, plus_infty),
+    TEST_ff_f (fdim, plus_infty, -9, plus_infty),
+    TEST_ff_f (fdim, minus_infty, 9, 0),
+    TEST_ff_f (fdim, minus_infty, -9, 0),
+    TEST_ff_f (fdim, 9, minus_infty, plus_infty),
+    TEST_ff_f (fdim, -9, minus_infty, plus_infty),
+    TEST_ff_f (fdim, 9, plus_infty, 0),
+    TEST_ff_f (fdim, -9, plus_infty, 0),
+
+    TEST_ff_f (fdim, 0, qnan_value, qnan_value),
+    TEST_ff_f (fdim, 9, qnan_value, qnan_value),
+    TEST_ff_f (fdim, -9, qnan_value, qnan_value),
+    TEST_ff_f (fdim, qnan_value, 9, qnan_value),
+    TEST_ff_f (fdim, qnan_value, -9, qnan_value),
+    TEST_ff_f (fdim, plus_infty, qnan_value, qnan_value),
+    TEST_ff_f (fdim, minus_infty, qnan_value, qnan_value),
+    TEST_ff_f (fdim, qnan_value, plus_infty, qnan_value),
+    TEST_ff_f (fdim, qnan_value, minus_infty, qnan_value),
+    TEST_ff_f (fdim, qnan_value, qnan_value, qnan_value),
+
+    TEST_ff_f (fdim, plus_infty, plus_infty, 0),
+    END_DATA (fdim)
+  };
+
 static void
 fdim_test (void)
 {
   START (fdim);
-
-  TEST_ff_f (fdim, 0, 0, 0);
-  TEST_ff_f (fdim, 9, 0, 9);
-  TEST_ff_f (fdim, 0, 9, 0);
-  TEST_ff_f (fdim, -9, 0, 0);
-  TEST_ff_f (fdim, 0, -9, 9);
-
-  TEST_ff_f (fdim, plus_infty, 9, plus_infty);
-  TEST_ff_f (fdim, plus_infty, -9, plus_infty);
-  TEST_ff_f (fdim, minus_infty, 9, 0);
-  TEST_ff_f (fdim, minus_infty, -9, 0);
-  TEST_ff_f (fdim, 9, minus_infty, plus_infty);
-  TEST_ff_f (fdim, -9, minus_infty, plus_infty);
-  TEST_ff_f (fdim, 9, plus_infty, 0);
-  TEST_ff_f (fdim, -9, plus_infty, 0);
-
-  TEST_ff_f (fdim, 0, qnan_value, qnan_value);
-  TEST_ff_f (fdim, 9, qnan_value, qnan_value);
-  TEST_ff_f (fdim, -9, qnan_value, qnan_value);
-  TEST_ff_f (fdim, qnan_value, 9, qnan_value);
-  TEST_ff_f (fdim, qnan_value, -9, qnan_value);
-  TEST_ff_f (fdim, plus_infty, qnan_value, qnan_value);
-  TEST_ff_f (fdim, minus_infty, qnan_value, qnan_value);
-  TEST_ff_f (fdim, qnan_value, plus_infty, qnan_value);
-  TEST_ff_f (fdim, qnan_value, minus_infty, qnan_value);
-  TEST_ff_f (fdim, qnan_value, qnan_value, qnan_value);
-
-  TEST_ff_f (fdim, plus_infty, plus_infty, 0);
-
+  RUN_TEST_LOOP_ff_f (fdim, fdim_test_data, );
   END (fdim);
 }
 
@@ -9140,127 +9180,142 @@ fma_test_upward (void)
 }
 
 
+static const struct test_ff_f_data fmax_test_data[] =
+  {
+    START_DATA (fmax),
+    TEST_ff_f (fmax, 0, 0, 0),
+    TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero),
+    TEST_ff_f (fmax, 9, 0, 9),
+    TEST_ff_f (fmax, 0, 9, 9),
+    TEST_ff_f (fmax, -9, 0, 0),
+    TEST_ff_f (fmax, 0, -9, 0),
+
+    TEST_ff_f (fmax, plus_infty, 9, plus_infty),
+    TEST_ff_f (fmax, 0, plus_infty, plus_infty),
+    TEST_ff_f (fmax, -9, plus_infty, plus_infty),
+    TEST_ff_f (fmax, plus_infty, -9, plus_infty),
+
+    TEST_ff_f (fmax, minus_infty, 9, 9),
+    TEST_ff_f (fmax, minus_infty, -9, -9),
+    TEST_ff_f (fmax, 9, minus_infty, 9),
+    TEST_ff_f (fmax, -9, minus_infty, -9),
+
+    TEST_ff_f (fmax, 0, qnan_value, 0),
+    TEST_ff_f (fmax, 9, qnan_value, 9),
+    TEST_ff_f (fmax, -9, qnan_value, -9),
+    TEST_ff_f (fmax, qnan_value, 0, 0),
+    TEST_ff_f (fmax, qnan_value, 9, 9),
+    TEST_ff_f (fmax, qnan_value, -9, -9),
+    TEST_ff_f (fmax, plus_infty, qnan_value, plus_infty),
+    TEST_ff_f (fmax, minus_infty, qnan_value, minus_infty),
+    TEST_ff_f (fmax, qnan_value, plus_infty, plus_infty),
+    TEST_ff_f (fmax, qnan_value, minus_infty, minus_infty),
+    TEST_ff_f (fmax, qnan_value, qnan_value, qnan_value),
+    END_DATA (fmax)
+  };
+
 static void
 fmax_test (void)
 {
   START (fmax);
-
-  TEST_ff_f (fmax, 0, 0, 0);
-  TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
-  TEST_ff_f (fmax, 9, 0, 9);
-  TEST_ff_f (fmax, 0, 9, 9);
-  TEST_ff_f (fmax, -9, 0, 0);
-  TEST_ff_f (fmax, 0, -9, 0);
-
-  TEST_ff_f (fmax, plus_infty, 9, plus_infty);
-  TEST_ff_f (fmax, 0, plus_infty, plus_infty);
-  TEST_ff_f (fmax, -9, plus_infty, plus_infty);
-  TEST_ff_f (fmax, plus_infty, -9, plus_infty);
-
-  TEST_ff_f (fmax, minus_infty, 9, 9);
-  TEST_ff_f (fmax, minus_infty, -9, -9);
-  TEST_ff_f (fmax, 9, minus_infty, 9);
-  TEST_ff_f (fmax, -9, minus_infty, -9);
-
-  TEST_ff_f (fmax, 0, qnan_value, 0);
-  TEST_ff_f (fmax, 9, qnan_value, 9);
-  TEST_ff_f (fmax, -9, qnan_value, -9);
-  TEST_ff_f (fmax, qnan_value, 0, 0);
-  TEST_ff_f (fmax, qnan_value, 9, 9);
-  TEST_ff_f (fmax, qnan_value, -9, -9);
-  TEST_ff_f (fmax, plus_infty, qnan_value, plus_infty);
-  TEST_ff_f (fmax, minus_infty, qnan_value, minus_infty);
-  TEST_ff_f (fmax, qnan_value, plus_infty, plus_infty);
-  TEST_ff_f (fmax, qnan_value, minus_infty, minus_infty);
-  TEST_ff_f (fmax, qnan_value, qnan_value, qnan_value);
-
+  RUN_TEST_LOOP_ff_f (fmax, fmax_test_data, );
   END (fmax);
 }
 
 
+static const struct test_ff_f_data fmin_test_data[] =
+  {
+    START_DATA (fmin),
+    TEST_ff_f (fmin, 0, 0, 0),
+    TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero),
+    TEST_ff_f (fmin, 9, 0, 0),
+    TEST_ff_f (fmin, 0, 9, 0),
+    TEST_ff_f (fmin, -9, 0, -9),
+    TEST_ff_f (fmin, 0, -9, -9),
+
+    TEST_ff_f (fmin, plus_infty, 9, 9),
+    TEST_ff_f (fmin, 9, plus_infty, 9),
+    TEST_ff_f (fmin, plus_infty, -9, -9),
+    TEST_ff_f (fmin, -9, plus_infty, -9),
+    TEST_ff_f (fmin, minus_infty, 9, minus_infty),
+    TEST_ff_f (fmin, minus_infty, -9, minus_infty),
+    TEST_ff_f (fmin, 9, minus_infty, minus_infty),
+    TEST_ff_f (fmin, -9, minus_infty, minus_infty),
+
+    TEST_ff_f (fmin, 0, qnan_value, 0),
+    TEST_ff_f (fmin, 9, qnan_value, 9),
+    TEST_ff_f (fmin, -9, qnan_value, -9),
+    TEST_ff_f (fmin, qnan_value, 0, 0),
+    TEST_ff_f (fmin, qnan_value, 9, 9),
+    TEST_ff_f (fmin, qnan_value, -9, -9),
+    TEST_ff_f (fmin, plus_infty, qnan_value, plus_infty),
+    TEST_ff_f (fmin, minus_infty, qnan_value, minus_infty),
+    TEST_ff_f (fmin, qnan_value, plus_infty, plus_infty),
+    TEST_ff_f (fmin, qnan_value, minus_infty, minus_infty),
+    TEST_ff_f (fmin, qnan_value, qnan_value, qnan_value),
+    END_DATA (fmin)
+  };
+
 static void
 fmin_test (void)
 {
   START (fmin);
-
-  TEST_ff_f (fmin, 0, 0, 0);
-  TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
-  TEST_ff_f (fmin, 9, 0, 0);
-  TEST_ff_f (fmin, 0, 9, 0);
-  TEST_ff_f (fmin, -9, 0, -9);
-  TEST_ff_f (fmin, 0, -9, -9);
-
-  TEST_ff_f (fmin, plus_infty, 9, 9);
-  TEST_ff_f (fmin, 9, plus_infty, 9);
-  TEST_ff_f (fmin, plus_infty, -9, -9);
-  TEST_ff_f (fmin, -9, plus_infty, -9);
-  TEST_ff_f (fmin, minus_infty, 9, minus_infty);
-  TEST_ff_f (fmin, minus_infty, -9, minus_infty);
-  TEST_ff_f (fmin, 9, minus_infty, minus_infty);
-  TEST_ff_f (fmin, -9, minus_infty, minus_infty);
-
-  TEST_ff_f (fmin, 0, qnan_value, 0);
-  TEST_ff_f (fmin, 9, qnan_value, 9);
-  TEST_ff_f (fmin, -9, qnan_value, -9);
-  TEST_ff_f (fmin, qnan_value, 0, 0);
-  TEST_ff_f (fmin, qnan_value, 9, 9);
-  TEST_ff_f (fmin, qnan_value, -9, -9);
-  TEST_ff_f (fmin, plus_infty, qnan_value, plus_infty);
-  TEST_ff_f (fmin, minus_infty, qnan_value, minus_infty);
-  TEST_ff_f (fmin, qnan_value, plus_infty, plus_infty);
-  TEST_ff_f (fmin, qnan_value, minus_infty, minus_infty);
-  TEST_ff_f (fmin, qnan_value, qnan_value, qnan_value);
-
+  RUN_TEST_LOOP_ff_f (fmin, fmin_test_data, );
   END (fmin);
 }
 
 
-static void
-fmod_test (void)
-{
-  errno = 0;
-  FUNC(fmod) (6.5, 2.3L);
-  if (errno == ENOSYS)
-    /* Function not implemented.  */
-    return;
-
-  START (fmod);
-
-  /* fmod (+0, y) == +0 for y != 0.  */
-  TEST_ff_f (fmod, 0, 3, 0);
+static const struct test_ff_f_data fmod_test_data[] =
+  {
+    START_DATA (fmod),
+    /* fmod (+0, y) == +0 for y != 0.  */
+    TEST_ff_f (fmod, 0, 3, 0),
 
-  /* fmod (-0, y) == -0 for y != 0.  */
-  TEST_ff_f (fmod, minus_zero, 3, minus_zero);
+    /* fmod (-0, y) == -0 for y != 0.  */
+    TEST_ff_f (fmod, minus_zero, 3, minus_zero),
 
-  /* fmod (+inf, y) == qNaN plus invalid exception.  */
-  TEST_ff_f (fmod, plus_infty, 3, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
-  /* fmod (-inf, y) == qNaN plus invalid exception.  */
-  TEST_ff_f (fmod, minus_infty, 3, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
-  /* fmod (x, +0) == qNaN plus invalid exception.  */
-  TEST_ff_f (fmod, 3, 0, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
-  /* fmod (x, -0) == qNaN plus invalid exception.  */
-  TEST_ff_f (fmod, 3, minus_zero, qnan_value, INVALID_EXCEPTION);
+    /* fmod (+inf, y) == qNaN plus invalid exception.  */
+    TEST_ff_f (fmod, plus_infty, 3, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
+    /* fmod (-inf, y) == qNaN plus invalid exception.  */
+    TEST_ff_f (fmod, minus_infty, 3, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
+    /* fmod (x, +0) == qNaN plus invalid exception.  */
+    TEST_ff_f (fmod, 3, 0, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
+    /* fmod (x, -0) == qNaN plus invalid exception.  */
+    TEST_ff_f (fmod, 3, minus_zero, qnan_value, INVALID_EXCEPTION),
 
-  /* fmod (x, +inf) == x for x not infinite.  */
-  TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
-  /* fmod (x, -inf) == x for x not infinite.  */
-  TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
+    /* fmod (x, +inf) == x for x not infinite.  */
+    TEST_ff_f (fmod, 3.0, plus_infty, 3.0),
+    /* fmod (x, -inf) == x for x not infinite.  */
+    TEST_ff_f (fmod, 3.0, minus_infty, 3.0),
 
-  TEST_ff_f (fmod, qnan_value, qnan_value, qnan_value);
+    TEST_ff_f (fmod, qnan_value, qnan_value, qnan_value),
 
-  TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
-  TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
-  TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
-  TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
+    TEST_ff_f (fmod, 6.5, 2.25L, 2.0L),
+    TEST_ff_f (fmod, -6.5, 2.25L, -2.0L),
+    TEST_ff_f (fmod, 6.5, -2.25L, 2.0L),
+    TEST_ff_f (fmod, -6.5, -2.25L, -2.0L),
 
-  TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero);
+    TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero),
 #ifndef TEST_FLOAT
-  TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero);
+    TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero),
 #endif
 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
-  TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero);
+    TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero),
 #endif
+    END_DATA (fmod)
+  };
+
+static void
+fmod_test (void)
+{
+  errno = 0;
+  FUNC(fmod) (6.5, 2.3L);
+  if (errno == ENOSYS)
+    /* Function not implemented.  */
+    return;
 
+  START (fmod);
+  RUN_TEST_LOOP_ff_f (fmod, fmod_test_data, );
   END (fmod);
 }
 
@@ -9330,66 +9385,71 @@ gamma_test (void)
   END (gamma);
 }
 
-static void
-hypot_test (void)
-{
-  errno = 0;
-  FUNC(hypot) (0.7L, 12.4L);
-  if (errno == ENOSYS)
-    /* Function not implemented.  */
-    return;
-
-  START (hypot);
-
-  TEST_ff_f (hypot, plus_infty, 1, plus_infty);
-  TEST_ff_f (hypot, minus_infty, 1, plus_infty);
+static const struct test_ff_f_data hypot_test_data[] =
+  {
+    START_DATA (hypot),
+    TEST_ff_f (hypot, plus_infty, 1, plus_infty),
+    TEST_ff_f (hypot, minus_infty, 1, plus_infty),
 
 #ifndef TEST_INLINE
-  TEST_ff_f (hypot, plus_infty, qnan_value, plus_infty);
-  TEST_ff_f (hypot, minus_infty, qnan_value, plus_infty);
-  TEST_ff_f (hypot, qnan_value, plus_infty, plus_infty);
-  TEST_ff_f (hypot, qnan_value, minus_infty, plus_infty);
+    TEST_ff_f (hypot, plus_infty, qnan_value, plus_infty),
+    TEST_ff_f (hypot, minus_infty, qnan_value, plus_infty),
+    TEST_ff_f (hypot, qnan_value, plus_infty, plus_infty),
+    TEST_ff_f (hypot, qnan_value, minus_infty, plus_infty),
 #endif
 
-  TEST_ff_f (hypot, qnan_value, qnan_value, qnan_value);
+    TEST_ff_f (hypot, qnan_value, qnan_value, qnan_value),
 
-  /* hypot (x,y) == hypot (+-x, +-y)  */
-  TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
-  TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
+    /* hypot (x,y) == hypot (+-x, +-y)  */
+    TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L),
+    TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L),
 
-  /*  hypot (x,0) == fabs (x)  */
-  TEST_ff_f (hypot, 0.75L, 0, 0.75L);
-  TEST_ff_f (hypot, -0.75L, 0, 0.75L);
-  TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
+    /*  hypot (x,0) == fabs (x)  */
+    TEST_ff_f (hypot, 0.75L, 0, 0.75L),
+    TEST_ff_f (hypot, -0.75L, 0, 0.75L),
+    TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L),
 
-  TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
+    TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L),
 
-  TEST_ff_f (hypot, 1.0L, 0x1p-61L, 1.0L);
-  TEST_ff_f (hypot, 0x1p+0L, 0x1.fp-129L, 0x1p+0L);
+    TEST_ff_f (hypot, 1.0L, 0x1p-61L, 1.0L),
+    TEST_ff_f (hypot, 0x1p+0L, 0x1.fp-129L, 0x1p+0L),
 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
-  TEST_ff_f (hypot, 0x1.23456789abcdef0123456789ab8p-500L, 0x1.23456789abcdef0123456789ab8p-500L, 4.9155782399407039128612180934736799735113e-151L);
+    TEST_ff_f (hypot, 0x1.23456789abcdef0123456789ab8p-500L, 0x1.23456789abcdef0123456789ab8p-500L, 4.9155782399407039128612180934736799735113e-151L),
 #endif
 
 #if !(defined TEST_FLOAT && defined TEST_INLINE)
-  TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
-  TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
+    TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L),
+    TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L),
 #endif
 
 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
-  TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
-  TEST_ff_f (hypot, 0x1p+0L, 0x0.3ep-1022L, 0x1p+0L);
+    TES