tests/test-sprintf-posix.h

   1 /* Test of POSIX compatible vsprintf() and sprintf() functions.
   2    Copyright (C) 2007-2014 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18
  19 #include "minus-zero.h"
  20 #include "infinity.h"
  21 #include "nan.h"
  22
  23 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0.  */
  24 static int
  25 have_minus_zero ()
  26 {
  27   static double plus_zero = 0.0;
  28   double minus_zero = minus_zerod;
  29   return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  30 }
  31
  32 /* Representation of an 80-bit 'long double' as an initializer for a sequence
  33    of 'unsigned int' words.  */
  34 #ifdef WORDS_BIGENDIAN
  35 # define LDBL80_WORDS(exponent,manthi,mantlo) \
  36     { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
  37       ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16),    \
  38       (unsigned int) (mantlo) << 16                                        \
  39     }
  40 #else
  41 # define LDBL80_WORDS(exponent,manthi,mantlo) \
  42     { mantlo, manthi, exponent }
  43 #endif
  44
  45 static int
  46 strmatch (const char *pattern, const char *string)
  47 {
  48   if (strlen (pattern) != strlen (string))
  49     return 0;
  50   for (; *pattern != '\0'; pattern++, string++)
  51     if (*pattern != '*' && *string != *pattern)
  52       return 0;
  53   return 1;
  54 }
  55
  56 /* Test whether string[start_index..end_index-1] is a valid textual
  57    representation of NaN.  */
  58 static int
  59 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
  60 {
  61   if (start_index < end_index)
  62     {
  63       if (string[start_index] == '-')
  64         start_index++;
  65       if (start_index + 3 <= end_index
  66           && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
  67         {
  68           start_index += 3;
  69           if (start_index == end_index
  70               || (string[start_index] == '(' && string[end_index - 1] == ')'))
  71             return 1;
  72         }
  73     }
  74   return 0;
  75 }
  76
  77 static void
  78 test_function (int (*my_sprintf) (char *, const char *, ...))
  79 {
  80   char buf[8];
  81
  82   /* Test return value convention.  */
  83
  84   {
  85     int retval;
  86
  87     memcpy (buf, "DEADBEEF", 8);
  88     retval = my_sprintf (buf, "%d", 12345);
  89     ASSERT (retval == 5);
  90     ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
  91   }
  92
  93   /* Test support of size specifiers as in C99.  */
  94
  95   {
  96     char result[1000];
  97     int retval =
  98       my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  99     ASSERT (strcmp (result, "12345671 33") == 0);
 100     ASSERT (retval == strlen (result));
 101   }
 102
 103   {
 104     char result[1000];
 105     int retval =
 106       my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
 107     ASSERT (strcmp (result, "12345672 33") == 0);
 108     ASSERT (retval == strlen (result));
 109   }
 110
 111   {
 112     char result[1000];
 113     int retval =
 114       my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
 115     ASSERT (strcmp (result, "12345673 33") == 0);
 116     ASSERT (retval == strlen (result));
 117   }
 118
 119   {
 120     char result[1000];
 121     int retval =
 122       my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
 123     ASSERT (strcmp (result, "1.5 33") == 0);
 124     ASSERT (retval == strlen (result));
 125   }
 126
 127   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 128      output of floating-point numbers.  */
 129
 130   { /* A positive number.  */
 131     char result[1000];
 132     int retval =
 133       my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
 134     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 135             || strcmp (result, "0x3.244p+0 33") == 0
 136             || strcmp (result, "0x6.488p-1 33") == 0
 137             || strcmp (result, "0xc.91p-2 33") == 0);
 138     ASSERT (retval == strlen (result));
 139   }
 140
 141   { /* A negative number.  */
 142     char result[1000];
 143     int retval =
 144       my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
 145     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 146             || strcmp (result, "-0X3.244P+0 33") == 0
 147             || strcmp (result, "-0X6.488P-1 33") == 0
 148             || strcmp (result, "-0XC.91P-2 33") == 0);
 149     ASSERT (retval == strlen (result));
 150   }
 151
 152   { /* Positive zero.  */
 153     char result[1000];
 154     int retval =
 155       my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
 156     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 157     ASSERT (retval == strlen (result));
 158   }
 159
 160   { /* Negative zero.  */
 161     char result[1000];
 162     int retval =
 163       my_sprintf (result, "%a %d", minus_zerod, 33, 44, 55);
 164     if (have_minus_zero ())
 165       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 166     ASSERT (retval == strlen (result));
 167   }
 168
 169   { /* Positive infinity.  */
 170     char result[1000];
 171     int retval =
 172       my_sprintf (result, "%a %d", Infinityd (), 33, 44, 55);
 173     ASSERT (strcmp (result, "inf 33") == 0);
 174     ASSERT (retval == strlen (result));
 175   }
 176
 177   { /* Negative infinity.  */
 178     char result[1000];
 179     int retval =
 180       my_sprintf (result, "%a %d", - Infinityd (), 33, 44, 55);
 181     ASSERT (strcmp (result, "-inf 33") == 0);
 182     ASSERT (retval == strlen (result));
 183   }
 184
 185   { /* NaN.  */
 186     char result[1000];
 187     int retval =
 188       my_sprintf (result, "%a %d", NaNd (), 33, 44, 55);
 189     ASSERT (strlen (result) >= 3 + 3
 190             && strisnan (result, 0, strlen (result) - 3, 0)
 191             && strcmp (result + strlen (result) - 3, " 33") == 0);
 192     ASSERT (retval == strlen (result));
 193   }
 194
 195   { /* Rounding near the decimal point.  */
 196     char result[1000];
 197     int retval =
 198       my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
 199     ASSERT (strcmp (result, "0x2p+0 33") == 0
 200             || strcmp (result, "0x3p-1 33") == 0
 201             || strcmp (result, "0x6p-2 33") == 0
 202             || strcmp (result, "0xcp-3 33") == 0);
 203     ASSERT (retval == strlen (result));
 204   }
 205
 206   { /* Rounding with precision 0.  */
 207     char result[1000];
 208     int retval =
 209       my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
 210     ASSERT (strcmp (result, "0x2p+0 33") == 0
 211             || strcmp (result, "0x3p-1 33") == 0
 212             || strcmp (result, "0x6p-2 33") == 0
 213             || strcmp (result, "0xcp-3 33") == 0);
 214     ASSERT (retval == strlen (result));
 215   }
 216
 217   { /* Rounding with precision 1.  */
 218     char result[1000];
 219     int retval =
 220       my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
 221     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 222             || strcmp (result, "0x3.0p-1 33") == 0
 223             || strcmp (result, "0x6.1p-2 33") == 0
 224             || strcmp (result, "0xc.1p-3 33") == 0);
 225     ASSERT (retval == strlen (result));
 226   }
 227
 228   { /* Rounding with precision 2.  */
 229     char result[1000];
 230     int retval =
 231       my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
 232     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 233             || strcmp (result, "0x3.05p-1 33") == 0
 234             || strcmp (result, "0x6.0ap-2 33") == 0
 235             || strcmp (result, "0xc.14p-3 33") == 0);
 236     ASSERT (retval == strlen (result));
 237   }
 238
 239   { /* Rounding with precision 3.  */
 240     char result[1000];
 241     int retval =
 242       my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
 243     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 244             || strcmp (result, "0x3.052p-1 33") == 0
 245             || strcmp (result, "0x6.0a4p-2 33") == 0
 246             || strcmp (result, "0xc.148p-3 33") == 0);
 247     ASSERT (retval == strlen (result));
 248   }
 249
 250   { /* Rounding can turn a ...FFF into a ...000.  */
 251     char result[1000];
 252     int retval =
 253       my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
 254     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 255             || strcmp (result, "0x3.000p-1 33") == 0
 256             || strcmp (result, "0x6.000p-2 33") == 0
 257             || strcmp (result, "0xc.000p-3 33") == 0);
 258     ASSERT (retval == strlen (result));
 259   }
 260
 261   { /* Rounding can turn a ...FFF into a ...000.
 262        This shows a Mac OS X 10.3.9 (Darwin 7.9) bug.  */
 263     char result[1000];
 264     int retval =
 265       my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
 266     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 267             || strcmp (result, "0x2.0p+0 33") == 0
 268             || strcmp (result, "0x4.0p-1 33") == 0
 269             || strcmp (result, "0x8.0p-2 33") == 0);
 270     ASSERT (retval == strlen (result));
 271   }
 272
 273   { /* Width.  */
 274     char result[1000];
 275     int retval =
 276       my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
 277     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 278             || strcmp (result, "  0x3.8p-1 33") == 0
 279             || strcmp (result, "    0x7p-2 33") == 0
 280             || strcmp (result, "    0xep-3 33") == 0);
 281     ASSERT (retval == strlen (result));
 282   }
 283
 284   { /* Small precision.  */
 285     char result[1000];
 286     int retval =
 287       my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
 288     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 289             || strcmp (result, "0x3.8000000000p-1 33") == 0
 290             || strcmp (result, "0x7.0000000000p-2 33") == 0
 291             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 292     ASSERT (retval == strlen (result));
 293   }
 294
 295   { /* Large precision.  */
 296     char result[1000];
 297     int retval =
 298       my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
 299     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 300             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 301             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 302             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 303     ASSERT (retval == strlen (result));
 304   }
 305
 306   { /* FLAG_LEFT.  */
 307     char result[1000];
 308     int retval =
 309       my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
 310     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 311             || strcmp (result, "0x3.8p-1   33") == 0
 312             || strcmp (result, "0x7p-2     33") == 0
 313             || strcmp (result, "0xep-3     33") == 0);
 314     ASSERT (retval == strlen (result));
 315   }
 316
 317   { /* FLAG_SHOWSIGN.  */
 318     char result[1000];
 319     int retval =
 320       my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
 321     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 322             || strcmp (result, "+0x3.8p-1 33") == 0
 323             || strcmp (result, "+0x7p-2 33") == 0
 324             || strcmp (result, "+0xep-3 33") == 0);
 325     ASSERT (retval == strlen (result));
 326   }
 327
 328   { /* FLAG_SPACE.  */
 329     char result[1000];
 330     int retval =
 331       my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
 332     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 333             || strcmp (result, " 0x3.8p-1 33") == 0
 334             || strcmp (result, " 0x7p-2 33") == 0
 335             || strcmp (result, " 0xep-3 33") == 0);
 336     ASSERT (retval == strlen (result));
 337   }
 338
 339   { /* FLAG_ALT.  */
 340     char result[1000];
 341     int retval =
 342       my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
 343     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 344             || strcmp (result, "0x3.8p-1 33") == 0
 345             || strcmp (result, "0x7.p-2 33") == 0
 346             || strcmp (result, "0xe.p-3 33") == 0);
 347     ASSERT (retval == strlen (result));
 348   }
 349
 350   { /* FLAG_ALT.  */
 351     char result[1000];
 352     int retval =
 353       my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
 354     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 355             || strcmp (result, "0x2.p-1 33") == 0
 356             || strcmp (result, "0x4.p-2 33") == 0
 357             || strcmp (result, "0x8.p-3 33") == 0);
 358     ASSERT (retval == strlen (result));
 359   }
 360
 361   { /* FLAG_ZERO with finite number.  */
 362     char result[1000];
 363     int retval =
 364       my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
 365     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 366             || strcmp (result, "0x003.8p-1 33") == 0
 367             || strcmp (result, "0x00007p-2 33") == 0
 368             || strcmp (result, "0x0000ep-3 33") == 0);
 369     ASSERT (retval == strlen (result));
 370   }
 371
 372   { /* FLAG_ZERO with infinite number.  */
 373     char result[1000];
 374     int retval =
 375       my_sprintf (result, "%010a %d", Infinityd (), 33, 44, 55);
 376     /* "0000000inf 33" is not a valid result; see
 377        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 378     ASSERT (strcmp (result, "       inf 33") == 0);
 379     ASSERT (retval == strlen (result));
 380   }
 381
 382   { /* FLAG_ZERO with NaN.  */
 383     char result[1000];
 384     int retval =
 385       my_sprintf (result, "%050a %d", NaNd (), 33, 44, 55);
 386     /* "0000000nan 33" is not a valid result; see
 387        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 388     ASSERT (strlen (result) == 50 + 3
 389             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 390             && strcmp (result + strlen (result) - 3, " 33") == 0);
 391     ASSERT (retval == strlen (result));
 392   }
 393
 394   { /* A positive number.  */
 395     char result[1000];
 396     int retval =
 397       my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
 398     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 399             || strcmp (result, "0x3.244p+0 33") == 0
 400             || strcmp (result, "0x6.488p-1 33") == 0
 401             || strcmp (result, "0xc.91p-2 33") == 0);
 402     ASSERT (retval == strlen (result));
 403   }
 404
 405   { /* A negative number.  */
 406     char result[1000];
 407     int retval =
 408       my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
 409     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 410             || strcmp (result, "-0X3.244P+0 33") == 0
 411             || strcmp (result, "-0X6.488P-1 33") == 0
 412             || strcmp (result, "-0XC.91P-2 33") == 0);
 413     ASSERT (retval == strlen (result));
 414   }
 415
 416   { /* Positive zero.  */
 417     char result[1000];
 418     int retval =
 419       my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
 420     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 421     ASSERT (retval == strlen (result));
 422   }
 423
 424   { /* Negative zero.  */
 425     char result[1000];
 426     int retval =
 427       my_sprintf (result, "%La %d", minus_zerol, 33, 44, 55);
 428     if (have_minus_zero ())
 429       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 430     ASSERT (retval == strlen (result));
 431   }
 432
 433   { /* Positive infinity.  */
 434     char result[1000];
 435     int retval =
 436       my_sprintf (result, "%La %d", Infinityl (), 33, 44, 55);
 437     ASSERT (strcmp (result, "inf 33") == 0);
 438     ASSERT (retval == strlen (result));
 439   }
 440
 441   { /* Negative infinity.  */
 442     char result[1000];
 443     int retval =
 444       my_sprintf (result, "%La %d", - Infinityl (), 33, 44, 55);
 445     ASSERT (strcmp (result, "-inf 33") == 0);
 446     ASSERT (retval == strlen (result));
 447   }
 448
 449   { /* NaN.  */
 450     char result[1000];
 451     int retval =
 452       my_sprintf (result, "%La %d", NaNl (), 33, 44, 55);
 453     ASSERT (strlen (result) >= 3 + 3
 454             && strisnan (result, 0, strlen (result) - 3, 0)
 455             && strcmp (result + strlen (result) - 3, " 33") == 0);
 456     ASSERT (retval == strlen (result));
 457   }
 458 #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_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
 459   { /* Quiet NaN.  */
 460     static union { unsigned int word[4]; long double value; } x =
 461       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
 462     char result[1000];
 463     int retval =
 464       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 465     ASSERT (strlen (result) >= 3 + 3
 466             && strisnan (result, 0, strlen (result) - 3, 0)
 467             && strcmp (result + strlen (result) - 3, " 33") == 0);
 468     ASSERT (retval == strlen (result));
 469   }
 470   {
 471     /* Signalling NaN.  */
 472     static union { unsigned int word[4]; long double value; } x =
 473       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
 474     char result[1000];
 475     int retval =
 476       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 477     ASSERT (strlen (result) >= 3 + 3
 478             && strisnan (result, 0, strlen (result) - 3, 0)
 479             && strcmp (result + strlen (result) - 3, " 33") == 0);
 480     ASSERT (retval == strlen (result));
 481   }
 482   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
 483      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
 484        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
 485        Application Architecture.
 486        Table 5-2 "Floating-Point Register Encodings"
 487        Figure 5-6 "Memory to Floating-Point Register Data Translation"
 488    */
 489   { /* Pseudo-NaN.  */
 490     static union { unsigned int word[4]; long double value; } x =
 491       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
 492     char result[1000];
 493     int retval =
 494       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 495     ASSERT (strlen (result) >= 3 + 3
 496             && strisnan (result, 0, strlen (result) - 3, 0)
 497             && strcmp (result + strlen (result) - 3, " 33") == 0);
 498     ASSERT (retval == strlen (result));
 499   }
 500   { /* Pseudo-Infinity.  */
 501     static union { unsigned int word[4]; long double value; } x =
 502       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
 503     char result[1000];
 504     int retval =
 505       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 506     ASSERT (strlen (result) >= 3 + 3
 507             && strisnan (result, 0, strlen (result) - 3, 0)
 508             && strcmp (result + strlen (result) - 3, " 33") == 0);
 509     ASSERT (retval == strlen (result));
 510   }
 511   { /* Pseudo-Zero.  */
 512     static union { unsigned int word[4]; long double value; } x =
 513       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
 514     char result[1000];
 515     int retval =
 516       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 517     ASSERT (strlen (result) >= 3 + 3
 518             && strisnan (result, 0, strlen (result) - 3, 0)
 519             && strcmp (result + strlen (result) - 3, " 33") == 0);
 520     ASSERT (retval == strlen (result));
 521   }
 522   { /* Unnormalized number.  */
 523     static union { unsigned int word[4]; long double value; } x =
 524       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
 525     char result[1000];
 526     int retval =
 527       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 528     ASSERT (strlen (result) >= 3 + 3
 529             && strisnan (result, 0, strlen (result) - 3, 0)
 530             && strcmp (result + strlen (result) - 3, " 33") == 0);
 531     ASSERT (retval == strlen (result));
 532   }
 533   { /* Pseudo-Denormal.  */
 534     static union { unsigned int word[4]; long double value; } x =
 535       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
 536     char result[1000];
 537     int retval =
 538       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
 539     ASSERT (strlen (result) >= 3 + 3
 540             && strisnan (result, 0, strlen (result) - 3, 0)
 541             && strcmp (result + strlen (result) - 3, " 33") == 0);
 542     ASSERT (retval == strlen (result));
 543   }
 544 #endif
 545
 546   { /* Rounding near the decimal point.  */
 547     char result[1000];
 548     int retval =
 549       my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
 550     ASSERT (strcmp (result, "0x2p+0 33") == 0
 551             || strcmp (result, "0x3p-1 33") == 0
 552             || strcmp (result, "0x6p-2 33") == 0
 553             || strcmp (result, "0xcp-3 33") == 0);
 554     ASSERT (retval == strlen (result));
 555   }
 556
 557   { /* Rounding with precision 0.  */
 558     char result[1000];
 559     int retval =
 560       my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
 561     ASSERT (strcmp (result, "0x2p+0 33") == 0
 562             || strcmp (result, "0x3p-1 33") == 0
 563             || strcmp (result, "0x6p-2 33") == 0
 564             || strcmp (result, "0xcp-3 33") == 0);
 565     ASSERT (retval == strlen (result));
 566   }
 567
 568   { /* Rounding with precision 1.  */
 569     char result[1000];
 570     int retval =
 571       my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
 572     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 573             || strcmp (result, "0x3.0p-1 33") == 0
 574             || strcmp (result, "0x6.1p-2 33") == 0
 575             || strcmp (result, "0xc.1p-3 33") == 0);
 576     ASSERT (retval == strlen (result));
 577   }
 578
 579   { /* Rounding with precision 2.  */
 580     char result[1000];
 581     int retval =
 582       my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
 583     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 584             || strcmp (result, "0x3.05p-1 33") == 0
 585             || strcmp (result, "0x6.0ap-2 33") == 0
 586             || strcmp (result, "0xc.14p-3 33") == 0);
 587     ASSERT (retval == strlen (result));
 588   }
 589
 590   { /* Rounding with precision 3.  */
 591     char result[1000];
 592     int retval =
 593       my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
 594     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 595             || strcmp (result, "0x3.052p-1 33") == 0
 596             || strcmp (result, "0x6.0a4p-2 33") == 0
 597             || strcmp (result, "0xc.148p-3 33") == 0);
 598     ASSERT (retval == strlen (result));
 599   }
 600
 601   { /* Rounding can turn a ...FFF into a ...000.  */
 602     char result[1000];
 603     int retval =
 604       my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
 605     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 606             || strcmp (result, "0x3.000p-1 33") == 0
 607             || strcmp (result, "0x6.000p-2 33") == 0
 608             || strcmp (result, "0xc.000p-3 33") == 0);
 609     ASSERT (retval == strlen (result));
 610   }
 611
 612   { /* Rounding can turn a ...FFF into a ...000.
 613        This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
 614        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 615     char result[1000];
 616     int retval =
 617       my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
 618     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 619             || strcmp (result, "0x2.0p+0 33") == 0
 620             || strcmp (result, "0x4.0p-1 33") == 0
 621             || strcmp (result, "0x8.0p-2 33") == 0);
 622     ASSERT (retval == strlen (result));
 623   }
 624
 625   { /* Width.  */
 626     char result[1000];
 627     int retval =
 628       my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
 629     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 630             || strcmp (result, "  0x3.8p-1 33") == 0
 631             || strcmp (result, "    0x7p-2 33") == 0
 632             || strcmp (result, "    0xep-3 33") == 0);
 633     ASSERT (retval == strlen (result));
 634   }
 635
 636   { /* Small precision.  */
 637     char result[1000];
 638     int retval =
 639       my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
 640     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 641             || strcmp (result, "0x3.8000000000p-1 33") == 0
 642             || strcmp (result, "0x7.0000000000p-2 33") == 0
 643             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 644     ASSERT (retval == strlen (result));
 645   }
 646
 647   { /* Large precision.  */
 648     char result[1000];
 649     int retval =
 650       my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
 651     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 652             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 653             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 654             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 655     ASSERT (retval == strlen (result));
 656   }
 657
 658   { /* FLAG_LEFT.  */
 659     char result[1000];
 660     int retval =
 661       my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
 662     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 663             || strcmp (result, "0x3.8p-1   33") == 0
 664             || strcmp (result, "0x7p-2     33") == 0
 665             || strcmp (result, "0xep-3     33") == 0);
 666     ASSERT (retval == strlen (result));
 667   }
 668
 669   { /* FLAG_SHOWSIGN.  */
 670     char result[1000];
 671     int retval =
 672       my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
 673     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 674             || strcmp (result, "+0x3.8p-1 33") == 0
 675             || strcmp (result, "+0x7p-2 33") == 0
 676             || strcmp (result, "+0xep-3 33") == 0);
 677     ASSERT (retval == strlen (result));
 678   }
 679
 680   { /* FLAG_SPACE.  */
 681     char result[1000];
 682     int retval =
 683       my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
 684     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 685             || strcmp (result, " 0x3.8p-1 33") == 0
 686             || strcmp (result, " 0x7p-2 33") == 0
 687             || strcmp (result, " 0xep-3 33") == 0);
 688     ASSERT (retval == strlen (result));
 689   }
 690
 691   { /* FLAG_ALT.  */
 692     char result[1000];
 693     int retval =
 694       my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
 695     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 696             || strcmp (result, "0x3.8p-1 33") == 0
 697             || strcmp (result, "0x7.p-2 33") == 0
 698             || strcmp (result, "0xe.p-3 33") == 0);
 699     ASSERT (retval == strlen (result));
 700   }
 701
 702   { /* FLAG_ALT.  */
 703     char result[1000];
 704     int retval =
 705       my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
 706     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 707             || strcmp (result, "0x2.p-1 33") == 0
 708             || strcmp (result, "0x4.p-2 33") == 0
 709             || strcmp (result, "0x8.p-3 33") == 0);
 710     ASSERT (retval == strlen (result));
 711   }
 712
 713   { /* FLAG_ZERO with finite number.  */
 714     char result[1000];
 715     int retval =
 716       my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
 717     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 718             || strcmp (result, "0x003.8p-1 33") == 0
 719             || strcmp (result, "0x00007p-2 33") == 0
 720             || strcmp (result, "0x0000ep-3 33") == 0);
 721     ASSERT (retval == strlen (result));
 722   }
 723
 724   { /* FLAG_ZERO with infinite number.  */
 725     char result[1000];
 726     int retval =
 727       my_sprintf (result, "%010La %d", Infinityl (), 33, 44, 55);
 728     /* "0000000inf 33" is not a valid result; see
 729        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 730     ASSERT (strcmp (result, "       inf 33") == 0);
 731     ASSERT (retval == strlen (result));
 732   }
 733
 734   { /* FLAG_ZERO with NaN.  */
 735     char result[1000];
 736     int retval =
 737       my_sprintf (result, "%050La %d", NaNl (), 33, 44, 55);
 738     /* "0000000nan 33" is not a valid result; see
 739        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 740     ASSERT (strlen (result) == 50 + 3
 741             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 742             && strcmp (result + strlen (result) - 3, " 33") == 0);
 743     ASSERT (retval == strlen (result));
 744   }
 745
 746   /* Test the support of the %f format directive.  */
 747
 748   { /* A positive number.  */
 749     char result[1000];
 750     int retval =
 751       my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
 752     ASSERT (strcmp (result, "12.750000 33") == 0);
 753     ASSERT (retval == strlen (result));
 754   }
 755
 756   { /* A larger positive number.  */
 757     char result[1000];
 758     int retval =
 759       my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
 760     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 761     ASSERT (retval == strlen (result));
 762   }
 763
 764   { /* Small and large positive numbers.  */
 765     static struct { double value; const char *string; } data[] =
 766       {
 767         { 1.234321234321234e-37, "0.000000" },
 768         { 1.234321234321234e-36, "0.000000" },
 769         { 1.234321234321234e-35, "0.000000" },
 770         { 1.234321234321234e-34, "0.000000" },
 771         { 1.234321234321234e-33, "0.000000" },
 772         { 1.234321234321234e-32, "0.000000" },
 773         { 1.234321234321234e-31, "0.000000" },
 774         { 1.234321234321234e-30, "0.000000" },
 775         { 1.234321234321234e-29, "0.000000" },
 776         { 1.234321234321234e-28, "0.000000" },
 777         { 1.234321234321234e-27, "0.000000" },
 778         { 1.234321234321234e-26, "0.000000" },
 779         { 1.234321234321234e-25, "0.000000" },
 780         { 1.234321234321234e-24, "0.000000" },
 781         { 1.234321234321234e-23, "0.000000" },
 782         { 1.234321234321234e-22, "0.000000" },
 783         { 1.234321234321234e-21, "0.000000" },
 784         { 1.234321234321234e-20, "0.000000" },
 785         { 1.234321234321234e-19, "0.000000" },
 786         { 1.234321234321234e-18, "0.000000" },
 787         { 1.234321234321234e-17, "0.000000" },
 788         { 1.234321234321234e-16, "0.000000" },
 789         { 1.234321234321234e-15, "0.000000" },
 790         { 1.234321234321234e-14, "0.000000" },
 791         { 1.234321234321234e-13, "0.000000" },
 792         { 1.234321234321234e-12, "0.000000" },
 793         { 1.234321234321234e-11, "0.000000" },
 794         { 1.234321234321234e-10, "0.000000" },
 795         { 1.234321234321234e-9, "0.000000" },
 796         { 1.234321234321234e-8, "0.000000" },
 797         { 1.234321234321234e-7, "0.000000" },
 798         { 1.234321234321234e-6, "0.000001" },
 799         { 1.234321234321234e-5, "0.000012" },
 800         { 1.234321234321234e-4, "0.000123" },
 801         { 1.234321234321234e-3, "0.001234" },
 802         { 1.234321234321234e-2, "0.012343" },
 803         { 1.234321234321234e-1, "0.123432" },
 804         { 1.234321234321234, "1.234321" },
 805         { 1.234321234321234e1, "12.343212" },
 806         { 1.234321234321234e2, "123.432123" },
 807         { 1.234321234321234e3, "1234.321234" },
 808         { 1.234321234321234e4, "12343.212343" },
 809         { 1.234321234321234e5, "123432.123432" },
 810         { 1.234321234321234e6, "1234321.234321" },
 811         { 1.234321234321234e7, "12343212.343212" },
 812         { 1.234321234321234e8, "123432123.432123" },
 813         { 1.234321234321234e9, "1234321234.321234" },
 814         { 1.234321234321234e10, "12343212343.2123**" },
 815         { 1.234321234321234e11, "123432123432.123***" },
 816         { 1.234321234321234e12, "1234321234321.23****" },
 817         { 1.234321234321234e13, "12343212343212.3*****" },
 818         { 1.234321234321234e14, "123432123432123.******" },
 819         { 1.234321234321234e15, "1234321234321234.000000" },
 820         { 1.234321234321234e16, "123432123432123**.000000" },
 821         { 1.234321234321234e17, "123432123432123***.000000" },
 822         { 1.234321234321234e18, "123432123432123****.000000" },
 823         { 1.234321234321234e19, "123432123432123*****.000000" },
 824         { 1.234321234321234e20, "123432123432123******.000000" },
 825         { 1.234321234321234e21, "123432123432123*******.000000" },
 826         { 1.234321234321234e22, "123432123432123********.000000" },
 827         { 1.234321234321234e23, "123432123432123*********.000000" },
 828         { 1.234321234321234e24, "123432123432123**********.000000" },
 829         { 1.234321234321234e25, "123432123432123***********.000000" },
 830         { 1.234321234321234e26, "123432123432123************.000000" },
 831         { 1.234321234321234e27, "123432123432123*************.000000" },
 832         { 1.234321234321234e28, "123432123432123**************.000000" },
 833         { 1.234321234321234e29, "123432123432123***************.000000" },
 834         { 1.234321234321234e30, "123432123432123****************.000000" },
 835         { 1.234321234321234e31, "123432123432123*****************.000000" },
 836         { 1.234321234321234e32, "123432123432123******************.000000" },
 837         { 1.234321234321234e33, "123432123432123*******************.000000" },
 838         { 1.234321234321234e34, "123432123432123********************.000000" },
 839         { 1.234321234321234e35, "123432123432123*********************.000000" },
 840         { 1.234321234321234e36, "123432123432123**********************.000000" }
 841       };
 842     size_t k;
 843     for (k = 0; k < SIZEOF (data); k++)
 844       {
 845         char result[1000];
 846         int retval =
 847           my_sprintf (result, "%f", data[k].value);
 848         ASSERT (strmatch (data[k].string, result));
 849         ASSERT (retval == strlen (result));
 850       }
 851   }
 852
 853   { /* A negative number.  */
 854     char result[1000];
 855     int retval =
 856       my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
 857     ASSERT (strcmp (result, "-0.031250 33") == 0);
 858     ASSERT (retval == strlen (result));
 859   }
 860
 861   { /* Positive zero.  */
 862     char result[1000];
 863     int retval =
 864       my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
 865     ASSERT (strcmp (result, "0.000000 33") == 0);
 866     ASSERT (retval == strlen (result));
 867   }
 868
 869   { /* Negative zero.  */
 870     char result[1000];
 871     int retval =
 872       my_sprintf (result, "%f %d", minus_zerod, 33, 44, 55);
 873     if (have_minus_zero ())
 874       ASSERT (strcmp (result, "-0.000000 33") == 0);
 875     ASSERT (retval == strlen (result));
 876   }
 877
 878   { /* Positive infinity.  */
 879     char result[1000];
 880     int retval =
 881       my_sprintf (result, "%f %d", Infinityd (), 33, 44, 55);
 882     ASSERT (strcmp (result, "inf 33") == 0
 883             || strcmp (result, "infinity 33") == 0);
 884     ASSERT (retval == strlen (result));
 885   }
 886
 887   { /* Negative infinity.  */
 888     char result[1000];
 889     int retval =
 890       my_sprintf (result, "%f %d", - Infinityd (), 33, 44, 55);
 891     ASSERT (strcmp (result, "-inf 33") == 0
 892             || strcmp (result, "-infinity 33") == 0);
 893     ASSERT (retval == strlen (result));
 894   }
 895
 896   { /* NaN.  */
 897     char result[1000];
 898     int retval =
 899       my_sprintf (result, "%f %d", NaNd (), 33, 44, 55);
 900     ASSERT (strlen (result) >= 3 + 3
 901             && strisnan (result, 0, strlen (result) - 3, 0)
 902             && strcmp (result + strlen (result) - 3, " 33") == 0);
 903     ASSERT (retval == strlen (result));
 904   }
 905
 906   { /* Width.  */
 907     char result[1000];
 908     int retval =
 909       my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
 910     ASSERT (strcmp (result, "  1.750000 33") == 0);
 911     ASSERT (retval == strlen (result));
 912   }
 913
 914   { /* FLAG_LEFT.  */
 915     char result[1000];
 916     int retval =
 917       my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
 918     ASSERT (strcmp (result, "1.750000   33") == 0);
 919     ASSERT (retval == strlen (result));
 920   }
 921
 922   { /* FLAG_SHOWSIGN.  */
 923     char result[1000];
 924     int retval =
 925       my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
 926     ASSERT (strcmp (result, "+1.750000 33") == 0);
 927     ASSERT (retval == strlen (result));
 928   }
 929
 930   { /* FLAG_SPACE.  */
 931     char result[1000];
 932     int retval =
 933       my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
 934     ASSERT (strcmp (result, " 1.750000 33") == 0);
 935     ASSERT (retval == strlen (result));
 936   }
 937
 938   { /* FLAG_ALT.  */
 939     char result[1000];
 940     int retval =
 941       my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
 942     ASSERT (strcmp (result, "1.750000 33") == 0);
 943     ASSERT (retval == strlen (result));
 944   }
 945
 946   { /* FLAG_ALT.  */
 947     char result[1000];
 948     int retval =
 949       my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
 950     ASSERT (strcmp (result, "2. 33") == 0);
 951     ASSERT (retval == strlen (result));
 952   }
 953
 954   { /* FLAG_ZERO with finite number.  */
 955     char result[1000];
 956     int retval =
 957       my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
 958     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 959     ASSERT (retval == strlen (result));
 960   }
 961
 962   { /* FLAG_ZERO with infinite number.  */
 963     char result[1000];
 964     int retval =
 965       my_sprintf (result, "%015f %d", - Infinityd (), 33, 44, 55);
 966     ASSERT (strcmp (result, "           -inf 33") == 0
 967             || strcmp (result, "      -infinity 33") == 0);
 968     ASSERT (retval == strlen (result));
 969   }
 970
 971   { /* FLAG_ZERO with NaN.  */
 972     char result[1000];
 973     int retval =
 974       my_sprintf (result, "%050f %d", NaNd (), 33, 44, 55);
 975     ASSERT (strlen (result) == 50 + 3
 976             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 977             && strcmp (result + strlen (result) - 3, " 33") == 0);
 978     ASSERT (retval == strlen (result));
 979   }
 980
 981   { /* Precision.  */
 982     char result[1000];
 983     int retval =
 984       my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
 985     ASSERT (strcmp (result, "1234 33") == 0);
 986     ASSERT (retval == strlen (result));
 987   }
 988
 989   { /* Precision with no rounding.  */
 990     char result[100];
 991     int retval =
 992       my_sprintf (result, "%.2f %d", 999.951, 33, 44, 55);
 993     ASSERT (strcmp (result, "999.95 33") == 0);
 994     ASSERT (retval == strlen (result));
 995   }
 996
 997   { /* Precision with rounding.  */
 998     char result[100];
 999     int retval =
1000       my_sprintf (result, "%.2f %d", 999.996, 33, 44, 55);
1001     ASSERT (strcmp (result, "1000.00 33") == 0);
1002     ASSERT (retval == strlen (result));
1003   }
1004
1005   { /* A positive number.  */
1006     char result[1000];
1007     int retval =
1008       my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
1009     ASSERT (strcmp (result, "12.750000 33") == 0);
1010     ASSERT (retval == strlen (result));
1011   }
1012
1013   { /* A larger positive number.  */
1014     char result[1000];
1015     int retval =
1016       my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
1017     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1018     ASSERT (retval == strlen (result));
1019   }
1020
1021   { /* Small and large positive numbers.  */
1022     static struct { long double value; const char *string; } data[] =
1023       {
1024         { 1.234321234321234e-37L, "0.000000" },
1025         { 1.234321234321234e-36L, "0.000000" },
1026         { 1.234321234321234e-35L, "0.000000" },
1027         { 1.234321234321234e-34L, "0.000000" },
1028         { 1.234321234321234e-33L, "0.000000" },
1029         { 1.234321234321234e-32L, "0.000000" },
1030         { 1.234321234321234e-31L, "0.000000" },
1031         { 1.234321234321234e-30L, "0.000000" },
1032         { 1.234321234321234e-29L, "0.000000" },
1033         { 1.234321234321234e-28L, "0.000000" },
1034         { 1.234321234321234e-27L, "0.000000" },
1035         { 1.234321234321234e-26L, "0.000000" },
1036         { 1.234321234321234e-25L, "0.000000" },
1037         { 1.234321234321234e-24L, "0.000000" },
1038         { 1.234321234321234e-23L, "0.000000" },
1039         { 1.234321234321234e-22L, "0.000000" },
1040         { 1.234321234321234e-21L, "0.000000" },
1041         { 1.234321234321234e-20L, "0.000000" },
1042         { 1.234321234321234e-19L, "0.000000" },
1043         { 1.234321234321234e-18L, "0.000000" },
1044         { 1.234321234321234e-17L, "0.000000" },
1045         { 1.234321234321234e-16L, "0.000000" },
1046         { 1.234321234321234e-15L, "0.000000" },
1047         { 1.234321234321234e-14L, "0.000000" },
1048         { 1.234321234321234e-13L, "0.000000" },
1049         { 1.234321234321234e-12L, "0.000000" },
1050         { 1.234321234321234e-11L, "0.000000" },
1051         { 1.234321234321234e-10L, "0.000000" },
1052         { 1.234321234321234e-9L, "0.000000" },
1053         { 1.234321234321234e-8L, "0.000000" },
1054         { 1.234321234321234e-7L, "0.000000" },
1055         { 1.234321234321234e-6L, "0.000001" },
1056         { 1.234321234321234e-5L, "0.000012" },
1057         { 1.234321234321234e-4L, "0.000123" },
1058         { 1.234321234321234e-3L, "0.001234" },
1059         { 1.234321234321234e-2L, "0.012343" },
1060         { 1.234321234321234e-1L, "0.123432" },
1061         { 1.234321234321234L, "1.234321" },
1062         { 1.234321234321234e1L, "12.343212" },
1063         { 1.234321234321234e2L, "123.432123" },
1064         { 1.234321234321234e3L, "1234.321234" },
1065         { 1.234321234321234e4L, "12343.212343" },
1066         { 1.234321234321234e5L, "123432.123432" },
1067         { 1.234321234321234e6L, "1234321.234321" },
1068         { 1.234321234321234e7L, "12343212.343212" },
1069         { 1.234321234321234e8L, "123432123.432123" },
1070         { 1.234321234321234e9L, "1234321234.321234" },
1071         { 1.234321234321234e10L, "12343212343.2123**" },
1072         { 1.234321234321234e11L, "123432123432.123***" },
1073         { 1.234321234321234e12L, "1234321234321.23****" },
1074         { 1.234321234321234e13L, "12343212343212.3*****" },
1075         { 1.234321234321234e14L, "123432123432123.******" },
1076         { 1.234321234321234e15L, "1234321234321234.000000" },
1077         { 1.234321234321234e16L, "123432123432123**.000000" },
1078         { 1.234321234321234e17L, "123432123432123***.000000" },
1079         { 1.234321234321234e18L, "123432123432123****.000000" },
1080         { 1.234321234321234e19L, "123432123432123*****.000000" },
1081         { 1.234321234321234e20L, "123432123432123******.000000" },
1082         { 1.234321234321234e21L, "123432123432123*******.000000" },
1083         { 1.234321234321234e22L, "123432123432123********.000000" },
1084         { 1.234321234321234e23L, "123432123432123*********.000000" },
1085         { 1.234321234321234e24L, "123432123432123**********.000000" },
1086         { 1.234321234321234e25L, "123432123432123***********.000000" },
1087         { 1.234321234321234e26L, "123432123432123************.000000" },
1088         { 1.234321234321234e27L, "123432123432123*************.000000" },
1089         { 1.234321234321234e28L, "123432123432123**************.000000" },
1090         { 1.234321234321234e29L, "123432123432123***************.000000" },
1091         { 1.234321234321234e30L, "123432123432123****************.000000" },
1092         { 1.234321234321234e31L, "123432123432123*****************.000000" },
1093         { 1.234321234321234e32L, "123432123432123******************.000000" },
1094         { 1.234321234321234e33L, "123432123432123*******************.000000" },
1095         { 1.234321234321234e34L, "123432123432123********************.000000" },
1096         { 1.234321234321234e35L, "123432123432123*********************.000000" },
1097         { 1.234321234321234e36L, "123432123432123**********************.000000" }
1098       };
1099     size_t k;
1100     for (k = 0; k < SIZEOF (data); k++)
1101       {
1102         char result[1000];
1103         int retval =
1104           my_sprintf (result, "%Lf", data[k].value);
1105         ASSERT (strmatch (data[k].string, result));
1106         ASSERT (retval == strlen (result));
1107       }
1108   }
1109
1110   { /* A negative number.  */
1111     char result[1000];
1112     int retval =
1113       my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
1114     ASSERT (strcmp (result, "-0.031250 33") == 0);
1115     ASSERT (retval == strlen (result));
1116   }
1117
1118   { /* Positive zero.  */
1119     char result[1000];
1120     int retval =
1121       my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
1122     ASSERT (strcmp (result, "0.000000 33") == 0);
1123     ASSERT (retval == strlen (result));
1124   }
1125
1126   { /* Negative zero.  */
1127     char result[1000];
1128     int retval =
1129       my_sprintf (result, "%Lf %d", minus_zerol, 33, 44, 55);
1130     if (have_minus_zero ())
1131       ASSERT (strcmp (result, "-0.000000 33") == 0);
1132     ASSERT (retval == strlen (result));
1133   }
1134
1135   { /* Positive infinity.  */
1136     char result[1000];
1137     int retval =
1138       my_sprintf (result, "%Lf %d", Infinityl (), 33, 44, 55);
1139     ASSERT (strcmp (result, "inf 33") == 0
1140             || strcmp (result, "infinity 33") == 0);
1141     ASSERT (retval == strlen (result));
1142   }
1143
1144   { /* Negative infinity.  */
1145     char result[1000];
1146     int retval =
1147       my_sprintf (result, "%Lf %d", - Infinityl (), 33, 44, 55);
1148     ASSERT (strcmp (result, "-inf 33") == 0
1149             || strcmp (result, "-infinity 33") == 0);
1150     ASSERT (retval == strlen (result));
1151   }
1152
1153   { /* NaN.  */
1154     char result[1000];
1155     int retval =
1156       my_sprintf (result, "%Lf %d", NaNl (), 33, 44, 55);
1157     ASSERT (strlen (result) >= 3 + 3
1158             && strisnan (result, 0, strlen (result) - 3, 0)
1159             && strcmp (result + strlen (result) - 3, " 33") == 0);
1160     ASSERT (retval == strlen (result));
1161   }
1162 #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_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
1163   { /* Quiet NaN.  */
1164     static union { unsigned int word[4]; long double value; } x =
1165       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1166     char result[1000];
1167     int retval =
1168       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1169     ASSERT (strlen (result) >= 3 + 3
1170             && strisnan (result, 0, strlen (result) - 3, 0)
1171             && strcmp (result + strlen (result) - 3, " 33") == 0);
1172     ASSERT (retval == strlen (result));
1173   }
1174   {
1175     /* Signalling NaN.  */
1176     static union { unsigned int word[4]; long double value; } x =
1177       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1178     char result[1000];
1179     int retval =
1180       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1181     ASSERT (strlen (result) >= 3 + 3
1182             && strisnan (result, 0, strlen (result) - 3, 0)
1183             && strcmp (result + strlen (result) - 3, " 33") == 0);
1184     ASSERT (retval == strlen (result));
1185   }
1186   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1187      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1188        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1189        Application Architecture.
1190        Table 5-2 "Floating-Point Register Encodings"
1191        Figure 5-6 "Memory to Floating-Point Register Data Translation"
1192    */
1193   { /* Pseudo-NaN.  */
1194     static union { unsigned int word[4]; long double value; } x =
1195       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1196     char result[1000];
1197     int retval =
1198       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1199     ASSERT (strlen (result) >= 3 + 3
1200             && strisnan (result, 0, strlen (result) - 3, 0)
1201             && strcmp (result + strlen (result) - 3, " 33") == 0);
1202     ASSERT (retval == strlen (result));
1203   }
1204   { /* Pseudo-Infinity.  */
1205     static union { unsigned int word[4]; long double value; } x =
1206       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1207     char result[1000];
1208     int retval =
1209       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1210     ASSERT (strlen (result) >= 3 + 3
1211             && strisnan (result, 0, strlen (result) - 3, 0)
1212             && strcmp (result + strlen (result) - 3, " 33") == 0);
1213     ASSERT (retval == strlen (result));
1214   }
1215   { /* Pseudo-Zero.  */
1216     static union { unsigned int word[4]; long double value; } x =
1217       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1218     char result[1000];
1219     int retval =
1220       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1221     ASSERT (strlen (result) >= 3 + 3
1222             && strisnan (result, 0, strlen (result) - 3, 0)
1223             && strcmp (result + strlen (result) - 3, " 33") == 0);
1224     ASSERT (retval == strlen (result));
1225   }
1226   { /* Unnormalized number.  */
1227     static union { unsigned int word[4]; long double value; } x =
1228       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1229     char result[1000];
1230     int retval =
1231       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1232     ASSERT (strlen (result) >= 3 + 3
1233             && strisnan (result, 0, strlen (result) - 3, 0)
1234             && strcmp (result + strlen (result) - 3, " 33") == 0);
1235     ASSERT (retval == strlen (result));
1236   }
1237   { /* Pseudo-Denormal.  */
1238     static union { unsigned int word[4]; long double value; } x =
1239       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1240     char result[1000];
1241     int retval =
1242       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1243     ASSERT (strlen (result) >= 3 + 3
1244             && strisnan (result, 0, strlen (result) - 3, 0)
1245             && strcmp (result + strlen (result) - 3, " 33") == 0);
1246     ASSERT (retval == strlen (result));
1247   }
1248 #endif
1249
1250   { /* Width.  */
1251     char result[1000];
1252     int retval =
1253       my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
1254     ASSERT (strcmp (result, "  1.750000 33") == 0);
1255     ASSERT (retval == strlen (result));
1256   }
1257
1258   { /* FLAG_LEFT.  */
1259     char result[1000];
1260     int retval =
1261       my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
1262     ASSERT (strcmp (result, "1.750000   33") == 0);
1263     ASSERT (retval == strlen (result));
1264   }
1265
1266   { /* FLAG_SHOWSIGN.  */
1267     char result[1000];
1268     int retval =
1269       my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
1270     ASSERT (strcmp (result, "+1.750000 33") == 0);
1271     ASSERT (retval == strlen (result));
1272   }
1273
1274   { /* FLAG_SPACE.  */
1275     char result[1000];
1276     int retval =
1277       my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
1278     ASSERT (strcmp (result, " 1.750000 33") == 0);
1279     ASSERT (retval == strlen (result));
1280   }
1281
1282   { /* FLAG_ALT.  */
1283     char result[1000];
1284     int retval =
1285       my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
1286     ASSERT (strcmp (result, "1.750000 33") == 0);
1287     ASSERT (retval == strlen (result));
1288   }
1289
1290   { /* FLAG_ALT.  */
1291     char result[1000];
1292     int retval =
1293       my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
1294     ASSERT (strcmp (result, "2. 33") == 0);
1295     ASSERT (retval == strlen (result));
1296   }
1297
1298   { /* FLAG_ZERO with finite number.  */
1299     char result[1000];
1300     int retval =
1301       my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
1302     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1303     ASSERT (retval == strlen (result));
1304   }
1305
1306   { /* FLAG_ZERO with infinite number.  */
1307     char result[1000];
1308     int retval =
1309       my_sprintf (result, "%015Lf %d", - Infinityl (), 33, 44, 55);
1310     ASSERT (strcmp (result, "           -inf 33") == 0
1311             || strcmp (result, "      -infinity 33") == 0);
1312     ASSERT (retval == strlen (result));
1313   }
1314
1315   { /* FLAG_ZERO with NaN.  */
1316     char result[1000];
1317     int retval =
1318       my_sprintf (result, "%050Lf %d", NaNl (), 33, 44, 55);
1319     ASSERT (strlen (result) == 50 + 3
1320             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1321             && strcmp (result + strlen (result) - 3, " 33") == 0);
1322     ASSERT (retval == strlen (result));
1323   }
1324
1325   { /* Precision.  */
1326     char result[1000];
1327     int retval =
1328       my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
1329     ASSERT (strcmp (result, "1234 33") == 0);
1330     ASSERT (retval == strlen (result));
1331   }
1332
1333   { /* Precision with no rounding.  */
1334     char result[100];
1335     int retval =
1336       my_sprintf (result, "%.2Lf %d", 999.951L, 33, 44, 55);
1337     ASSERT (strcmp (result, "999.95 33") == 0);
1338     ASSERT (retval == strlen (result));
1339   }
1340
1341   { /* Precision with rounding.  */
1342     char result[100];
1343     int retval =
1344       my_sprintf (result, "%.2Lf %d", 999.996L, 33, 44, 55);
1345     ASSERT (strcmp (result, "1000.00 33") == 0);
1346     ASSERT (retval == strlen (result));
1347   }
1348
1349   /* Test the support of the %F format directive.  */
1350
1351   { /* A positive number.  */
1352     char result[1000];
1353     int retval =
1354       my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
1355     ASSERT (strcmp (result, "12.750000 33") == 0);
1356     ASSERT (retval == strlen (result));
1357   }
1358
1359   { /* A larger positive number.  */
1360     char result[1000];
1361     int retval =
1362       my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
1363     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1364     ASSERT (retval == strlen (result));
1365   }
1366
1367   { /* A negative number.  */
1368     char result[1000];
1369     int retval =
1370       my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
1371     ASSERT (strcmp (result, "-0.031250 33") == 0);
1372     ASSERT (retval == strlen (result));
1373   }
1374
1375   { /* Positive zero.  */
1376     char result[1000];
1377     int retval =
1378       my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
1379     ASSERT (strcmp (result, "0.000000 33") == 0);
1380     ASSERT (retval == strlen (result));
1381   }
1382
1383   { /* Negative zero.  */
1384     char result[1000];
1385     int retval =
1386       my_sprintf (result, "%F %d", minus_zerod, 33, 44, 55);
1387     if (have_minus_zero ())
1388       ASSERT (strcmp (result, "-0.000000 33") == 0);
1389     ASSERT (retval == strlen (result));
1390   }
1391
1392   { /* Positive infinity.  */
1393     char result[1000];
1394     int retval =
1395       my_sprintf (result, "%F %d", Infinityd (), 33, 44, 55);
1396     ASSERT (strcmp (result, "INF 33") == 0
1397             || strcmp (result, "INFINITY 33") == 0);
1398     ASSERT (retval == strlen (result));
1399   }
1400
1401   { /* Negative infinity.  */
1402     char result[1000];
1403     int retval =
1404       my_sprintf (result, "%F %d", - Infinityd (), 33, 44, 55);
1405     ASSERT (strcmp (result, "-INF 33") == 0
1406             || strcmp (result, "-INFINITY 33") == 0);
1407     ASSERT (retval == strlen (result));
1408   }
1409
1410   { /* NaN.  */
1411     char result[1000];
1412     int retval =
1413       my_sprintf (result, "%F %d", NaNd (), 33, 44, 55);
1414     ASSERT (strlen (result) >= 3 + 3
1415             && strisnan (result, 0, strlen (result) - 3, 1)
1416             && strcmp (result + strlen (result) - 3, " 33") == 0);
1417     ASSERT (retval == strlen (result));
1418   }
1419
1420   { /* FLAG_ZERO.  */
1421     char result[1000];
1422     int retval =
1423       my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
1424     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1425     ASSERT (retval == strlen (result));
1426   }
1427
1428   { /* FLAG_ZERO with infinite number.  */
1429     char result[1000];
1430     int retval =
1431       my_sprintf (result, "%015F %d", - Infinityd (), 33, 44, 55);
1432     ASSERT (strcmp (result, "           -INF 33") == 0
1433             || strcmp (result, "      -INFINITY 33") == 0);
1434     ASSERT (retval == strlen (result));
1435   }
1436
1437   { /* Precision.  */
1438     char result[1000];
1439     int retval =
1440       my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
1441     ASSERT (strcmp (result, "1234 33") == 0);
1442     ASSERT (retval == strlen (result));
1443   }
1444
1445   { /* Precision with no rounding.  */
1446     char result[100];
1447     int retval =
1448       my_sprintf (result, "%.2F %d", 999.951, 33, 44, 55);
1449     ASSERT (strcmp (result, "999.95 33") == 0);
1450     ASSERT (retval == strlen (result));
1451   }
1452
1453   { /* Precision with rounding.  */
1454     char result[100];
1455     int retval =
1456       my_sprintf (result, "%.2F %d", 999.996, 33, 44, 55);
1457     ASSERT (strcmp (result, "1000.00 33") == 0);
1458     ASSERT (retval == strlen (result));
1459   }
1460
1461   { /* A positive number.  */
1462     char result[1000];
1463     int retval =
1464       my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
1465     ASSERT (strcmp (result, "12.750000 33") == 0);
1466     ASSERT (retval == strlen (result));
1467   }
1468
1469   { /* A larger positive number.  */
1470     char result[1000];
1471     int retval =
1472       my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
1473     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1474     ASSERT (retval == strlen (result));
1475   }
1476
1477   { /* A negative number.  */
1478     char result[1000];
1479     int retval =
1480       my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
1481     ASSERT (strcmp (result, "-0.031250 33") == 0);
1482     ASSERT (retval == strlen (result));
1483   }
1484
1485   { /* Positive zero.  */
1486     char result[1000];
1487     int retval =
1488       my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
1489     ASSERT (strcmp (result, "0.000000 33") == 0);
1490     ASSERT (retval == strlen (result));
1491   }
1492
1493   { /* Negative zero.  */
1494     char result[1000];
1495     int retval =
1496       my_sprintf (result, "%LF %d", minus_zerol, 33, 44, 55);
1497     if (have_minus_zero ())
1498       ASSERT (strcmp (result, "-0.000000 33") == 0);
1499     ASSERT (retval == strlen (result));
1500   }
1501
1502   { /* Positive infinity.  */
1503     char result[1000];
1504     int retval =
1505       my_sprintf (result, "%LF %d", Infinityl (), 33, 44, 55);
1506     ASSERT (strcmp (result, "INF 33") == 0
1507             || strcmp (result, "INFINITY 33") == 0);
1508     ASSERT (retval == strlen (result));
1509   }
1510
1511   { /* Negative infinity.  */
1512     char result[1000];
1513     int retval =
1514       my_sprintf (result, "%LF %d", - Infinityl (), 33, 44, 55);
1515     ASSERT (strcmp (result, "-INF 33") == 0
1516             || strcmp (result, "-INFINITY 33") == 0);
1517     ASSERT (retval == strlen (result));
1518   }
1519
1520   { /* NaN.  */
1521     char result[1000];
1522     int retval =
1523       my_sprintf (result, "%LF %d", NaNl (), 33, 44, 55);
1524     ASSERT (strlen (result) >= 3 + 3
1525             && strisnan (result, 0, strlen (result) - 3, 1)
1526             && strcmp (result + strlen (result) - 3, " 33") == 0);
1527     ASSERT (retval == strlen (result));
1528   }
1529
1530   { /* FLAG_ZERO.  */
1531     char result[1000];
1532     int retval =
1533       my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
1534     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1535     ASSERT (retval == strlen (result));
1536   }
1537
1538   { /* FLAG_ZERO with infinite number.  */
1539     char result[1000];
1540     int retval =
1541       my_sprintf (result, "%015LF %d", - Infinityl (), 33, 44, 55);
1542     ASSERT (strcmp (result, "           -INF 33") == 0
1543             || strcmp (result, "      -INFINITY 33") == 0);
1544     ASSERT (retval == strlen (result));
1545   }
1546
1547   { /* Precision.  */
1548     char result[1000];
1549     int retval =
1550       my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
1551     ASSERT (strcmp (result, "1234 33") == 0);
1552     ASSERT (retval == strlen (result));
1553   }
1554
1555   { /* Precision with no rounding.  */
1556     char result[100];
1557     int retval =
1558       my_sprintf (result, "%.2LF %d", 999.951L, 33, 44, 55);
1559     ASSERT (strcmp (result, "999.95 33") == 0);
1560     ASSERT (retval == strlen (result));
1561   }
1562
1563   { /* Precision with rounding.  */
1564     char result[100];
1565     int retval =
1566       my_sprintf (result, "%.2LF %d", 999.996L, 33, 44, 55);
1567     ASSERT (strcmp (result, "1000.00 33") == 0);
1568     ASSERT (retval == strlen (result));
1569   }
1570
1571   /* Test the support of the %e format directive.  */
1572
1573   { /* A positive number.  */
1574     char result[1000];
1575     int retval =
1576       my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
1577     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1578             || strcmp (result, "1.275000e+001 33") == 0);
1579     ASSERT (retval == strlen (result));
1580   }
1581
1582   { /* A larger positive number.  */
1583     char result[1000];
1584     int retval =
1585       my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
1586     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1587             || strcmp (result, "1.234567e+006 33") == 0);
1588     ASSERT (retval == strlen (result));
1589   }
1590
1591   { /* Small and large positive numbers.  */
1592     static struct { double value; const char *string; } data[] =
1593       {
1594         { 1.234321234321234e-37, "1.234321e-37" },
1595         { 1.234321234321234e-36, "1.234321e-36" },
1596         { 1.234321234321234e-35, "1.234321e-35" },
1597         { 1.234321234321234e-34, "1.234321e-34" },
1598         { 1.234321234321234e-33, "1.234321e-33" },
1599         { 1.234321234321234e-32, "1.234321e-32" },
1600         { 1.234321234321234e-31, "1.234321e-31" },
1601         { 1.234321234321234e-30, "1.234321e-30" },
1602         { 1.234321234321234e-29, "1.234321e-29" },
1603         { 1.234321234321234e-28, "1.234321e-28" },
1604         { 1.234321234321234e-27, "1.234321e-27" },
1605         { 1.234321234321234e-26, "1.234321e-26" },
1606         { 1.234321234321234e-25, "1.234321e-25" },
1607         { 1.234321234321234e-24, "1.234321e-24" },
1608         { 1.234321234321234e-23, "1.234321e-23" },
1609         { 1.234321234321234e-22, "1.234321e-22" },
1610         { 1.234321234321234e-21, "1.234321e-21" },
1611         { 1.234321234321234e-20, "1.234321e-20" },
1612         { 1.234321234321234e-19, "1.234321e-19" },
1613         { 1.234321234321234e-18, "1.234321e-18" },
1614         { 1.234321234321234e-17, "1.234321e-17" },
1615         { 1.234321234321234e-16, "1.234321e-16" },
1616         { 1.234321234321234e-15, "1.234321e-15" },
1617         { 1.234321234321234e-14, "1.234321e-14" },
1618         { 1.234321234321234e-13, "1.234321e-13" },
1619         { 1.234321234321234e-12, "1.234321e-12" },
1620         { 1.234321234321234e-11, "1.234321e-11" },
1621         { 1.234321234321234e-10, "1.234321e-10" },
1622         { 1.234321234321234e-9, "1.234321e-09" },
1623         { 1.234321234321234e-8, "1.234321e-08" },
1624         { 1.234321234321234e-7, "1.234321e-07" },
1625         { 1.234321234321234e-6, "1.234321e-06" },
1626         { 1.234321234321234e-5, "1.234321e-05" },
1627         { 1.234321234321234e-4, "1.234321e-04" },
1628         { 1.234321234321234e-3, "1.234321e-03" },
1629         { 1.234321234321234e-2, "1.234321e-02" },
1630         { 1.234321234321234e-1, "1.234321e-01" },
1631         { 1.234321234321234, "1.234321e+00" },
1632         { 1.234321234321234e1, "1.234321e+01" },
1633         { 1.234321234321234e2, "1.234321e+02" },
1634         { 1.234321234321234e3, "1.234321e+03" },
1635         { 1.234321234321234e4, "1.234321e+04" },
1636         { 1.234321234321234e5, "1.234321e+05" },
1637         { 1.234321234321234e6, "1.234321e+06" },
1638         { 1.234321234321234e7, "1.234321e+07" },
1639         { 1.234321234321234e8, "1.234321e+08" },
1640         { 1.234321234321234e9, "1.234321e+09" },
1641         { 1.234321234321234e10, "1.234321e+10" },
1642         { 1.234321234321234e11, "1.234321e+11" },
1643         { 1.234321234321234e12, "1.234321e+12" },
1644         { 1.234321234321234e13, "1.234321e+13" },
1645         { 1.234321234321234e14, "1.234321e+14" },
1646         { 1.234321234321234e15, "1.234321e+15" },
1647         { 1.234321234321234e16, "1.234321e+16" },
1648         { 1.234321234321234e17, "1.234321e+17" },
1649         { 1.234321234321234e18, "1.234321e+18" },
1650         { 1.234321234321234e19, "1.234321e+19" },
1651         { 1.234321234321234e20, "1.234321e+20" },
1652         { 1.234321234321234e21, "1.234321e+21" },
1653         { 1.234321234321234e22, "1.234321e+22" },
1654         { 1.234321234321234e23, "1.234321e+23" },
1655         { 1.234321234321234e24, "1.234321e+24" },
1656         { 1.234321234321234e25, "1.234321e+25" },
1657         { 1.234321234321234e26, "1.234321e+26" },
1658         { 1.234321234321234e27, "1.234321e+27" },
1659         { 1.234321234321234e28, "1.234321e+28" },
1660         { 1.234321234321234e29, "1.234321e+29" },
1661         { 1.234321234321234e30, "1.234321e+30" },
1662         { 1.234321234321234e31, "1.234321e+31" },
1663         { 1.234321234321234e32, "1.234321e+32" },
1664         { 1.234321234321234e33, "1.234321e+33" },
1665         { 1.234321234321234e34, "1.234321e+34" },
1666         { 1.234321234321234e35, "1.234321e+35" },
1667         { 1.234321234321234e36, "1.234321e+36" }
1668       };
1669     size_t k;
1670     for (k = 0; k < SIZEOF (data); k++)
1671       {
1672         char result[1000];
1673         int retval =
1674           my_sprintf (result, "%e", data[k].value);
1675         const char *expected = data[k].string;
1676         ASSERT (strcmp (result, expected) == 0
1677                 /* Some implementations produce exponents with 3 digits.  */
1678                 || (strlen (result) == strlen (expected) + 1
1679                     && memcmp (result, expected, strlen (expected) - 2) == 0
1680                     && result[strlen (expected) - 2] == '0'
1681                     && strcmp (result + strlen (expected) - 1,
1682                                expected + strlen (expected) - 2)
1683                        == 0));
1684         ASSERT (retval == strlen (result));
1685       }
1686   }
1687
1688   { /* A negative number.  */
1689     char result[1000];
1690     int retval =
1691       my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
1692     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1693             || strcmp (result, "-3.125000e-002 33") == 0);
1694     ASSERT (retval == strlen (result));
1695   }
1696
1697   { /* Positive zero.  */
1698     char result[1000];
1699     int retval =
1700       my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
1701     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1702             || strcmp (result, "0.000000e+000 33") == 0);
1703     ASSERT (retval == strlen (result));
1704   }
1705
1706   { /* Negative zero.  */
1707     char result[1000];
1708     int retval =
1709       my_sprintf (result, "%e %d", minus_zerod, 33, 44, 55);
1710     if (have_minus_zero ())
1711       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1712               || strcmp (result, "-0.000000e+000 33") == 0);
1713     ASSERT (retval == strlen (result));
1714   }
1715
1716   { /* Positive infinity.  */
1717     char result[1000];
1718     int retval =
1719       my_sprintf (result, "%e %d", Infinityd (), 33, 44, 55);
1720     ASSERT (strcmp (result, "inf 33") == 0
1721             || strcmp (result, "infinity 33") == 0);
1722     ASSERT (retval == strlen (result));
1723   }
1724
1725   { /* Negative infinity.  */
1726     char result[1000];
1727     int retval =
1728       my_sprintf (result, "%e %d", - Infinityd (), 33, 44, 55);
1729     ASSERT (strcmp (result, "-inf 33") == 0
1730             || strcmp (result, "-infinity 33") == 0);
1731     ASSERT (retval == strlen (result));
1732   }
1733
1734   { /* NaN.  */
1735     char result[1000];
1736     int retval =
1737       my_sprintf (result, "%e %d", NaNd (), 33, 44, 55);
1738     ASSERT (strlen (result) >= 3 + 3
1739             && strisnan (result, 0, strlen (result) - 3, 0)
1740             && strcmp (result + strlen (result) - 3, " 33") == 0);
1741     ASSERT (retval == strlen (result));
1742   }
1743
1744   { /* Width.  */
1745     char result[1000];
1746     int retval =
1747       my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
1748     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
1749             || strcmp (result, "  1.750000e+000 33") == 0);
1750     ASSERT (retval == strlen (result));
1751   }
1752
1753   { /* FLAG_LEFT.  */
1754     char result[1000];
1755     int retval =
1756       my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
1757     ASSERT (strcmp (result, "1.750000e+00    33") == 0
1758             || strcmp (result, "1.750000e+000   33") == 0);
1759     ASSERT (retval == strlen (result));
1760   }
1761
1762   { /* FLAG_SHOWSIGN.  */
1763     char result[1000];
1764     int retval =
1765       my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
1766     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1767             || strcmp (result, "+1.750000e+000 33") == 0);
1768     ASSERT (retval == strlen (result));
1769   }
1770
1771   { /* FLAG_SPACE.  */
1772     char result[1000];
1773     int retval =
1774       my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
1775     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1776             || strcmp (result, " 1.750000e+000 33") == 0);
1777     ASSERT (retval == strlen (result));
1778   }
1779
1780   { /* FLAG_ALT.  */
1781     char result[1000];
1782     int retval =
1783       my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
1784     ASSERT (strcmp (result, "1.750000e+00 33") == 0
1785             || strcmp (result, "1.750000e+000 33") == 0);
1786     ASSERT (retval == strlen (result));
1787   }
1788
1789   { /* FLAG_ALT.  */
1790     char result[1000];
1791     int retval =
1792       my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
1793     ASSERT (strcmp (result, "2.e+00 33") == 0
1794             || strcmp (result, "2.e+000 33") == 0);
1795     ASSERT (retval == strlen (result));
1796   }
1797
1798   { /* FLAG_ALT.  */
1799     char result[1000];
1800     int retval =
1801       my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
1802     ASSERT (strcmp (result, "1.e+01 33") == 0
1803             || strcmp (result, "1.e+001 33") == 0);
1804     ASSERT (retval == strlen (result));
1805   }
1806
1807   { /* FLAG_ZERO with finite number.  */
1808     char result[1000];
1809     int retval =
1810       my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
1811     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1812             || strcmp (result, "001.234000e+003 33") == 0);
1813     ASSERT (retval == strlen (result));
1814   }
1815
1816   { /* FLAG_ZERO with infinite number.  */
1817     char result[1000];
1818     int retval =
1819       my_sprintf (result, "%015e %d", - Infinityd (), 33, 44, 55);
1820     ASSERT (strcmp (result, "           -inf 33") == 0
1821             || strcmp (result, "      -infinity 33") == 0);
1822     ASSERT (retval == strlen (result));
1823   }
1824
1825   { /* FLAG_ZERO with NaN.  */
1826     char result[1000];
1827     int retval =
1828       my_sprintf (result, "%050e %d", NaNd (), 33, 44, 55);
1829     ASSERT (strlen (result) == 50 + 3
1830             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1831             && strcmp (result + strlen (result) - 3, " 33") == 0);
1832     ASSERT (retval == strlen (result));
1833   }
1834
1835   { /* Precision.  */
1836     char result[1000];
1837     int retval =
1838       my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
1839     ASSERT (strcmp (result, "1e+03 33") == 0
1840             || strcmp (result, "1e+003 33") == 0);
1841     ASSERT (retval == strlen (result));
1842   }
1843
1844   { /* Precision with no rounding.  */
1845     char result[100];
1846     int retval =
1847       my_sprintf (result, "%.4e %d", 999.951, 33, 44, 55);
1848     ASSERT (strcmp (result, "9.9995e+02 33") == 0
1849             || strcmp (result, "9.9995e+002 33") == 0);
1850     ASSERT (retval == strlen (result));
1851   }
1852
1853   { /* Precision with rounding.  */
1854     char result[100];
1855     int retval =
1856       my_sprintf (result, "%.4e %d", 999.996, 33, 44, 55);
1857     ASSERT (strcmp (result, "1.0000e+03 33") == 0
1858             || strcmp (result, "1.0000e+003 33") == 0);
1859     ASSERT (retval == strlen (result));
1860   }
1861
1862   { /* A positive number.  */
1863     char result[1000];
1864     int retval =
1865       my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
1866     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1867             || strcmp (result, "1.275000e+001 33") == 0);
1868     ASSERT (retval == strlen (result));
1869   }
1870
1871   { /* A larger positive number.  */
1872     char result[1000];
1873     int retval =
1874       my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
1875     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1876             || strcmp (result, "1.234567e+006 33") == 0);
1877     ASSERT (retval == strlen (result));
1878   }
1879
1880   { /* Small and large positive numbers.  */
1881     static struct { long double value; const char *string; } data[] =
1882       {
1883         { 1.234321234321234e-37L, "1.234321e-37" },
1884         { 1.234321234321234e-36L, "1.234321e-36" },
1885         { 1.234321234321234e-35L, "1.234321e-35" },
1886         { 1.234321234321234e-34L, "1.234321e-34" },
1887         { 1.234321234321234e-33L, "1.234321e-33" },
1888         { 1.234321234321234e-32L, "1.234321e-32" },
1889         { 1.234321234321234e-31L, "1.234321e-31" },
1890         { 1.234321234321234e-30L, "1.234321e-30" },
1891         { 1.234321234321234e-29L, "1.234321e-29" },
1892         { 1.234321234321234e-28L, "1.234321e-28" },
1893         { 1.234321234321234e-27L, "1.234321e-27" },
1894         { 1.234321234321234e-26L, "1.234321e-26" },
1895         { 1.234321234321234e-25L, "1.234321e-25" },
1896         { 1.234321234321234e-24L, "1.234321e-24" },
1897         { 1.234321234321234e-23L, "1.234321e-23" },
1898         { 1.234321234321234e-22L, "1.234321e-22" },
1899         { 1.234321234321234e-21L, "1.234321e-21" },
1900         { 1.234321234321234e-20L, "1.234321e-20" },
1901         { 1.234321234321234e-19L, "1.234321e-19" },
1902         { 1.234321234321234e-18L, "1.234321e-18" },
1903         { 1.234321234321234e-17L, "1.234321e-17" },
1904         { 1.234321234321234e-16L, "1.234321e-16" },
1905         { 1.234321234321234e-15L, "1.234321e-15" },
1906         { 1.234321234321234e-14L, "1.234321e-14" },
1907         { 1.234321234321234e-13L, "1.234321e-13" },
1908         { 1.234321234321234e-12L, "1.234321e-12" },
1909         { 1.234321234321234e-11L, "1.234321e-11" },
1910         { 1.234321234321234e-10L, "1.234321e-10" },
1911         { 1.234321234321234e-9L, "1.234321e-09" },
1912         { 1.234321234321234e-8L, "1.234321e-08" },
1913         { 1.234321234321234e-7L, "1.234321e-07" },
1914         { 1.234321234321234e-6L, "1.234321e-06" },
1915         { 1.234321234321234e-5L, "1.234321e-05" },
1916         { 1.234321234321234e-4L, "1.234321e-04" },
1917         { 1.234321234321234e-3L, "1.234321e-03" },
1918         { 1.234321234321234e-2L, "1.234321e-02" },
1919         { 1.234321234321234e-1L, "1.234321e-01" },
1920         { 1.234321234321234L, "1.234321e+00" },
1921         { 1.234321234321234e1L, "1.234321e+01" },
1922         { 1.234321234321234e2L, "1.234321e+02" },
1923         { 1.234321234321234e3L, "1.234321e+03" },
1924         { 1.234321234321234e4L, "1.234321e+04" },
1925         { 1.234321234321234e5L, "1.234321e+05" },
1926         { 1.234321234321234e6L, "1.234321e+06" },
1927         { 1.234321234321234e7L, "1.234321e+07" },
1928         { 1.234321234321234e8L, "1.234321e+08" },
1929         { 1.234321234321234e9L, "1.234321e+09" },
1930         { 1.234321234321234e10L, "1.234321e+10" },
1931         { 1.234321234321234e11L, "1.234321e+11" },
1932         { 1.234321234321234e12L, "1.234321e+12" },
1933         { 1.234321234321234e13L, "1.234321e+13" },
1934         { 1.234321234321234e14L, "1.234321e+14" },
1935         { 1.234321234321234e15L, "1.234321e+15" },
1936         { 1.234321234321234e16L, "1.234321e+16" },
1937         { 1.234321234321234e17L, "1.234321e+17" },
1938         { 1.234321234321234e18L, "1.234321e+18" },
1939         { 1.234321234321234e19L, "1.234321e+19" },
1940         { 1.234321234321234e20L, "1.234321e+20" },
1941         { 1.234321234321234e21L, "1.234321e+21" },
1942         { 1.234321234321234e22L, "1.234321e+22" },
1943         { 1.234321234321234e23L, "1.234321e+23" },
1944         { 1.234321234321234e24L, "1.234321e+24" },
1945         { 1.234321234321234e25L, "1.234321e+25" },
1946         { 1.234321234321234e26L, "1.234321e+26" },
1947         { 1.234321234321234e27L, "1.234321e+27" },
1948         { 1.234321234321234e28L, "1.234321e+28" },
1949         { 1.234321234321234e29L, "1.234321e+29" },
1950         { 1.234321234321234e30L, "1.234321e+30" },
1951         { 1.234321234321234e31L, "1.234321e+31" },
1952         { 1.234321234321234e32L, "1.234321e+32" },
1953         { 1.234321234321234e33L, "1.234321e+33" },
1954         { 1.234321234321234e34L, "1.234321e+34" },
1955         { 1.234321234321234e35L, "1.234321e+35" },
1956         { 1.234321234321234e36L, "1.234321e+36" }
1957       };
1958     size_t k;
1959     for (k = 0; k < SIZEOF (data); k++)
1960       {
1961         char result[1000];
1962         int retval =
1963           my_sprintf (result, "%Le", data[k].value);
1964         const char *expected = data[k].string;
1965         ASSERT (strcmp (result, expected) == 0
1966                 /* Some implementations produce exponents with 3 digits.  */
1967                 || (strlen (result) == strlen (expected) + 1
1968                     && memcmp (result, expected, strlen (expected) - 2) == 0
1969                     && result[strlen (expected) - 2] == '0'
1970                     && strcmp (result + strlen (expected) - 1,
1971                                expected + strlen (expected) - 2)
1972                        == 0));
1973         ASSERT (retval == strlen (result));
1974       }
1975   }
1976
1977   { /* A negative number.  */
1978     char result[1000];
1979     int retval =
1980       my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
1981     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1982             || strcmp (result, "-3.125000e-002 33") == 0);
1983     ASSERT (retval == strlen (result));
1984   }
1985
1986   { /* Positive zero.  */
1987     char result[1000];
1988     int retval =
1989       my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
1990     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1991             || strcmp (result, "0.000000e+000 33") == 0);
1992     ASSERT (retval == strlen (result));
1993   }
1994
1995   { /* Negative zero.  */
1996     char result[1000];
1997     int retval =
1998       my_sprintf (result, "%Le %d", minus_zerol, 33, 44, 55);
1999     if (have_minus_zero ())
2000       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
2001               || strcmp (result, "-0.000000e+000 33") == 0);
2002     ASSERT (retval == strlen (result));
2003   }
2004
2005   { /* Positive infinity.  */
2006     char result[1000];
2007     int retval =
2008       my_sprintf (result, "%Le %d", Infinityl (), 33, 44, 55);
2009     ASSERT (strcmp (result, "inf 33") == 0
2010             || strcmp (result, "infinity 33") == 0);
2011     ASSERT (retval == strlen (result));
2012   }
2013
2014   { /* Negative infinity.  */
2015     char result[1000];
2016     int retval =
2017       my_sprintf (result, "%Le %d", - Infinityl (), 33, 44, 55);
2018     ASSERT (strcmp (result, "-inf 33") == 0
2019             || strcmp (result, "-infinity 33") == 0);
2020     ASSERT (retval == strlen (result));
2021   }
2022
2023   { /* NaN.  */
2024     char result[1000];
2025     int retval =
2026       my_sprintf (result, "%Le %d", NaNl (), 33, 44, 55);
2027     ASSERT (strlen (result) >= 3 + 3
2028             && strisnan (result, 0, strlen (result) - 3, 0)
2029             && strcmp (result + strlen (result) - 3, " 33") == 0);
2030     ASSERT (retval == strlen (result));
2031   }
2032 #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_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
2033   { /* Quiet NaN.  */
2034     static union { unsigned int word[4]; long double value; } x =
2035       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2036     char result[1000];
2037     int retval =
2038       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2039     ASSERT (strlen (result) >= 3 + 3
2040             && strisnan (result, 0, strlen (result) - 3, 0)
2041             && strcmp (result + strlen (result) - 3, " 33") == 0);
2042     ASSERT (retval == strlen (result));
2043   }
2044   {
2045     /* Signalling NaN.  */
2046     static union { unsigned int word[4]; long double value; } x =
2047       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2048     char result[1000];
2049     int retval =
2050       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2051     ASSERT (strlen (result) >= 3 + 3
2052             && strisnan (result, 0, strlen (result) - 3, 0)
2053             && strcmp (result + strlen (result) - 3, " 33") == 0);
2054     ASSERT (retval == strlen (result));
2055   }
2056   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2057      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2058        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2059        Application Architecture.
2060        Table 5-2 "Floating-Point Register Encodings"
2061        Figure 5-6 "Memory to Floating-Point Register Data Translation"
2062    */
2063   { /* Pseudo-NaN.  */
2064     static union { unsigned int word[4]; long double value; } x =
2065       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2066     char result[1000];
2067     int retval =
2068       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2069     ASSERT (strlen (result) >= 3 + 3
2070             && strisnan (result, 0, strlen (result) - 3, 0)
2071             && strcmp (result + strlen (result) - 3, " 33") == 0);
2072     ASSERT (retval == strlen (result));
2073   }
2074   { /* Pseudo-Infinity.  */
2075     static union { unsigned int word[4]; long double value; } x =
2076       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2077     char result[1000];
2078     int retval =
2079       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2080     ASSERT (strlen (result) >= 3 + 3
2081             && strisnan (result, 0, strlen (result) - 3, 0)
2082             && strcmp (result + strlen (result) - 3, " 33") == 0);
2083     ASSERT (retval == strlen (result));
2084   }
2085   { /* Pseudo-Zero.  */
2086     static union { unsigned int word[4]; long double value; } x =
2087       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2088     char result[1000];
2089     int retval =
2090       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2091     ASSERT (strlen (result) >= 3 + 3
2092             && strisnan (result, 0, strlen (result) - 3, 0)
2093             && strcmp (result + strlen (result) - 3, " 33") == 0);
2094     ASSERT (retval == strlen (result));
2095   }
2096   { /* Unnormalized number.  */
2097     static union { unsigned int word[4]; long double value; } x =
2098       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2099     char result[1000];
2100     int retval =
2101       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2102     ASSERT (strlen (result) >= 3 + 3
2103             && strisnan (result, 0, strlen (result) - 3, 0)
2104             && strcmp (result + strlen (result) - 3, " 33") == 0);
2105     ASSERT (retval == strlen (result));
2106   }
2107   { /* Pseudo-Denormal.  */
2108     static union { unsigned int word[4]; long double value; } x =
2109       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2110     char result[1000];
2111     int retval =
2112       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2113     ASSERT (strlen (result) >= 3 + 3
2114             && strisnan (result, 0, strlen (result) - 3, 0)
2115             && strcmp (result + strlen (result) - 3, " 33") == 0);
2116     ASSERT (retval == strlen (result));
2117   }
2118 #endif
2119
2120   { /* Width.  */
2121     char result[1000];
2122     int retval =
2123       my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
2124     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
2125             || strcmp (result, "  1.750000e+000 33") == 0);
2126     ASSERT (retval == strlen (result));
2127   }
2128
2129   { /* FLAG_LEFT.  */
2130     char result[1000];
2131     int retval =
2132       my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
2133     ASSERT (strcmp (result, "1.750000e+00    33") == 0
2134             || strcmp (result, "1.750000e+000   33") == 0);
2135     ASSERT (retval == strlen (result));
2136   }
2137
2138   { /* FLAG_SHOWSIGN.  */
2139     char result[1000];
2140     int retval =
2141       my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
2142     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
2143             || strcmp (result, "+1.750000e+000 33") == 0);
2144     ASSERT (retval == strlen (result));
2145   }
2146
2147   { /* FLAG_SPACE.  */
2148     char result[1000];
2149     int retval =
2150       my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
2151     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2152             || strcmp (result, " 1.750000e+000 33") == 0);
2153     ASSERT (retval == strlen (result));
2154   }
2155
2156   { /* FLAG_ALT.  */
2157     char result[1000];
2158     int retval =
2159       my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
2160     ASSERT (strcmp (result, "1.750000e+00 33") == 0
2161             || strcmp (result, "1.750000e+000 33") == 0);
2162     ASSERT (retval == strlen (result));
2163   }
2164
2165   { /* FLAG_ALT.  */
2166     char result[1000];
2167     int retval =
2168       my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
2169     ASSERT (strcmp (result, "2.e+00 33") == 0
2170             || strcmp (result, "2.e+000 33") == 0);
2171     ASSERT (retval == strlen (result));
2172   }
2173
2174   { /* FLAG_ALT.  */
2175     char result[1000];
2176     int retval =
2177       my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
2178     ASSERT (strcmp (result, "1.e+01 33") == 0
2179             || strcmp (result, "1.e+001 33") == 0);
2180     ASSERT (retval == strlen (result));
2181   }
2182
2183   { /* FLAG_ZERO with finite number.  */
2184     char result[1000];
2185     int retval =
2186       my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
2187     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
2188             || strcmp (result, "001.234000e+003 33") == 0);
2189     ASSERT (retval == strlen (result));
2190   }
2191
2192   { /* FLAG_ZERO with infinite number.  */
2193     char result[1000];
2194     int retval =
2195       my_sprintf (result, "%015Le %d", - Infinityl (), 33, 44, 55);
2196     ASSERT (strcmp (result, "           -inf 33") == 0
2197             || strcmp (result, "      -infinity 33") == 0);
2198     ASSERT (retval == strlen (result));
2199   }
2200
2201   { /* FLAG_ZERO with NaN.  */
2202     char result[1000];
2203     int retval =
2204       my_sprintf (result, "%050Le %d", NaNl (), 33, 44, 55);
2205     ASSERT (strlen (result) == 50 + 3
2206             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2207             && strcmp (result + strlen (result) - 3, " 33") == 0);
2208     ASSERT (retval == strlen (result));
2209   }
2210
2211   { /* Precision.  */
2212     char result[1000];
2213     int retval =
2214       my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
2215     ASSERT (strcmp (result, "1e+03 33") == 0
2216             || strcmp (result, "1e+003 33") == 0);
2217     ASSERT (retval == strlen (result));
2218   }
2219
2220   { /* Precision with no rounding.  */
2221     char result[100];
2222     int retval =
2223       my_sprintf (result, "%.4Le %d", 999.951L, 33, 44, 55);
2224     ASSERT (strcmp (result, "9.9995e+02 33") == 0
2225             || strcmp (result, "9.9995e+002 33") == 0);
2226     ASSERT (retval == strlen (result));
2227   }
2228
2229   { /* Precision with rounding.  */
2230     char result[100];
2231     int retval =
2232       my_sprintf (result, "%.4Le %d", 999.996L, 33, 44, 55);
2233     ASSERT (strcmp (result, "1.0000e+03 33") == 0
2234             || strcmp (result, "1.0000e+003 33") == 0);
2235     ASSERT (retval == strlen (result));
2236   }
2237
2238   /* Test the support of the %g format directive.  */
2239
2240   { /* A positive number.  */
2241     char result[1000];
2242     int retval =
2243       my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
2244     ASSERT (strcmp (result, "12.75 33") == 0);
2245     ASSERT (retval == strlen (result));
2246   }
2247
2248   { /* A larger positive number.  */
2249     char result[1000];
2250     int retval =
2251       my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
2252     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2253             || strcmp (result, "1.23457e+006 33") == 0);
2254     ASSERT (retval == strlen (result));
2255   }
2256
2257   { /* Small and large positive numbers.  */
2258     static struct { double value; const char *string; } data[] =
2259       {
2260         { 1.234321234321234e-37, "1.23432e-37" },
2261         { 1.234321234321234e-36, "1.23432e-36" },
2262         { 1.234321234321234e-35, "1.23432e-35" },
2263         { 1.234321234321234e-34, "1.23432e-34" },
2264         { 1.234321234321234e-33, "1.23432e-33" },
2265         { 1.234321234321234e-32, "1.23432e-32" },
2266         { 1.234321234321234e-31, "1.23432e-31" },
2267         { 1.234321234321234e-30, "1.23432e-30" },
2268         { 1.234321234321234e-29, "1.23432e-29" },
2269         { 1.234321234321234e-28, "1.23432e-28" },
2270         { 1.234321234321234e-27, "1.23432e-27" },
2271         { 1.234321234321234e-26, "1.23432e-26" },
2272         { 1.234321234321234e-25, "1.23432e-25" },
2273         { 1.234321234321234e-24, "1.23432e-24" },
2274         { 1.234321234321234e-23, "1.23432e-23" },
2275         { 1.234321234321234e-22, "1.23432e-22" },
2276         { 1.234321234321234e-21, "1.23432e-21" },
2277         { 1.234321234321234e-20, "1.23432e-20" },
2278         { 1.234321234321234e-19, "1.23432e-19" },
2279         { 1.234321234321234e-18, "1.23432e-18" },
2280         { 1.234321234321234e-17, "1.23432e-17" },
2281         { 1.234321234321234e-16, "1.23432e-16" },
2282         { 1.234321234321234e-15, "1.23432e-15" },
2283         { 1.234321234321234e-14, "1.23432e-14" },
2284         { 1.234321234321234e-13, "1.23432e-13" },
2285         { 1.234321234321234e-12, "1.23432e-12" },
2286         { 1.234321234321234e-11, "1.23432e-11" },
2287         { 1.234321234321234e-10, "1.23432e-10" },
2288         { 1.234321234321234e-9, "1.23432e-09" },
2289         { 1.234321234321234e-8, "1.23432e-08" },
2290         { 1.234321234321234e-7, "1.23432e-07" },
2291         { 1.234321234321234e-6, "1.23432e-06" },
2292         { 1.234321234321234e-5, "1.23432e-05" },
2293         { 1.234321234321234e-4, "0.000123432" },
2294         { 1.234321234321234e-3, "0.00123432" },
2295         { 1.234321234321234e-2, "0.0123432" },
2296         { 1.234321234321234e-1, "0.123432" },
2297         { 1.234321234321234, "1.23432" },
2298         { 1.234321234321234e1, "12.3432" },
2299         { 1.234321234321234e2, "123.432" },
2300         { 1.234321234321234e3, "1234.32" },
2301         { 1.234321234321234e4, "12343.2" },
2302         { 1.234321234321234e5, "123432" },
2303         { 1.234321234321234e6, "1.23432e+06" },
2304         { 1.234321234321234e7, "1.23432e+07" },
2305         { 1.234321234321234e8, "1.23432e+08" },
2306         { 1.234321234321234e9, "1.23432e+09" },
2307         { 1.234321234321234e10, "1.23432e+10" },
2308         { 1.234321234321234e11, "1.23432e+11" },
2309         { 1.234321234321234e12, "1.23432e+12" },
2310         { 1.234321234321234e13, "1.23432e+13" },
2311         { 1.234321234321234e14, "1.23432e+14" },
2312         { 1.234321234321234e15, "1.23432e+15" },
2313         { 1.234321234321234e16, "1.23432e+16" },
2314         { 1.234321234321234e17, "1.23432e+17" },
2315         { 1.234321234321234e18, "1.23432e+18" },
2316         { 1.234321234321234e19, "1.23432e+19" },
2317         { 1.234321234321234e20, "1.23432e+20" },
2318         { 1.234321234321234e21, "1.23432e+21" },
2319         { 1.234321234321234e22, "1.23432e+22" },
2320         { 1.234321234321234e23, "1.23432e+23" },
2321         { 1.234321234321234e24, "1.23432e+24" },
2322         { 1.234321234321234e25, "1.23432e+25" },
2323         { 1.234321234321234e26, "1.23432e+26" },
2324         { 1.234321234321234e27, "1.23432e+27" },
2325         { 1.234321234321234e28, "1.23432e+28" },
2326         { 1.234321234321234e29, "1.23432e+29" },
2327         { 1.234321234321234e30, "1.23432e+30" },
2328         { 1.234321234321234e31, "1.23432e+31" },
2329         { 1.234321234321234e32, "1.23432e+32" },
2330         { 1.234321234321234e33, "1.23432e+33" },
2331         { 1.234321234321234e34, "1.23432e+34" },
2332         { 1.234321234321234e35, "1.23432e+35" },
2333         { 1.234321234321234e36, "1.23432e+36" }
2334       };
2335     size_t k;
2336     for (k = 0; k < SIZEOF (data); k++)
2337       {
2338         char result[1000];
2339         int retval =
2340           my_sprintf (result, "%g", data[k].value);
2341         const char *expected = data[k].string;
2342         ASSERT (strcmp (result, expected) == 0
2343                 /* Some implementations produce exponents with 3 digits.  */
2344                 || (expected[strlen (expected) - 4] == 'e'
2345                     && strlen (result) == strlen (expected) + 1
2346                     && memcmp (result, expected, strlen (expected) - 2) == 0
2347                     && result[strlen (expected) - 2] == '0'
2348                     && strcmp (result + strlen (expected) - 1,
2349                                expected + strlen (expected) - 2)
2350                        == 0));
2351         ASSERT (retval == strlen (result));
2352       }
2353   }
2354
2355   { /* A negative number.  */
2356     char result[1000];
2357     int retval =
2358       my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
2359     ASSERT (strcmp (result, "-0.03125 33") == 0);
2360     ASSERT (retval == strlen (result));
2361   }
2362
2363   { /* Positive zero.  */
2364     char result[1000];
2365     int retval =
2366       my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
2367     ASSERT (strcmp (result, "0 33") == 0);
2368     ASSERT (retval == strlen (result));
2369   }
2370
2371   { /* Negative zero.  */
2372     char result[1000];
2373     int retval =
2374       my_sprintf (result, "%g %d", minus_zerod, 33, 44, 55);
2375     if (have_minus_zero ())
2376       ASSERT (strcmp (result, "-0 33") == 0);
2377     ASSERT (retval == strlen (result));
2378   }
2379
2380   { /* Positive infinity.  */
2381     char result[1000];
2382     int retval =
2383       my_sprintf (result, "%g %d", Infinityd (), 33, 44, 55);
2384     ASSERT (strcmp (result, "inf 33") == 0
2385             || strcmp (result, "infinity 33") == 0);
2386     ASSERT (retval == strlen (result));
2387   }
2388
2389   { /* Negative infinity.  */
2390     char result[1000];
2391     int retval =
2392       my_sprintf (result, "%g %d", - Infinityd (), 33, 44, 55);
2393     ASSERT (strcmp (result, "-inf 33") == 0
2394             || strcmp (result, "-infinity 33") == 0);
2395     ASSERT (retval == strlen (result));
2396   }
2397
2398   { /* NaN.  */
2399     char result[1000];
2400     int retval =
2401       my_sprintf (result, "%g %d", NaNd (), 33, 44, 55);
2402     ASSERT (strlen (result) >= 3 + 3
2403             && strisnan (result, 0, strlen (result) - 3, 0)
2404             && strcmp (result + strlen (result) - 3, " 33") == 0);
2405     ASSERT (retval == strlen (result));
2406   }
2407
2408   { /* Width.  */
2409     char result[1000];
2410     int retval =
2411       my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
2412     ASSERT (strcmp (result, "      1.75 33") == 0);
2413     ASSERT (retval == strlen (result));
2414   }
2415
2416   { /* FLAG_LEFT.  */
2417     char result[1000];
2418     int retval =
2419       my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
2420     ASSERT (strcmp (result, "1.75       33") == 0);
2421     ASSERT (retval == strlen (result));
2422   }
2423
2424   { /* FLAG_SHOWSIGN.  */
2425     char result[1000];
2426     int retval =
2427       my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
2428     ASSERT (strcmp (result, "+1.75 33") == 0);
2429     ASSERT (retval == strlen (result));
2430   }
2431
2432   { /* FLAG_SPACE.  */
2433     char result[1000];
2434     int retval =
2435       my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
2436     ASSERT (strcmp (result, " 1.75 33") == 0);
2437     ASSERT (retval == strlen (result));
2438   }
2439
2440   { /* FLAG_ALT.  */
2441     char result[1000];
2442     int retval =
2443       my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
2444     ASSERT (strcmp (result, "1.75000 33") == 0);
2445     ASSERT (retval == strlen (result));
2446   }
2447
2448   { /* FLAG_ALT.  */
2449     char result[1000];
2450     int retval =
2451       my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
2452     ASSERT (strcmp (result, "2. 33") == 0);
2453     ASSERT (retval == strlen (result));
2454   }
2455
2456   { /* FLAG_ALT.  */
2457     char result[1000];
2458     int retval =
2459       my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
2460     ASSERT (strcmp (result, "1.e+01 33") == 0
2461             || strcmp (result, "1.e+001 33") == 0);
2462     ASSERT (retval == strlen (result));
2463   }
2464
2465   { /* FLAG_ZERO with finite number.  */
2466     char result[1000];
2467     int retval =
2468       my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
2469     ASSERT (strcmp (result, "0000001234 33") == 0);
2470     ASSERT (retval == strlen (result));
2471   }
2472
2473   { /* FLAG_ZERO with infinite number.  */
2474     char result[1000];
2475     int retval =
2476       my_sprintf (result, "%015g %d", - Infinityd (), 33, 44, 55);
2477     ASSERT (strcmp (result, "           -inf 33") == 0
2478             || strcmp (result, "      -infinity 33") == 0);
2479     ASSERT (retval == strlen (result));
2480   }
2481
2482   { /* FLAG_ZERO with NaN.  */
2483     char result[1000];
2484     int retval =
2485       my_sprintf (result, "%050g %d", NaNd (), 33, 44, 55);
2486     ASSERT (strlen (result) == 50 + 3
2487             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2488             && strcmp (result + strlen (result) - 3, " 33") == 0);
2489     ASSERT (retval == strlen (result));
2490   }
2491
2492   { /* Precision.  */
2493     char result[1000];
2494     int retval =
2495       my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
2496     ASSERT (strcmp (result, "1e+03 33") == 0
2497             || strcmp (result, "1e+003 33") == 0);
2498     ASSERT (retval == strlen (result));
2499   }
2500
2501   { /* Precision with no rounding.  */
2502     char result[100];
2503     int retval =
2504       my_sprintf (result, "%.5g %d", 999.951, 33, 44, 55);
2505     ASSERT (strcmp (result, "999.95 33") == 0);
2506     ASSERT (retval == strlen (result));
2507   }
2508
2509   { /* Precision with rounding.  */
2510     char result[100];
2511     int retval =
2512       my_sprintf (result, "%.5g %d", 999.996, 33, 44, 55);
2513     ASSERT (strcmp (result, "1000 33") == 0);
2514     ASSERT (retval == strlen (result));
2515   }
2516
2517   { /* A positive number.  */
2518     char result[1000];
2519     int retval =
2520       my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
2521     ASSERT (strcmp (result, "12.75 33") == 0);
2522     ASSERT (retval == strlen (result));
2523   }
2524
2525   { /* A larger positive number.  */
2526     char result[1000];
2527     int retval =
2528       my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
2529     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2530             || strcmp (result, "1.23457e+006 33") == 0);
2531     ASSERT (retval == strlen (result));
2532   }
2533
2534   { /* Small and large positive numbers.  */
2535     static struct { long double value; const char *string; } data[] =
2536       {
2537         { 1.234321234321234e-37L, "1.23432e-37" },
2538         { 1.234321234321234e-36L, "1.23432e-36" },
2539         { 1.234321234321234e-35L, "1.23432e-35" },
2540         { 1.234321234321234e-34L, "1.23432e-34" },
2541         { 1.234321234321234e-33L, "1.23432e-33" },
2542         { 1.234321234321234e-32L, "1.23432e-32" },
2543         { 1.234321234321234e-31L, "1.23432e-31" },
2544         { 1.234321234321234e-30L, "1.23432e-30" },
2545         { 1.234321234321234e-29L, "1.23432e-29" },
2546         { 1.234321234321234e-28L, "1.23432e-28" },
2547         { 1.234321234321234e-27L, "1.23432e-27" },
2548         { 1.234321234321234e-26L, "1.23432e-26" },
2549         { 1.234321234321234e-25L, "1.23432e-25" },
2550         { 1.234321234321234e-24L, "1.23432e-24" },
2551         { 1.234321234321234e-23L, "1.23432e-23" },
2552         { 1.234321234321234e-22L, "1.23432e-22" },
2553         { 1.234321234321234e-21L, "1.23432e-21" },
2554         { 1.234321234321234e-20L, "1.23432e-20" },
2555         { 1.234321234321234e-19L, "1.23432e-19" },
2556         { 1.234321234321234e-18L, "1.23432e-18" },
2557         { 1.234321234321234e-17L, "1.23432e-17" },
2558         { 1.234321234321234e-16L, "1.23432e-16" },
2559         { 1.234321234321234e-15L, "1.23432e-15" },
2560         { 1.234321234321234e-14L, "1.23432e-14" },
2561         { 1.234321234321234e-13L, "1.23432e-13" },
2562         { 1.234321234321234e-12L, "1.23432e-12" },
2563         { 1.234321234321234e-11L, "1.23432e-11" },
2564         { 1.234321234321234e-10L, "1.23432e-10" },
2565         { 1.234321234321234e-9L, "1.23432e-09" },
2566         { 1.234321234321234e-8L, "1.23432e-08" },
2567         { 1.234321234321234e-7L, "1.23432e-07" },
2568         { 1.234321234321234e-6L, "1.23432e-06" },
2569         { 1.234321234321234e-5L, "1.23432e-05" },
2570         { 1.234321234321234e-4L, "0.000123432" },
2571         { 1.234321234321234e-3L, "0.00123432" },
2572         { 1.234321234321234e-2L, "0.0123432" },
2573         { 1.234321234321234e-1L, "0.123432" },
2574         { 1.234321234321234L, "1.23432" },
2575         { 1.234321234321234e1L, "12.3432" },
2576         { 1.234321234321234e2L, "123.432" },
2577         { 1.234321234321234e3L, "1234.32" },
2578         { 1.234321234321234e4L, "12343.2" },
2579         { 1.234321234321234e5L, "123432" },
2580         { 1.234321234321234e6L, "1.23432e+06" },
2581         { 1.234321234321234e7L, "1.23432e+07" },
2582         { 1.234321234321234e8L, "1.23432e+08" },
2583         { 1.234321234321234e9L, "1.23432e+09" },
2584         { 1.234321234321234e10L, "1.23432e+10" },
2585         { 1.234321234321234e11L, "1.23432e+11" },
2586         { 1.234321234321234e12L, "1.23432e+12" },
2587         { 1.234321234321234e13L, "1.23432e+13" },
2588         { 1.234321234321234e14L, "1.23432e+14" },
2589         { 1.234321234321234e15L, "1.23432e+15" },
2590         { 1.234321234321234e16L, "1.23432e+16" },
2591         { 1.234321234321234e17L, "1.23432e+17" },
2592         { 1.234321234321234e18L, "1.23432e+18" },
2593         { 1.234321234321234e19L, "1.23432e+19" },
2594         { 1.234321234321234e20L, "1.23432e+20" },
2595         { 1.234321234321234e21L, "1.23432e+21" },
2596         { 1.234321234321234e22L, "1.23432e+22" },
2597         { 1.234321234321234e23L, "1.23432e+23" },
2598         { 1.234321234321234e24L, "1.23432e+24" },
2599         { 1.234321234321234e25L, "1.23432e+25" },
2600         { 1.234321234321234e26L, "1.23432e+26" },
2601         { 1.234321234321234e27L, "1.23432e+27" },
2602         { 1.234321234321234e28L, "1.23432e+28" },
2603         { 1.234321234321234e29L, "1.23432e+29" },
2604         { 1.234321234321234e30L, "1.23432e+30" },
2605         { 1.234321234321234e31L, "1.23432e+31" },
2606         { 1.234321234321234e32L, "1.23432e+32" },
2607         { 1.234321234321234e33L, "1.23432e+33" },
2608         { 1.234321234321234e34L, "1.23432e+34" },
2609         { 1.234321234321234e35L, "1.23432e+35" },
2610         { 1.234321234321234e36L, "1.23432e+36" }
2611       };
2612     size_t k;
2613     for (k = 0; k < SIZEOF (data); k++)
2614       {
2615         char result[1000];
2616         int retval =
2617           my_sprintf (result, "%Lg", data[k].value);
2618         const char *expected = data[k].string;
2619         ASSERT (strcmp (result, expected) == 0
2620                 /* Some implementations produce exponents with 3 digits.  */
2621                 || (expected[strlen (expected) - 4] == 'e'
2622                     && strlen (result) == strlen (expected) + 1
2623                     && memcmp (result, expected, strlen (expected) - 2) == 0
2624                     && result[strlen (expected) - 2] == '0'
2625                     && strcmp (result + strlen (expected) - 1,
2626                                expected + strlen (expected) - 2)
2627                        == 0));
2628         ASSERT (retval == strlen (result));
2629       }
2630   }
2631
2632   { /* A negative number.  */
2633     char result[1000];
2634     int retval =
2635       my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
2636     ASSERT (strcmp (result, "-0.03125 33") == 0);
2637     ASSERT (retval == strlen (result));
2638   }
2639
2640   { /* Positive zero.  */
2641     char result[1000];
2642     int retval =
2643       my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
2644     ASSERT (strcmp (result, "0 33") == 0);
2645     ASSERT (retval == strlen (result));
2646   }
2647
2648   { /* Negative zero.  */
2649     char result[1000];
2650     int retval =
2651       my_sprintf (result, "%Lg %d", minus_zerol, 33, 44, 55);
2652     if (have_minus_zero ())
2653       ASSERT (strcmp (result, "-0 33") == 0);
2654     ASSERT (retval == strlen (result));
2655   }
2656
2657   { /* Positive infinity.  */
2658     char result[1000];
2659     int retval =
2660       my_sprintf (result, "%Lg %d", Infinityl (), 33, 44, 55);
2661     ASSERT (strcmp (result, "inf 33") == 0
2662             || strcmp (result, "infinity 33") == 0);
2663     ASSERT (retval == strlen (result));
2664   }
2665
2666   { /* Negative infinity.  */
2667     char result[1000];
2668     int retval =
2669       my_sprintf (result, "%Lg %d", - Infinityl (), 33, 44, 55);
2670     ASSERT (strcmp (result, "-inf 33") == 0
2671             || strcmp (result, "-infinity 33") == 0);
2672     ASSERT (retval == strlen (result));
2673   }
2674
2675   { /* NaN.  */
2676     char result[1000];
2677     int retval =
2678       my_sprintf (result, "%Lg %d", NaNl (), 33, 44, 55);
2679     ASSERT (strlen (result) >= 3 + 3
2680             && strisnan (result, 0, strlen (result) - 3, 0)
2681             && strcmp (result + strlen (result) - 3, " 33") == 0);
2682     ASSERT (retval == strlen (result));
2683   }
2684 #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_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
2685   { /* Quiet NaN.  */
2686     static union { unsigned int word[4]; long double value; } x =
2687       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2688     char result[1000];
2689     int retval =
2690       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
2691     ASSERT (strlen (result) >= 3 + 3
2692             && strisnan (result, 0, strlen (result) - 3, 0)
2693             && strcmp (result + strlen (result) - 3, " 33") == 0);
2694     ASSERT (retval == strlen (result));
2695   }
2696   {
2697     /* Signalling NaN.  */
2698     static union { unsigned int word[4]; long double value; } x =
2699       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2700     char result[1000];
2701     int retval =
2702       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
2703     ASSERT (strlen (result) >= 3 + 3
2704             && strisnan (result, 0, strlen (result) - 3, 0)
2705             && strcmp (result + strlen (result) - 3, " 33") == 0);
2706     ASSERT (retval == strlen (result));
2707   }
2708   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2709      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2710        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2711        Application Architecture.
2712        Table 5-2 "Floating-Point Register Encodings"
2713        Figure 5-6 "Memory to Floating-Point Register Data Translation"
2714    */
2715   { /* Pseudo-NaN.  */
2716     static union { unsigned int word[4]; long double value; } x =
2717       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2718     char result[1000];
2719     int retval =
2720       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2721     ASSERT (strlen (result) >= 3 + 3
2722             && strisnan (result, 0, strlen (result) - 3, 0)
2723             && strcmp (result + strlen (result) - 3, " 33") == 0);
2724     ASSERT (retval == strlen (result));
2725   }
2726   { /* Pseudo-Infinity.  */
2727     static union { unsigned int word[4]; long double value; } x =
2728       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2729     char result[1000];
2730     int retval =
2731       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2732     ASSERT (strlen (result) >= 3 + 3
2733             && strisnan (result, 0, strlen (result) - 3, 0)
2734             && strcmp (result + strlen (result) - 3, " 33") == 0);
2735     ASSERT (retval == strlen (result));
2736   }
2737   { /* Pseudo-Zero.  */
2738     static union { unsigned int word[4]; long double value; } x =
2739       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2740     char result[1000];
2741     int retval =
2742       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2743     ASSERT (strlen (result) >= 3 + 3
2744             && strisnan (result, 0, strlen (result) - 3, 0)
2745             && strcmp (result + strlen (result) - 3, " 33") == 0);
2746     ASSERT (retval == strlen (result));
2747   }
2748   { /* Unnormalized number.  */
2749     static union { unsigned int word[4]; long double value; } x =
2750       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2751     char result[1000];
2752     int retval =
2753       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2754     ASSERT (strlen (result) >= 3 + 3
2755             && strisnan (result, 0, strlen (result) - 3, 0)
2756             && strcmp (result + strlen (result) - 3, " 33") == 0);
2757     ASSERT (retval == strlen (result));
2758   }
2759   { /* Pseudo-Denormal.  */
2760     static union { unsigned int word[4]; long double value; } x =
2761       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2762     char result[1000];
2763     int retval =
2764       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2765     ASSERT (strlen (result) >= 3 + 3
2766             && strisnan (result, 0, strlen (result) - 3, 0)
2767             && strcmp (result + strlen (result) - 3, " 33") == 0);
2768     ASSERT (retval == strlen (result));
2769   }
2770 #endif
2771
2772   { /* Width.  */
2773     char result[1000];
2774     int retval =
2775       my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
2776     ASSERT (strcmp (result, "      1.75 33") == 0);
2777     ASSERT (retval == strlen (result));
2778   }
2779
2780   { /* FLAG_LEFT.  */
2781     char result[1000];
2782     int retval =
2783       my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
2784     ASSERT (strcmp (result, "1.75       33") == 0);
2785     ASSERT (retval == strlen (result));
2786   }
2787
2788   { /* FLAG_SHOWSIGN.  */
2789     char result[1000];
2790     int retval =
2791       my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
2792     ASSERT (strcmp (result, "+1.75 33") == 0);
2793     ASSERT (retval == strlen (result));
2794   }
2795
2796   { /* FLAG_SPACE.  */
2797     char result[1000];
2798     int retval =
2799       my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
2800     ASSERT (strcmp (result, " 1.75 33") == 0);
2801     ASSERT (retval == strlen (result));
2802   }
2803
2804   { /* FLAG_ALT.  */
2805     char result[1000];
2806     int retval =
2807       my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
2808     ASSERT (strcmp (result, "1.75000 33") == 0);
2809     ASSERT (retval == strlen (result));
2810   }
2811
2812   { /* FLAG_ALT.  */
2813     char result[1000];
2814     int retval =
2815       my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
2816     ASSERT (strcmp (result, "2. 33") == 0);
2817     ASSERT (retval == strlen (result));
2818   }
2819
2820   { /* FLAG_ALT.  */
2821     char result[1000];
2822     int retval =
2823       my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
2824     ASSERT (strcmp (result, "1.e+01 33") == 0
2825             || strcmp (result, "1.e+001 33") == 0);
2826     ASSERT (retval == strlen (result));
2827   }
2828
2829   { /* FLAG_ZERO with finite number.  */
2830     char result[1000];
2831     int retval =
2832       my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
2833     ASSERT (strcmp (result, "0000001234 33") == 0);
2834     ASSERT (retval == strlen (result));
2835   }
2836
2837   { /* FLAG_ZERO with infinite number.  */
2838     char result[1000];
2839     int retval =
2840       my_sprintf (result, "%015Lg %d", - Infinityl (), 33, 44, 55);
2841     ASSERT (strcmp (result, "           -inf 33") == 0
2842             || strcmp (result, "      -infinity 33") == 0);
2843     ASSERT (retval == strlen (result));
2844   }
2845
2846   { /* FLAG_ZERO with NaN.  */
2847     char result[1000];
2848     int retval =
2849       my_sprintf (result, "%050Lg %d", NaNl (), 33, 44, 55);
2850     ASSERT (strlen (result) == 50 + 3
2851             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2852             && strcmp (result + strlen (result) - 3, " 33") == 0);
2853     ASSERT (retval == strlen (result));
2854   }
2855
2856   { /* Precision.  */
2857     char result[1000];
2858     int retval =
2859       my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
2860     ASSERT (strcmp (result, "1e+03 33") == 0
2861             || strcmp (result, "1e+003 33") == 0);
2862     ASSERT (retval == strlen (result));
2863   }
2864
2865   { /* Precision with no rounding.  */
2866     char result[100];
2867     int retval =
2868       my_sprintf (result, "%.5Lg %d", 999.951L, 33, 44, 55);
2869     ASSERT (strcmp (result, "999.95 33") == 0);
2870     ASSERT (retval == strlen (result));
2871   }
2872
2873   { /* Precision with rounding.  */
2874     char result[100];
2875     int retval =
2876       my_sprintf (result, "%.5Lg %d", 999.996L, 33, 44, 55);
2877     ASSERT (strcmp (result, "1000 33") == 0);
2878     ASSERT (retval == strlen (result));
2879   }
2880
2881   /* Test the support of the %n format directive.  */
2882
2883   {
2884     int count = -1;
2885     char result[1000];
2886     int retval =
2887       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
2888     ASSERT (strcmp (result, "123 ") == 0);
2889     ASSERT (retval == strlen (result));
2890     ASSERT (count == 4);
2891   }
2892
2893   /* Test the support of the POSIX/XSI format strings with positions.  */
2894
2895   {
2896     char result[1000];
2897     int retval =
2898       my_sprintf (result, "%2$d %1$d", 33, 55);
2899     ASSERT (strcmp (result, "55 33") == 0);
2900     ASSERT (retval == strlen (result));
2901   }
2902
2903   /* Test the support of the grouping flag.  */
2904
2905   {
2906     char result[1000];
2907     int retval =
2908       my_sprintf (result, "%'d %d", 1234567, 99);
2909     ASSERT (result[strlen (result) - 1] == '9');
2910     ASSERT (retval == strlen (result));
2911   }
2912
2913   /* Test the support of the left-adjust flag.  */
2914
2915   {
2916     char result[1000];
2917     int retval =
2918       my_sprintf (result, "a%*sc", -3, "b");
2919     ASSERT (strcmp (result, "ab  c") == 0);
2920     ASSERT (retval == strlen (result));
2921   }
2922
2923   {
2924     char result[1000];
2925     int retval =
2926       my_sprintf (result, "a%-*sc", 3, "b");
2927     ASSERT (strcmp (result, "ab  c") == 0);
2928     ASSERT (retval == strlen (result));
2929   }
2930
2931   {
2932     char result[1000];
2933     int retval =
2934       my_sprintf (result, "a%-*sc", -3, "b");
2935     ASSERT (strcmp (result, "ab  c") == 0);
2936     ASSERT (retval == strlen (result));
2937   }
2938
2939   /* Test the support of large precision.  */
2940
2941   {
2942     char result[5000];
2943     int retval =
2944       my_sprintf (result, "%.4000d %d", 1234567, 99);
2945     size_t i;
2946     for (i = 0; i < 4000 - 7; i++)
2947       ASSERT (result[i] == '0');
2948     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2949     ASSERT (retval == strlen (result));
2950   }
2951
2952   {
2953     char result[5000];
2954     int retval =
2955       my_sprintf (result, "%.*d %d", 4000, 1234567, 99);
2956     size_t i;
2957     for (i = 0; i < 4000 - 7; i++)
2958       ASSERT (result[i] == '0');
2959     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2960     ASSERT (retval == strlen (result));
2961   }
2962
2963   {
2964     char result[5000];
2965     int retval =
2966       my_sprintf (result, "%.4000d %d", -1234567, 99);
2967     size_t i;
2968     ASSERT (result[0] == '-');
2969     for (i = 0; i < 4000 - 7; i++)
2970       ASSERT (result[1 + i] == '0');
2971     ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
2972     ASSERT (retval == strlen (result));
2973   }
2974
2975   {
2976     char result[5000];
2977     int retval =
2978       my_sprintf (result, "%.4000u %d", 1234567, 99);
2979     size_t i;
2980     for (i = 0; i < 4000 - 7; i++)
2981       ASSERT (result[i] == '0');
2982     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2983     ASSERT (retval == strlen (result));
2984   }
2985
2986   {
2987     char result[5000];
2988     int retval =
2989       my_sprintf (result, "%.4000o %d", 1234567, 99);
2990     size_t i;
2991     for (i = 0; i < 4000 - 7; i++)
2992       ASSERT (result[i] == '0');
2993     ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
2994     ASSERT (retval == strlen (result));
2995   }
2996
2997   {
2998     char result[5000];
2999     int retval =
3000       my_sprintf (result, "%.4000x %d", 1234567, 99);
3001     size_t i;
3002     for (i = 0; i < 4000 - 6; i++)
3003       ASSERT (result[i] == '0');
3004     ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
3005     ASSERT (retval == strlen (result));
3006   }
3007
3008   {
3009     char result[5000];
3010     int retval =
3011       my_sprintf (result, "%#.4000x %d", 1234567, 99);
3012     size_t i;
3013     ASSERT (result[0] == '0');
3014     ASSERT (result[1] == 'x');
3015     for (i = 0; i < 4000 - 6; i++)
3016       ASSERT (result[2 + i] == '0');
3017     ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
3018     ASSERT (retval == strlen (result));
3019   }
3020
3021   {
3022     char result[5000];
3023     int retval =
3024       my_sprintf (result, "%.4000f %d", 1.0, 99);
3025     size_t i;
3026     ASSERT (result[0] == '1');
3027     ASSERT (result[1] == '.');
3028     for (i = 0; i < 4000; i++)
3029       ASSERT (result[2 + i] == '0');
3030     ASSERT (strcmp (result + 2 + 4000, " 99") == 0);
3031     ASSERT (retval == strlen (result));
3032   }
3033
3034   {
3035     char result[1000];
3036     int retval =
3037       my_sprintf (result, "%.511f %d", 1.0, 99);
3038     size_t i;
3039     ASSERT (result[0] == '1');
3040     ASSERT (result[1] == '.');
3041     for (i = 0; i < 511; i++)
3042       ASSERT (result[2 + i] == '0');
3043     ASSERT (strcmp (result + 2 + 511, " 99") == 0);
3044     ASSERT (retval == strlen (result));
3045   }
3046
3047   {
3048     char input[5000];
3049     char result[5000];
3050     int retval;
3051     size_t i;
3052
3053     for (i = 0; i < sizeof (input) - 1; i++)
3054       input[i] = 'a' + ((1000000 / (i + 1)) % 26);
3055     input[i] = '\0';
3056     retval = my_sprintf (result, "%.4000s %d", input, 99);
3057     ASSERT (memcmp (result, input, 4000) == 0);
3058     ASSERT (strcmp (result + 4000, " 99") == 0);
3059     ASSERT (retval == strlen (result));
3060   }
3061
3062   /* Test the support of the %s format directive.  */
3063
3064   /* To verify that these tests succeed, it is necessary to run them under
3065      a tool that checks against invalid memory accesses, such as ElectricFence
3066      or "valgrind --tool=memcheck".  */
3067   {
3068     size_t i;
3069
3070     for (i = 1; i <= 8; i++)
3071       {
3072         char *block;
3073         char result[5000];
3074         int retval;
3075
3076         block = (char *) malloc (i);
3077         memcpy (block, "abcdefgh", i);
3078         retval = my_sprintf (result, "%.*s", (int) i, block);
3079         ASSERT (memcmp (result, block, i) == 0);
3080         ASSERT (result[i] == '\0');
3081         ASSERT (retval == strlen (result));
3082         free (block);
3083       }
3084   }
3085 #if HAVE_WCHAR_T
3086   {
3087     size_t i;
3088
3089     for (i = 1; i <= 8; i++)
3090       {
3091         wchar_t *block;
3092         size_t j;
3093         char result[5000];
3094         int retval;
3095
3096         block = (wchar_t *) malloc (i * sizeof (wchar_t));
3097         for (j = 0; j < i; j++)
3098           block[j] = "abcdefgh"[j];
3099         retval = my_sprintf (result, "%.*ls", (int) i, block);
3100         ASSERT (memcmp (result, "abcdefgh", i) == 0);
3101         ASSERT (result[i] == '\0');
3102         ASSERT (retval == strlen (result));
3103         free (block);
3104       }
3105   }
3106 #endif
3107 }