tests/test-sprintf-posix.h

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