tests/test-sprintf-posix.h

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