[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
tests: Refactor functions for signalling NaNs
|
From: |
Bruno Haible |
|
Subject: |
tests: Refactor functions for signalling NaNs |
|
Date: |
Mon, 09 Oct 2023 23:22:58 +0200 |
This patch centralizes the code for producing signalling NaNs.
2023-10-09 Bruno Haible <bruno@clisp.org>
tests: Refactor functions for signalling NaNs.
* tests/snan.h: New file, based on tests/test-isnanf.h,
tests/test-isnand.h, tests/test-isnanl.h.
* tests/test-isfinite.c: Include snan.h.
(test_isfinitef, test_isfinited, test_isfinitel): Simplify.
* tests/test-isinf.c: Include snan.h.
(test_isinff, test_isinfd, test_isinfl): Simplify.
* tests/test-isnan.c: Include snan.h.
(test_float, test_double, test_long_double): Simplify.
* tests/test-isnanf.h: Include snan.h.
(main): Simplify.
* tests/test-isnand.h: Include snan.h.
(main): Simplify.
* tests/test-isnanl.h: Include snan.h.
(main): Simplify.
* tests/test-signbit.c: Include snan.h.
(test_signbitf, test_signbitd, test_signbitl): Simplify.
* tests/test-stdio.c: Include qnan.h, snan.h instead of nan.h.
(main): Test quiet NaNs always. Also test a signalling NaN.
* modules/isfinite-tests (Files): Add tests/nan.h, tests/snan.h.
* modules/isinf-tests (Files): Likewise.
* modules/isnan-tests (Files): Add tests/snan.h.
* modules/isnanf-tests (Files): Likewise.
* modules/isnanf-nolibm-tests (Files): Likewise.
* modules/isnand-tests (Files): Likewise.
* modules/isnand-nolibm-tests (Files): Likewise.
* modules/isnanl-tests (Files): Likewise.
* modules/isnanl-nolibm-tests (Files): Likewise.
* modules/signbit-tests (Files): Likewise.
* modules/stdio-tests (Files): Add tests/qnan.h, tests/snan.h.
diff --git a/modules/isfinite-tests b/modules/isfinite-tests
index 56207be027..bf7964648b 100644
--- a/modules/isfinite-tests
+++ b/modules/isfinite-tests
@@ -1,6 +1,8 @@
Files:
tests/test-isfinite.c
tests/infinity.h
+tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
diff --git a/modules/isinf-tests b/modules/isinf-tests
index 02719fe601..fb958d74ea 100644
--- a/modules/isinf-tests
+++ b/modules/isinf-tests
@@ -1,6 +1,8 @@
Files:
tests/test-isinf.c
tests/infinity.h
+tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
diff --git a/modules/isnan-tests b/modules/isnan-tests
index c794455c5b..06ebb72156 100644
--- a/modules/isnan-tests
+++ b/modules/isnan-tests
@@ -3,6 +3,7 @@ tests/test-isnan.c
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
diff --git a/modules/isnand-nolibm-tests b/modules/isnand-nolibm-tests
index 7b74b0b7ed..c8d92f3a75 100644
--- a/modules/isnand-nolibm-tests
+++ b/modules/isnand-nolibm-tests
@@ -4,6 +4,7 @@ tests/test-isnand.h
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentd.m4
diff --git a/modules/isnand-tests b/modules/isnand-tests
index fb3fc494c9..30a2c6f9e6 100644
--- a/modules/isnand-tests
+++ b/modules/isnand-tests
@@ -4,6 +4,7 @@ tests/test-isnand.h
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentd.m4
diff --git a/modules/isnanf-nolibm-tests b/modules/isnanf-nolibm-tests
index 4635edd9a5..acd8bd34bc 100644
--- a/modules/isnanf-nolibm-tests
+++ b/modules/isnanf-nolibm-tests
@@ -4,6 +4,7 @@ tests/test-isnanf.h
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
diff --git a/modules/isnanf-tests b/modules/isnanf-tests
index 1566695546..c094c02a37 100644
--- a/modules/isnanf-tests
+++ b/modules/isnanf-tests
@@ -4,6 +4,7 @@ tests/test-isnanf.h
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
diff --git a/modules/isnanl-nolibm-tests b/modules/isnanl-nolibm-tests
index 927ad69388..58a0f51fa1 100644
--- a/modules/isnanl-nolibm-tests
+++ b/modules/isnanl-nolibm-tests
@@ -4,6 +4,7 @@ tests/test-isnanl.h
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentl.m4
diff --git a/modules/isnanl-tests b/modules/isnanl-tests
index b00e5d5910..5a2d880c3f 100644
--- a/modules/isnanl-tests
+++ b/modules/isnanl-tests
@@ -4,6 +4,7 @@ tests/test-isnanl.h
tests/minus-zero.h
tests/infinity.h
tests/nan.h
+tests/snan.h
tests/macros.h
m4/exponentl.m4
diff --git a/modules/signbit-tests b/modules/signbit-tests
index 9465de790b..3b3ef9b6b6 100644
--- a/modules/signbit-tests
+++ b/modules/signbit-tests
@@ -4,6 +4,7 @@ tests/minus-zero.h
tests/infinity.h
tests/nan.h
tests/qnan.h
+tests/snan.h
tests/macros.h
m4/exponentf.m4
m4/exponentd.m4
diff --git a/modules/stdio-tests b/modules/stdio-tests
index 52b753e2f7..84199d5aa3 100644
--- a/modules/stdio-tests
+++ b/modules/stdio-tests
@@ -1,6 +1,8 @@
Files:
tests/test-stdio.c
tests/nan.h
+tests/qnan.h
+tests/snan.h
tests/macros.h
m4/exponentd.m4
diff --git a/tests/snan.h b/tests/snan.h
new file mode 100644
index 0000000000..e877000ece
--- /dev/null
+++ b/tests/snan.h
@@ -0,0 +1,120 @@
+/* Macros for signalling not-a-number.
+ Copyright (C) 2007-2023 Free Software Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>. */
+
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+
+#include "nan.h"
+
+
+#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
+
+# define HAVE_SNANF 1
+
+/* Returns a signalling 'float' NaN. */
+_GL_UNUSED static float
+SNaNf ()
+{
+ #define NWORDS \
+ ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
+ typedef union { float value; unsigned int word[NWORDS]; } memory_float;
+ memory_float m;
+ m.value = NaNf ();
+ #if FLT_EXPBIT0_BIT > 0
+ m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
+ #else
+ m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
+ ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
+ #endif
+ if (FLT_EXPBIT0_WORD < NWORDS / 2)
+ m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
+ else
+ m.word[0] |= (unsigned int) 1;
+ #undef NWORDS
+ return m.value;
+}
+
+#endif
+
+
+#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
+
+# define HAVE_SNAND 1
+
+/* Returns a signalling 'double' NaN. */
+_GL_UNUSED static double
+SNaNd ()
+{
+ #define NWORDS \
+ ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
+ typedef union { double value; unsigned int word[NWORDS]; } memory_double;
+ memory_double m;
+ m.value = NaNd ();
+ #if DBL_EXPBIT0_BIT > 0
+ m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
+ #else
+ m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
+ ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
+ #endif
+ m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
+ |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
+ #undef NWORDS
+ return m.value;
+}
+
+#endif
+
+
+#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
+
+# define HAVE_SNANL 1
+
+/* Returns a signalling 'long double' NaN. */
+_GL_UNUSED static long double
+SNaNl ()
+{
+ /* A bit pattern that is different from a Quiet NaN. With a bit of luck,
+ it's a Signalling NaN. */
+ #define NWORDS \
+ ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
+ typedef union { unsigned int word[NWORDS]; long double value; }
+ memory_long_double;
+ memory_long_double m;
+ m.value = NaNl ();
+ #if defined __powerpc__ && LDBL_MANT_DIG == 106
+ /* This is PowerPC "double double", a pair of two doubles. Inf and NaN are
+ represented as the corresponding 64-bit IEEE values in the first double;
+ the second is ignored. Manipulate only the first double. */
+ #define HNWORDS \
+ ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
+ #else
+ #define HNWORDS NWORDS
+ #endif
+ #if LDBL_EXPBIT0_BIT > 0
+ m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
+ #else
+ m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < HNWORDS / 2 ? 1 : - 1)]
+ ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
+ #endif
+ m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < HNWORDS / 2 ? 1 : - 1)]
+ |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
+ #undef HNWORDS
+ #undef NWORDS
+ return m.value;
+}
+
+#endif
diff --git a/tests/test-isfinite.c b/tests/test-isfinite.c
index edb5f43327..3c6da8d128 100644
--- a/tests/test-isfinite.c
+++ b/tests/test-isfinite.c
@@ -30,6 +30,7 @@
#include <limits.h>
#include "infinity.h"
+#include "snan.h"
#include "macros.h"
float zerof = 0.0f;
@@ -56,27 +57,9 @@ test_isfinitef ()
ASSERT (!isfinite (- Infinityf ()));
/* Quiet NaN. */
ASSERT (!isfinite (zerof / zerof));
-#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
+#if HAVE_SNANF
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { float value; unsigned int word[NWORDS]; } memory_float;
- memory_float m;
- m.value = zerof / zerof;
-# if FLT_EXPBIT0_BIT > 0
- m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
-# else
- m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- if (FLT_EXPBIT0_WORD < NWORDS / 2)
- m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
- else
- m.word[0] |= (unsigned int) 1;
- ASSERT (!isfinite (m.value));
- #undef NWORDS
- }
+ ASSERT (!isfinite (SNaNf ()));
#endif
}
@@ -100,36 +83,15 @@ test_isfinited ()
ASSERT (!isfinite (- Infinityd ()));
/* Quiet NaN. */
ASSERT (!isfinite (zerod / zerod));
-#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
+#if HAVE_SNAND
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { double value; unsigned int word[NWORDS]; } memory_double;
- memory_double m;
- m.value = zerod / zerod;
-# if DBL_EXPBIT0_BIT > 0
- m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
-# else
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
- ASSERT (!isfinite (m.value));
- #undef NWORDS
- }
+ ASSERT (!isfinite (SNaNd ()));
#endif
}
static void
test_isfinitel ()
{
- #define NWORDS \
- ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
- typedef union { unsigned int word[NWORDS]; long double value; }
- memory_long_double;
-
/* Zero. */
ASSERT (isfinite (0.0L));
/* Subnormal values. */
@@ -147,35 +109,16 @@ test_isfinitel ()
ASSERT (!isfinite (- Infinityl ()));
/* Quiet NaN. */
ASSERT (!isfinite (zerol / zerol));
-
-#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
- /* A bit pattern that is different from a Quiet NaN. With a bit of luck,
- it's a Signalling NaN. */
- {
-#if defined __powerpc__ && LDBL_MANT_DIG == 106
- /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are
- represented as the corresponding 64-bit IEEE values in the first double;
- the second is ignored. Manipulate only the first double. */
- #undef NWORDS
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
-#endif
-
- memory_long_double m;
- m.value = zerol / zerol;
-# if LDBL_EXPBIT0_BIT > 0
- m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
-# else
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
- ASSERT (!isfinite (m.value));
- }
+#if HAVE_SNANL
+ /* Signalling NaN. */
+ ASSERT (!isfinite (SNaNl ()));
#endif
#if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined
__amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined
_M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
+ #define NWORDS \
+ ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
+ typedef union { unsigned int word[NWORDS]; long double value; }
+ memory_long_double;
/* Representation of an 80-bit 'long double' as an initializer for a sequence
of 'unsigned int' words. */
# ifdef WORDS_BIGENDIAN
@@ -225,9 +168,8 @@ test_isfinitel ()
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isfinite (x.value) || !isfinite (x.value));
}
-#endif
-
#undef NWORDS
+#endif
}
int
diff --git a/tests/test-isinf.c b/tests/test-isinf.c
index f1bca0ce10..d3e435b3b2 100644
--- a/tests/test-isinf.c
+++ b/tests/test-isinf.c
@@ -30,6 +30,7 @@
#include <limits.h>
#include "infinity.h"
+#include "snan.h"
#include "macros.h"
float zerof = 0.0f;
@@ -58,27 +59,9 @@ test_isinff ()
ASSERT (isinf (- Infinityf ()));
/* Quiet NaN. */
ASSERT (!isinf (zerof / zerof));
-#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
+#if HAVE_SNANF
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { float value; unsigned int word[NWORDS]; } memory_float;
- memory_float m;
- m.value = zerof / zerof;
-# if FLT_EXPBIT0_BIT > 0
- m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
-# else
- m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- if (FLT_EXPBIT0_WORD < NWORDS / 2)
- m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
- else
- m.word[0] |= (unsigned int) 1;
- ASSERT (!isinf (m.value));
- #undef NWORDS
- }
+ ASSERT (!isinf (SNaNf ()));
#endif
}
@@ -104,36 +87,15 @@ test_isinfd ()
ASSERT (isinf (- Infinityd ()));
/* Quiet NaN. */
ASSERT (!isinf (zerod / zerod));
-#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
+#if HAVE_SNAND
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { double value; unsigned int word[NWORDS]; } memory_double;
- memory_double m;
- m.value = zerod / zerod;
-# if DBL_EXPBIT0_BIT > 0
- m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
-# else
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
- ASSERT (!isinf (m.value));
- #undef NWORDS
- }
+ ASSERT (!isinf (SNaNd ()));
#endif
}
static void
test_isinfl ()
{
- #define NWORDS \
- ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
- typedef union { unsigned int word[NWORDS]; long double value; }
- memory_long_double;
-
/* Zero. */
ASSERT (!isinf (0.0L));
/* Subnormal values. */
@@ -153,35 +115,16 @@ test_isinfl ()
ASSERT (isinf (- Infinityl ()));
/* Quiet NaN. */
ASSERT (!isinf (zerol / zerol));
-
-#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
- /* A bit pattern that is different from a Quiet NaN. With a bit of luck,
- it's a Signalling NaN. */
- {
-#if defined __powerpc__ && LDBL_MANT_DIG == 106
- /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are
- represented as the corresponding 64-bit IEEE values in the first double;
- the second is ignored. Manipulate only the first double. */
- #undef NWORDS
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
-#endif
-
- memory_long_double m;
- m.value = zerol / zerol;
-# if LDBL_EXPBIT0_BIT > 0
- m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
-# else
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
- ASSERT (!isinf (m.value));
- }
+#if HAVE_SNANL
+ /* Signalling NaN. */
+ ASSERT (!isinf (SNaNl ()));
#endif
#if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined
__amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined
_M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
+ #define NWORDS \
+ ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
+ typedef union { unsigned int word[NWORDS]; long double value; }
+ memory_long_double;
/* Representation of an 80-bit 'long double' as an initializer for a sequence
of 'unsigned int' words. */
# ifdef WORDS_BIGENDIAN
@@ -231,9 +174,8 @@ test_isinfl ()
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isinf (x.value) || !isinf (x.value));
}
-#endif
-
#undef NWORDS
+#endif
}
int
diff --git a/tests/test-isnan.c b/tests/test-isnan.c
index 062c4cad24..2d744596f5 100644
--- a/tests/test-isnan.c
+++ b/tests/test-isnan.c
@@ -32,6 +32,7 @@
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
static void
@@ -51,26 +52,9 @@ test_float (void)
ASSERT (!isnan (- Infinityf ()));
/* Quiet NaN. */
ASSERT (isnan (NaNf ()));
-#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
+#if HAVE_SNANF
/* Signalling NaN. */
- {
- #define NWORDSF \
- ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { float value; unsigned int word[NWORDSF]; } memory_float;
- memory_float m;
- m.value = NaNf ();
-# if FLT_EXPBIT0_BIT > 0
- m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
-# else
- m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDSF / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- if (FLT_EXPBIT0_WORD < NWORDSF / 2)
- m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
- else
- m.word[0] |= (unsigned int) 1;
- ASSERT (isnan (m.value));
- }
+ ASSERT (isnan (SNaNf ()));
#endif
}
@@ -91,35 +75,15 @@ test_double (void)
ASSERT (!isnan (- Infinityd ()));
/* Quiet NaN. */
ASSERT (isnan (NaNd ()));
-#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
+#if HAVE_SNAND
/* Signalling NaN. */
- {
- #define NWORDSD \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { double value; unsigned int word[NWORDSD]; } memory_double;
- memory_double m;
- m.value = NaNd ();
-# if DBL_EXPBIT0_BIT > 0
- m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
-# else
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDSD / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDSD / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
- ASSERT (isnan (m.value));
- }
+ ASSERT (isnan (SNaNd ()));
#endif
}
static void
test_long_double (void)
{
- #define NWORDSL \
- ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
- typedef union { unsigned int word[NWORDSL]; long double value; }
- memory_long_double;
-
/* Finite values. */
ASSERT (!isnan (3.141L));
ASSERT (!isnan (3.141e30L));
@@ -134,35 +98,16 @@ test_long_double (void)
ASSERT (!isnan (- Infinityl ()));
/* Quiet NaN. */
ASSERT (isnan (NaNl ()));
-
-#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
- /* A bit pattern that is different from a Quiet NaN. With a bit of luck,
- it's a Signalling NaN. */
- {
-#if defined __powerpc__ && LDBL_MANT_DIG == 106
- /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are
- represented as the corresponding 64-bit IEEE values in the first double;
- the second is ignored. Manipulate only the first double. */
- #undef NWORDSL
- #define NWORDSL \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
-#endif
-
- memory_long_double m;
- m.value = NaNl ();
-# if LDBL_EXPBIT0_BIT > 0
- m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
-# else
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDSL / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDSL / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
- ASSERT (isnan (m.value));
- }
+#if HAVE_SNANL
+ /* Signalling NaN. */
+ ASSERT (isnan (SNaNl ()));
#endif
#if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined
__amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined
_M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
+ #define NWORDS \
+ ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
+ typedef union { unsigned int word[NWORDS]; long double value; }
+ memory_long_double;
/* Representation of an 80-bit 'long double' as an initializer for a sequence
of 'unsigned int' words. */
# ifdef WORDS_BIGENDIAN
@@ -212,6 +157,7 @@ test_long_double (void)
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isnan (x.value) || !isnan (x.value));
}
+ #undef NWORDS
#endif
}
diff --git a/tests/test-isnand.h b/tests/test-isnand.h
index 2d89ce1aed..e52756efd5 100644
--- a/tests/test-isnand.h
+++ b/tests/test-isnand.h
@@ -21,6 +21,7 @@
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
int
@@ -40,24 +41,9 @@ main ()
ASSERT (!isnand (- Infinityd ()));
/* Quiet NaN. */
ASSERT (isnand (NaNd ()));
-#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
+#if HAVE_SNAND
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { double value; unsigned int word[NWORDS]; } memory_double;
- memory_double m;
- m.value = NaNd ();
-# if DBL_EXPBIT0_BIT > 0
- m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
-# else
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
- ASSERT (isnand (m.value));
- }
+ ASSERT (isnand (SNaNd ()));
#endif
return 0;
}
diff --git a/tests/test-isnanf.h b/tests/test-isnanf.h
index aa2a72c128..0cd78350a6 100644
--- a/tests/test-isnanf.h
+++ b/tests/test-isnanf.h
@@ -21,6 +21,7 @@
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
int
@@ -40,26 +41,9 @@ main ()
ASSERT (!isnanf (- Infinityf ()));
/* Quiet NaN. */
ASSERT (isnanf (NaNf ()));
-#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
+#if HAVE_SNANF
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { float value; unsigned int word[NWORDS]; } memory_float;
- memory_float m;
- m.value = NaNf ();
-# if FLT_EXPBIT0_BIT > 0
- m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
-# else
- m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- if (FLT_EXPBIT0_WORD < NWORDS / 2)
- m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
- else
- m.word[0] |= (unsigned int) 1;
- ASSERT (isnanf (m.value));
- }
+ ASSERT (isnanf (SNaNf ()));
#endif
return 0;
}
diff --git a/tests/test-isnanl.h b/tests/test-isnanl.h
index 4ca408bf91..fa7d87b3cd 100644
--- a/tests/test-isnanl.h
+++ b/tests/test-isnanl.h
@@ -22,16 +22,12 @@
#include "minus-zero.h"
#include "infinity.h"
#include "nan.h"
+#include "snan.h"
#include "macros.h"
int
main ()
{
- #define NWORDS \
- ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
- typedef union { unsigned int word[NWORDS]; long double value; }
- memory_long_double;
-
/* Finite values. */
ASSERT (!isnanl (3.141L));
ASSERT (!isnanl (3.141e30L));
@@ -46,35 +42,16 @@ main ()
ASSERT (!isnanl (- Infinityl ()));
/* Quiet NaN. */
ASSERT (isnanl (NaNl ()));
-
-#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
- /* A bit pattern that is different from a Quiet NaN. With a bit of luck,
- it's a Signalling NaN. */
- {
-#if defined __powerpc__ && LDBL_MANT_DIG == 106
- /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are
- represented as the corresponding 64-bit IEEE values in the first double;
- the second is ignored. Manipulate only the first double. */
- #undef NWORDS
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
-#endif
-
- memory_long_double m;
- m.value = NaNl ();
-# if LDBL_EXPBIT0_BIT > 0
- m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
-# else
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
- ASSERT (isnanl (m.value));
- }
+#if HAVE_SNANL
+ /* Signalling NaN. */
+ ASSERT (isnanl (SNaNl ()));
#endif
#if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined
__amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined
_M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
+ #define NWORDS \
+ ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
+ typedef union { unsigned int word[NWORDS]; long double value; }
+ memory_long_double;
/* Representation of an 80-bit 'long double' as an initializer for a sequence
of 'unsigned int' words. */
# ifdef WORDS_BIGENDIAN
@@ -124,6 +101,7 @@ main ()
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
ASSERT (isnanl (x.value) || !isnanl (x.value));
}
+ #undef NWORDS
#endif
return 0;
diff --git a/tests/test-signbit.c b/tests/test-signbit.c
index 2c1daccef2..f89fdf6d05 100644
--- a/tests/test-signbit.c
+++ b/tests/test-signbit.c
@@ -31,6 +31,7 @@
#include "minus-zero.h"
#include "infinity.h"
#include "qnan.h"
+#include "snan.h"
#include "macros.h"
float zerof = 0.0f;
@@ -59,27 +60,9 @@ test_signbitf ()
/* Quiet NaN. */
ASSERT (!signbit (positive_NaNf ()));
ASSERT (signbit (negative_NaNf ()));
-#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
+#if HAVE_SNANF
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { float value; unsigned int word[NWORDS]; } memory_float;
- memory_float m;
- m.value = zerof / zerof;
-# if FLT_EXPBIT0_BIT > 0
- m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
-# else
- m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- if (FLT_EXPBIT0_WORD < NWORDS / 2)
- m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
- else
- m.word[0] |= (unsigned int) 1;
- (void) signbit (m.value);
- #undef NWORDS
- }
+ (void) signbit (SNaNf ());
#endif
}
@@ -105,25 +88,9 @@ test_signbitd ()
/* Quiet NaN. */
ASSERT (!signbit (positive_NaNd ()));
ASSERT (signbit (negative_NaNd ()));
-#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
+#if HAVE_SNAND
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
- typedef union { double value; unsigned int word[NWORDS]; } memory_double;
- memory_double m;
- m.value = zerod / zerod;
-# if DBL_EXPBIT0_BIT > 0
- m.word[DBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (DBL_EXPBIT0_BIT - 1);
-# else
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[DBL_EXPBIT0_WORD + (DBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << DBL_EXPBIT0_BIT;
- (void) signbit (m.value);
- #undef NWORDS
- }
+ (void) signbit (SNaNd ());
#endif
}
@@ -149,35 +116,9 @@ test_signbitl ()
/* Quiet NaN. */
ASSERT (!signbit (positive_NaNl ()));
ASSERT (signbit (negative_NaNl ()));
-#if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
+#if HAVE_SNANL
/* Signalling NaN. */
- {
- #define NWORDS \
- ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned
int))
- typedef union { long double value; unsigned int word[NWORDS]; }
memory_long_double;
-
-#if defined __powerpc__ && LDBL_MANT_DIG == 106
- /* This is PowerPC "double double", a pair of two doubles. Inf and Nan are
- represented as the corresponding 64-bit IEEE values in the first double;
- the second is ignored. Manipulate only the first double. */
- #undef NWORDS
- #define NWORDS \
- ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
-#endif
-
- memory_long_double m;
- m.value = zerol / zerol;
-# if LDBL_EXPBIT0_BIT > 0
- m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
-# else
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
-# endif
- m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
- |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
- (void) signbit (m.value);
- #undef NWORDS
- }
+ (void) signbit (SNaNl ());
#endif
}
diff --git a/tests/test-stdio.c b/tests/test-stdio.c
index 9794f4d856..cc44250150 100644
--- a/tests/test-stdio.c
+++ b/tests/test-stdio.c
@@ -39,12 +39,25 @@ va_list t5;
#include <string.h>
-#include "nan.h"
+#include "qnan.h"
+#include "snan.h"
#include "macros.h"
int
main (void)
{
+ {
+ double value1;
+ char buf[64];
+
+ value1 = positive_NaNd();
+ sprintf (buf, "%g", value1);
+ ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX);
+
+ value1 = negative_NaNd();
+ sprintf (buf, "%g", value1);
+ ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX);
+ }
#if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT
/* Check the value of _PRINTF_NAN_LEN_MAX. */
{
@@ -56,7 +69,7 @@ main (void)
memory_double value2;
char buf[64];
- value1 = NaNd();
+ value1 = SNaNd();
sprintf (buf, "%g", value1);
ASSERT (strlen (buf) <= _PRINTF_NAN_LEN_MAX);
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- tests: Refactor functions for signalling NaNs,
Bruno Haible <=