test: Handle 32-bit double/64-bit long double configurations

keith-packard · keith-packard · commit 788901374ebb · 2023-11-10T23:35:37.000-08:00
Use 32-bit appropriate values where possible, otherwise skip tests
that assume doubles are 64-bits.

Signed-off-by: Keith Packard &lt;keithp@keithp.com&gt;
diff --git a/test/libc-testsuite/snprintf.c b/test/libc-testsuite/snprintf.c
@@ -178,6 +178,7 @@ int test_snprintf(void)
 	TEST_S(b, "123", "incorrect output");
 	TEST(i, b[5], 'x', "buffer overrun");
 
+#if __SIZEOF_DOUBLE__ == 8
 #if defined(TINY_STDIO) || (!defined(NO_FLOATING_POINT) && (!defined(_WANT_IO_LONG_DOUBLE) || defined(_LDBL_EQ_DBL)))
 	/* Perform ascii arithmetic to test printing tiny doubles */
 	TEST(i, snprintf(b, sizeof b, "%.1022f", 0x1p-1021), 1024, "%d != %d");
@@ -193,6 +194,7 @@ int test_snprintf(void)
 //	for (j=2; b[j]=='0'; j++);
 //	TEST(i, j, 1024, "%d != %d");
 #endif
+#endif
 
 
 #ifndef DISABLE_SLOW_TESTS
@@ -209,7 +211,7 @@ int test_snprintf(void)
 
         (void) fp_tests;
         (void) k;
-#if !defined(NO_FLOATING_POINT) && defined(_IO_FLOAT_EXACT)
+#if !defined(NO_FLOATING_POINT) && defined(_IO_FLOAT_EXACT) && __SIZEOF_DOUBLE__ == 8
 	for (j=0; fp_tests[j].fmt; j++) {
 		TEST(i, snprintf(b, sizeof b, fp_tests[j].fmt, fp_tests[j].f), (int) strlen(b), "%d != %d");
 		TEST_S(b, fp_tests[j].expect, "bad floating point conversion");
diff --git a/test/libc-testsuite/sscanf.c b/test/libc-testsuite/sscanf.c
@@ -44,6 +44,10 @@ TEST(t, d, (double)x, "%g != %g") )
 #pragma GCC diagnostic ignored "-Wliteral-range"
 #pragma GCC diagnostic ignored "-Wformat-extra-args"
 
+#if defined(__PICOLIBC__) && !defined(TINY_STDIO) && __SIZEOF_DOUBLE__ != 8
+#define NO_FLOATING_POINT
+#endif
+
 int test_sscanf(void)
 {
 	int i;
diff --git a/test/libc-testsuite/strtod.c b/test/libc-testsuite/strtod.c
@@ -59,8 +59,12 @@ int test_strtod(void)
 		TEST(d2, strtod(buf, 0), d, "round trip fail %a != %a (%a)");
 	}
 
+#if defined(__PICOLIBC__) && !defined(TINY_STDIO) && __SIZEOF_DOUBLE__ != 8
+        /* skip strtod tests for legacy stdio on systems with atypical doubles */
+#else
 	TEST(d, strtod("0x1p4", 0), 16.0, "hex float %a != %a");
 	TEST(d, strtod("0x1.1p4", 0), 17.0, "hex float %a != %a");
+#endif
 
 	return err;
 }
diff --git a/test/long_double.c b/test/long_double.c
@@ -190,6 +190,10 @@ typedef const struct {
 #undef TEST_IO_LONG_DOUBLE
 #endif
 
+#if defined(__PICOLIBC__) && !defined(TINY_STDIO) && __LDBL_MANT_DIG__ != 64
+#undef TEST_IO_LONG_DOUBLE
+#endif
+
 #ifdef TEST_IO_LONG_DOUBLE
 static long double vals[] = {
     1.0L,
diff --git a/test/math_errhandling.c b/test/math_errhandling.c
@@ -219,8 +219,8 @@ e_to_str(int e)
 #define BIGODD  0x1.123456789abcdef2p+63l
 #define BIGEVEN 0x1.123456789abcdef0p+63l
 #else
-#define BIGODD  0x1.123456789abcdp+52
-#define BIGEVEN 0x1.123456789abccp+52
+#define BIGODD  0x1.123456789abcdp+52l
+#define BIGEVEN 0x1.123456789abccp+52l
 #endif
 #define SMALL __LDBL_DENORM_MIN__
 #define FLOAT_T long double
@@ -266,10 +266,17 @@ e_to_str(int e)
 #endif
 #define DOUBLE_EXCEPTION_TEST EXCEPTION_TEST
 
+#if __SIZEOF_DOUBLE__ == 4
+#define BIG 3e38
+#define BIGODD  0x1.123456p+23
+#define BIGEVEN 0x1.123454p+23
+#define SMALL 1e-45
+#else
 #define BIG 1.7e308
 #define BIGODD  0x1.123456789abcdp+52
 #define BIGEVEN 0x1.123456789abccp+52
 #define SMALL 5e-324
+#endif
 #define FLOAT_T double
 #define MIN_VAL __DBL_DENORM_MIN__
 #define MAX_VAL __DBL_MAX__
diff --git a/test/printf_scanf.c b/test/printf_scanf.c
@@ -351,7 +351,11 @@ main(void)
 #define float_type double
 #define scanf_format "%lf"
 #if defined(TINY_STDIO) && !defined(_IO_FLOAT_EXACT)
-#define ERROR_MAX 1e-14
+# if __SIZEOF_DOUBLE__ == 4
+#  define ERROR_MAX 1e-6
+# else
+#  define ERROR_MAX 1e-14
+# endif
 #else
 #if (!defined(TINY_STDIO) && defined(_WANT_IO_LONG_DOUBLE))
 /* __ldtoa is really broken */
diff --git a/test/test-efcvt.c b/test/test-efcvt.c
@@ -105,6 +105,9 @@ const struct test fcvt_tests[] = {
 
 const struct test fcvt_extra_tests[] = {
 #ifdef TINY_STDIO
+#if __SIZEOF_DOUBLE__ == 4
+    { 0x1.fffffep127, 9, 39, 0, "340282350000000000000000000000000000000000000000" },
+#else
     { 0x1.fffffffffffffp1023, 17, 309, 0, "17976931348623157"
       "0000000000000000000000000000000000000000"
       "0000000000000000000000000000000000000000"
@@ -116,6 +119,7 @@ const struct test fcvt_extra_tests[] = {
       "000000000000"
       "00000000000000000"},
     { 0x1.fffffep127, 9, 39, 0, "340282346638528860000000000000000000000000000000" },
+#endif
 #else
     { 0x1.fffffffffffffp1023, 17, 309, 0, "17976931348623157"
       "0814527423731704356798070567525844996598"
diff --git a/test/test-fma.c b/test/test-fma.c
@@ -60,6 +60,21 @@ static int roundings[] = {
 #endif
 };
 
+static int rounding_map[] = {
+#ifdef FE_TONEAREST
+    0,
+#endif
+#ifdef FE_UPWARD
+    1,
+#endif
+#ifdef FE_DOWNWARD
+    2,
+#endif
+#ifdef FE_TOWARDZERO
+    3,
+#endif
+};
+
 static const char *rounding_names[] = {
 #ifdef FE_TONEAREST
     "FE_TONEAREST",
@@ -163,7 +178,7 @@ test_fmaf(void)
             float y = fmaf_vec[t].y;
             float z = fmaf_vec[t].z;
             volatile float r = fmaf(x, y, z);
-            float s = fmaf_vec[t].r[ro];
+            float s = fmaf_vec[t].r[rounding_map[ro]];
             if (!equalf(r, s)) {
                 strfromf(xs, sizeof(xs), "%a", x);
                 strfromf(ys, sizeof(xs), "%a", y);
@@ -227,7 +242,7 @@ test_fma(void)
             double y = fma_vec[t].y;
             double z = fma_vec[t].z;
             volatile double r = fma(x, y, z);
-            double s = fma_vec[t].r[ro];
+            double s = fma_vec[t].r[rounding_map[ro]];
             if (!equal(r, s)) {
                 printf("%u: round %s %a * %a + %a -> got %a want %a\n",
                        t, rounding_names[ro],
@@ -288,7 +303,7 @@ test_fmal(void)
             long double y = fmal_vec[t].y;
             long double z = fmal_vec[t].z;
             long double r = fmal(x, y, z);
-            long double s = fmal_vec[t].r[ro];
+            long double s = fmal_vec[t].r[rounding_map[ro]];
             if (!equall(r, s)) {
                 printf("%u: round %s %La * %La + %La -> got %La want %La\n",
                        t, rounding_names[ro],
diff --git a/test/test-strtod.c b/test/test-strtod.c
@@ -58,7 +58,8 @@ static const struct {
     { "0x1.000002p0@", 0x1.000002p0, 0x1.000002p0f, 0x1.000002p0l },
     { "0x1.000003p0@", 0x1.000003p0, 0x1.000004p0f, 0x1.000003p0l },
     { "0x1.000001p0@", 0x1.000001p0, 0x1.000000p0f, 0x1.000001p0l },
-    { "0x1.000001000000001p0@", 0x1.000001p0, 0x1.000002p0f, 0x1.000001000000001p0l },
+    { "0x1.000001000000001p0@", 0x1.000001000000001p0, 0x1.000002p0f, 0x1.000001000000001p0l },
+#if __SIZEOF_DOUBLE__ == 8
     /* Check round-to-even for doubles */
     { "0x100000000000008p0@", 0x1p56, 0x1p56f, 0x1.00000000000008p56l },
     { "0x100000000000008.p0@", 0x1p56, 0x1p56f, 0x1.00000000000008p56l },
@@ -67,16 +68,19 @@ static const struct {
     { "0x10000000000000801p0@", 0x1.0000000000001p64, 0x1p64f, 0x1.0000000000000801p64l },
     { "0x10000000000000800.0000000000001p0@", 0x1.0000000000001p64, 0x1p64f, 0x1.00000000000008p64l },
     { "0x10000000000001800p0@", 0x1.0000000000002p64, 0x1p64f, 0x1.00000000000018p64l },
+#endif
     /* Check max values for floats */
     { "0x1.fffffep126@", 0x1.fffffep126,  0x1.fffffep126f, 0x1.fffffep126l },
     { "0x1.ffffffp126@", 0x1.ffffffp126,  0x1.000000p127f, 0x1.ffffffp126l },
     { "0x1.fffffep127@", 0x1.fffffep127,  0x1.fffffep127f, 0x1.fffffep127l },
     { "0x1.ffffffp127@", 0x1.ffffffp127, (float) INFINITY, 0x1.ffffffp127l },   /* rounds up to INFINITY for float */
+#if __SIZEOF_DOUBLE__ == 8
     /* Check max values for doubles */
     { "0x1.fffffffffffffp1022@",  0x1.fffffffffffffp1022, (float) INFINITY, 0x1.fffffffffffffp1022l },
     { "0x1.fffffffffffff8p1022@", 0x1.0000000000000p1023, (float) INFINITY, 0x1.fffffffffffff8p1022l }, /* rounds up for double */
     { "0x1.fffffffffffffp1023@",  0x1.fffffffffffffp1023, (float) INFINITY, 0x1.fffffffffffffp1023l },
-#ifdef _TEST_LONG_DOUBLE
+#endif
+#if defined(_TEST_LONG_DOUBLE) && __SIZEOF_LONG_DOUBLE__ > 8
 #if __LDBL_MANT_DIG__ > __DBL_MANT_DIG__
     { "0x1.fffffffffffff8p1023@",      (double) INFINITY, (float) INFINITY, 0x1.fffffffffffff8p1023l }, /* rounds up to INFINITY for double */
 #else
diff --git a/test/testcases.c b/test/testcases.c
@@ -26,6 +26,9 @@
 #  define BINARY_FORMAT
 # endif
 # ifdef _HAS_IO_DOUBLE
+#  if __SIZEOF_DOUBLE__ == 4
+#   define LOW_FLOAT
+#  endif
 # elif defined(_HAS_IO_FLOAT)
 #  define LOW_FLOAT
 # else
@@ -42,6 +45,9 @@
 #  define NO_CASE_HEX
 # endif
 #else
+# if __SIZEOF_DOUBLE__ == 4
+#  define LOW_FLOAT
+# endif
 # ifdef NO_FLOATING_POINT
 #  define NO_FLOAT
 # endif
@@ -685,7 +691,11 @@
     result |= test(__LINE__, "INF", "%A", (double) INFINITY);
     result |= test(__LINE__, "-INF", "%A", (double) -INFINITY);
 #ifdef LOW_FLOAT
+#ifdef NORMALIZED_A
+    result |= test(__LINE__, "0x1p-149", "%a", 0x1p-149);
+#else
     result |= test(__LINE__, "0x0.000002p-126", "%a", 0x1p-149);
+#endif
 #else
 #ifdef NORMALIZED_A
     /* newlib legacy stdio normalizes %a format */

Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,12 @@ int test_strtod(void)`
`59`	`59`	`TEST(d2, strtod(buf, 0), d, "round trip fail %a != %a (%a)");`
`60`	`60`	`}`
`61`	`61`
	`62`	`+#if defined(__PICOLIBC__) && !defined(TINY_STDIO) && __SIZEOF_DOUBLE__ != 8`
	`63`	`+ /* skip strtod tests for legacy stdio on systems with atypical doubles */`
	`64`	`+#else`
`62`	`65`	`TEST(d, strtod("0x1p4", 0), 16.0, "hex float %a != %a");`
`63`	`66`	`TEST(d, strtod("0x1.1p4", 0), 17.0, "hex float %a != %a");`
	`67`	`+#endif`
`64`	`68`
`65`	`69`	`return err;`
`66`	`70`	`}`