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 %n format directive.  */
1277
1278   {
1279     int count = -1;
1280     char result[1000];
1281     int retval =
1282       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
1283     ASSERT (strcmp (result, "123 ") == 0);
1284     ASSERT (retval == strlen (result));
1285     ASSERT (count == 4);
1286   }
1287
1288   /* Test the support of the POSIX/XSI format strings with positions.  */
1289
1290   {
1291     char result[1000];
1292     int retval =
1293       my_sprintf (result, "%2$d %1$d", 33, 55);
1294     ASSERT (strcmp (result, "55 33") == 0);
1295     ASSERT (retval == strlen (result));
1296   }
1297
1298   /* Test the support of the grouping flag.  */
1299
1300   {
1301     char result[1000];
1302     int retval =
1303       my_sprintf (result, "%'d %d", 1234567, 99);
1304     ASSERT (result[strlen (result) - 1] == '9');
1305     ASSERT (retval == strlen (result));
1306   }
1307 }