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 <math.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", NAN, 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", NAN, 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", 0.0L / 0.0L, 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", 0.0L / 0.0L, 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", NAN, 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", NAN, 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     static long double zero = 0.0L;
1137     char result[1000];
1138     int retval =
1139       my_sprintf (result, "%Lf %d", zero / zero, 33, 44, 55);
1140     ASSERT (strlen (result) >= 3 + 3
1141             && strisnan (result, 0, strlen (result) - 3, 0)
1142             && strcmp (result + strlen (result) - 3, " 33") == 0);
1143     ASSERT (retval == strlen (result));
1144   }
1145 #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_))
1146   { /* Quiet NaN.  */
1147     static union { unsigned int word[4]; long double value; } x =
1148       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1149     char result[1000];
1150     int retval =
1151       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1152     ASSERT (strlen (result) >= 3 + 3
1153             && strisnan (result, 0, strlen (result) - 3, 0)
1154             && strcmp (result + strlen (result) - 3, " 33") == 0);
1155     ASSERT (retval == strlen (result));
1156   }
1157   {
1158     /* Signalling NaN.  */
1159     static union { unsigned int word[4]; long double value; } x =
1160       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1161     char result[1000];
1162     int retval =
1163       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1164     ASSERT (strlen (result) >= 3 + 3
1165             && strisnan (result, 0, strlen (result) - 3, 0)
1166             && strcmp (result + strlen (result) - 3, " 33") == 0);
1167     ASSERT (retval == strlen (result));
1168   }
1169   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1170      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1171        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1172        Application Architecture.
1173        Table 5-2 "Floating-Point Register Encodings"
1174        Figure 5-6 "Memory to Floating-Point Register Data Translation"
1175    */
1176   { /* Pseudo-NaN.  */
1177     static union { unsigned int word[4]; long double value; } x =
1178       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1179     char result[1000];
1180     int retval =
1181       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1182     ASSERT (strlen (result) >= 3 + 3
1183             && strisnan (result, 0, strlen (result) - 3, 0)
1184             && strcmp (result + strlen (result) - 3, " 33") == 0);
1185     ASSERT (retval == strlen (result));
1186   }
1187   { /* Pseudo-Infinity.  */
1188     static union { unsigned int word[4]; long double value; } x =
1189       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1190     char result[1000];
1191     int retval =
1192       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1193     ASSERT (strlen (result) >= 3 + 3
1194             && strisnan (result, 0, strlen (result) - 3, 0)
1195             && strcmp (result + strlen (result) - 3, " 33") == 0);
1196     ASSERT (retval == strlen (result));
1197   }
1198   { /* Pseudo-Zero.  */
1199     static union { unsigned int word[4]; long double value; } x =
1200       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1201     char result[1000];
1202     int retval =
1203       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1204     ASSERT (strlen (result) >= 3 + 3
1205             && strisnan (result, 0, strlen (result) - 3, 0)
1206             && strcmp (result + strlen (result) - 3, " 33") == 0);
1207     ASSERT (retval == strlen (result));
1208   }
1209   { /* Unnormalized number.  */
1210     static union { unsigned int word[4]; long double value; } x =
1211       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1212     char result[1000];
1213     int retval =
1214       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1215     ASSERT (strlen (result) >= 3 + 3
1216             && strisnan (result, 0, strlen (result) - 3, 0)
1217             && strcmp (result + strlen (result) - 3, " 33") == 0);
1218     ASSERT (retval == strlen (result));
1219   }
1220   { /* Pseudo-Denormal.  */
1221     static union { unsigned int word[4]; long double value; } x =
1222       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1223     char result[1000];
1224     int retval =
1225       my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1226     ASSERT (strlen (result) >= 3 + 3
1227             && strisnan (result, 0, strlen (result) - 3, 0)
1228             && strcmp (result + strlen (result) - 3, " 33") == 0);
1229     ASSERT (retval == strlen (result));
1230   }
1231 #endif
1232
1233   { /* Width.  */
1234     char result[1000];
1235     int retval =
1236       my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
1237     ASSERT (strcmp (result, "  1.750000 33") == 0);
1238     ASSERT (retval == strlen (result));
1239   }
1240
1241   { /* FLAG_LEFT.  */
1242     char result[1000];
1243     int retval =
1244       my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
1245     ASSERT (strcmp (result, "1.750000   33") == 0);
1246     ASSERT (retval == strlen (result));
1247   }
1248
1249   { /* FLAG_SHOWSIGN.  */
1250     char result[1000];
1251     int retval =
1252       my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
1253     ASSERT (strcmp (result, "+1.750000 33") == 0);
1254     ASSERT (retval == strlen (result));
1255   }
1256
1257   { /* FLAG_SPACE.  */
1258     char result[1000];
1259     int retval =
1260       my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
1261     ASSERT (strcmp (result, " 1.750000 33") == 0);
1262     ASSERT (retval == strlen (result));
1263   }
1264
1265   { /* FLAG_ALT.  */
1266     char result[1000];
1267     int retval =
1268       my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
1269     ASSERT (strcmp (result, "1.750000 33") == 0);
1270     ASSERT (retval == strlen (result));
1271   }
1272
1273   { /* FLAG_ALT.  */
1274     char result[1000];
1275     int retval =
1276       my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
1277     ASSERT (strcmp (result, "2. 33") == 0);
1278     ASSERT (retval == strlen (result));
1279   }
1280
1281   { /* FLAG_ZERO with finite number.  */
1282     char result[1000];
1283     int retval =
1284       my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
1285     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1286     ASSERT (retval == strlen (result));
1287   }
1288
1289   { /* FLAG_ZERO with infinite number.  */
1290     char result[1000];
1291     int retval =
1292       my_sprintf (result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1293     ASSERT (strcmp (result, "           -inf 33") == 0
1294             || strcmp (result, "      -infinity 33") == 0);
1295     ASSERT (retval == strlen (result));
1296   }
1297
1298   { /* FLAG_ZERO with NaN.  */
1299     static long double zero = 0.0L;
1300     char result[1000];
1301     int retval =
1302       my_sprintf (result, "%050Lf %d", zero / zero, 33, 44, 55);
1303     ASSERT (strlen (result) == 50 + 3
1304             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1305             && strcmp (result + strlen (result) - 3, " 33") == 0);
1306     ASSERT (retval == strlen (result));
1307   }
1308
1309   { /* Precision.  */
1310     char result[1000];
1311     int retval =
1312       my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
1313     ASSERT (strcmp (result, "1234 33") == 0);
1314     ASSERT (retval == strlen (result));
1315   }
1316
1317   /* Test the support of the %F format directive.  */
1318
1319   { /* A positive number.  */
1320     char result[1000];
1321     int retval =
1322       my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
1323     ASSERT (strcmp (result, "12.750000 33") == 0);
1324     ASSERT (retval == strlen (result));
1325   }
1326
1327   { /* A larger positive number.  */
1328     char result[1000];
1329     int retval =
1330       my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
1331     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1332     ASSERT (retval == strlen (result));
1333   }
1334
1335   { /* A negative number.  */
1336     char result[1000];
1337     int retval =
1338       my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
1339     ASSERT (strcmp (result, "-0.031250 33") == 0);
1340     ASSERT (retval == strlen (result));
1341   }
1342
1343   { /* Positive zero.  */
1344     char result[1000];
1345     int retval =
1346       my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
1347     ASSERT (strcmp (result, "0.000000 33") == 0);
1348     ASSERT (retval == strlen (result));
1349   }
1350
1351   { /* Negative zero.  */
1352     char result[1000];
1353     int retval =
1354       my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
1355     if (have_minus_zero ())
1356       ASSERT (strcmp (result, "-0.000000 33") == 0);
1357     ASSERT (retval == strlen (result));
1358   }
1359
1360   { /* Positive infinity.  */
1361     char result[1000];
1362     int retval =
1363       my_sprintf (result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1364     ASSERT (strcmp (result, "INF 33") == 0
1365             || strcmp (result, "INFINITY 33") == 0);
1366     ASSERT (retval == strlen (result));
1367   }
1368
1369   { /* Negative infinity.  */
1370     char result[1000];
1371     int retval =
1372       my_sprintf (result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1373     ASSERT (strcmp (result, "-INF 33") == 0
1374             || strcmp (result, "-INFINITY 33") == 0);
1375     ASSERT (retval == strlen (result));
1376   }
1377
1378   { /* NaN.  */
1379     char result[1000];
1380     int retval =
1381       my_sprintf (result, "%F %d", NAN, 33, 44, 55);
1382     ASSERT (strlen (result) >= 3 + 3
1383             && strisnan (result, 0, strlen (result) - 3, 1)
1384             && strcmp (result + strlen (result) - 3, " 33") == 0);
1385     ASSERT (retval == strlen (result));
1386   }
1387
1388   { /* FLAG_ZERO.  */
1389     char result[1000];
1390     int retval =
1391       my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
1392     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1393     ASSERT (retval == strlen (result));
1394   }
1395
1396   { /* FLAG_ZERO with infinite number.  */
1397     char result[1000];
1398     int retval =
1399       my_sprintf (result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1400     ASSERT (strcmp (result, "           -INF 33") == 0
1401             || strcmp (result, "      -INFINITY 33") == 0);
1402     ASSERT (retval == strlen (result));
1403   }
1404
1405   { /* Precision.  */
1406     char result[1000];
1407     int retval =
1408       my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
1409     ASSERT (strcmp (result, "1234 33") == 0);
1410     ASSERT (retval == strlen (result));
1411   }
1412
1413   { /* A positive number.  */
1414     char result[1000];
1415     int retval =
1416       my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
1417     ASSERT (strcmp (result, "12.750000 33") == 0);
1418     ASSERT (retval == strlen (result));
1419   }
1420
1421   { /* A larger positive number.  */
1422     char result[1000];
1423     int retval =
1424       my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
1425     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1426     ASSERT (retval == strlen (result));
1427   }
1428
1429   { /* A negative number.  */
1430     char result[1000];
1431     int retval =
1432       my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
1433     ASSERT (strcmp (result, "-0.031250 33") == 0);
1434     ASSERT (retval == strlen (result));
1435   }
1436
1437   { /* Positive zero.  */
1438     char result[1000];
1439     int retval =
1440       my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
1441     ASSERT (strcmp (result, "0.000000 33") == 0);
1442     ASSERT (retval == strlen (result));
1443   }
1444
1445   { /* Negative zero.  */
1446     char result[1000];
1447     int retval =
1448       my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
1449     if (have_minus_zero ())
1450       ASSERT (strcmp (result, "-0.000000 33") == 0);
1451     ASSERT (retval == strlen (result));
1452   }
1453
1454   { /* Positive infinity.  */
1455     char result[1000];
1456     int retval =
1457       my_sprintf (result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1458     ASSERT (strcmp (result, "INF 33") == 0
1459             || strcmp (result, "INFINITY 33") == 0);
1460     ASSERT (retval == strlen (result));
1461   }
1462
1463   { /* Negative infinity.  */
1464     char result[1000];
1465     int retval =
1466       my_sprintf (result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1467     ASSERT (strcmp (result, "-INF 33") == 0
1468             || strcmp (result, "-INFINITY 33") == 0);
1469     ASSERT (retval == strlen (result));
1470   }
1471
1472   { /* NaN.  */
1473     static long double zero = 0.0L;
1474     char result[1000];
1475     int retval =
1476       my_sprintf (result, "%LF %d", zero / zero, 33, 44, 55);
1477     ASSERT (strlen (result) >= 3 + 3
1478             && strisnan (result, 0, strlen (result) - 3, 1)
1479             && strcmp (result + strlen (result) - 3, " 33") == 0);
1480     ASSERT (retval == strlen (result));
1481   }
1482
1483   { /* FLAG_ZERO.  */
1484     char result[1000];
1485     int retval =
1486       my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
1487     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1488     ASSERT (retval == strlen (result));
1489   }
1490
1491   { /* FLAG_ZERO with infinite number.  */
1492     char result[1000];
1493     int retval =
1494       my_sprintf (result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1495     ASSERT (strcmp (result, "           -INF 33") == 0
1496             || strcmp (result, "      -INFINITY 33") == 0);
1497     ASSERT (retval == strlen (result));
1498   }
1499
1500   { /* Precision.  */
1501     char result[1000];
1502     int retval =
1503       my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
1504     ASSERT (strcmp (result, "1234 33") == 0);
1505     ASSERT (retval == strlen (result));
1506   }
1507
1508   /* Test the support of the %e format directive.  */
1509
1510   { /* A positive number.  */
1511     char result[1000];
1512     int retval =
1513       my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
1514     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1515             || strcmp (result, "1.275000e+001 33") == 0);
1516     ASSERT (retval == strlen (result));
1517   }
1518
1519   { /* A larger positive number.  */
1520     char result[1000];
1521     int retval =
1522       my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
1523     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1524             || strcmp (result, "1.234567e+006 33") == 0);
1525     ASSERT (retval == strlen (result));
1526   }
1527
1528   { /* Small and large positive numbers.  */
1529     static struct { double value; const char *string; } data[] =
1530       {
1531         { 1.234321234321234e-37, "1.234321e-37" },
1532         { 1.234321234321234e-36, "1.234321e-36" },
1533         { 1.234321234321234e-35, "1.234321e-35" },
1534         { 1.234321234321234e-34, "1.234321e-34" },
1535         { 1.234321234321234e-33, "1.234321e-33" },
1536         { 1.234321234321234e-32, "1.234321e-32" },
1537         { 1.234321234321234e-31, "1.234321e-31" },
1538         { 1.234321234321234e-30, "1.234321e-30" },
1539         { 1.234321234321234e-29, "1.234321e-29" },
1540         { 1.234321234321234e-28, "1.234321e-28" },
1541         { 1.234321234321234e-27, "1.234321e-27" },
1542         { 1.234321234321234e-26, "1.234321e-26" },
1543         { 1.234321234321234e-25, "1.234321e-25" },
1544         { 1.234321234321234e-24, "1.234321e-24" },
1545         { 1.234321234321234e-23, "1.234321e-23" },
1546         { 1.234321234321234e-22, "1.234321e-22" },
1547         { 1.234321234321234e-21, "1.234321e-21" },
1548         { 1.234321234321234e-20, "1.234321e-20" },
1549         { 1.234321234321234e-19, "1.234321e-19" },
1550         { 1.234321234321234e-18, "1.234321e-18" },
1551         { 1.234321234321234e-17, "1.234321e-17" },
1552         { 1.234321234321234e-16, "1.234321e-16" },
1553         { 1.234321234321234e-15, "1.234321e-15" },
1554         { 1.234321234321234e-14, "1.234321e-14" },
1555         { 1.234321234321234e-13, "1.234321e-13" },
1556         { 1.234321234321234e-12, "1.234321e-12" },
1557         { 1.234321234321234e-11, "1.234321e-11" },
1558         { 1.234321234321234e-10, "1.234321e-10" },
1559         { 1.234321234321234e-9, "1.234321e-09" },
1560         { 1.234321234321234e-8, "1.234321e-08" },
1561         { 1.234321234321234e-7, "1.234321e-07" },
1562         { 1.234321234321234e-6, "1.234321e-06" },
1563         { 1.234321234321234e-5, "1.234321e-05" },
1564         { 1.234321234321234e-4, "1.234321e-04" },
1565         { 1.234321234321234e-3, "1.234321e-03" },
1566         { 1.234321234321234e-2, "1.234321e-02" },
1567         { 1.234321234321234e-1, "1.234321e-01" },
1568         { 1.234321234321234, "1.234321e+00" },
1569         { 1.234321234321234e1, "1.234321e+01" },
1570         { 1.234321234321234e2, "1.234321e+02" },
1571         { 1.234321234321234e3, "1.234321e+03" },
1572         { 1.234321234321234e4, "1.234321e+04" },
1573         { 1.234321234321234e5, "1.234321e+05" },
1574         { 1.234321234321234e6, "1.234321e+06" },
1575         { 1.234321234321234e7, "1.234321e+07" },
1576         { 1.234321234321234e8, "1.234321e+08" },
1577         { 1.234321234321234e9, "1.234321e+09" },
1578         { 1.234321234321234e10, "1.234321e+10" },
1579         { 1.234321234321234e11, "1.234321e+11" },
1580         { 1.234321234321234e12, "1.234321e+12" },
1581         { 1.234321234321234e13, "1.234321e+13" },
1582         { 1.234321234321234e14, "1.234321e+14" },
1583         { 1.234321234321234e15, "1.234321e+15" },
1584         { 1.234321234321234e16, "1.234321e+16" },
1585         { 1.234321234321234e17, "1.234321e+17" },
1586         { 1.234321234321234e18, "1.234321e+18" },
1587         { 1.234321234321234e19, "1.234321e+19" },
1588         { 1.234321234321234e20, "1.234321e+20" },
1589         { 1.234321234321234e21, "1.234321e+21" },
1590         { 1.234321234321234e22, "1.234321e+22" },
1591         { 1.234321234321234e23, "1.234321e+23" },
1592         { 1.234321234321234e24, "1.234321e+24" },
1593         { 1.234321234321234e25, "1.234321e+25" },
1594         { 1.234321234321234e26, "1.234321e+26" },
1595         { 1.234321234321234e27, "1.234321e+27" },
1596         { 1.234321234321234e28, "1.234321e+28" },
1597         { 1.234321234321234e29, "1.234321e+29" },
1598         { 1.234321234321234e30, "1.234321e+30" },
1599         { 1.234321234321234e31, "1.234321e+31" },
1600         { 1.234321234321234e32, "1.234321e+32" },
1601         { 1.234321234321234e33, "1.234321e+33" },
1602         { 1.234321234321234e34, "1.234321e+34" },
1603         { 1.234321234321234e35, "1.234321e+35" },
1604         { 1.234321234321234e36, "1.234321e+36" }
1605       };
1606     size_t k;
1607     for (k = 0; k < SIZEOF (data); k++)
1608       {
1609         char result[1000];
1610         int retval =
1611           my_sprintf (result, "%e", data[k].value);
1612         const char *expected = data[k].string;
1613         ASSERT (result != NULL);
1614         ASSERT (strcmp (result, expected) == 0
1615                 /* Some implementations produce exponents with 3 digits.  */
1616                 || (strlen (result) == strlen (expected) + 1
1617                     && memcmp (result, expected, strlen (expected) - 2) == 0
1618                     && result[strlen (expected) - 2] == '0'
1619                     && strcmp (result + strlen (expected) - 1,
1620                                expected + strlen (expected) - 2)
1621                        == 0));
1622         ASSERT (retval == strlen (result));
1623       }
1624   }
1625
1626   { /* A negative number.  */
1627     char result[1000];
1628     int retval =
1629       my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
1630     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1631             || strcmp (result, "-3.125000e-002 33") == 0);
1632     ASSERT (retval == strlen (result));
1633   }
1634
1635   { /* Positive zero.  */
1636     char result[1000];
1637     int retval =
1638       my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
1639     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1640             || strcmp (result, "0.000000e+000 33") == 0);
1641     ASSERT (retval == strlen (result));
1642   }
1643
1644   { /* Negative zero.  */
1645     char result[1000];
1646     int retval =
1647       my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
1648     if (have_minus_zero ())
1649       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1650               || strcmp (result, "-0.000000e+000 33") == 0);
1651     ASSERT (retval == strlen (result));
1652   }
1653
1654   { /* Positive infinity.  */
1655     char result[1000];
1656     int retval =
1657       my_sprintf (result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1658     ASSERT (strcmp (result, "inf 33") == 0
1659             || strcmp (result, "infinity 33") == 0);
1660     ASSERT (retval == strlen (result));
1661   }
1662
1663   { /* Negative infinity.  */
1664     char result[1000];
1665     int retval =
1666       my_sprintf (result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1667     ASSERT (strcmp (result, "-inf 33") == 0
1668             || strcmp (result, "-infinity 33") == 0);
1669     ASSERT (retval == strlen (result));
1670   }
1671
1672   { /* NaN.  */
1673     char result[1000];
1674     int retval =
1675       my_sprintf (result, "%e %d", NAN, 33, 44, 55);
1676     ASSERT (strlen (result) >= 3 + 3
1677             && strisnan (result, 0, strlen (result) - 3, 0)
1678             && strcmp (result + strlen (result) - 3, " 33") == 0);
1679     ASSERT (retval == strlen (result));
1680   }
1681
1682   { /* Width.  */
1683     char result[1000];
1684     int retval =
1685       my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
1686     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
1687             || strcmp (result, "  1.750000e+000 33") == 0);
1688     ASSERT (retval == strlen (result));
1689   }
1690
1691   { /* FLAG_LEFT.  */
1692     char result[1000];
1693     int retval =
1694       my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
1695     ASSERT (strcmp (result, "1.750000e+00    33") == 0
1696             || strcmp (result, "1.750000e+000   33") == 0);
1697     ASSERT (retval == strlen (result));
1698   }
1699
1700   { /* FLAG_SHOWSIGN.  */
1701     char result[1000];
1702     int retval =
1703       my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
1704     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1705             || strcmp (result, "+1.750000e+000 33") == 0);
1706     ASSERT (retval == strlen (result));
1707   }
1708
1709   { /* FLAG_SPACE.  */
1710     char result[1000];
1711     int retval =
1712       my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
1713     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1714             || strcmp (result, " 1.750000e+000 33") == 0);
1715     ASSERT (retval == strlen (result));
1716   }
1717
1718   { /* FLAG_ALT.  */
1719     char result[1000];
1720     int retval =
1721       my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
1722     ASSERT (strcmp (result, "1.750000e+00 33") == 0
1723             || strcmp (result, "1.750000e+000 33") == 0);
1724     ASSERT (retval == strlen (result));
1725   }
1726
1727   { /* FLAG_ALT.  */
1728     char result[1000];
1729     int retval =
1730       my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
1731     ASSERT (strcmp (result, "2.e+00 33") == 0
1732             || strcmp (result, "2.e+000 33") == 0);
1733     ASSERT (retval == strlen (result));
1734   }
1735
1736   { /* FLAG_ALT.  */
1737     char result[1000];
1738     int retval =
1739       my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
1740     ASSERT (strcmp (result, "1.e+01 33") == 0
1741             || strcmp (result, "1.e+001 33") == 0);
1742     ASSERT (retval == strlen (result));
1743   }
1744
1745   { /* FLAG_ZERO with finite number.  */
1746     char result[1000];
1747     int retval =
1748       my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
1749     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1750             || strcmp (result, "001.234000e+003 33") == 0);
1751     ASSERT (retval == strlen (result));
1752   }
1753
1754   { /* FLAG_ZERO with infinite number.  */
1755     char result[1000];
1756     int retval =
1757       my_sprintf (result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1758     ASSERT (strcmp (result, "           -inf 33") == 0
1759             || strcmp (result, "      -infinity 33") == 0);
1760     ASSERT (retval == strlen (result));
1761   }
1762
1763   { /* FLAG_ZERO with NaN.  */
1764     char result[1000];
1765     int retval =
1766       my_sprintf (result, "%050e %d", NAN, 33, 44, 55);
1767     ASSERT (strlen (result) == 50 + 3
1768             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1769             && strcmp (result + strlen (result) - 3, " 33") == 0);
1770     ASSERT (retval == strlen (result));
1771   }
1772
1773   { /* Precision.  */
1774     char result[1000];
1775     int retval =
1776       my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
1777     ASSERT (strcmp (result, "1e+03 33") == 0
1778             || strcmp (result, "1e+003 33") == 0);
1779     ASSERT (retval == strlen (result));
1780   }
1781
1782   { /* A positive number.  */
1783     char result[1000];
1784     int retval =
1785       my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
1786     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1787     ASSERT (retval == strlen (result));
1788   }
1789
1790   { /* A larger positive number.  */
1791     char result[1000];
1792     int retval =
1793       my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
1794     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1795     ASSERT (retval == strlen (result));
1796   }
1797
1798   { /* Small and large positive numbers.  */
1799     static struct { long double value; const char *string; } data[] =
1800       {
1801         { 1.234321234321234e-37L, "1.234321e-37" },
1802         { 1.234321234321234e-36L, "1.234321e-36" },
1803         { 1.234321234321234e-35L, "1.234321e-35" },
1804         { 1.234321234321234e-34L, "1.234321e-34" },
1805         { 1.234321234321234e-33L, "1.234321e-33" },
1806         { 1.234321234321234e-32L, "1.234321e-32" },
1807         { 1.234321234321234e-31L, "1.234321e-31" },
1808         { 1.234321234321234e-30L, "1.234321e-30" },
1809         { 1.234321234321234e-29L, "1.234321e-29" },
1810         { 1.234321234321234e-28L, "1.234321e-28" },
1811         { 1.234321234321234e-27L, "1.234321e-27" },
1812         { 1.234321234321234e-26L, "1.234321e-26" },
1813         { 1.234321234321234e-25L, "1.234321e-25" },
1814         { 1.234321234321234e-24L, "1.234321e-24" },
1815         { 1.234321234321234e-23L, "1.234321e-23" },
1816         { 1.234321234321234e-22L, "1.234321e-22" },
1817         { 1.234321234321234e-21L, "1.234321e-21" },
1818         { 1.234321234321234e-20L, "1.234321e-20" },
1819         { 1.234321234321234e-19L, "1.234321e-19" },
1820         { 1.234321234321234e-18L, "1.234321e-18" },
1821         { 1.234321234321234e-17L, "1.234321e-17" },
1822         { 1.234321234321234e-16L, "1.234321e-16" },
1823         { 1.234321234321234e-15L, "1.234321e-15" },
1824         { 1.234321234321234e-14L, "1.234321e-14" },
1825         { 1.234321234321234e-13L, "1.234321e-13" },
1826         { 1.234321234321234e-12L, "1.234321e-12" },
1827         { 1.234321234321234e-11L, "1.234321e-11" },
1828         { 1.234321234321234e-10L, "1.234321e-10" },
1829         { 1.234321234321234e-9L, "1.234321e-09" },
1830         { 1.234321234321234e-8L, "1.234321e-08" },
1831         { 1.234321234321234e-7L, "1.234321e-07" },
1832         { 1.234321234321234e-6L, "1.234321e-06" },
1833         { 1.234321234321234e-5L, "1.234321e-05" },
1834         { 1.234321234321234e-4L, "1.234321e-04" },
1835         { 1.234321234321234e-3L, "1.234321e-03" },
1836         { 1.234321234321234e-2L, "1.234321e-02" },
1837         { 1.234321234321234e-1L, "1.234321e-01" },
1838         { 1.234321234321234L, "1.234321e+00" },
1839         { 1.234321234321234e1L, "1.234321e+01" },
1840         { 1.234321234321234e2L, "1.234321e+02" },
1841         { 1.234321234321234e3L, "1.234321e+03" },
1842         { 1.234321234321234e4L, "1.234321e+04" },
1843         { 1.234321234321234e5L, "1.234321e+05" },
1844         { 1.234321234321234e6L, "1.234321e+06" },
1845         { 1.234321234321234e7L, "1.234321e+07" },
1846         { 1.234321234321234e8L, "1.234321e+08" },
1847         { 1.234321234321234e9L, "1.234321e+09" },
1848         { 1.234321234321234e10L, "1.234321e+10" },
1849         { 1.234321234321234e11L, "1.234321e+11" },
1850         { 1.234321234321234e12L, "1.234321e+12" },
1851         { 1.234321234321234e13L, "1.234321e+13" },
1852         { 1.234321234321234e14L, "1.234321e+14" },
1853         { 1.234321234321234e15L, "1.234321e+15" },
1854         { 1.234321234321234e16L, "1.234321e+16" },
1855         { 1.234321234321234e17L, "1.234321e+17" },
1856         { 1.234321234321234e18L, "1.234321e+18" },
1857         { 1.234321234321234e19L, "1.234321e+19" },
1858         { 1.234321234321234e20L, "1.234321e+20" },
1859         { 1.234321234321234e21L, "1.234321e+21" },
1860         { 1.234321234321234e22L, "1.234321e+22" },
1861         { 1.234321234321234e23L, "1.234321e+23" },
1862         { 1.234321234321234e24L, "1.234321e+24" },
1863         { 1.234321234321234e25L, "1.234321e+25" },
1864         { 1.234321234321234e26L, "1.234321e+26" },
1865         { 1.234321234321234e27L, "1.234321e+27" },
1866         { 1.234321234321234e28L, "1.234321e+28" },
1867         { 1.234321234321234e29L, "1.234321e+29" },
1868         { 1.234321234321234e30L, "1.234321e+30" },
1869         { 1.234321234321234e31L, "1.234321e+31" },
1870         { 1.234321234321234e32L, "1.234321e+32" },
1871         { 1.234321234321234e33L, "1.234321e+33" },
1872         { 1.234321234321234e34L, "1.234321e+34" },
1873         { 1.234321234321234e35L, "1.234321e+35" },
1874         { 1.234321234321234e36L, "1.234321e+36" }
1875       };
1876     size_t k;
1877     for (k = 0; k < SIZEOF (data); k++)
1878       {
1879         char result[1000];
1880         int retval =
1881           my_sprintf (result, "%Le", data[k].value);
1882         ASSERT (strcmp (result, data[k].string) == 0);
1883         ASSERT (retval == strlen (result));
1884       }
1885   }
1886
1887   { /* A negative number.  */
1888     char result[1000];
1889     int retval =
1890       my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
1891     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1892     ASSERT (retval == strlen (result));
1893   }
1894
1895   { /* Positive zero.  */
1896     char result[1000];
1897     int retval =
1898       my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
1899     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1900     ASSERT (retval == strlen (result));
1901   }
1902
1903   { /* Negative zero.  */
1904     char result[1000];
1905     int retval =
1906       my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
1907     if (have_minus_zero ())
1908       ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1909     ASSERT (retval == strlen (result));
1910   }
1911
1912   { /* Positive infinity.  */
1913     char result[1000];
1914     int retval =
1915       my_sprintf (result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1916     ASSERT (strcmp (result, "inf 33") == 0
1917             || strcmp (result, "infinity 33") == 0);
1918     ASSERT (retval == strlen (result));
1919   }
1920
1921   { /* Negative infinity.  */
1922     char result[1000];
1923     int retval =
1924       my_sprintf (result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1925     ASSERT (strcmp (result, "-inf 33") == 0
1926             || strcmp (result, "-infinity 33") == 0);
1927     ASSERT (retval == strlen (result));
1928   }
1929
1930   { /* NaN.  */
1931     static long double zero = 0.0L;
1932     char result[1000];
1933     int retval =
1934       my_sprintf (result, "%Le %d", zero / zero, 33, 44, 55);
1935     ASSERT (strlen (result) >= 3 + 3
1936             && strisnan (result, 0, strlen (result) - 3, 0)
1937             && strcmp (result + strlen (result) - 3, " 33") == 0);
1938     ASSERT (retval == strlen (result));
1939   }
1940 #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_))
1941   { /* Quiet NaN.  */
1942     static union { unsigned int word[4]; long double value; } x =
1943       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1944     char result[1000];
1945     int retval =
1946       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
1947     ASSERT (strlen (result) >= 3 + 3
1948             && strisnan (result, 0, strlen (result) - 3, 0)
1949             && strcmp (result + strlen (result) - 3, " 33") == 0);
1950     ASSERT (retval == strlen (result));
1951   }
1952   {
1953     /* Signalling NaN.  */
1954     static union { unsigned int word[4]; long double value; } x =
1955       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1956     char result[1000];
1957     int retval =
1958       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
1959     ASSERT (strlen (result) >= 3 + 3
1960             && strisnan (result, 0, strlen (result) - 3, 0)
1961             && strcmp (result + strlen (result) - 3, " 33") == 0);
1962     ASSERT (retval == strlen (result));
1963   }
1964   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1965      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1966        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1967        Application Architecture.
1968        Table 5-2 "Floating-Point Register Encodings"
1969        Figure 5-6 "Memory to Floating-Point Register Data Translation"
1970    */
1971   { /* Pseudo-NaN.  */
1972     static union { unsigned int word[4]; long double value; } x =
1973       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1974     char result[1000];
1975     int retval =
1976       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
1977     ASSERT (strlen (result) >= 3 + 3
1978             && strisnan (result, 0, strlen (result) - 3, 0)
1979             && strcmp (result + strlen (result) - 3, " 33") == 0);
1980     ASSERT (retval == strlen (result));
1981   }
1982   { /* Pseudo-Infinity.  */
1983     static union { unsigned int word[4]; long double value; } x =
1984       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1985     char result[1000];
1986     int retval =
1987       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
1988     ASSERT (strlen (result) >= 3 + 3
1989             && strisnan (result, 0, strlen (result) - 3, 0)
1990             && strcmp (result + strlen (result) - 3, " 33") == 0);
1991     ASSERT (retval == strlen (result));
1992   }
1993   { /* Pseudo-Zero.  */
1994     static union { unsigned int word[4]; long double value; } x =
1995       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1996     char result[1000];
1997     int retval =
1998       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
1999     ASSERT (strlen (result) >= 3 + 3
2000             && strisnan (result, 0, strlen (result) - 3, 0)
2001             && strcmp (result + strlen (result) - 3, " 33") == 0);
2002     ASSERT (retval == strlen (result));
2003   }
2004   { /* Unnormalized number.  */
2005     static union { unsigned int word[4]; long double value; } x =
2006       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2007     char result[1000];
2008     int retval =
2009       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2010     ASSERT (strlen (result) >= 3 + 3
2011             && strisnan (result, 0, strlen (result) - 3, 0)
2012             && strcmp (result + strlen (result) - 3, " 33") == 0);
2013     ASSERT (retval == strlen (result));
2014   }
2015   { /* Pseudo-Denormal.  */
2016     static union { unsigned int word[4]; long double value; } x =
2017       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2018     char result[1000];
2019     int retval =
2020       my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2021     ASSERT (strlen (result) >= 3 + 3
2022             && strisnan (result, 0, strlen (result) - 3, 0)
2023             && strcmp (result + strlen (result) - 3, " 33") == 0);
2024     ASSERT (retval == strlen (result));
2025   }
2026 #endif
2027
2028   { /* Width.  */
2029     char result[1000];
2030     int retval =
2031       my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
2032     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
2033     ASSERT (retval == strlen (result));
2034   }
2035
2036   { /* FLAG_LEFT.  */
2037     char result[1000];
2038     int retval =
2039       my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
2040     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
2041     ASSERT (retval == strlen (result));
2042   }
2043
2044   { /* FLAG_SHOWSIGN.  */
2045     char result[1000];
2046     int retval =
2047       my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
2048     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2049     ASSERT (retval == strlen (result));
2050   }
2051
2052   { /* FLAG_SPACE.  */
2053     char result[1000];
2054     int retval =
2055       my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
2056     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2057     ASSERT (retval == strlen (result));
2058   }
2059
2060   { /* FLAG_ALT.  */
2061     char result[1000];
2062     int retval =
2063       my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
2064     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2065     ASSERT (retval == strlen (result));
2066   }
2067
2068   { /* FLAG_ALT.  */
2069     char result[1000];
2070     int retval =
2071       my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
2072     ASSERT (strcmp (result, "2.e+00 33") == 0);
2073     ASSERT (retval == strlen (result));
2074   }
2075
2076   { /* FLAG_ALT.  */
2077     char result[1000];
2078     int retval =
2079       my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
2080     ASSERT (strcmp (result, "1.e+01 33") == 0);
2081     ASSERT (retval == strlen (result));
2082   }
2083
2084   { /* FLAG_ZERO with finite number.  */
2085     char result[1000];
2086     int retval =
2087       my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
2088     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2089     ASSERT (retval == strlen (result));
2090   }
2091
2092   { /* FLAG_ZERO with infinite number.  */
2093     char result[1000];
2094     int retval =
2095       my_sprintf (result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2096     ASSERT (strcmp (result, "           -inf 33") == 0
2097             || strcmp (result, "      -infinity 33") == 0);
2098     ASSERT (retval == strlen (result));
2099   }
2100
2101   { /* FLAG_ZERO with NaN.  */
2102     static long double zero = 0.0L;
2103     char result[1000];
2104     int retval =
2105       my_sprintf (result, "%050Le %d", zero / zero, 33, 44, 55);
2106     ASSERT (strlen (result) == 50 + 3
2107             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2108             && strcmp (result + strlen (result) - 3, " 33") == 0);
2109     ASSERT (retval == strlen (result));
2110   }
2111
2112   { /* Precision.  */
2113     char result[1000];
2114     int retval =
2115       my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
2116     ASSERT (strcmp (result, "1e+03 33") == 0);
2117     ASSERT (retval == strlen (result));
2118   }
2119
2120   /* Test the support of the %g format directive.  */
2121
2122   { /* A positive number.  */
2123     char result[1000];
2124     int retval =
2125       my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
2126     ASSERT (strcmp (result, "12.75 33") == 0);
2127     ASSERT (retval == strlen (result));
2128   }
2129
2130   { /* A larger positive number.  */
2131     char result[1000];
2132     int retval =
2133       my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
2134     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2135             || strcmp (result, "1.23457e+006 33") == 0);
2136     ASSERT (retval == strlen (result));
2137   }
2138
2139   { /* Small and large positive numbers.  */
2140     static struct { double value; const char *string; } data[] =
2141       {
2142         { 1.234321234321234e-37, "1.23432e-37" },
2143         { 1.234321234321234e-36, "1.23432e-36" },
2144         { 1.234321234321234e-35, "1.23432e-35" },
2145         { 1.234321234321234e-34, "1.23432e-34" },
2146         { 1.234321234321234e-33, "1.23432e-33" },
2147         { 1.234321234321234e-32, "1.23432e-32" },
2148         { 1.234321234321234e-31, "1.23432e-31" },
2149         { 1.234321234321234e-30, "1.23432e-30" },
2150         { 1.234321234321234e-29, "1.23432e-29" },
2151         { 1.234321234321234e-28, "1.23432e-28" },
2152         { 1.234321234321234e-27, "1.23432e-27" },
2153         { 1.234321234321234e-26, "1.23432e-26" },
2154         { 1.234321234321234e-25, "1.23432e-25" },
2155         { 1.234321234321234e-24, "1.23432e-24" },
2156         { 1.234321234321234e-23, "1.23432e-23" },
2157         { 1.234321234321234e-22, "1.23432e-22" },
2158         { 1.234321234321234e-21, "1.23432e-21" },
2159         { 1.234321234321234e-20, "1.23432e-20" },
2160         { 1.234321234321234e-19, "1.23432e-19" },
2161         { 1.234321234321234e-18, "1.23432e-18" },
2162         { 1.234321234321234e-17, "1.23432e-17" },
2163         { 1.234321234321234e-16, "1.23432e-16" },
2164         { 1.234321234321234e-15, "1.23432e-15" },
2165         { 1.234321234321234e-14, "1.23432e-14" },
2166         { 1.234321234321234e-13, "1.23432e-13" },
2167         { 1.234321234321234e-12, "1.23432e-12" },
2168         { 1.234321234321234e-11, "1.23432e-11" },
2169         { 1.234321234321234e-10, "1.23432e-10" },
2170         { 1.234321234321234e-9, "1.23432e-09" },
2171         { 1.234321234321234e-8, "1.23432e-08" },
2172         { 1.234321234321234e-7, "1.23432e-07" },
2173         { 1.234321234321234e-6, "1.23432e-06" },
2174         { 1.234321234321234e-5, "1.23432e-05" },
2175         { 1.234321234321234e-4, "0.000123432" },
2176         { 1.234321234321234e-3, "0.00123432" },
2177         { 1.234321234321234e-2, "0.0123432" },
2178         { 1.234321234321234e-1, "0.123432" },
2179         { 1.234321234321234, "1.23432" },
2180         { 1.234321234321234e1, "12.3432" },
2181         { 1.234321234321234e2, "123.432" },
2182         { 1.234321234321234e3, "1234.32" },
2183         { 1.234321234321234e4, "12343.2" },
2184         { 1.234321234321234e5, "123432" },
2185         { 1.234321234321234e6, "1.23432e+06" },
2186         { 1.234321234321234e7, "1.23432e+07" },
2187         { 1.234321234321234e8, "1.23432e+08" },
2188         { 1.234321234321234e9, "1.23432e+09" },
2189         { 1.234321234321234e10, "1.23432e+10" },
2190         { 1.234321234321234e11, "1.23432e+11" },
2191         { 1.234321234321234e12, "1.23432e+12" },
2192         { 1.234321234321234e13, "1.23432e+13" },
2193         { 1.234321234321234e14, "1.23432e+14" },
2194         { 1.234321234321234e15, "1.23432e+15" },
2195         { 1.234321234321234e16, "1.23432e+16" },
2196         { 1.234321234321234e17, "1.23432e+17" },
2197         { 1.234321234321234e18, "1.23432e+18" },
2198         { 1.234321234321234e19, "1.23432e+19" },
2199         { 1.234321234321234e20, "1.23432e+20" },
2200         { 1.234321234321234e21, "1.23432e+21" },
2201         { 1.234321234321234e22, "1.23432e+22" },
2202         { 1.234321234321234e23, "1.23432e+23" },
2203         { 1.234321234321234e24, "1.23432e+24" },
2204         { 1.234321234321234e25, "1.23432e+25" },
2205         { 1.234321234321234e26, "1.23432e+26" },
2206         { 1.234321234321234e27, "1.23432e+27" },
2207         { 1.234321234321234e28, "1.23432e+28" },
2208         { 1.234321234321234e29, "1.23432e+29" },
2209         { 1.234321234321234e30, "1.23432e+30" },
2210         { 1.234321234321234e31, "1.23432e+31" },
2211         { 1.234321234321234e32, "1.23432e+32" },
2212         { 1.234321234321234e33, "1.23432e+33" },
2213         { 1.234321234321234e34, "1.23432e+34" },
2214         { 1.234321234321234e35, "1.23432e+35" },
2215         { 1.234321234321234e36, "1.23432e+36" }
2216       };
2217     size_t k;
2218     for (k = 0; k < SIZEOF (data); k++)
2219       {
2220         char result[1000];
2221         int retval =
2222           my_sprintf (result, "%g", data[k].value);
2223         const char *expected = data[k].string;
2224         ASSERT (strcmp (result, expected) == 0
2225                 /* Some implementations produce exponents with 3 digits.  */
2226                 || (expected[strlen (expected) - 4] == 'e'
2227                     && strlen (result) == strlen (expected) + 1
2228                     && memcmp (result, expected, strlen (expected) - 2) == 0
2229                     && result[strlen (expected) - 2] == '0'
2230                     && strcmp (result + strlen (expected) - 1,
2231                                expected + strlen (expected) - 2)
2232                        == 0));
2233         ASSERT (retval == strlen (result));
2234       }
2235   }
2236
2237   { /* A negative number.  */
2238     char result[1000];
2239     int retval =
2240       my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
2241     ASSERT (strcmp (result, "-0.03125 33") == 0);
2242     ASSERT (retval == strlen (result));
2243   }
2244
2245   { /* Positive zero.  */
2246     char result[1000];
2247     int retval =
2248       my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
2249     ASSERT (strcmp (result, "0 33") == 0);
2250     ASSERT (retval == strlen (result));
2251   }
2252
2253   { /* Negative zero.  */
2254     char result[1000];
2255     int retval =
2256       my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
2257     if (have_minus_zero ())
2258       ASSERT (strcmp (result, "-0 33") == 0);
2259     ASSERT (retval == strlen (result));
2260   }
2261
2262   { /* Positive infinity.  */
2263     char result[1000];
2264     int retval =
2265       my_sprintf (result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2266     ASSERT (strcmp (result, "inf 33") == 0
2267             || strcmp (result, "infinity 33") == 0);
2268     ASSERT (retval == strlen (result));
2269   }
2270
2271   { /* Negative infinity.  */
2272     char result[1000];
2273     int retval =
2274       my_sprintf (result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2275     ASSERT (strcmp (result, "-inf 33") == 0
2276             || strcmp (result, "-infinity 33") == 0);
2277     ASSERT (retval == strlen (result));
2278   }
2279
2280   { /* NaN.  */
2281     char result[1000];
2282     int retval =
2283       my_sprintf (result, "%g %d", NAN, 33, 44, 55);
2284     ASSERT (strlen (result) >= 3 + 3
2285             && strisnan (result, 0, strlen (result) - 3, 0)
2286             && strcmp (result + strlen (result) - 3, " 33") == 0);
2287     ASSERT (retval == strlen (result));
2288   }
2289
2290   { /* Width.  */
2291     char result[1000];
2292     int retval =
2293       my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
2294     ASSERT (strcmp (result, "      1.75 33") == 0);
2295     ASSERT (retval == strlen (result));
2296   }
2297
2298   { /* FLAG_LEFT.  */
2299     char result[1000];
2300     int retval =
2301       my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
2302     ASSERT (strcmp (result, "1.75       33") == 0);
2303     ASSERT (retval == strlen (result));
2304   }
2305
2306   { /* FLAG_SHOWSIGN.  */
2307     char result[1000];
2308     int retval =
2309       my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
2310     ASSERT (strcmp (result, "+1.75 33") == 0);
2311     ASSERT (retval == strlen (result));
2312   }
2313
2314   { /* FLAG_SPACE.  */
2315     char result[1000];
2316     int retval =
2317       my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
2318     ASSERT (strcmp (result, " 1.75 33") == 0);
2319     ASSERT (retval == strlen (result));
2320   }
2321
2322   { /* FLAG_ALT.  */
2323     char result[1000];
2324     int retval =
2325       my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
2326     ASSERT (strcmp (result, "1.75000 33") == 0);
2327     ASSERT (retval == strlen (result));
2328   }
2329
2330   { /* FLAG_ALT.  */
2331     char result[1000];
2332     int retval =
2333       my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
2334     ASSERT (strcmp (result, "2. 33") == 0);
2335     ASSERT (retval == strlen (result));
2336   }
2337
2338   { /* FLAG_ALT.  */
2339     char result[1000];
2340     int retval =
2341       my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
2342     ASSERT (strcmp (result, "1.e+01 33") == 0
2343             || strcmp (result, "1.e+001 33") == 0);
2344     ASSERT (retval == strlen (result));
2345   }
2346
2347   { /* FLAG_ZERO with finite number.  */
2348     char result[1000];
2349     int retval =
2350       my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
2351     ASSERT (strcmp (result, "0000001234 33") == 0);
2352     ASSERT (retval == strlen (result));
2353   }
2354
2355   { /* FLAG_ZERO with infinite number.  */
2356     char result[1000];
2357     int retval =
2358       my_sprintf (result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2359     ASSERT (strcmp (result, "           -inf 33") == 0
2360             || strcmp (result, "      -infinity 33") == 0);
2361     ASSERT (retval == strlen (result));
2362   }
2363
2364   { /* FLAG_ZERO with NaN.  */
2365     char result[1000];
2366     int retval =
2367       my_sprintf (result, "%050g %d", NAN, 33, 44, 55);
2368     ASSERT (strlen (result) == 50 + 3
2369             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2370             && strcmp (result + strlen (result) - 3, " 33") == 0);
2371     ASSERT (retval == strlen (result));
2372   }
2373
2374   { /* Precision.  */
2375     char result[1000];
2376     int retval =
2377       my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
2378     ASSERT (strcmp (result, "1e+03 33") == 0
2379             || strcmp (result, "1e+003 33") == 0);
2380     ASSERT (retval == strlen (result));
2381   }
2382
2383   { /* A positive number.  */
2384     char result[1000];
2385     int retval =
2386       my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
2387     ASSERT (strcmp (result, "12.75 33") == 0);
2388     ASSERT (retval == strlen (result));
2389   }
2390
2391   { /* A larger positive number.  */
2392     char result[1000];
2393     int retval =
2394       my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
2395     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2396     ASSERT (retval == strlen (result));
2397   }
2398
2399   { /* Small and large positive numbers.  */
2400     static struct { long double value; const char *string; } data[] =
2401       {
2402         { 1.234321234321234e-37L, "1.23432e-37" },
2403         { 1.234321234321234e-36L, "1.23432e-36" },
2404         { 1.234321234321234e-35L, "1.23432e-35" },
2405         { 1.234321234321234e-34L, "1.23432e-34" },
2406         { 1.234321234321234e-33L, "1.23432e-33" },
2407         { 1.234321234321234e-32L, "1.23432e-32" },
2408         { 1.234321234321234e-31L, "1.23432e-31" },
2409         { 1.234321234321234e-30L, "1.23432e-30" },
2410         { 1.234321234321234e-29L, "1.23432e-29" },
2411         { 1.234321234321234e-28L, "1.23432e-28" },
2412         { 1.234321234321234e-27L, "1.23432e-27" },
2413         { 1.234321234321234e-26L, "1.23432e-26" },
2414         { 1.234321234321234e-25L, "1.23432e-25" },
2415         { 1.234321234321234e-24L, "1.23432e-24" },
2416         { 1.234321234321234e-23L, "1.23432e-23" },
2417         { 1.234321234321234e-22L, "1.23432e-22" },
2418         { 1.234321234321234e-21L, "1.23432e-21" },
2419         { 1.234321234321234e-20L, "1.23432e-20" },
2420         { 1.234321234321234e-19L, "1.23432e-19" },
2421         { 1.234321234321234e-18L, "1.23432e-18" },
2422         { 1.234321234321234e-17L, "1.23432e-17" },
2423         { 1.234321234321234e-16L, "1.23432e-16" },
2424         { 1.234321234321234e-15L, "1.23432e-15" },
2425         { 1.234321234321234e-14L, "1.23432e-14" },
2426         { 1.234321234321234e-13L, "1.23432e-13" },
2427         { 1.234321234321234e-12L, "1.23432e-12" },
2428         { 1.234321234321234e-11L, "1.23432e-11" },
2429         { 1.234321234321234e-10L, "1.23432e-10" },
2430         { 1.234321234321234e-9L, "1.23432e-09" },
2431         { 1.234321234321234e-8L, "1.23432e-08" },
2432         { 1.234321234321234e-7L, "1.23432e-07" },
2433         { 1.234321234321234e-6L, "1.23432e-06" },
2434         { 1.234321234321234e-5L, "1.23432e-05" },
2435         { 1.234321234321234e-4L, "0.000123432" },
2436         { 1.234321234321234e-3L, "0.00123432" },
2437         { 1.234321234321234e-2L, "0.0123432" },
2438         { 1.234321234321234e-1L, "0.123432" },
2439         { 1.234321234321234L, "1.23432" },
2440         { 1.234321234321234e1L, "12.3432" },
2441         { 1.234321234321234e2L, "123.432" },
2442         { 1.234321234321234e3L, "1234.32" },
2443         { 1.234321234321234e4L, "12343.2" },
2444         { 1.234321234321234e5L, "123432" },
2445         { 1.234321234321234e6L, "1.23432e+06" },
2446         { 1.234321234321234e7L, "1.23432e+07" },
2447         { 1.234321234321234e8L, "1.23432e+08" },
2448         { 1.234321234321234e9L, "1.23432e+09" },
2449         { 1.234321234321234e10L, "1.23432e+10" },
2450         { 1.234321234321234e11L, "1.23432e+11" },
2451         { 1.234321234321234e12L, "1.23432e+12" },
2452         { 1.234321234321234e13L, "1.23432e+13" },
2453         { 1.234321234321234e14L, "1.23432e+14" },
2454         { 1.234321234321234e15L, "1.23432e+15" },
2455         { 1.234321234321234e16L, "1.23432e+16" },
2456         { 1.234321234321234e17L, "1.23432e+17" },
2457         { 1.234321234321234e18L, "1.23432e+18" },
2458         { 1.234321234321234e19L, "1.23432e+19" },
2459         { 1.234321234321234e20L, "1.23432e+20" },
2460         { 1.234321234321234e21L, "1.23432e+21" },
2461         { 1.234321234321234e22L, "1.23432e+22" },
2462         { 1.234321234321234e23L, "1.23432e+23" },
2463         { 1.234321234321234e24L, "1.23432e+24" },
2464         { 1.234321234321234e25L, "1.23432e+25" },
2465         { 1.234321234321234e26L, "1.23432e+26" },
2466         { 1.234321234321234e27L, "1.23432e+27" },
2467         { 1.234321234321234e28L, "1.23432e+28" },
2468         { 1.234321234321234e29L, "1.23432e+29" },
2469         { 1.234321234321234e30L, "1.23432e+30" },
2470         { 1.234321234321234e31L, "1.23432e+31" },
2471         { 1.234321234321234e32L, "1.23432e+32" },
2472         { 1.234321234321234e33L, "1.23432e+33" },
2473         { 1.234321234321234e34L, "1.23432e+34" },
2474         { 1.234321234321234e35L, "1.23432e+35" },
2475         { 1.234321234321234e36L, "1.23432e+36" }
2476       };
2477     size_t k;
2478     for (k = 0; k < SIZEOF (data); k++)
2479       {
2480         char result[1000];
2481         int retval =
2482           my_sprintf (result, "%Lg", data[k].value);
2483         ASSERT (strcmp (result, data[k].string) == 0);
2484         ASSERT (retval == strlen (result));
2485       }
2486   }
2487
2488   { /* A negative number.  */
2489     char result[1000];
2490     int retval =
2491       my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
2492     ASSERT (strcmp (result, "-0.03125 33") == 0);
2493     ASSERT (retval == strlen (result));
2494   }
2495
2496   { /* Positive zero.  */
2497     char result[1000];
2498     int retval =
2499       my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
2500     ASSERT (strcmp (result, "0 33") == 0);
2501     ASSERT (retval == strlen (result));
2502   }
2503
2504   { /* Negative zero.  */
2505     char result[1000];
2506     int retval =
2507       my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
2508     if (have_minus_zero ())
2509       ASSERT (strcmp (result, "-0 33") == 0);
2510     ASSERT (retval == strlen (result));
2511   }
2512
2513   { /* Positive infinity.  */
2514     char result[1000];
2515     int retval =
2516       my_sprintf (result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2517     ASSERT (strcmp (result, "inf 33") == 0
2518             || strcmp (result, "infinity 33") == 0);
2519     ASSERT (retval == strlen (result));
2520   }
2521
2522   { /* Negative infinity.  */
2523     char result[1000];
2524     int retval =
2525       my_sprintf (result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2526     ASSERT (strcmp (result, "-inf 33") == 0
2527             || strcmp (result, "-infinity 33") == 0);
2528     ASSERT (retval == strlen (result));
2529   }
2530
2531   { /* NaN.  */
2532     static long double zero = 0.0L;
2533     char result[1000];
2534     int retval =
2535       my_sprintf (result, "%Lg %d", zero / zero, 33, 44, 55);
2536     ASSERT (strlen (result) >= 3 + 3
2537             && strisnan (result, 0, strlen (result) - 3, 0)
2538             && strcmp (result + strlen (result) - 3, " 33") == 0);
2539     ASSERT (retval == strlen (result));
2540   }
2541 #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_))
2542   { /* Quiet NaN.  */
2543     static union { unsigned int word[4]; long double value; } x =
2544       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2545     char result[1000];
2546     int retval =
2547       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
2548     ASSERT (strlen (result) >= 3 + 3
2549             && strisnan (result, 0, strlen (result) - 3, 0)
2550             && strcmp (result + strlen (result) - 3, " 33") == 0);
2551     ASSERT (retval == strlen (result));
2552   }
2553   {
2554     /* Signalling NaN.  */
2555     static union { unsigned int word[4]; long double value; } x =
2556       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2557     char result[1000];
2558     int retval =
2559       my_sprintf (result, "%La %d", x.value, 33, 44, 55);
2560     ASSERT (strlen (result) >= 3 + 3
2561             && strisnan (result, 0, strlen (result) - 3, 0)
2562             && strcmp (result + strlen (result) - 3, " 33") == 0);
2563     ASSERT (retval == strlen (result));
2564   }
2565   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2566      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2567        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2568        Application Architecture.
2569        Table 5-2 "Floating-Point Register Encodings"
2570        Figure 5-6 "Memory to Floating-Point Register Data Translation"
2571    */
2572   { /* Pseudo-NaN.  */
2573     static union { unsigned int word[4]; long double value; } x =
2574       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2575     char result[1000];
2576     int retval =
2577       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2578     ASSERT (strlen (result) >= 3 + 3
2579             && strisnan (result, 0, strlen (result) - 3, 0)
2580             && strcmp (result + strlen (result) - 3, " 33") == 0);
2581     ASSERT (retval == strlen (result));
2582   }
2583   { /* Pseudo-Infinity.  */
2584     static union { unsigned int word[4]; long double value; } x =
2585       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2586     char result[1000];
2587     int retval =
2588       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2589     ASSERT (strlen (result) >= 3 + 3
2590             && strisnan (result, 0, strlen (result) - 3, 0)
2591             && strcmp (result + strlen (result) - 3, " 33") == 0);
2592     ASSERT (retval == strlen (result));
2593   }
2594   { /* Pseudo-Zero.  */
2595     static union { unsigned int word[4]; long double value; } x =
2596       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2597     char result[1000];
2598     int retval =
2599       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2600     ASSERT (strlen (result) >= 3 + 3
2601             && strisnan (result, 0, strlen (result) - 3, 0)
2602             && strcmp (result + strlen (result) - 3, " 33") == 0);
2603     ASSERT (retval == strlen (result));
2604   }
2605   { /* Unnormalized number.  */
2606     static union { unsigned int word[4]; long double value; } x =
2607       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2608     char result[1000];
2609     int retval =
2610       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2611     ASSERT (strlen (result) >= 3 + 3
2612             && strisnan (result, 0, strlen (result) - 3, 0)
2613             && strcmp (result + strlen (result) - 3, " 33") == 0);
2614     ASSERT (retval == strlen (result));
2615   }
2616   { /* Pseudo-Denormal.  */
2617     static union { unsigned int word[4]; long double value; } x =
2618       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2619     char result[1000];
2620     int retval =
2621       my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2622     ASSERT (strlen (result) >= 3 + 3
2623             && strisnan (result, 0, strlen (result) - 3, 0)
2624             && strcmp (result + strlen (result) - 3, " 33") == 0);
2625     ASSERT (retval == strlen (result));
2626   }
2627 #endif
2628
2629   { /* Width.  */
2630     char result[1000];
2631     int retval =
2632       my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
2633     ASSERT (strcmp (result, "      1.75 33") == 0);
2634     ASSERT (retval == strlen (result));
2635   }
2636
2637   { /* FLAG_LEFT.  */
2638     char result[1000];
2639     int retval =
2640       my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
2641     ASSERT (strcmp (result, "1.75       33") == 0);
2642     ASSERT (retval == strlen (result));
2643   }
2644
2645   { /* FLAG_SHOWSIGN.  */
2646     char result[1000];
2647     int retval =
2648       my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
2649     ASSERT (strcmp (result, "+1.75 33") == 0);
2650     ASSERT (retval == strlen (result));
2651   }
2652
2653   { /* FLAG_SPACE.  */
2654     char result[1000];
2655     int retval =
2656       my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
2657     ASSERT (strcmp (result, " 1.75 33") == 0);
2658     ASSERT (retval == strlen (result));
2659   }
2660
2661   { /* FLAG_ALT.  */
2662     char result[1000];
2663     int retval =
2664       my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
2665     ASSERT (strcmp (result, "1.75000 33") == 0);
2666     ASSERT (retval == strlen (result));
2667   }
2668
2669   { /* FLAG_ALT.  */
2670     char result[1000];
2671     int retval =
2672       my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
2673     ASSERT (strcmp (result, "2. 33") == 0);
2674     ASSERT (retval == strlen (result));
2675   }
2676
2677   { /* FLAG_ALT.  */
2678     char result[1000];
2679     int retval =
2680       my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
2681     ASSERT (strcmp (result, "1.e+01 33") == 0);
2682     ASSERT (retval == strlen (result));
2683   }
2684
2685   { /* FLAG_ZERO with finite number.  */
2686     char result[1000];
2687     int retval =
2688       my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
2689     ASSERT (strcmp (result, "0000001234 33") == 0);
2690     ASSERT (retval == strlen (result));
2691   }
2692
2693   { /* FLAG_ZERO with infinite number.  */
2694     char result[1000];
2695     int retval =
2696       my_sprintf (result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2697     ASSERT (strcmp (result, "           -inf 33") == 0
2698             || strcmp (result, "      -infinity 33") == 0);
2699     ASSERT (retval == strlen (result));
2700   }
2701
2702   { /* FLAG_ZERO with NaN.  */
2703     static long double zero = 0.0L;
2704     char result[1000];
2705     int retval =
2706       my_sprintf (result, "%050Lg %d", zero / zero, 33, 44, 55);
2707     ASSERT (strlen (result) == 50 + 3
2708             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2709             && strcmp (result + strlen (result) - 3, " 33") == 0);
2710     ASSERT (retval == strlen (result));
2711   }
2712
2713   { /* Precision.  */
2714     char result[1000];
2715     int retval =
2716       my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
2717     ASSERT (strcmp (result, "1e+03 33") == 0);
2718     ASSERT (retval == strlen (result));
2719   }
2720
2721   /* Test the support of the %n format directive.  */
2722
2723   {
2724     int count = -1;
2725     char result[1000];
2726     int retval =
2727       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
2728     ASSERT (strcmp (result, "123 ") == 0);
2729     ASSERT (retval == strlen (result));
2730     ASSERT (count == 4);
2731   }
2732
2733   /* Test the support of the POSIX/XSI format strings with positions.  */
2734
2735   {
2736     char result[1000];
2737     int retval =
2738       my_sprintf (result, "%2$d %1$d", 33, 55);
2739     ASSERT (strcmp (result, "55 33") == 0);
2740     ASSERT (retval == strlen (result));
2741   }
2742
2743   /* Test the support of the grouping flag.  */
2744
2745   {
2746     char result[1000];
2747     int retval =
2748       my_sprintf (result, "%'d %d", 1234567, 99);
2749     ASSERT (result[strlen (result) - 1] == '9');
2750     ASSERT (retval == strlen (result));
2751   }
2752
2753   /* Test the support of the left-adjust flag.  */
2754
2755   {
2756     char result[1000];
2757     int retval =
2758       my_sprintf (result, "a%*sc", -3, "b");
2759     ASSERT (strcmp (result, "ab  c") == 0);
2760     ASSERT (retval == strlen (result));
2761   }
2762
2763   {
2764     char result[1000];
2765     int retval =
2766       my_sprintf (result, "a%-*sc", 3, "b");
2767     ASSERT (strcmp (result, "ab  c") == 0);
2768     ASSERT (retval == strlen (result));
2769   }
2770
2771   {
2772     char result[1000];
2773     int retval =
2774       my_sprintf (result, "a%-*sc", -3, "b");
2775     ASSERT (strcmp (result, "ab  c") == 0);
2776     ASSERT (retval == strlen (result));
2777   }
2778
2779   /* Test the support of large precision.  */
2780
2781   {
2782     char result[5000];
2783     int retval =
2784       my_sprintf (result, "%.4000d %d", 1234567, 99);
2785     size_t i;
2786     ASSERT (result != NULL);
2787     for (i = 0; i < 4000 - 7; i++)
2788       ASSERT (result[i] == '0');
2789     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2790     ASSERT (retval == strlen (result));
2791   }
2792
2793   {
2794     char result[5000];
2795     int retval =
2796       my_sprintf (result, "%.4000d %d", -1234567, 99);
2797     size_t i;
2798     ASSERT (result != NULL);
2799     ASSERT (result[0] == '-');
2800     for (i = 0; i < 4000 - 7; i++)
2801       ASSERT (result[1 + i] == '0');
2802     ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
2803     ASSERT (retval == strlen (result));
2804   }
2805
2806   {
2807     char result[5000];
2808     int retval =
2809       my_sprintf (result, "%.4000u %d", 1234567, 99);
2810     size_t i;
2811     ASSERT (result != NULL);
2812     for (i = 0; i < 4000 - 7; i++)
2813       ASSERT (result[i] == '0');
2814     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2815     ASSERT (retval == strlen (result));
2816   }
2817
2818   {
2819     char result[5000];
2820     int retval =
2821       my_sprintf (result, "%.4000o %d", 1234567, 99);
2822     size_t i;
2823     ASSERT (result != NULL);
2824     for (i = 0; i < 4000 - 7; i++)
2825       ASSERT (result[i] == '0');
2826     ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
2827     ASSERT (retval == strlen (result));
2828   }
2829
2830   {
2831     char result[5000];
2832     int retval =
2833       my_sprintf (result, "%.4000x %d", 1234567, 99);
2834     size_t i;
2835     ASSERT (result != NULL);
2836     for (i = 0; i < 4000 - 6; i++)
2837       ASSERT (result[i] == '0');
2838     ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
2839     ASSERT (retval == strlen (result));
2840   }
2841
2842   {
2843     char result[5000];
2844     int retval =
2845       my_sprintf (result, "%#.4000x %d", 1234567, 99);
2846     size_t i;
2847     ASSERT (result != NULL);
2848     ASSERT (result[0] == '0');
2849     ASSERT (result[1] == 'x');
2850     for (i = 0; i < 4000 - 6; i++)
2851       ASSERT (result[2 + i] == '0');
2852     ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
2853     ASSERT (retval == strlen (result));
2854   }
2855
2856   {
2857     char input[5000];
2858     char result[5000];
2859     int retval;
2860     size_t i;
2861
2862     for (i = 0; i < sizeof (input) - 1; i++)
2863       input[i] = 'a' + ((1000000 / (i + 1)) % 26);
2864     input[i] = '\0';
2865     retval = my_sprintf (result, "%.4000s %d", input, 99);
2866     ASSERT (result != NULL);
2867     ASSERT (memcmp (result, input, 4000) == 0);
2868     ASSERT (strcmp (result + 4000, " 99") == 0);
2869     ASSERT (retval == strlen (result));
2870   }
2871 }