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