X-Git-Url: https://erislabs.net/gitweb/?a=blobdiff_plain;f=tests%2Ftest-sprintf-posix.h;h=5fb9250c101a23304c0741762431f778a4b9478f;hb=9d5d03ff00b8b11b51450ce107159b263efb1739;hp=a61112b74286114480348eac39023fba7573d344;hpb=48e570fe66a8153d82ef3f51e496211d0c553ecd;p=gnulib.git

diff --git a/tests/test-sprintf-posix.h b/tests/test-sprintf-posix.h
index a61112b74..5fb9250c1 100644
--- a/tests/test-sprintf-posix.h
+++ b/tests/test-sprintf-posix.h
@@ -1,10 +1,10 @@
 /* Test of POSIX compatible vsprintf() and sprintf() functions.
-   Copyright (C) 2007 Free Software Foundation, Inc.
+   Copyright (C) 2007-2008 Free Software Foundation, Inc.
 
-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -12,21 +12,46 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software Foundation,
-   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
 
-/* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0.  */
-#ifdef __DECC
-static double
-NaN ()
+#include "nan.h"
+
+/* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0.  */
+static int
+have_minus_zero ()
 {
-  static double zero = 0.0;
-  return zero / zero;
+  static double plus_zero = 0.0;
+  double minus_zero = - plus_zero;
+  return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
 }
+
+/* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+   So we use -zerod instead.  */
+double zerod = 0.0;
+
+/* On HP-UX 10.20, negating 0.0L does not yield -0.0L.
+   So we use minus_zerol instead.
+   Note that the expression -LDBL_MIN * LDBL_MIN does not work on other
+   platforms, such as when cross-compiling to PowerPC on MacOS X 10.5.  */
+#if defined __hpux || defined __sgi
+long double minus_zerol = -LDBL_MIN * LDBL_MIN;
 #else
-# define NaN() (0.0 / 0.0)
+long double minus_zerol = -0.0L;
+#endif
+
+/* Representation of an 80-bit 'long double' as an initializer for a sequence
+   of 'unsigned int' words.  */
+#ifdef WORDS_BIGENDIAN
+# define LDBL80_WORDS(exponent,manthi,mantlo) \
+    { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
+      ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16),    \
+      (unsigned int) (mantlo) << 16                                        \
+    }
+#else
+# define LDBL80_WORDS(exponent,manthi,mantlo) \
+    { mantlo, manthi, exponent }
 #endif
 
 static int
@@ -40,6 +65,27 @@ strmatch (const char *pattern, const char *string)
   return 1;
 }
 
+/* Test whether string[start_index..end_index-1] is a valid textual
+   representation of NaN.  */
+static int
+strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
+{
+  if (start_index < end_index)
+    {
+      if (string[start_index] == '-')
+	start_index++;
+      if (start_index + 3 <= end_index
+	  && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
+	{
+	  start_index += 3;
+	  if (start_index == end_index
+	      || (string[start_index] == '(' && string[end_index - 1] == ')'))
+	    return 1;
+	}
+    }
+  return 0;
+}
+
 static void
 test_function (int (*my_sprintf) (char *, const char *, ...))
 {
@@ -126,8 +172,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
-    ASSERT (strcmp (result, "-0x0p+0 33") == 0);
+      my_sprintf (result, "%a %d", -zerod, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0x0p+0 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -150,8 +197,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%a %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%a %d", NaNd (), 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));
   }
 
@@ -345,10 +394,12 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* FLAG_ZERO with NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%010a %d", NaN (), 33, 44, 55);
+      my_sprintf (result, "%050a %d", NaNd (), 33, 44, 55);
     /* "0000000nan 33" is not a valid result; see
        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
-    ASSERT (strcmp (result, "       nan 33") == 0);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -385,8 +436,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "-0x0p+0 33") == 0);
+      my_sprintf (result, "%La %d", minus_zerol, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0x0p+0 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -409,10 +461,99 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%La %d", NaNl (), 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));
+  }
+#if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
+  { /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
+  {
+    /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && 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"
+   */
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+#endif
 
   { /* Rounding near the decimal point.  */
     char result[1000];
@@ -605,10 +746,12 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* FLAG_ZERO with NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
+      my_sprintf (result, "%050La %d", NaNl (), 33, 44, 55);
     /* "0000000nan 33" is not a valid result; see
        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
-    ASSERT (strcmp (result, "       nan 33") == 0);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -738,8 +881,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%f %d", -0.0, 33, 44, 55);
-    ASSERT (strcmp (result, "-0.000000 33") == 0);
+      my_sprintf (result, "%f %d", -zerod, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0.000000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -764,8 +908,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%f %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%f %d", NaNd (), 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));
   }
 
@@ -837,8 +983,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* FLAG_ZERO with NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%015f %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "            nan 33") == 0);
+      my_sprintf (result, "%050f %d", NaNd (), 33, 44, 55);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -850,6 +998,22 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     ASSERT (retval == strlen (result));
   }
 
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
   { /* A positive number.  */
     char result[1000];
     int retval =
@@ -974,8 +1138,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%Lf %d", -0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "-0.000000 33") == 0);
+      my_sprintf (result, "%Lf %d", minus_zerol, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0.000000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -998,13 +1163,101 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%Lf %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%Lf %d", NaNl (), 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));
+  }
+#if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
+  { /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+  {
+    /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && 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"
+   */
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
   }
+  { /* 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));
+  }
+#endif
 
   { /* Width.  */
     char result[1000];
@@ -1072,11 +1325,12 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* FLAG_ZERO with NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%015Lf %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "            nan 33") == 0);
+      my_sprintf (result, "%050Lf %d", NaNl (), 33, 44, 55);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1088,6 +1342,22 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     ASSERT (retval == strlen (result));
   }
 
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
   /* Test the support of the %F format directive.  */
 
   { /* A positive number.  */
@@ -1125,8 +1395,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
-    ASSERT (strcmp (result, "-0.000000 33") == 0);
+      my_sprintf (result, "%F %d", -zerod, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0.000000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1151,8 +1422,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%F %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "NAN 33") == 0);
+      my_sprintf (result, "%F %d", NaNd (), 33, 44, 55);
+    ASSERT (strlen (result) >= 3 + 3
+	    && strisnan (result, 0, strlen (result) - 3, 1)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1181,6 +1454,22 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     ASSERT (retval == strlen (result));
   }
 
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
   { /* A positive number.  */
     char result[1000];
     int retval =
@@ -1216,8 +1505,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "-0.000000 33") == 0);
+      my_sprintf (result, "%LF %d", minus_zerol, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0.000000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1240,11 +1530,12 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%LF %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "NAN 33") == 0);
+      my_sprintf (result, "%LF %d", NaNl (), 33, 44, 55);
+    ASSERT (strlen (result) >= 3 + 3
+	    && strisnan (result, 0, strlen (result) - 3, 1)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1273,13 +1564,30 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     ASSERT (retval == strlen (result));
   }
 
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
   /* 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);
+    ASSERT (strcmp (result, "1.275000e+01 33") == 0
+	    || strcmp (result, "1.275000e+001 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1287,7 +1595,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
-    ASSERT (strcmp (result, "1.234567e+06 33") == 0);
+    ASSERT (strcmp (result, "1.234567e+06 33") == 0
+	    || strcmp (result, "1.234567e+006 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1375,7 +1684,15 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
 	char result[1000];
 	int retval =
 	  my_sprintf (result, "%e", data[k].value);
-	ASSERT (strmatch (data[k].string, result));
+	const char *expected = data[k].string;
+	ASSERT (strcmp (result, expected) == 0
+		/* Some implementations produce exponents with 3 digits.  */
+		|| (strlen (result) == strlen (expected) + 1
+		    && memcmp (result, expected, strlen (expected) - 2) == 0
+		    && result[strlen (expected) - 2] == '0'
+		    && strcmp (result + strlen (expected) - 1,
+			       expected + strlen (expected) - 2)
+		       == 0));
 	ASSERT (retval == strlen (result));
       }
   }
@@ -1384,7 +1701,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
-    ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
+    ASSERT (strcmp (result, "-3.125000e-02 33") == 0
+	    || strcmp (result, "-3.125000e-002 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1392,15 +1710,18 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
-    ASSERT (strcmp (result, "0.000000e+00 33") == 0);
+    ASSERT (strcmp (result, "0.000000e+00 33") == 0
+	    || strcmp (result, "0.000000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
-    ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
+      my_sprintf (result, "%e %d", -zerod, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0.000000e+00 33") == 0
+	      || strcmp (result, "-0.000000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1425,8 +1746,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%e %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%e %d", NaNd (), 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));
   }
 
@@ -1434,7 +1757,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
-    ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, "   1.750000e+00 33") == 0
+	    || strcmp (result, "  1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1442,7 +1766,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
-    ASSERT (strcmp (result, "1.750000e+00    33") == 0);
+    ASSERT (strcmp (result, "1.750000e+00    33") == 0
+	    || strcmp (result, "1.750000e+000   33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1450,7 +1775,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
-    ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, "+1.750000e+00 33") == 0
+	    || strcmp (result, "+1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1458,7 +1784,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
-    ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, " 1.750000e+00 33") == 0
+	    || strcmp (result, " 1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1466,7 +1793,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
-    ASSERT (strcmp (result, "1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, "1.750000e+00 33") == 0
+	    || strcmp (result, "1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1474,7 +1802,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
-    ASSERT (strcmp (result, "2.e+00 33") == 0);
+    ASSERT (strcmp (result, "2.e+00 33") == 0
+	    || strcmp (result, "2.e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1482,7 +1811,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
-    ASSERT (strcmp (result, "1.e+01 33") == 0);
+    ASSERT (strcmp (result, "1.e+01 33") == 0
+	    || strcmp (result, "1.e+001 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1490,7 +1820,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
-    ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
+    ASSERT (strcmp (result, "0001.234000e+03 33") == 0
+	    || strcmp (result, "001.234000e+003 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1506,8 +1837,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* FLAG_ZERO with NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%015e %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "            nan 33") == 0);
+      my_sprintf (result, "%050e %d", NaNd (), 33, 44, 55);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1515,7 +1848,26 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
-    ASSERT (strcmp (result, "1e+03 33") == 0);
+    ASSERT (strcmp (result, "1e+03 33") == 0
+	    || strcmp (result, "1e+003 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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
+	    || strcmp (result, "9.9995e+002 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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
+	    || strcmp (result, "1.0000e+003 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1523,7 +1875,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.275000e+01 33") == 0);
+    ASSERT (strcmp (result, "1.275000e+01 33") == 0
+	    || strcmp (result, "1.275000e+001 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1531,7 +1884,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.234567e+06 33") == 0);
+    ASSERT (strcmp (result, "1.234567e+06 33") == 0
+	    || strcmp (result, "1.234567e+006 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1619,7 +1973,15 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
 	char result[1000];
 	int retval =
 	  my_sprintf (result, "%Le", data[k].value);
-	ASSERT (strmatch (data[k].string, result));
+	const char *expected = data[k].string;
+	ASSERT (strcmp (result, expected) == 0
+		/* Some implementations produce exponents with 3 digits.  */
+		|| (strlen (result) == strlen (expected) + 1
+		    && memcmp (result, expected, strlen (expected) - 2) == 0
+		    && result[strlen (expected) - 2] == '0'
+		    && strcmp (result + strlen (expected) - 1,
+			       expected + strlen (expected) - 2)
+		       == 0));
 	ASSERT (retval == strlen (result));
       }
   }
@@ -1628,7 +1990,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
-    ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
+    ASSERT (strcmp (result, "-3.125000e-02 33") == 0
+	    || strcmp (result, "-3.125000e-002 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1636,15 +1999,18 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "0.000000e+00 33") == 0);
+    ASSERT (strcmp (result, "0.000000e+00 33") == 0
+	    || strcmp (result, "0.000000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
+      my_sprintf (result, "%Le %d", minus_zerol, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0.000000e+00 33") == 0
+	      || strcmp (result, "-0.000000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1667,19 +2033,108 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%Le %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%Le %d", NaNl (), 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));
+  }
+#if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
+  { /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+  {
+    /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && 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"
+   */
+  { /* 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));
+  }
+  { /* 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));
   }
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+#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);
+    ASSERT (strcmp (result, "   1.750000e+00 33") == 0
+	    || strcmp (result, "  1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1687,7 +2142,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.750000e+00    33") == 0);
+    ASSERT (strcmp (result, "1.750000e+00    33") == 0
+	    || strcmp (result, "1.750000e+000   33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1695,7 +2151,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, "+1.750000e+00 33") == 0
+	    || strcmp (result, "+1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1703,7 +2160,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
-    ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, " 1.750000e+00 33") == 0
+	    || strcmp (result, " 1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1711,7 +2169,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.750000e+00 33") == 0);
+    ASSERT (strcmp (result, "1.750000e+00 33") == 0
+	    || strcmp (result, "1.750000e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1719,7 +2178,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "2.e+00 33") == 0);
+    ASSERT (strcmp (result, "2.e+00 33") == 0
+	    || strcmp (result, "2.e+000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1727,7 +2187,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.e+01 33") == 0);
+    ASSERT (strcmp (result, "1.e+01 33") == 0
+	    || strcmp (result, "1.e+001 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1735,7 +2196,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
+    ASSERT (strcmp (result, "0001.234000e+03 33") == 0
+	    || strcmp (result, "001.234000e+003 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1749,11 +2211,12 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* FLAG_ZERO with NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%015Le %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "            nan 33") == 0);
+      my_sprintf (result, "%050Le %d", NaNl (), 33, 44, 55);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1761,7 +2224,26 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "1e+03 33") == 0);
+    ASSERT (strcmp (result, "1e+03 33") == 0
+	    || strcmp (result, "1e+003 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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
+	    || strcmp (result, "9.9995e+002 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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
+	    || strcmp (result, "1.0000e+003 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1779,7 +2261,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
-    ASSERT (strcmp (result, "1.23457e+06 33") == 0);
+    ASSERT (strcmp (result, "1.23457e+06 33") == 0
+	    || strcmp (result, "1.23457e+006 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1867,7 +2350,16 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
 	char result[1000];
 	int retval =
 	  my_sprintf (result, "%g", data[k].value);
-	ASSERT (strmatch (data[k].string, result));
+	const char *expected = data[k].string;
+	ASSERT (strcmp (result, expected) == 0
+		/* Some implementations produce exponents with 3 digits.  */
+		|| (expected[strlen (expected) - 4] == 'e'
+		    && strlen (result) == strlen (expected) + 1
+		    && memcmp (result, expected, strlen (expected) - 2) == 0
+		    && result[strlen (expected) - 2] == '0'
+		    && strcmp (result + strlen (expected) - 1,
+			       expected + strlen (expected) - 2)
+		       == 0));
 	ASSERT (retval == strlen (result));
       }
   }
@@ -1891,8 +2383,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
-    ASSERT (strcmp (result, "-0 33") == 0);
+      my_sprintf (result, "%g %d", -zerod, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1917,8 +2410,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%g %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%g %d", NaNd (), 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));
   }
 
@@ -1974,7 +2469,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
-    ASSERT (strcmp (result, "1.e+01 33") == 0);
+    ASSERT (strcmp (result, "1.e+01 33") == 0
+	    || strcmp (result, "1.e+001 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -1998,8 +2494,10 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* FLAG_ZERO with NaN.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%015g %d", NaN (), 33, 44, 55);
-    ASSERT (strcmp (result, "            nan 33") == 0);
+      my_sprintf (result, "%050g %d", NaNd (), 33, 44, 55);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2007,7 +2505,24 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
-    ASSERT (strcmp (result, "1e+03 33") == 0);
+    ASSERT (strcmp (result, "1e+03 33") == 0
+	    || strcmp (result, "1e+003 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* Precision with rounding.  */
+    char result[100];
+    int retval =
+      my_sprintf (result, "%.5g %d", 999.996, 33, 44, 55);
+    ASSERT (strcmp (result, "1000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2023,7 +2538,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.23457e+06 33") == 0);
+    ASSERT (strcmp (result, "1.23457e+06 33") == 0
+	    || strcmp (result, "1.23457e+006 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2111,7 +2627,16 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
 	char result[1000];
 	int retval =
 	  my_sprintf (result, "%Lg", data[k].value);
-	ASSERT (strmatch (data[k].string, result));
+	const char *expected = data[k].string;
+	ASSERT (strcmp (result, expected) == 0
+		/* Some implementations produce exponents with 3 digits.  */
+		|| (expected[strlen (expected) - 4] == 'e'
+		    && strlen (result) == strlen (expected) + 1
+		    && memcmp (result, expected, strlen (expected) - 2) == 0
+		    && result[strlen (expected) - 2] == '0'
+		    && strcmp (result + strlen (expected) - 1,
+			       expected + strlen (expected) - 2)
+		       == 0));
 	ASSERT (retval == strlen (result));
       }
   }
@@ -2135,8 +2660,9 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   { /* Negative zero.  */
     char result[1000];
     int retval =
-      my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "-0 33") == 0);
+      my_sprintf (result, "%Lg %d", minus_zerol, 33, 44, 55);
+    if (have_minus_zero ())
+      ASSERT (strcmp (result, "-0 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2159,13 +2685,101 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%Lg %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "nan 33") == 0);
+      my_sprintf (result, "%Lg %d", NaNl (), 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));
   }
+#if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
+  { /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+  {
+    /* 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
+	    && strisnan (result, 0, strlen (result) - 3, 0)
+	    && 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"
+   */
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+  { /* 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));
+  }
+#endif
 
   { /* Width.  */
     char result[1000];
@@ -2219,7 +2833,8 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
-    ASSERT (strcmp (result, "1.e+01 33") == 0);
+    ASSERT (strcmp (result, "1.e+01 33") == 0
+	    || strcmp (result, "1.e+001 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2241,11 +2856,12 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
   }
 
   { /* FLAG_ZERO with NaN.  */
-    static long double zero = 0.0L;
     char result[1000];
     int retval =
-      my_sprintf (result, "%015Lg %d", zero / zero, 33, 44, 55);
-    ASSERT (strcmp (result, "            nan 33") == 0);
+      my_sprintf (result, "%050Lg %d", NaNl (), 33, 44, 55);
+    ASSERT (strlen (result) == 50 + 3
+	    && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
+	    && strcmp (result + strlen (result) - 3, " 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2253,7 +2869,24 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     char result[1000];
     int retval =
       my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
-    ASSERT (strcmp (result, "1e+03 33") == 0);
+    ASSERT (strcmp (result, "1e+03 33") == 0
+	    || strcmp (result, "1e+003 33") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  { /* Precision with rounding.  */
+    char result[100];
+    int retval =
+      my_sprintf (result, "%.5Lg %d", 999.996L, 33, 44, 55);
+    ASSERT (strcmp (result, "1000 33") == 0);
     ASSERT (retval == strlen (result));
   }
 
@@ -2288,4 +2921,127 @@ test_function (int (*my_sprintf) (char *, const char *, ...))
     ASSERT (result[strlen (result) - 1] == '9');
     ASSERT (retval == strlen (result));
   }
+
+  /* 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);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[1000];
+    int retval =
+      my_sprintf (result, "a%-*sc", 3, "b");
+    ASSERT (strcmp (result, "ab  c") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[1000];
+    int retval =
+      my_sprintf (result, "a%-*sc", -3, "b");
+    ASSERT (strcmp (result, "ab  c") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  /* Test the support of large precision.  */
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%.4000d %d", 1234567, 99);
+    size_t i;
+    for (i = 0; i < 4000 - 7; i++)
+      ASSERT (result[i] == '0');
+    ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%.*d %d", 4000, 1234567, 99);
+    size_t i;
+    for (i = 0; i < 4000 - 7; i++)
+      ASSERT (result[i] == '0');
+    ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%.4000d %d", -1234567, 99);
+    size_t i;
+    ASSERT (result[0] == '-');
+    for (i = 0; i < 4000 - 7; i++)
+      ASSERT (result[1 + i] == '0');
+    ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%.4000u %d", 1234567, 99);
+    size_t i;
+    for (i = 0; i < 4000 - 7; i++)
+      ASSERT (result[i] == '0');
+    ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%.4000o %d", 1234567, 99);
+    size_t i;
+    for (i = 0; i < 4000 - 7; i++)
+      ASSERT (result[i] == '0');
+    ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%.4000x %d", 1234567, 99);
+    size_t i;
+    for (i = 0; i < 4000 - 6; i++)
+      ASSERT (result[i] == '0');
+    ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char result[5000];
+    int retval =
+      my_sprintf (result, "%#.4000x %d", 1234567, 99);
+    size_t i;
+    ASSERT (result[0] == '0');
+    ASSERT (result[1] == 'x');
+    for (i = 0; i < 4000 - 6; i++)
+      ASSERT (result[2 + i] == '0');
+    ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
+
+  {
+    char input[5000];
+    char result[5000];
+    int retval;
+    size_t i;
+
+    for (i = 0; i < sizeof (input) - 1; i++)
+      input[i] = 'a' + ((1000000 / (i + 1)) % 26);
+    input[i] = '\0';
+    retval = my_sprintf (result, "%.4000s %d", input, 99);
+    ASSERT (memcmp (result, input, 4000) == 0);
+    ASSERT (strcmp (result + 4000, " 99") == 0);
+    ASSERT (retval == strlen (result));
+  }
 }