pintos-os.org Git - pspp/blob - 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     ASSERT (retval == strlen (result));
1284   }
1285
1286   { /* A larger positive number.  */
1287     char result[1000];
1288     int retval =
1289       my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
1290     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1291     ASSERT (retval == strlen (result));
1292   }
1293
1294   { /* Small and large positive numbers.  */
1295     static struct { double value; const char *string; } data[] =
1296       {
1297         { 1.234321234321234e-37, "1.234321e-37" },
1298         { 1.234321234321234e-36, "1.234321e-36" },
1299         { 1.234321234321234e-35, "1.234321e-35" },
1300         { 1.234321234321234e-34, "1.234321e-34" },
1301         { 1.234321234321234e-33, "1.234321e-33" },
1302         { 1.234321234321234e-32, "1.234321e-32" },
1303         { 1.234321234321234e-31, "1.234321e-31" },
1304         { 1.234321234321234e-30, "1.234321e-30" },
1305         { 1.234321234321234e-29, "1.234321e-29" },
1306         { 1.234321234321234e-28, "1.234321e-28" },
1307         { 1.234321234321234e-27, "1.234321e-27" },
1308         { 1.234321234321234e-26, "1.234321e-26" },
1309         { 1.234321234321234e-25, "1.234321e-25" },
1310         { 1.234321234321234e-24, "1.234321e-24" },
1311         { 1.234321234321234e-23, "1.234321e-23" },
1312         { 1.234321234321234e-22, "1.234321e-22" },
1313         { 1.234321234321234e-21, "1.234321e-21" },
1314         { 1.234321234321234e-20, "1.234321e-20" },
1315         { 1.234321234321234e-19, "1.234321e-19" },
1316         { 1.234321234321234e-18, "1.234321e-18" },
1317         { 1.234321234321234e-17, "1.234321e-17" },
1318         { 1.234321234321234e-16, "1.234321e-16" },
1319         { 1.234321234321234e-15, "1.234321e-15" },
1320         { 1.234321234321234e-14, "1.234321e-14" },
1321         { 1.234321234321234e-13, "1.234321e-13" },
1322         { 1.234321234321234e-12, "1.234321e-12" },
1323         { 1.234321234321234e-11, "1.234321e-11" },
1324         { 1.234321234321234e-10, "1.234321e-10" },
1325         { 1.234321234321234e-9, "1.234321e-09" },
1326         { 1.234321234321234e-8, "1.234321e-08" },
1327         { 1.234321234321234e-7, "1.234321e-07" },
1328         { 1.234321234321234e-6, "1.234321e-06" },
1329         { 1.234321234321234e-5, "1.234321e-05" },
1330         { 1.234321234321234e-4, "1.234321e-04" },
1331         { 1.234321234321234e-3, "1.234321e-03" },
1332         { 1.234321234321234e-2, "1.234321e-02" },
1333         { 1.234321234321234e-1, "1.234321e-01" },
1334         { 1.234321234321234, "1.234321e+00" },
1335         { 1.234321234321234e1, "1.234321e+01" },
1336         { 1.234321234321234e2, "1.234321e+02" },
1337         { 1.234321234321234e3, "1.234321e+03" },
1338         { 1.234321234321234e4, "1.234321e+04" },
1339         { 1.234321234321234e5, "1.234321e+05" },
1340         { 1.234321234321234e6, "1.234321e+06" },
1341         { 1.234321234321234e7, "1.234321e+07" },
1342         { 1.234321234321234e8, "1.234321e+08" },
1343         { 1.234321234321234e9, "1.234321e+09" },
1344         { 1.234321234321234e10, "1.234321e+10" },
1345         { 1.234321234321234e11, "1.234321e+11" },
1346         { 1.234321234321234e12, "1.234321e+12" },
1347         { 1.234321234321234e13, "1.234321e+13" },
1348         { 1.234321234321234e14, "1.234321e+14" },
1349         { 1.234321234321234e15, "1.234321e+15" },
1350         { 1.234321234321234e16, "1.234321e+16" },
1351         { 1.234321234321234e17, "1.234321e+17" },
1352         { 1.234321234321234e18, "1.234321e+18" },
1353         { 1.234321234321234e19, "1.234321e+19" },
1354         { 1.234321234321234e20, "1.234321e+20" },
1355         { 1.234321234321234e21, "1.234321e+21" },
1356         { 1.234321234321234e22, "1.234321e+22" },
1357         { 1.234321234321234e23, "1.234321e+23" },
1358         { 1.234321234321234e24, "1.234321e+24" },
1359         { 1.234321234321234e25, "1.234321e+25" },
1360         { 1.234321234321234e26, "1.234321e+26" },
1361         { 1.234321234321234e27, "1.234321e+27" },
1362         { 1.234321234321234e28, "1.234321e+28" },
1363         { 1.234321234321234e29, "1.234321e+29" },
1364         { 1.234321234321234e30, "1.234321e+30" },
1365         { 1.234321234321234e31, "1.234321e+31" },
1366         { 1.234321234321234e32, "1.234321e+32" },
1367         { 1.234321234321234e33, "1.234321e+33" },
1368         { 1.234321234321234e34, "1.234321e+34" },
1369         { 1.234321234321234e35, "1.234321e+35" },
1370         { 1.234321234321234e36, "1.234321e+36" }
1371       };
1372     size_t k;
1373     for (k = 0; k < SIZEOF (data); k++)
1374       {
1375         char result[1000];
1376         int retval =
1377           my_sprintf (result, "%e", data[k].value);
1378         ASSERT (strmatch (data[k].string, result));
1379         ASSERT (retval == strlen (result));
1380       }
1381   }
1382
1383   { /* A negative number.  */
1384     char result[1000];
1385     int retval =
1386       my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
1387     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1388     ASSERT (retval == strlen (result));
1389   }
1390
1391   { /* Positive zero.  */
1392     char result[1000];
1393     int retval =
1394       my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
1395     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1396     ASSERT (retval == strlen (result));
1397   }
1398
1399   { /* Negative zero.  */
1400     char result[1000];
1401     int retval =
1402       my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
1403     ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1404     ASSERT (retval == strlen (result));
1405   }
1406
1407   { /* Positive infinity.  */
1408     char result[1000];
1409     int retval =
1410       my_sprintf (result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1411     ASSERT (strcmp (result, "inf 33") == 0
1412             || strcmp (result, "infinity 33") == 0);
1413     ASSERT (retval == strlen (result));
1414   }
1415
1416   { /* Negative infinity.  */
1417     char result[1000];
1418     int retval =
1419       my_sprintf (result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1420     ASSERT (strcmp (result, "-inf 33") == 0
1421             || strcmp (result, "-infinity 33") == 0);
1422     ASSERT (retval == strlen (result));
1423   }
1424
1425   { /* NaN.  */
1426     char result[1000];
1427     int retval =
1428       my_sprintf (result, "%e %d", NaN (), 33, 44, 55);
1429     ASSERT (strcmp (result, "nan 33") == 0);
1430     ASSERT (retval == strlen (result));
1431   }
1432
1433   { /* Width.  */
1434     char result[1000];
1435     int retval =
1436       my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
1437     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
1438     ASSERT (retval == strlen (result));
1439   }
1440
1441   { /* FLAG_LEFT.  */
1442     char result[1000];
1443     int retval =
1444       my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
1445     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
1446     ASSERT (retval == strlen (result));
1447   }
1448
1449   { /* FLAG_SHOWSIGN.  */
1450     char result[1000];
1451     int retval =
1452       my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
1453     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
1454     ASSERT (retval == strlen (result));
1455   }
1456
1457   { /* FLAG_SPACE.  */
1458     char result[1000];
1459     int retval =
1460       my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
1461     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1462     ASSERT (retval == strlen (result));
1463   }
1464
1465   { /* FLAG_ALT.  */
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     ASSERT (retval == strlen (result));
1471   }
1472
1473   { /* FLAG_ALT.  */
1474     char result[1000];
1475     int retval =
1476       my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
1477     ASSERT (strcmp (result, "2.e+00 33") == 0);
1478     ASSERT (retval == strlen (result));
1479   }
1480
1481   { /* FLAG_ALT.  */
1482     char result[1000];
1483     int retval =
1484       my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
1485     ASSERT (strcmp (result, "1.e+01 33") == 0);
1486     ASSERT (retval == strlen (result));
1487   }
1488
1489   { /* FLAG_ZERO with finite number.  */
1490     char result[1000];
1491     int retval =
1492       my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
1493     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
1494     ASSERT (retval == strlen (result));
1495   }
1496
1497   { /* FLAG_ZERO with infinite number.  */
1498     char result[1000];
1499     int retval =
1500       my_sprintf (result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1501     ASSERT (strcmp (result, "           -inf 33") == 0
1502             || strcmp (result, "      -infinity 33") == 0);
1503     ASSERT (retval == strlen (result));
1504   }
1505
1506   { /* FLAG_ZERO with NaN.  */
1507     char result[1000];
1508     int retval =
1509       my_sprintf (result, "%015e %d", NaN (), 33, 44, 55);
1510     ASSERT (strcmp (result, "            nan 33") == 0);
1511     ASSERT (retval == strlen (result));
1512   }
1513
1514   { /* Precision.  */
1515     char result[1000];
1516     int retval =
1517       my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
1518     ASSERT (strcmp (result, "1e+03 33") == 0);
1519     ASSERT (retval == strlen (result));
1520   }
1521
1522   { /* A positive number.  */
1523     char result[1000];
1524     int retval =
1525       my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
1526     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1527     ASSERT (retval == strlen (result));
1528   }
1529
1530   { /* A larger positive number.  */
1531     char result[1000];
1532     int retval =
1533       my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
1534     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1535     ASSERT (retval == strlen (result));
1536   }
1537
1538   { /* Small and large positive numbers.  */
1539     static struct { long double value; const char *string; } data[] =
1540       {
1541         { 1.234321234321234e-37L, "1.234321e-37" },
1542         { 1.234321234321234e-36L, "1.234321e-36" },
1543         { 1.234321234321234e-35L, "1.234321e-35" },
1544         { 1.234321234321234e-34L, "1.234321e-34" },
1545         { 1.234321234321234e-33L, "1.234321e-33" },
1546         { 1.234321234321234e-32L, "1.234321e-32" },
1547         { 1.234321234321234e-31L, "1.234321e-31" },
1548         { 1.234321234321234e-30L, "1.234321e-30" },
1549         { 1.234321234321234e-29L, "1.234321e-29" },
1550         { 1.234321234321234e-28L, "1.234321e-28" },
1551         { 1.234321234321234e-27L, "1.234321e-27" },
1552         { 1.234321234321234e-26L, "1.234321e-26" },
1553         { 1.234321234321234e-25L, "1.234321e-25" },
1554         { 1.234321234321234e-24L, "1.234321e-24" },
1555         { 1.234321234321234e-23L, "1.234321e-23" },
1556         { 1.234321234321234e-22L, "1.234321e-22" },
1557         { 1.234321234321234e-21L, "1.234321e-21" },
1558         { 1.234321234321234e-20L, "1.234321e-20" },
1559         { 1.234321234321234e-19L, "1.234321e-19" },
1560         { 1.234321234321234e-18L, "1.234321e-18" },
1561         { 1.234321234321234e-17L, "1.234321e-17" },
1562         { 1.234321234321234e-16L, "1.234321e-16" },
1563         { 1.234321234321234e-15L, "1.234321e-15" },
1564         { 1.234321234321234e-14L, "1.234321e-14" },
1565         { 1.234321234321234e-13L, "1.234321e-13" },
1566         { 1.234321234321234e-12L, "1.234321e-12" },
1567         { 1.234321234321234e-11L, "1.234321e-11" },
1568         { 1.234321234321234e-10L, "1.234321e-10" },
1569         { 1.234321234321234e-9L, "1.234321e-09" },
1570         { 1.234321234321234e-8L, "1.234321e-08" },
1571         { 1.234321234321234e-7L, "1.234321e-07" },
1572         { 1.234321234321234e-6L, "1.234321e-06" },
1573         { 1.234321234321234e-5L, "1.234321e-05" },
1574         { 1.234321234321234e-4L, "1.234321e-04" },
1575         { 1.234321234321234e-3L, "1.234321e-03" },
1576         { 1.234321234321234e-2L, "1.234321e-02" },
1577         { 1.234321234321234e-1L, "1.234321e-01" },
1578         { 1.234321234321234L, "1.234321e+00" },
1579         { 1.234321234321234e1L, "1.234321e+01" },
1580         { 1.234321234321234e2L, "1.234321e+02" },
1581         { 1.234321234321234e3L, "1.234321e+03" },
1582         { 1.234321234321234e4L, "1.234321e+04" },
1583         { 1.234321234321234e5L, "1.234321e+05" },
1584         { 1.234321234321234e6L, "1.234321e+06" },
1585         { 1.234321234321234e7L, "1.234321e+07" },
1586         { 1.234321234321234e8L, "1.234321e+08" },
1587         { 1.234321234321234e9L, "1.234321e+09" },
1588         { 1.234321234321234e10L, "1.234321e+10" },
1589         { 1.234321234321234e11L, "1.234321e+11" },
1590         { 1.234321234321234e12L, "1.234321e+12" },
1591         { 1.234321234321234e13L, "1.234321e+13" },
1592         { 1.234321234321234e14L, "1.234321e+14" },
1593         { 1.234321234321234e15L, "1.234321e+15" },
1594         { 1.234321234321234e16L, "1.234321e+16" },
1595         { 1.234321234321234e17L, "1.234321e+17" },
1596         { 1.234321234321234e18L, "1.234321e+18" },
1597         { 1.234321234321234e19L, "1.234321e+19" },
1598         { 1.234321234321234e20L, "1.234321e+20" },
1599         { 1.234321234321234e21L, "1.234321e+21" },
1600         { 1.234321234321234e22L, "1.234321e+22" },
1601         { 1.234321234321234e23L, "1.234321e+23" },
1602         { 1.234321234321234e24L, "1.234321e+24" },
1603         { 1.234321234321234e25L, "1.234321e+25" },
1604         { 1.234321234321234e26L, "1.234321e+26" },
1605         { 1.234321234321234e27L, "1.234321e+27" },
1606         { 1.234321234321234e28L, "1.234321e+28" },
1607         { 1.234321234321234e29L, "1.234321e+29" },
1608         { 1.234321234321234e30L, "1.234321e+30" },
1609         { 1.234321234321234e31L, "1.234321e+31" },
1610         { 1.234321234321234e32L, "1.234321e+32" },
1611         { 1.234321234321234e33L, "1.234321e+33" },
1612         { 1.234321234321234e34L, "1.234321e+34" },
1613         { 1.234321234321234e35L, "1.234321e+35" },
1614         { 1.234321234321234e36L, "1.234321e+36" }
1615       };
1616     size_t k;
1617     for (k = 0; k < SIZEOF (data); k++)
1618       {
1619         char result[1000];
1620         int retval =
1621           my_sprintf (result, "%Le", data[k].value);
1622         ASSERT (strmatch (data[k].string, result));
1623         ASSERT (retval == strlen (result));
1624       }
1625   }
1626
1627   { /* A negative number.  */
1628     char result[1000];
1629     int retval =
1630       my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
1631     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1632     ASSERT (retval == strlen (result));
1633   }
1634
1635   { /* Positive zero.  */
1636     char result[1000];
1637     int retval =
1638       my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
1639     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1640     ASSERT (retval == strlen (result));
1641   }
1642
1643   { /* Negative zero.  */
1644     char result[1000];
1645     int retval =
1646       my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
1647     ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1648     ASSERT (retval == strlen (result));
1649   }
1650
1651   { /* Positive infinity.  */
1652     char result[1000];
1653     int retval =
1654       my_sprintf (result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1655     ASSERT (strcmp (result, "inf 33") == 0
1656             || strcmp (result, "infinity 33") == 0);
1657     ASSERT (retval == strlen (result));
1658   }
1659
1660   { /* Negative infinity.  */
1661     char result[1000];
1662     int retval =
1663       my_sprintf (result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1664     ASSERT (strcmp (result, "-inf 33") == 0
1665             || strcmp (result, "-infinity 33") == 0);
1666     ASSERT (retval == strlen (result));
1667   }
1668
1669   { /* NaN.  */
1670     static long double zero = 0.0L;
1671     char result[1000];
1672     int retval =
1673       my_sprintf (result, "%Le %d", zero / zero, 33, 44, 55);
1674     ASSERT (strcmp (result, "nan 33") == 0);
1675     ASSERT (retval == strlen (result));
1676   }
1677
1678   { /* Width.  */
1679     char result[1000];
1680     int retval =
1681       my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
1682     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
1683     ASSERT (retval == strlen (result));
1684   }
1685
1686   { /* FLAG_LEFT.  */
1687     char result[1000];
1688     int retval =
1689       my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
1690     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
1691     ASSERT (retval == strlen (result));
1692   }
1693
1694   { /* FLAG_SHOWSIGN.  */
1695     char result[1000];
1696     int retval =
1697       my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
1698     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
1699     ASSERT (retval == strlen (result));
1700   }
1701
1702   { /* FLAG_SPACE.  */
1703     char result[1000];
1704     int retval =
1705       my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
1706     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1707     ASSERT (retval == strlen (result));
1708   }
1709
1710   { /* FLAG_ALT.  */
1711     char result[1000];
1712     int retval =
1713       my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
1714     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1715     ASSERT (retval == strlen (result));
1716   }
1717
1718   { /* FLAG_ALT.  */
1719     char result[1000];
1720     int retval =
1721       my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
1722     ASSERT (strcmp (result, "2.e+00 33") == 0);
1723     ASSERT (retval == strlen (result));
1724   }
1725
1726   { /* FLAG_ALT.  */
1727     char result[1000];
1728     int retval =
1729       my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
1730     ASSERT (strcmp (result, "1.e+01 33") == 0);
1731     ASSERT (retval == strlen (result));
1732   }
1733
1734   { /* FLAG_ZERO with finite number.  */
1735     char result[1000];
1736     int retval =
1737       my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
1738     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
1739     ASSERT (retval == strlen (result));
1740   }
1741
1742   { /* FLAG_ZERO with infinite number.  */
1743     char result[1000];
1744     int retval =
1745       my_sprintf (result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
1746     ASSERT (strcmp (result, "           -inf 33") == 0
1747             || strcmp (result, "      -infinity 33") == 0);
1748     ASSERT (retval == strlen (result));
1749   }
1750
1751   { /* FLAG_ZERO with NaN.  */
1752     static long double zero = 0.0L;
1753     char result[1000];
1754     int retval =
1755       my_sprintf (result, "%015Le %d", zero / zero, 33, 44, 55);
1756     ASSERT (strcmp (result, "            nan 33") == 0);
1757     ASSERT (retval == strlen (result));
1758   }
1759
1760   { /* Precision.  */
1761     char result[1000];
1762     int retval =
1763       my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
1764     ASSERT (strcmp (result, "1e+03 33") == 0);
1765     ASSERT (retval == strlen (result));
1766   }
1767
1768   /* Test the support of the %g format directive.  */
1769
1770   { /* A positive number.  */
1771     char result[1000];
1772     int retval =
1773       my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
1774     ASSERT (strcmp (result, "12.75 33") == 0);
1775     ASSERT (retval == strlen (result));
1776   }
1777
1778   { /* A larger positive number.  */
1779     char result[1000];
1780     int retval =
1781       my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
1782     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
1783     ASSERT (retval == strlen (result));
1784   }
1785
1786   { /* Small and large positive numbers.  */
1787     static struct { double value; const char *string; } data[] =
1788       {
1789         { 1.234321234321234e-37, "1.23432e-37" },
1790         { 1.234321234321234e-36, "1.23432e-36" },
1791         { 1.234321234321234e-35, "1.23432e-35" },
1792         { 1.234321234321234e-34, "1.23432e-34" },
1793         { 1.234321234321234e-33, "1.23432e-33" },
1794         { 1.234321234321234e-32, "1.23432e-32" },
1795         { 1.234321234321234e-31, "1.23432e-31" },
1796         { 1.234321234321234e-30, "1.23432e-30" },
1797         { 1.234321234321234e-29, "1.23432e-29" },
1798         { 1.234321234321234e-28, "1.23432e-28" },
1799         { 1.234321234321234e-27, "1.23432e-27" },
1800         { 1.234321234321234e-26, "1.23432e-26" },
1801         { 1.234321234321234e-25, "1.23432e-25" },
1802         { 1.234321234321234e-24, "1.23432e-24" },
1803         { 1.234321234321234e-23, "1.23432e-23" },
1804         { 1.234321234321234e-22, "1.23432e-22" },
1805         { 1.234321234321234e-21, "1.23432e-21" },
1806         { 1.234321234321234e-20, "1.23432e-20" },
1807         { 1.234321234321234e-19, "1.23432e-19" },
1808         { 1.234321234321234e-18, "1.23432e-18" },
1809         { 1.234321234321234e-17, "1.23432e-17" },
1810         { 1.234321234321234e-16, "1.23432e-16" },
1811         { 1.234321234321234e-15, "1.23432e-15" },
1812         { 1.234321234321234e-14, "1.23432e-14" },
1813         { 1.234321234321234e-13, "1.23432e-13" },
1814         { 1.234321234321234e-12, "1.23432e-12" },
1815         { 1.234321234321234e-11, "1.23432e-11" },
1816         { 1.234321234321234e-10, "1.23432e-10" },
1817         { 1.234321234321234e-9, "1.23432e-09" },
1818         { 1.234321234321234e-8, "1.23432e-08" },
1819         { 1.234321234321234e-7, "1.23432e-07" },
1820         { 1.234321234321234e-6, "1.23432e-06" },
1821         { 1.234321234321234e-5, "1.23432e-05" },
1822         { 1.234321234321234e-4, "0.000123432" },
1823         { 1.234321234321234e-3, "0.00123432" },
1824         { 1.234321234321234e-2, "0.0123432" },
1825         { 1.234321234321234e-1, "0.123432" },
1826         { 1.234321234321234, "1.23432" },
1827         { 1.234321234321234e1, "12.3432" },
1828         { 1.234321234321234e2, "123.432" },
1829         { 1.234321234321234e3, "1234.32" },
1830         { 1.234321234321234e4, "12343.2" },
1831         { 1.234321234321234e5, "123432" },
1832         { 1.234321234321234e6, "1.23432e+06" },
1833         { 1.234321234321234e7, "1.23432e+07" },
1834         { 1.234321234321234e8, "1.23432e+08" },
1835         { 1.234321234321234e9, "1.23432e+09" },
1836         { 1.234321234321234e10, "1.23432e+10" },
1837         { 1.234321234321234e11, "1.23432e+11" },
1838         { 1.234321234321234e12, "1.23432e+12" },
1839         { 1.234321234321234e13, "1.23432e+13" },
1840         { 1.234321234321234e14, "1.23432e+14" },
1841         { 1.234321234321234e15, "1.23432e+15" },
1842         { 1.234321234321234e16, "1.23432e+16" },
1843         { 1.234321234321234e17, "1.23432e+17" },
1844         { 1.234321234321234e18, "1.23432e+18" },
1845         { 1.234321234321234e19, "1.23432e+19" },
1846         { 1.234321234321234e20, "1.23432e+20" },
1847         { 1.234321234321234e21, "1.23432e+21" },
1848         { 1.234321234321234e22, "1.23432e+22" },
1849         { 1.234321234321234e23, "1.23432e+23" },
1850         { 1.234321234321234e24, "1.23432e+24" },
1851         { 1.234321234321234e25, "1.23432e+25" },
1852         { 1.234321234321234e26, "1.23432e+26" },
1853         { 1.234321234321234e27, "1.23432e+27" },
1854         { 1.234321234321234e28, "1.23432e+28" },
1855         { 1.234321234321234e29, "1.23432e+29" },
1856         { 1.234321234321234e30, "1.23432e+30" },
1857         { 1.234321234321234e31, "1.23432e+31" },
1858         { 1.234321234321234e32, "1.23432e+32" },
1859         { 1.234321234321234e33, "1.23432e+33" },
1860         { 1.234321234321234e34, "1.23432e+34" },
1861         { 1.234321234321234e35, "1.23432e+35" },
1862         { 1.234321234321234e36, "1.23432e+36" }
1863       };
1864     size_t k;
1865     for (k = 0; k < SIZEOF (data); k++)
1866       {
1867         char result[1000];
1868         int retval =
1869           my_sprintf (result, "%g", data[k].value);
1870         ASSERT (strmatch (data[k].string, result));
1871         ASSERT (retval == strlen (result));
1872       }
1873   }
1874
1875   { /* A negative number.  */
1876     char result[1000];
1877     int retval =
1878       my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
1879     ASSERT (strcmp (result, "-0.03125 33") == 0);
1880     ASSERT (retval == strlen (result));
1881   }
1882
1883   { /* Positive zero.  */
1884     char result[1000];
1885     int retval =
1886       my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
1887     ASSERT (strcmp (result, "0 33") == 0);
1888     ASSERT (retval == strlen (result));
1889   }
1890
1891   { /* Negative zero.  */
1892     char result[1000];
1893     int retval =
1894       my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
1895     ASSERT (strcmp (result, "-0 33") == 0);
1896     ASSERT (retval == strlen (result));
1897   }
1898
1899   { /* Positive infinity.  */
1900     char result[1000];
1901     int retval =
1902       my_sprintf (result, "%g %d", 1.0 / 0.0, 33, 44, 55);
1903     ASSERT (strcmp (result, "inf 33") == 0
1904             || strcmp (result, "infinity 33") == 0);
1905     ASSERT (retval == strlen (result));
1906   }
1907
1908   { /* Negative infinity.  */
1909     char result[1000];
1910     int retval =
1911       my_sprintf (result, "%g %d", -1.0 / 0.0, 33, 44, 55);
1912     ASSERT (strcmp (result, "-inf 33") == 0
1913             || strcmp (result, "-infinity 33") == 0);
1914     ASSERT (retval == strlen (result));
1915   }
1916
1917   { /* NaN.  */
1918     char result[1000];
1919     int retval =
1920       my_sprintf (result, "%g %d", NaN (), 33, 44, 55);
1921     ASSERT (strcmp (result, "nan 33") == 0);
1922     ASSERT (retval == strlen (result));
1923   }
1924
1925   { /* Width.  */
1926     char result[1000];
1927     int retval =
1928       my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
1929     ASSERT (strcmp (result, "      1.75 33") == 0);
1930     ASSERT (retval == strlen (result));
1931   }
1932
1933   { /* FLAG_LEFT.  */
1934     char result[1000];
1935     int retval =
1936       my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
1937     ASSERT (strcmp (result, "1.75       33") == 0);
1938     ASSERT (retval == strlen (result));
1939   }
1940
1941   { /* FLAG_SHOWSIGN.  */
1942     char result[1000];
1943     int retval =
1944       my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
1945     ASSERT (strcmp (result, "+1.75 33") == 0);
1946     ASSERT (retval == strlen (result));
1947   }
1948
1949   { /* FLAG_SPACE.  */
1950     char result[1000];
1951     int retval =
1952       my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
1953     ASSERT (strcmp (result, " 1.75 33") == 0);
1954     ASSERT (retval == strlen (result));
1955   }
1956
1957   { /* FLAG_ALT.  */
1958     char result[1000];
1959     int retval =
1960       my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
1961     ASSERT (strcmp (result, "1.75000 33") == 0);
1962     ASSERT (retval == strlen (result));
1963   }
1964
1965   { /* FLAG_ALT.  */
1966     char result[1000];
1967     int retval =
1968       my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
1969     ASSERT (strcmp (result, "2. 33") == 0);
1970     ASSERT (retval == strlen (result));
1971   }
1972
1973   { /* FLAG_ALT.  */
1974     char result[1000];
1975     int retval =
1976       my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
1977     ASSERT (strcmp (result, "1.e+01 33") == 0);
1978     ASSERT (retval == strlen (result));
1979   }
1980
1981   { /* FLAG_ZERO with finite number.  */
1982     char result[1000];
1983     int retval =
1984       my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
1985     ASSERT (strcmp (result, "0000001234 33") == 0);
1986     ASSERT (retval == strlen (result));
1987   }
1988
1989   { /* FLAG_ZERO with infinite number.  */
1990     char result[1000];
1991     int retval =
1992       my_sprintf (result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
1993     ASSERT (strcmp (result, "           -inf 33") == 0
1994             || strcmp (result, "      -infinity 33") == 0);
1995     ASSERT (retval == strlen (result));
1996   }
1997
1998   { /* FLAG_ZERO with NaN.  */
1999     char result[1000];
2000     int retval =
2001       my_sprintf (result, "%015g %d", NaN (), 33, 44, 55);
2002     ASSERT (strcmp (result, "            nan 33") == 0);
2003     ASSERT (retval == strlen (result));
2004   }
2005
2006   { /* Precision.  */
2007     char result[1000];
2008     int retval =
2009       my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
2010     ASSERT (strcmp (result, "1e+03 33") == 0);
2011     ASSERT (retval == strlen (result));
2012   }
2013
2014   { /* A positive number.  */
2015     char result[1000];
2016     int retval =
2017       my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
2018     ASSERT (strcmp (result, "12.75 33") == 0);
2019     ASSERT (retval == strlen (result));
2020   }
2021
2022   { /* A larger positive number.  */
2023     char result[1000];
2024     int retval =
2025       my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
2026     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2027     ASSERT (retval == strlen (result));
2028   }
2029
2030   { /* Small and large positive numbers.  */
2031     static struct { long double value; const char *string; } data[] =
2032       {
2033         { 1.234321234321234e-37L, "1.23432e-37" },
2034         { 1.234321234321234e-36L, "1.23432e-36" },
2035         { 1.234321234321234e-35L, "1.23432e-35" },
2036         { 1.234321234321234e-34L, "1.23432e-34" },
2037         { 1.234321234321234e-33L, "1.23432e-33" },
2038         { 1.234321234321234e-32L, "1.23432e-32" },
2039         { 1.234321234321234e-31L, "1.23432e-31" },
2040         { 1.234321234321234e-30L, "1.23432e-30" },
2041         { 1.234321234321234e-29L, "1.23432e-29" },
2042         { 1.234321234321234e-28L, "1.23432e-28" },
2043         { 1.234321234321234e-27L, "1.23432e-27" },
2044         { 1.234321234321234e-26L, "1.23432e-26" },
2045         { 1.234321234321234e-25L, "1.23432e-25" },
2046         { 1.234321234321234e-24L, "1.23432e-24" },
2047         { 1.234321234321234e-23L, "1.23432e-23" },
2048         { 1.234321234321234e-22L, "1.23432e-22" },
2049         { 1.234321234321234e-21L, "1.23432e-21" },
2050         { 1.234321234321234e-20L, "1.23432e-20" },
2051         { 1.234321234321234e-19L, "1.23432e-19" },
2052         { 1.234321234321234e-18L, "1.23432e-18" },
2053         { 1.234321234321234e-17L, "1.23432e-17" },
2054         { 1.234321234321234e-16L, "1.23432e-16" },
2055         { 1.234321234321234e-15L, "1.23432e-15" },
2056         { 1.234321234321234e-14L, "1.23432e-14" },
2057         { 1.234321234321234e-13L, "1.23432e-13" },
2058         { 1.234321234321234e-12L, "1.23432e-12" },
2059         { 1.234321234321234e-11L, "1.23432e-11" },
2060         { 1.234321234321234e-10L, "1.23432e-10" },
2061         { 1.234321234321234e-9L, "1.23432e-09" },
2062         { 1.234321234321234e-8L, "1.23432e-08" },
2063         { 1.234321234321234e-7L, "1.23432e-07" },
2064         { 1.234321234321234e-6L, "1.23432e-06" },
2065         { 1.234321234321234e-5L, "1.23432e-05" },
2066         { 1.234321234321234e-4L, "0.000123432" },
2067         { 1.234321234321234e-3L, "0.00123432" },
2068         { 1.234321234321234e-2L, "0.0123432" },
2069         { 1.234321234321234e-1L, "0.123432" },
2070         { 1.234321234321234L, "1.23432" },
2071         { 1.234321234321234e1L, "12.3432" },
2072         { 1.234321234321234e2L, "123.432" },
2073         { 1.234321234321234e3L, "1234.32" },
2074         { 1.234321234321234e4L, "12343.2" },
2075         { 1.234321234321234e5L, "123432" },
2076         { 1.234321234321234e6L, "1.23432e+06" },
2077         { 1.234321234321234e7L, "1.23432e+07" },
2078         { 1.234321234321234e8L, "1.23432e+08" },
2079         { 1.234321234321234e9L, "1.23432e+09" },
2080         { 1.234321234321234e10L, "1.23432e+10" },
2081         { 1.234321234321234e11L, "1.23432e+11" },
2082         { 1.234321234321234e12L, "1.23432e+12" },
2083         { 1.234321234321234e13L, "1.23432e+13" },
2084         { 1.234321234321234e14L, "1.23432e+14" },
2085         { 1.234321234321234e15L, "1.23432e+15" },
2086         { 1.234321234321234e16L, "1.23432e+16" },
2087         { 1.234321234321234e17L, "1.23432e+17" },
2088         { 1.234321234321234e18L, "1.23432e+18" },
2089         { 1.234321234321234e19L, "1.23432e+19" },
2090         { 1.234321234321234e20L, "1.23432e+20" },
2091         { 1.234321234321234e21L, "1.23432e+21" },
2092         { 1.234321234321234e22L, "1.23432e+22" },
2093         { 1.234321234321234e23L, "1.23432e+23" },
2094         { 1.234321234321234e24L, "1.23432e+24" },
2095         { 1.234321234321234e25L, "1.23432e+25" },
2096         { 1.234321234321234e26L, "1.23432e+26" },
2097         { 1.234321234321234e27L, "1.23432e+27" },
2098         { 1.234321234321234e28L, "1.23432e+28" },
2099         { 1.234321234321234e29L, "1.23432e+29" },
2100         { 1.234321234321234e30L, "1.23432e+30" },
2101         { 1.234321234321234e31L, "1.23432e+31" },
2102         { 1.234321234321234e32L, "1.23432e+32" },
2103         { 1.234321234321234e33L, "1.23432e+33" },
2104         { 1.234321234321234e34L, "1.23432e+34" },
2105         { 1.234321234321234e35L, "1.23432e+35" },
2106         { 1.234321234321234e36L, "1.23432e+36" }
2107       };
2108     size_t k;
2109     for (k = 0; k < SIZEOF (data); k++)
2110       {
2111         char result[1000];
2112         int retval =
2113           my_sprintf (result, "%Lg", data[k].value);
2114         ASSERT (strmatch (data[k].string, result));
2115         ASSERT (retval == strlen (result));
2116       }
2117   }
2118
2119   { /* A negative number.  */
2120     char result[1000];
2121     int retval =
2122       my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
2123     ASSERT (strcmp (result, "-0.03125 33") == 0);
2124     ASSERT (retval == strlen (result));
2125   }
2126
2127   { /* Positive zero.  */
2128     char result[1000];
2129     int retval =
2130       my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
2131     ASSERT (strcmp (result, "0 33") == 0);
2132     ASSERT (retval == strlen (result));
2133   }
2134
2135   { /* Negative zero.  */
2136     char result[1000];
2137     int retval =
2138       my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
2139     ASSERT (strcmp (result, "-0 33") == 0);
2140     ASSERT (retval == strlen (result));
2141   }
2142
2143   { /* Positive infinity.  */
2144     char result[1000];
2145     int retval =
2146       my_sprintf (result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2147     ASSERT (strcmp (result, "inf 33") == 0
2148             || strcmp (result, "infinity 33") == 0);
2149     ASSERT (retval == strlen (result));
2150   }
2151
2152   { /* Negative infinity.  */
2153     char result[1000];
2154     int retval =
2155       my_sprintf (result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2156     ASSERT (strcmp (result, "-inf 33") == 0
2157             || strcmp (result, "-infinity 33") == 0);
2158     ASSERT (retval == strlen (result));
2159   }
2160
2161   { /* NaN.  */
2162     static long double zero = 0.0L;
2163     char result[1000];
2164     int retval =
2165       my_sprintf (result, "%Lg %d", zero / zero, 33, 44, 55);
2166     ASSERT (strcmp (result, "nan 33") == 0);
2167     ASSERT (retval == strlen (result));
2168   }
2169
2170   { /* Width.  */
2171     char result[1000];
2172     int retval =
2173       my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
2174     ASSERT (strcmp (result, "      1.75 33") == 0);
2175     ASSERT (retval == strlen (result));
2176   }
2177
2178   { /* FLAG_LEFT.  */
2179     char result[1000];
2180     int retval =
2181       my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
2182     ASSERT (strcmp (result, "1.75       33") == 0);
2183     ASSERT (retval == strlen (result));
2184   }
2185
2186   { /* FLAG_SHOWSIGN.  */
2187     char result[1000];
2188     int retval =
2189       my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
2190     ASSERT (strcmp (result, "+1.75 33") == 0);
2191     ASSERT (retval == strlen (result));
2192   }
2193
2194   { /* FLAG_SPACE.  */
2195     char result[1000];
2196     int retval =
2197       my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
2198     ASSERT (strcmp (result, " 1.75 33") == 0);
2199     ASSERT (retval == strlen (result));
2200   }
2201
2202   { /* FLAG_ALT.  */
2203     char result[1000];
2204     int retval =
2205       my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
2206     ASSERT (strcmp (result, "1.75000 33") == 0);
2207     ASSERT (retval == strlen (result));
2208   }
2209
2210   { /* FLAG_ALT.  */
2211     char result[1000];
2212     int retval =
2213       my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
2214     ASSERT (strcmp (result, "2. 33") == 0);
2215     ASSERT (retval == strlen (result));
2216   }
2217
2218   { /* FLAG_ALT.  */
2219     char result[1000];
2220     int retval =
2221       my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
2222     ASSERT (strcmp (result, "1.e+01 33") == 0);
2223     ASSERT (retval == strlen (result));
2224   }
2225
2226   { /* FLAG_ZERO with finite number.  */
2227     char result[1000];
2228     int retval =
2229       my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
2230     ASSERT (strcmp (result, "0000001234 33") == 0);
2231     ASSERT (retval == strlen (result));
2232   }
2233
2234   { /* FLAG_ZERO with infinite number.  */
2235     char result[1000];
2236     int retval =
2237       my_sprintf (result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2238     ASSERT (strcmp (result, "           -inf 33") == 0
2239             || strcmp (result, "      -infinity 33") == 0);
2240     ASSERT (retval == strlen (result));
2241   }
2242
2243   { /* FLAG_ZERO with NaN.  */
2244     static long double zero = 0.0L;
2245     char result[1000];
2246     int retval =
2247       my_sprintf (result, "%015Lg %d", zero / zero, 33, 44, 55);
2248     ASSERT (strcmp (result, "            nan 33") == 0);
2249     ASSERT (retval == strlen (result));
2250   }
2251
2252   { /* Precision.  */
2253     char result[1000];
2254     int retval =
2255       my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
2256     ASSERT (strcmp (result, "1e+03 33") == 0);
2257     ASSERT (retval == strlen (result));
2258   }
2259
2260   /* Test the support of the %n format directive.  */
2261
2262   {
2263     int count = -1;
2264     char result[1000];
2265     int retval =
2266       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
2267     ASSERT (strcmp (result, "123 ") == 0);
2268     ASSERT (retval == strlen (result));
2269     ASSERT (count == 4);
2270   }
2271
2272   /* Test the support of the POSIX/XSI format strings with positions.  */
2273
2274   {
2275     char result[1000];
2276     int retval =
2277       my_sprintf (result, "%2$d %1$d", 33, 55);
2278     ASSERT (strcmp (result, "55 33") == 0);
2279     ASSERT (retval == strlen (result));
2280   }
2281
2282   /* Test the support of the grouping flag.  */
2283
2284   {
2285     char result[1000];
2286     int retval =
2287       my_sprintf (result, "%'d %d", 1234567, 99);
2288     ASSERT (result[strlen (result) - 1] == '9');
2289     ASSERT (retval == strlen (result));
2290   }
2291 }