Make tst-strtod2 and tst-strtod5 type-generic

Some of the strtod tests use type-generic machinery in tst-strtod.h to
test the strto* functions for all floating types, while others only
test double even when the tests are in fact meaningful for all
floating types.

Convert tst-strtod2 and tst-strtod5 to use the type-generic machinery
so they test all floating types.  I haven't tried to convert them to
use newer test interfaces in other ways, just made the changes
necessary to use the type-generic machinery.

Tested for x86_64.

diff --git a/stdlib/tst-strtod2.c b/stdlib/tst-strtod2.c
index a7df82ebbde14c5f624d4fdf397ee00ec218e122..2cb0953fa911efd0a3c0a1a430eee9e68684da08 100644 (file)
--- a/stdlib/tst-strtod2.c
+++ b/stdlib/tst-strtod2.c
@@ -1,43 +1,61 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-struct test
-{
-  const char *str;
-  double result;
-  size_t offset;
-} tests[] =
-{
-  { "0xy", 0.0, 1 },
-  { "0x.y", 0.0, 1 },
-  { "0x0.y", 0.0, 4 },
-  { "0x.0y", 0.0, 4 },
-  { ".y", 0.0, 0 },
-  { "0.y", 0.0, 2 },
-  { ".0y", 0.0, 2 }
-};
+#include "tst-strtod.h"
+
+#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF)                   \
+struct test_strto ## FSUF                                              \
+{                                                                      \
+  const char *str;                                                     \
+  FTYPE result;                                                                \
+  size_t offset;                                                       \
+} tests_strto ## FSUF[] =                                              \
+{                                                                      \
+  { "0xy", 0.0 ## LSUF, 1 },                                           \
+  { "0x.y", 0.0 ## LSUF, 1 },                                          \
+  { "0x0.y", 0.0 ## LSUF, 4 },                                         \
+  { "0x.0y", 0.0 ## LSUF, 4 },                                         \
+  { ".y", 0.0 ## LSUF, 0 },                                            \
+  { "0.y", 0.0 ## LSUF, 2 },                                           \
+  { ".0y", 0.0 ## LSUF, 2 }                                            \
+};                                                                     \
+                                                                       \
+static int                                                             \
+test_strto ## FSUF (void)                                              \
+{                                                                      \
+  int status = 0;                                                      \
+  for (size_t i = 0;                                                   \
+       i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \
+       ++i)                                                            \
+    {                                                                  \
+      char *ep;                                                                \
+      FTYPE r = strto ## FSUF (tests_strto ## FSUF[i].str, &ep);       \
+      if (r != tests_strto ## FSUF[i].result)                          \
+       {                                                               \
+         char buf1[FSTRLENMAX], buf2[FSTRLENMAX];                      \
+         FTOSTR (buf1, sizeof (buf1), "%g", r);                        \
+         FTOSTR (buf2, sizeof (buf2), "%g", tests_strto ## FSUF[i].result); \
+         printf ("test %zu r = %s, expect %s\n", i, buf1, buf2);       \
+         status = 1;                                                   \
+       }                                                               \
+      if (ep != tests_strto ## FSUF[i].str + tests_strto ## FSUF[i].offset) \
+       {                                                               \
+         printf ("test %zu strto" #FSUF                                \
+                 " parsed %tu characters, expected %zu\n",             \
+                 i, ep - tests_strto ## FSUF[i].str,                   \
+                 tests_strto ## FSUF[i].offset);                       \
+         status = 1;                                                   \
+       }                                                               \
+    }                                                                  \
+  return status;                                                       \
+}
+
+GEN_TEST_STRTOD_FOREACH (TEST_STRTOD)
 
 static int
 do_test (void)
 {
-  int status = 0;
-  for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); ++i)
-    {
-      char *ep;
-      double r = strtod (tests[i].str, &ep);
-      if (r != tests[i].result)
-       {
-         printf ("test %zu r = %g, expect %g\n", i, r, tests[i].result);
-         status = 1;
-       }
-      if (ep != tests[i].str + tests[i].offset)
-       {
-         printf ("test %zu strtod parsed %tu characters, expected %zu\n",
-                 i, ep - tests[i].str, tests[i].offset);
-         status = 1;
-       }
-    }
-  return status;
+  return STRTOD_TEST_FOREACH (test_strto);
 }
 
 #define TEST_FUNCTION do_test ()

diff --git a/stdlib/tst-strtod5.c b/stdlib/tst-strtod5.c
index 29153ec0057178e9e8e2d1162af689235df40180..7eb9b3a2d7f31b2a34d854763d31f942cb3b84f4 100644 (file)
--- a/stdlib/tst-strtod5.c
+++ b/stdlib/tst-strtod5.c
@@ -22,35 +22,75 @@
 #include <string.h>
 #include <math.h>
 
+#include "tst-strtod.h"
+
 #define NBSP "\xc2\xa0"
 
-static const struct
-{
-  const char *in;
-  double expected;
-} tests[] =
-  {
-    { "0", 0.0 },
-    { "000", 0.0 },
-    { "-0", -0.0 },
-    { "-000", -0.0 },
-    { "0,", 0.0 },
-    { "-0,", -0.0 },
-    { "0,0", 0.0 },
-    { "-0,0", -0.0 },
-    { "0e-10", 0.0 },
-    { "-0e-10", -0.0 },
-    { "0,e-10", 0.0 },
-    { "-0,e-10", -0.0 },
-    { "0,0e-10", 0.0 },
-    { "-0,0e-10", -0.0 },
-    { "0e-1000000", 0.0 },
-    { "-0e-1000000", -0.0 },
-    { "0,0e-1000000", 0.0 },
-    { "-0,0e-1000000", -0.0 },
-  };
-#define NTESTS (sizeof (tests) / sizeof (tests[0]))
+#define TEST_STRTOD(FSUF, FTYPE, FTOSTR, LSUF, CSUF)                   \
+static const struct                                                    \
+{                                                                      \
+  const char *in;                                                      \
+  FTYPE expected;                                                      \
+} tests_strto ## FSUF[] =                                              \
+  {                                                                    \
+    { "0", 0.0 ## LSUF },                                              \
+    { "000", 0.0 ## LSUF },                                            \
+    { "-0", -0.0 ## LSUF },                                            \
+    { "-000", -0.0 ## LSUF },                                          \
+    { "0,", 0.0 ## LSUF },                                             \
+    { "-0,", -0.0 ## LSUF },                                           \
+    { "0,0", 0.0 ## LSUF },                                            \
+    { "-0,0", -0.0 ## LSUF },                                          \
+    { "0e-10", 0.0 ## LSUF },                                          \
+    { "-0e-10", -0.0 ## LSUF },                                                \
+    { "0,e-10", 0.0 ## LSUF },                                         \
+    { "-0,e-10", -0.0 ## LSUF },                                       \
+    { "0,0e-10", 0.0 ## LSUF },                                                \
+    { "-0,0e-10", -0.0 ## LSUF },                                      \
+    { "0e-1000000", 0.0 ## LSUF },                                     \
+    { "-0e-1000000", -0.0 ## LSUF },                                   \
+    { "0,0e-1000000", 0.0 ## LSUF },                                   \
+    { "-0,0e-1000000", -0.0 ## LSUF },                                 \
+  };                                                                   \
+                                                                       \
+                                                                       \
+static int                                                             \
+test_strto ## FSUF (void)                                              \
+{                                                                      \
+  int status = 0;                                                      \
+                                                                       \
+  for (int i = 0;                                                      \
+       i < sizeof (tests_strto ## FSUF) / sizeof (tests_strto ## FSUF[0]); \
+       ++i)                                                            \
+    {                                                                  \
+      char *ep;                                                                \
+      FTYPE r = strto ## FSUF (tests_strto ## FSUF[i].in, &ep);                \
+                                                                       \
+      if (*ep != '\0')                                                 \
+       {                                                               \
+         printf ("%d: got rest string \"%s\", expected \"\"\n", i, ep); \
+         status = 1;                                                   \
+       }                                                               \
+                                                                       \
+      if (r != tests_strto ## FSUF[i].expected                         \
+         || (copysign ## CSUF (10.0 ## LSUF, r)                        \
+             != copysign ## CSUF (10.0 ## LSUF,                        \
+                                  tests_strto ## FSUF[i].expected)))   \
+       {                                                               \
+         char buf1[FSTRLENMAX], buf2[FSTRLENMAX];                      \
+         FTOSTR (buf1, sizeof (buf1), "%g", r);                        \
+         FTOSTR (buf2, sizeof (buf2), "%g",                            \
+                 tests_strto ## FSUF[i].expected);                     \
+         printf ("%d: got wrong results %s, expected %s\n",            \
+                 i, buf1, buf2);                                       \
+         status = 1;                                                   \
+       }                                                               \
+    }                                                                  \
+                                                                       \
+  return status;                                                       \
+}
 
+GEN_TEST_STRTOD_FOREACH (TEST_STRTOD)
 
 static int
 do_test (void)
@@ -61,29 +101,7 @@ do_test (void)
       return 1;
     }
 
-  int status = 0;
-
-  for (int i = 0; i < NTESTS; ++i)
-    {
-      char *ep;
-      double r = strtod (tests[i].in, &ep);
-
-      if (*ep != '\0')
-       {
-         printf ("%d: got rest string \"%s\", expected \"\"\n", i, ep);
-         status = 1;
-       }
-
-      if (r != tests[i].expected
-         || copysign (10.0, r) != copysign (10.0, tests[i].expected))
-       {
-         printf ("%d: got wrong results %g, expected %g\n",
-                 i, r, tests[i].expected);
-         status = 1;
-       }
-    }
-
-  return status;
+  return STRTOD_TEST_FOREACH (test_strto);
 }
 
 #include <support/test-driver.c>