tests/test-sprintf-posix.h

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