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