+2015-02-20 Paul Eggert <eggert@cs.ucla.edu>
+
+ printf, isinf, etc.: noncanonical != NaN
+ Do not require that isinf, printf, etc. treat noncanonical
+ values as NaNs. Instead, require only that they do not crash.
+ Problem reported by Joseph Myers in:
+ https://sourceware.org/ml/libc-alpha/2015-02/msg00244.html
+ * doc/posix-functions/dprintf.texi (dprintf):
+ * doc/posix-functions/fprintf.texi (fprintf):
+ * doc/posix-functions/isfinite.texi (isfinite):
+ * doc/posix-functions/isinf.texi (isinf):
+ * doc/posix-functions/isnan.texi (isnan):
+ * doc/posix-functions/printf.texi (printf):
+ * doc/posix-functions/snprintf.texi (snprintf):
+ * doc/posix-functions/sprintf.texi (sprintf):
+ * doc/posix-functions/vdprintf.texi (vdprintf):
+ * doc/posix-functions/vfprintf.texi (vfprintf):
+ * doc/posix-functions/vprintf.texi (vprintf):
+ * doc/posix-functions/vsnprintf.texi (vsnprintf):
+ * doc/posix-functions/vsprintf.texi (vsprintf):
+ Document this.
+ * m4/isfinite.m4 (gl_ISFINITEL_WORKS):
+ * m4/isinf.m4 (gl_ISINFL_WORKS):
+ * m4/isnanl.m4 (gl_FUNC_ISNANL_WORKS):
+ * m4/printf.m4 (gl_PRINTF_INFINITE_LONG_DOUBLE):
+ * tests/test-isfinite.c (test_isfinitel):
+ * tests/test-isinf.c (test_isinfl):
+ * tests/test-isnan.c (test_long_double):
+ * tests/test-isnanl.h (main):
+ * tests/test-snprintf-posix.h (test_function):
+ * tests/test-sprintf-posix.h (test_function):
+ * tests/test-vasnprintf-posix.c (test_function):
+ * tests/test-vasprintf-posix.c (test_function):
+o Test only that noncanonical values do not cause crashes, not that
+ they are treated as NaNs. In some cases this means a larger
+ output buffer is needed.
+
2015-02-20 Jaroslav Skarvada <jskarvad@redhat.com>
fts: remove redundant close() (trivial)
Portability problems fixed by Gnulib module @code{dprintf-posix}:
@itemize
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6.
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
This macro incorrectly yields true for some @samp{double} arguments, on some
platforms:
Linux/ia64 (signalling NaNs).
-@item
-This macro incorrectly yields true for some @samp{long double} arguments, on
-some platforms:
-x86 (pseudo-zeroes, unnormalized numbers, pseudo-denormals),
-x86_64 (pseudo-denormals),
-ia64 (pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, pseudo-denormals).
@end itemize
Portability problems not fixed by Gnulib:
@item
It is implementation-dependent whether @code{isfinite} raises an
exception given a signaling NaN operand.
+@item
+This macro returns an unspecified result when given noncanonical values
+such as unnormalized numbers, pseudo-denormals, pseudo-NaNs,
+pseudo-Infinities, and pseudo-zeroes.
@end itemize
@item
This macro is missing on some platforms:
AIX 5.1, IRIX 6.5, OSF/1 5.1, Solaris 11 2011-11.
-@item
-This macro incorrectly yields true for some @samp{long double} arguments, on
-some platforms:
-OpenBSD 4.9/x86 (pseudo-Infinity).
@end itemize
Portability problems not fixed by Gnulib:
@itemize
+@item
+This macro returns an unspecified result when given noncanonical values
+such as unnormalized numbers, pseudo-denormals, pseudo-NaNs,
+pseudo-Infinities, and pseudo-zeroes.
@end itemize
IRIX 6.5, OSF/1 5.1 with gcc, Solaris 11 2011-11.
@item
On IRIX 6.5 with @code{cc}, @code{isnan} does not recognize some NaNs.
-@item
-On NetBSD/i386 and glibc/ia64, @code{isnan} does not recognize some
-forms of NaNs, such as pseudo-NaNs, pseudo-Infinities, and
-unnormalized numbers.
-@item
-On i686 and @var{x}86-64, @code{__builtin_isnanl} (and thus
-@code{isnan} implementations based on it) in GCC 4.0 and later does
-not recognize pseudo-denormals as NaNs, and similarly for
-pseudo-zeroes, unnormalized numbers, and pseudo-denormals on ia64.
@end itemize
Portability problems not fixed by Gnulib:
@itemize
+@item
+This macro returns an unspecified result when given noncanonical values
+such as unnormalized numbers, pseudo-denormals, pseudo-NaNs,
+pseudo-Infinities, and pseudo-zeroes.
@end itemize
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
printf of @samp{long double} numbers is unsupported on some platforms:
BeOS.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, BeOS.
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
incorrect result on some platforms:
AIX 5.2, OSF/1 5.1, Solaris 11 2011-11, mingw, MSVC 9.
@item
-printf of @samp{long double} numbers outside the IEEE 754 range produces
-no meaningful results on some platforms:
-glibc and others, on x86, x86_64, IA-64 CPUs.
-@item
This function does not support the @samp{a} and @samp{A} directives on some
platforms:
glibc-2.3.6, Mac OS X 10.5, NetBSD 5.0, OpenBSD 4.0, AIX 5.2, HP-UX 11,
Portability problems not fixed by Gnulib:
@itemize
@item
+Formatting noncanonical @samp{long double} numbers produces
+nonmeaningful results on some platforms:
+glibc and others, on x86, x86_64, IA-64 CPUs.
+@item
When formatting an integer with grouping flag, this function inserts thousands
separators even in the "C" locale on some platforms:
NetBSD 5.1.
-# isfinite.m4 serial 14
+# isfinite.m4 serial 15
dnl Copyright (C) 2007-2015 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
AC_SUBST([ISFINITE_LIBM])
])
-dnl Test whether isfinite() on 'long double' recognizes all numbers which are
-dnl neither finite nor infinite. This test fails e.g. on i686, x86_64, ia64,
-dnl because of
-dnl - pseudo-denormals on x86_64,
-dnl - pseudo-zeroes, unnormalized numbers, and pseudo-denormals on i686,
-dnl - pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, and
-dnl pseudo-denormals on ia64.
+dnl Test whether isfinite() on 'long double' recognizes all canonical values
+dnl which are neither finite nor infinite.
AC_DEFUN([gl_ISFINITEL_WORKS],
[
AC_REQUIRE([AC_PROG_CC])
if (isfinite (x.value))
result |= 2;
}
- /* The isfinite macro should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isfinite should return something even for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- if (isfinite (x.value))
+ if (isfinite (x.value) && !isfinite (x.value))
result |= 4;
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- if (isfinite (x.value))
+ if (isfinite (x.value) && !isfinite (x.value))
result |= 8;
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- if (isfinite (x.value))
+ if (isfinite (x.value) && !isfinite (x.value))
result |= 16;
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- if (isfinite (x.value))
+ if (isfinite (x.value) && !isfinite (x.value))
result |= 32;
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- if (isfinite (x.value))
+ if (isfinite (x.value) && !isfinite (x.value))
result |= 64;
}
#endif
return result;
}]])], [gl_cv_func_isfinitel_works=yes], [gl_cv_func_isfinitel_works=no],
- [case "$host_cpu" in
- # Guess no on ia64, x86_64, i386.
- ia64 | x86_64 | i*86) gl_cv_func_isfinitel_works="guessing no";;
- *) gl_cv_func_isfinitel_works="guessing yes";;
- esac
- ])
+ [gl_cv_func_isfinitel_works="guessing yes"])
])
])
-# isinf.m4 serial 10
+# isinf.m4 serial 11
dnl Copyright (C) 2007-2015 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
dnl Test whether isinf() works:
dnl 1) Whether it correctly returns false for LDBL_MAX.
-dnl 2) Whether on 'long double' recognizes all numbers which are neither
-dnl finite nor infinite. This test fails on OpenBSD/x86, but could also
-dnl fail e.g. on i686, x86_64, ia64, because of
-dnl - pseudo-denormals on x86_64,
-dnl - pseudo-zeroes, unnormalized numbers, and pseudo-denormals on i686,
-dnl - pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, and
-dnl pseudo-denormals on ia64.
+dnl 2) Whether on 'long double' recognizes all canonical values which are
+dnl infinite.
AC_DEFUN([gl_ISINFL_WORKS],
[
AC_REQUIRE([AC_PROG_CC])
if (isinf (x.value))
result |= 2;
}
- /* The isinf macro should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isinf should return something even for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- if (isinf (x.value))
+ if (isinf (x.value) && !isinf (x.value))
result |= 4;
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- if (isinf (x.value))
+ if (isinf (x.value) && !isinf (x.value))
result |= 8;
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- if (isinf (x.value))
+ if (isinf (x.value) && !isinf (x.value))
result |= 16;
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- if (isinf (x.value))
+ if (isinf (x.value) && !isinf (x.value))
result |= 32;
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- if (isinf (x.value))
+ if (isinf (x.value) && !isinf (x.value))
result |= 64;
}
#endif
return result;
}]])], [gl_cv_func_isinfl_works=yes], [gl_cv_func_isinfl_works=no],
- [
- case "$host" in
- # Guess no on OpenBSD ia64, x86_64, i386.
- ia64-*-openbsd* | x86_64-*-openbsd* | i*86-*-openbsd*)
- gl_cv_func_isinfl_works="guessing no";;
- *)
- gl_cv_func_isinfl_works="guessing yes";;
- esac
- ])
+ [gl_cv_func_isinfl_works="guessing yes"])
])
])
-# isnanl.m4 serial 18
+# isnanl.m4 serial 19
dnl Copyright (C) 2007-2015 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
])
])
-dnl Test whether isnanl() recognizes all numbers which are neither finite nor
-dnl infinite. This test fails e.g. on NetBSD/i386 and on glibc/ia64.
-dnl Also, the GCC >= 4.0 built-in __builtin_isnanl does not pass the tests
-dnl - for pseudo-denormals on i686 and x86_64,
-dnl - for pseudo-zeroes, unnormalized numbers, and pseudo-denormals on ia64.
+dnl Test whether isnanl() recognizes all canonical numbers which are neither
+dnl finite nor infinite.
AC_DEFUN([gl_FUNC_ISNANL_WORKS],
[
AC_REQUIRE([AC_PROG_CC])
if (!isnanl (x.value))
result |= 2;
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isnanl should return something even for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- if (!isnanl (x.value))
+ if (isnanl (x.value) && !isnanl (x.value))
result |= 4;
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- if (!isnanl (x.value))
+ if (isnanl (x.value) && !isnanl (x.value))
result |= 8;
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- if (!isnanl (x.value))
+ if (isnanl (x.value) && !isnanl (x.value))
result |= 16;
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- if (!isnanl (x.value))
+ if (isnanl (x.value) && !isnanl (x.value))
result |= 32;
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- if (!isnanl (x.value))
+ if (isnanl (x.value) && !isnanl (x.value))
result |= 64;
}
#endif
}]])],
[gl_cv_func_isnanl_works=yes],
[gl_cv_func_isnanl_works=no],
- [case "$host_cpu" in
- # Guess no on ia64, x86_64, i386.
- ia64 | x86_64 | i*86) gl_cv_func_isnanl_works="guessing no";;
- *)
- case "$host_os" in
- netbsd*) gl_cv_func_isnanl_works="guessing no";;
- *) gl_cv_func_isnanl_works="guessing yes";;
- esac
- ;;
- esac
- ])
+ [gl_cv_func_isnanl_works="guessing yes"])
])
])
-# printf.m4 serial 51
+# printf.m4 serial 52
dnl Copyright (C) 2003, 2007-2015 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- if (sprintf (buf, "%Lf", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lf", x.value) <= 0)
result |= 4;
- if (sprintf (buf, "%Le", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Le", x.value) <= 0)
result |= 4;
- if (sprintf (buf, "%Lg", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lg", x.value) <= 0)
result |= 4;
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- if (sprintf (buf, "%Lf", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lf", x.value) <= 0)
result |= 8;
- if (sprintf (buf, "%Le", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Le", x.value) <= 0)
result |= 8;
- if (sprintf (buf, "%Lg", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lg", x.value) <= 0)
result |= 8;
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- if (sprintf (buf, "%Lf", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lf", x.value) <= 0)
result |= 16;
- if (sprintf (buf, "%Le", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Le", x.value) <= 0)
result |= 16;
- if (sprintf (buf, "%Lg", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lg", x.value) <= 0)
result |= 16;
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- if (sprintf (buf, "%Lf", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lf", x.value) <= 0)
result |= 32;
- if (sprintf (buf, "%Le", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Le", x.value) <= 0)
result |= 32;
- if (sprintf (buf, "%Lg", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lg", x.value) <= 0)
result |= 32;
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- if (sprintf (buf, "%Lf", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lf", x.value) <= 0)
result |= 64;
- if (sprintf (buf, "%Le", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Le", x.value) <= 0)
result |= 64;
- if (sprintf (buf, "%Lg", x.value) < 0
- || !strisnan (buf, 0, strlen (buf)))
+ if (sprintf (buf, "%Lg", x.value) <= 0)
result |= 64;
}
#endif
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
ASSERT (!isfinite (x.value));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isfinite should return something for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- ASSERT (!isfinite (x.value));
+ ASSERT (isfinite (x.value) || !isfinite (x.value));
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- ASSERT (!isfinite (x.value));
+ ASSERT (isfinite (x.value) || !isfinite (x.value));
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- ASSERT (!isfinite (x.value));
+ ASSERT (isfinite (x.value) || !isfinite (x.value));
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- ASSERT (!isfinite (x.value));
+ ASSERT (isfinite (x.value) || !isfinite (x.value));
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- ASSERT (!isfinite (x.value));
+ ASSERT (isfinite (x.value) || !isfinite (x.value));
}
#endif
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
ASSERT (!isinf (x.value));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isinf should return something for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- ASSERT (!isinf (x.value));
+ ASSERT (isinf (x.value) || !isinf (x.value));
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- ASSERT (!isinf (x.value));
+ ASSERT (isinf (x.value) || !isinf (x.value));
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- ASSERT (!isinf (x.value));
+ ASSERT (isinf (x.value) || !isinf (x.value));
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- ASSERT (!isinf (x.value));
+ ASSERT (isinf (x.value) || !isinf (x.value));
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- ASSERT (!isinf (x.value));
+ ASSERT (isinf (x.value) || !isinf (x.value));
}
#endif
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
ASSERT (isnan (x.value));
}
- /* The isnan function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isnan should return something for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- ASSERT (isnan (x.value));
+ ASSERT (isnan (x.value) || !isnan (x.value));
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- ASSERT (isnan (x.value));
+ ASSERT (isnan (x.value) || !isnan (x.value));
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- ASSERT (isnan (x.value));
+ ASSERT (isnan (x.value) || !isnan (x.value));
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- ASSERT (isnan (x.value));
+ ASSERT (isnan (x.value) || !isnan (x.value));
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- ASSERT (isnan (x.value));
+ ASSERT (isnan (x.value) || !isnan (x.value));
}
#endif
}
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
ASSERT (isnanl (x.value));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* isnanl should return something for noncanonical values. */
{ /* Pseudo-NaN. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- ASSERT (isnanl (x.value));
+ ASSERT (isnanl (x.value) || !isnanl (x.value));
}
{ /* Pseudo-Infinity. */
static memory_long_double x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- ASSERT (isnanl (x.value));
+ ASSERT (isnanl (x.value) || !isnanl (x.value));
}
{ /* Pseudo-Zero. */
static memory_long_double x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- ASSERT (isnanl (x.value));
+ ASSERT (isnanl (x.value) || !isnanl (x.value));
}
{ /* Unnormalized number. */
static memory_long_double x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- ASSERT (isnanl (x.value));
+ ASSERT (isnanl (x.value) || !isnanl (x.value));
}
{ /* Pseudo-Denormal. */
static memory_long_double x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- ASSERT (isnanl (x.value));
+ ASSERT (isnanl (x.value) || !isnanl (x.value));
}
#endif
{
char buf[8];
int size;
+ char result[5000];
/* Test return value convention. */
/* Test support of size specifiers as in C99. */
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
ASSERT (strcmp (result, "12345671 33") == 0);
}
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
ASSERT (strcmp (result, "12345672 33") == 0);
}
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
ASSERT (strcmp (result, "12345673 33") == 0);
}
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
ASSERT (strcmp (result, "1.5 33") == 0);
output of floating-point numbers. */
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
ASSERT (strcmp (result, "0x1.922p+1 33") == 0
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0x0p+0 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%a %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%a %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0);
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%a %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0);
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%a %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Rounding near the decimal point. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 0. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 1. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x1.8p+0 33") == 0
}
{ /* Rounding with precision 2. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x1.83p+0 33") == 0
}
{ /* Rounding with precision 3. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x1.829p+0 33") == 0
}
{ /* Rounding can turn a ...FFF into a ...000. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
ASSERT (strcmp (result, "0x1.800p+0 33") == 0
{ /* Rounding can turn a ...FFF into a ...000.
This shows a Mac OS X 10.3.9 (Darwin 7.9) bug. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
ASSERT (strcmp (result, "0x1.0p+1 33") == 0
}
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%10a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* Small precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
}
{ /* Large precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-10a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
ASSERT (strcmp (result, "0x1.p+0 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x001.cp+0 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%010a %d", Infinityd (), 33, 44, 55);
/* "0000000inf 33" is not a valid result; see
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050a %d", NaNd (), 33, 44, 55);
/* "0000000nan 33" is not a valid result; see
}
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.922p+1 33") == 0
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0x0p+0 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0);
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0);
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* snprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Rounding near the decimal point. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 0. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 1. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.8p+0 33") == 0
}
{ /* Rounding with precision 2. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.83p+0 33") == 0
}
{ /* Rounding with precision 3. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.829p+0 33") == 0
}
{ /* Rounding can turn a ...FFF into a ...000. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.800p+0 33") == 0
{ /* Rounding can turn a ...FFF into a ...000.
This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.0p+1 33") == 0
}
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* Small precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
}
{ /* Large precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.p+0 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x001.cp+0 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%010La %d", Infinityl (), 33, 44, 55);
/* "0000000inf 33" is not a valid result; see
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050La %d", NaNl (), 33, 44, 55);
/* "0000000nan 33" is not a valid result; see
/* Test the support of the %f format directive. */
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f", data[k].value);
ASSERT (strmatch (data[k].string, result));
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%f %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%10f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-10f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015f %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015f %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050f %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.f %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2f %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2f %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
}
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf", data[k].value);
ASSERT (strmatch (data[k].string, result));
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* snprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%10Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-10Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015Lf %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015Lf %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050Lf %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.Lf %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2Lf %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2Lf %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
/* Test the support of the %F format directive. */
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "INF 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-INF 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%F %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* FLAG_ZERO. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015F %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015F %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -INF 33") == 0
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.F %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2F %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2F %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
}
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "INF 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-INF 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%LF %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* FLAG_ZERO. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015LF %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015LF %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -INF 33") == 0
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.LF %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2LF %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.2LF %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
/* Test the support of the %e format directive. */
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "1.275000e+01 33") == 0
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1.234567e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-3.125000e-02 33") == 0
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0.000000e+00 33") == 0
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%e %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%15e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-15e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000e+00 33") == 0
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "2.e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.e %d", 9.75, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015e %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "0001.234000e+03 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015e %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050e %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.e %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.4e %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "9.9995e+02 33") == 0
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.4e %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1.0000e+03 33") == 0
}
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.275000e+01 33") == 0
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1.234567e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-3.125000e-02 33") == 0
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0.000000e+00 33") == 0
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* snprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%15Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-15Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000e+00 33") == 0
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "2.e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.Le %d", 9.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015Le %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "0001.234000e+03 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015Le %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050Le %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.Le %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.4Le %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "9.9995e+02 33") == 0
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.4Le %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1.0000e+03 33") == 0
/* Test the support of the %g format directive. */
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "12.75 33") == 0);
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1.23457e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-0.03125 33") == 0);
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%g %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%10g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-10g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.75 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+1.75 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.75000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.g %d", 9.75, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%010g %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "0000001234 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015g %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050g %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.g %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.5g %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.5g %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1000 33") == 0);
}
{ /* A positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "12.75 33") == 0);
}
{ /* A larger positive number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1.23457e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-0.03125 33") == 0);
}
{ /* Positive zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0 33") == 0);
}
{ /* Negative zero. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* snprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Width. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%10Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%-10Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.75 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%+Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+1.75 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "% Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.75000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ALT. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%#.Lg %d", 9.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%010Lg %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "0000001234 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%015Lg %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%050Lg %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.Lg %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.5Lg %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%.5Lg %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1000 33") == 0);
{
int count = -1;
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
ASSERT (strcmp (result, "123 ") == 0);
/* Test the support of the POSIX/XSI format strings with positions. */
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
ASSERT (strcmp (result, "55 33") == 0);
/* Test the support of the grouping flag. */
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "%'d %d", 1234567, 99);
ASSERT (result[strlen (result) - 1] == '9');
/* Test the support of the left-adjust flag. */
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "a%*sc", -3, "b");
ASSERT (strcmp (result, "ab c") == 0);
}
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "a%-*sc", 3, "b");
ASSERT (strcmp (result, "ab c") == 0);
}
{
- char result[100];
int retval =
my_snprintf (result, sizeof (result), "a%-*sc", -3, "b");
ASSERT (strcmp (result, "ab c") == 0);
/* Test the support of large precision. */
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.4000d %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.*d %d", 4000, 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.4000d %d", -1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.4000u %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.4000o %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.4000x %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%#.4000x %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_snprintf (result, sizeof (result), "%.4000f %d", 1.0, 99);
size_t i;
}
{
- char result[1000];
int retval =
my_snprintf (result, sizeof (result), "%.511f %d", 1.0, 99);
size_t i;
{
char input[5000];
- char result[5000];
int retval;
size_t i;
for (i = 1; i <= 8; i++)
{
char *block;
- char result[5000];
int retval;
block = (char *) malloc (i);
{
wchar_t *block;
size_t j;
- char result[5000];
int retval;
block = (wchar_t *) malloc (i * sizeof (wchar_t));
static void
test_function (int (*my_sprintf) (char *, const char *, ...))
{
+ char result[5000];
char buf[8];
/* Test return value convention. */
/* Test support of size specifiers as in C99. */
{
- char result[1000];
int retval =
my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
ASSERT (strcmp (result, "12345671 33") == 0);
}
{
- char result[1000];
int retval =
my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
ASSERT (strcmp (result, "12345672 33") == 0);
}
{
- char result[1000];
int retval =
my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
ASSERT (strcmp (result, "12345673 33") == 0);
}
{
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
ASSERT (strcmp (result, "1.5 33") == 0);
output of floating-point numbers. */
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
ASSERT (strcmp (result, "0x1.922p+1 33") == 0
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0x0p+0 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%a %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%a %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0);
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%a %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0);
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%a %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Rounding near the decimal point. */
- char result[1000];
int retval =
my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 0. */
- char result[1000];
int retval =
my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 1. */
- char result[1000];
int retval =
my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x1.8p+0 33") == 0
}
{ /* Rounding with precision 2. */
- char result[1000];
int retval =
my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x1.83p+0 33") == 0
}
{ /* Rounding with precision 3. */
- char result[1000];
int retval =
my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
ASSERT (strcmp (result, "0x1.829p+0 33") == 0
}
{ /* Rounding can turn a ...FFF into a ...000. */
- char result[1000];
int retval =
my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
ASSERT (strcmp (result, "0x1.800p+0 33") == 0
{ /* Rounding can turn a ...FFF into a ...000.
This shows a Mac OS X 10.3.9 (Darwin 7.9) bug. */
- char result[1000];
int retval =
my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
ASSERT (strcmp (result, "0x1.0p+1 33") == 0
}
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* Small precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
}
{ /* Large precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
ASSERT (strcmp (result, "0x1.p+0 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "0x001.cp+0 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%010a %d", Infinityd (), 33, 44, 55);
/* "0000000inf 33" is not a valid result; see
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050a %d", NaNd (), 33, 44, 55);
/* "0000000nan 33" is not a valid result; see
}
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.922p+1 33") == 0
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0x0p+0 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%La %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%La %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0);
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%La %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0);
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%La %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* sprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Rounding near the decimal point. */
- char result[1000];
int retval =
my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 0. */
- char result[1000];
int retval =
my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x2p+0 33") == 0
}
{ /* Rounding with precision 1. */
- char result[1000];
int retval =
my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.8p+0 33") == 0
}
{ /* Rounding with precision 2. */
- char result[1000];
int retval =
my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.83p+0 33") == 0
}
{ /* Rounding with precision 3. */
- char result[1000];
int retval =
my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.829p+0 33") == 0
}
{ /* Rounding can turn a ...FFF into a ...000. */
- char result[1000];
int retval =
my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.800p+0 33") == 0
{ /* Rounding can turn a ...FFF into a ...000.
This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
- char result[1000];
int retval =
my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.0p+1 33") == 0
}
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* Small precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
}
{ /* Large precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.cp+0 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
ASSERT (strcmp (result, "0x1.p+0 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "0x001.cp+0 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%010La %d", Infinityl (), 33, 44, 55);
/* "0000000inf 33" is not a valid result; see
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050La %d", NaNl (), 33, 44, 55);
/* "0000000nan 33" is not a valid result; see
/* Test the support of the %f format directive. */
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[1000];
int retval =
my_sprintf (result, "%f", data[k].value);
ASSERT (strmatch (data[k].string, result));
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%f %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015f %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050f %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2f %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2f %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
}
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[1000];
int retval =
my_sprintf (result, "%Lf", data[k].value);
ASSERT (strmatch (data[k].string, result));
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* sprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015Lf %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050Lf %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2Lf %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2Lf %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
/* Test the support of the %F format directive. */
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "INF 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-INF 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%F %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* FLAG_ZERO. */
- char result[1000];
int retval =
my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015F %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -INF 33") == 0
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2F %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2F %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
}
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "12.750000 33") == 0);
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234567.000000 33") == 0);
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-0.031250 33") == 0);
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0.000000 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "INF 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-INF 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%LF %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* FLAG_ZERO. */
- char result[1000];
int retval =
my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "00001234.000000 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015LF %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -INF 33") == 0
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1234 33") == 0);
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2LF %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.2LF %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1000.00 33") == 0);
/* Test the support of the %e format directive. */
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "1.275000e+01 33") == 0
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1.234567e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[1000];
int retval =
my_sprintf (result, "%e", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-3.125000e-02 33") == 0
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0.000000e+00 33") == 0
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%e %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000e+00 33") == 0
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "2.e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "0001.234000e+03 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015e %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050e %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.4e %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "9.9995e+02 33") == 0
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.4e %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1.0000e+03 33") == 0
}
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.275000e+01 33") == 0
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1.234567e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[1000];
int retval =
my_sprintf (result, "%Le", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-3.125000e-02 33") == 0
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0.000000e+00 33") == 0
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* sprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+1.750000e+00 33") == 0
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.750000e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "2.e+00 33") == 0
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "0001.234000e+03 33") == 0
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015Le %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050Le %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.4Le %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "9.9995e+02 33") == 0
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.4Le %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1.0000e+03 33") == 0
/* Test the support of the %g format directive. */
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
ASSERT (strcmp (result, "12.75 33") == 0);
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
ASSERT (strcmp (result, "1.23457e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[1000];
int retval =
my_sprintf (result, "%g", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
ASSERT (strcmp (result, "-0.03125 33") == 0);
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
ASSERT (strcmp (result, "0 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", minus_zerod, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%g %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
}
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.75 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "+1.75 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "1.75000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "0000001234 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015g %d", - Infinityd (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050g %d", NaNd (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.5g %d", 999.951, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.5g %d", 999.996, 33, 44, 55);
ASSERT (strcmp (result, "1000 33") == 0);
}
{ /* A positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
ASSERT (strcmp (result, "12.75 33") == 0);
}
{ /* A larger positive number. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
ASSERT (strcmp (result, "1.23457e+06 33") == 0
size_t k;
for (k = 0; k < SIZEOF (data); k++)
{
- char result[1000];
int retval =
my_sprintf (result, "%Lg", data[k].value);
const char *expected = data[k].string;
}
{ /* A negative number. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
ASSERT (strcmp (result, "-0.03125 33") == 0);
}
{ /* Positive zero. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
ASSERT (strcmp (result, "0 33") == 0);
}
{ /* Negative zero. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", minus_zerol, 33, 44, 55);
if (have_minus_zero ())
}
{ /* Positive infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "inf 33") == 0
}
{ /* Negative infinity. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, "-inf 33") == 0
}
{ /* NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
{ /* Quiet NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
/* Signalling NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%La %d", x.value, 33, 44, 55);
ASSERT (strlen (result) >= 3 + 3
&& strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* sprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Infinity. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Zero. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Unnormalized number. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
{ /* Pseudo-Denormal. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
- char result[1000];
int retval =
my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
}
#endif
{ /* Width. */
- char result[1000];
int retval =
my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_LEFT. */
- char result[1000];
int retval =
my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.75 33") == 0);
}
{ /* FLAG_SHOWSIGN. */
- char result[1000];
int retval =
my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "+1.75 33") == 0);
}
{ /* FLAG_SPACE. */
- char result[1000];
int retval =
my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, " 1.75 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.75000 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
ASSERT (strcmp (result, "2. 33") == 0);
}
{ /* FLAG_ALT. */
- char result[1000];
int retval =
my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
ASSERT (strcmp (result, "1.e+01 33") == 0
}
{ /* FLAG_ZERO with finite number. */
- char result[1000];
int retval =
my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "0000001234 33") == 0);
}
{ /* FLAG_ZERO with infinite number. */
- char result[1000];
int retval =
my_sprintf (result, "%015Lg %d", - Infinityl (), 33, 44, 55);
ASSERT (strcmp (result, " -inf 33") == 0
}
{ /* FLAG_ZERO with NaN. */
- char result[1000];
int retval =
my_sprintf (result, "%050Lg %d", NaNl (), 33, 44, 55);
ASSERT (strlen (result) == 50 + 3
}
{ /* Precision. */
- char result[1000];
int retval =
my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
ASSERT (strcmp (result, "1e+03 33") == 0
}
{ /* Precision with no rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.5Lg %d", 999.951L, 33, 44, 55);
ASSERT (strcmp (result, "999.95 33") == 0);
}
{ /* Precision with rounding. */
- char result[100];
int retval =
my_sprintf (result, "%.5Lg %d", 999.996L, 33, 44, 55);
ASSERT (strcmp (result, "1000 33") == 0);
{
int count = -1;
- char result[1000];
int retval =
my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
ASSERT (strcmp (result, "123 ") == 0);
/* Test the support of the POSIX/XSI format strings with positions. */
{
- char result[1000];
int retval =
my_sprintf (result, "%2$d %1$d", 33, 55);
ASSERT (strcmp (result, "55 33") == 0);
/* Test the support of the grouping flag. */
{
- char result[1000];
int retval =
my_sprintf (result, "%'d %d", 1234567, 99);
ASSERT (result[strlen (result) - 1] == '9');
/* Test the support of the left-adjust flag. */
{
- char result[1000];
int retval =
my_sprintf (result, "a%*sc", -3, "b");
ASSERT (strcmp (result, "ab c") == 0);
}
{
- char result[1000];
int retval =
my_sprintf (result, "a%-*sc", 3, "b");
ASSERT (strcmp (result, "ab c") == 0);
}
{
- char result[1000];
int retval =
my_sprintf (result, "a%-*sc", -3, "b");
ASSERT (strcmp (result, "ab c") == 0);
/* Test the support of large precision. */
{
- char result[5000];
int retval =
my_sprintf (result, "%.4000d %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%.*d %d", 4000, 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%.4000d %d", -1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%.4000u %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%.4000o %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%.4000x %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%#.4000x %d", 1234567, 99);
size_t i;
}
{
- char result[5000];
int retval =
my_sprintf (result, "%.4000f %d", 1.0, 99);
size_t i;
}
{
- char result[1000];
int retval =
my_sprintf (result, "%.511f %d", 1.0, 99);
size_t i;
{
char input[5000];
- char result[5000];
int retval;
size_t i;
for (i = 1; i <= 8; i++)
{
char *block;
- char result[5000];
int retval;
block = (char *) malloc (i);
{
wchar_t *block;
size_t j;
- char result[5000];
int retval;
block = (wchar_t *) malloc (i * sizeof (wchar_t));
ASSERT (length == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asnprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
char *result =
my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
char *result =
my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
char *result =
my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
char *result =
my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
char *result =
my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
#endif
ASSERT (length == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asnprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
char *result =
my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
char *result =
my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
char *result =
my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
char *result =
my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
char *result =
my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
#endif
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asnprintf should print something even for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
char *result =
my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 <= length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
#endif
ASSERT (length == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asnprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
char *result =
my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
char *result =
my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
char *result =
my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
char *result =
my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
char *result =
my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (length == strlen (result));
+ ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0);
free (result);
}
#endif
ASSERT (retval == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
int retval =
my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
int retval =
my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
int retval =
my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
int retval =
my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
int retval =
my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
#endif
ASSERT (retval == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
int retval =
my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
int retval =
my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
int retval =
my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
int retval =
my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
int retval =
my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
#endif
ASSERT (retval == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
int retval =
my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
int retval =
my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
int retval =
my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
int retval =
my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
int retval =
my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
#endif
ASSERT (retval == strlen (result));
free (result);
}
- /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
- Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
- Intel IA-64 Architecture Software Developer's Manual, Volume 1:
- Application Architecture.
- Table 5-2 "Floating-Point Register Encodings"
- Figure 5-6 "Memory to Floating-Point Register Data Translation"
- */
+ /* asprintf should print something for noncanonical values. */
{ /* Pseudo-NaN. */
static union { unsigned int word[4]; long double value; } x =
{ LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
int retval =
my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Infinity. */
int retval =
my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Zero. */
int retval =
my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Unnormalized number. */
int retval =
my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
{ /* Pseudo-Denormal. */
int retval =
my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
ASSERT (result != NULL);
- ASSERT (strlen (result) >= 3 + 3
- && strisnan (result, 0, strlen (result) - 3, 0)
- && strcmp (result + strlen (result) - 3, " 33") == 0);
ASSERT (retval == strlen (result));
+ ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
free (result);
}
#endif