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 void
  33 test_function (int (*my_sprintf) (char *, const char *, ...))
  34 {
  35   char buf[8];
  36
  37   /* Test return value convention.  */
  38
  39   {
  40     int retval;
  41
  42     memcpy (buf, "DEADBEEF", 8);
  43     retval = my_sprintf (buf, "%d", 12345);
  44     ASSERT (retval == 5);
  45     ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
  46   }
  47
  48   /* Test support of size specifiers as in C99.  */
  49
  50   {
  51     char result[1000];
  52     int retval =
  53       my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  54     ASSERT (strcmp (result, "12345671 33") == 0);
  55     ASSERT (retval == strlen (result));
  56   }
  57
  58   {
  59     char result[1000];
  60     int retval =
  61       my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
  62     ASSERT (strcmp (result, "12345672 33") == 0);
  63     ASSERT (retval == strlen (result));
  64   }
  65
  66   {
  67     char result[1000];
  68     int retval =
  69       my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
  70     ASSERT (strcmp (result, "12345673 33") == 0);
  71     ASSERT (retval == strlen (result));
  72   }
  73
  74   {
  75     char result[1000];
  76     int retval =
  77       my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
  78     ASSERT (strcmp (result, "1.5 33") == 0);
  79     ASSERT (retval == strlen (result));
  80   }
  81
  82   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
  83      output of floating-point numbers.  */
  84
  85   { /* A positive number.  */
  86     char result[1000];
  87     int retval =
  88       my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
  89     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
  90             || strcmp (result, "0x3.244p+0 33") == 0
  91             || strcmp (result, "0x6.488p-1 33") == 0
  92             || strcmp (result, "0xc.91p-2 33") == 0);
  93     ASSERT (retval == strlen (result));
  94   }
  95
  96   { /* A negative 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   { /* Positive zero.  */
 108     char result[1000];
 109     int retval =
 110       my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
 111     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 112     ASSERT (retval == strlen (result));
 113   }
 114
 115   { /* Negative zero.  */
 116     char result[1000];
 117     int retval =
 118       my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
 119     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 120     ASSERT (retval == strlen (result));
 121   }
 122
 123   { /* Positive infinity.  */
 124     char result[1000];
 125     int retval =
 126       my_sprintf (result, "%a %d", 1.0 / 0.0, 33, 44, 55);
 127     ASSERT (strcmp (result, "inf 33") == 0);
 128     ASSERT (retval == strlen (result));
 129   }
 130
 131   { /* Negative infinity.  */
 132     char result[1000];
 133     int retval =
 134       my_sprintf (result, "%a %d", -1.0 / 0.0, 33, 44, 55);
 135     ASSERT (strcmp (result, "-inf 33") == 0);
 136     ASSERT (retval == strlen (result));
 137   }
 138
 139   { /* NaN.  */
 140     char result[1000];
 141     int retval =
 142       my_sprintf (result, "%a %d", NaN (), 33, 44, 55);
 143     ASSERT (strcmp (result, "nan 33") == 0);
 144     ASSERT (retval == strlen (result));
 145   }
 146
 147   { /* Rounding near the decimal point.  */
 148     char result[1000];
 149     int retval =
 150       my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
 151     ASSERT (strcmp (result, "0x2p+0 33") == 0
 152             || strcmp (result, "0x3p-1 33") == 0
 153             || strcmp (result, "0x6p-2 33") == 0
 154             || strcmp (result, "0xcp-3 33") == 0);
 155     ASSERT (retval == strlen (result));
 156   }
 157
 158   { /* Rounding with precision 0.  */
 159     char result[1000];
 160     int retval =
 161       my_sprintf (result, "%.0a %d", 1.51, 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 1.  */
 170     char result[1000];
 171     int retval =
 172       my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
 173     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 174             || strcmp (result, "0x3.0p-1 33") == 0
 175             || strcmp (result, "0x6.1p-2 33") == 0
 176             || strcmp (result, "0xc.1p-3 33") == 0);
 177     ASSERT (retval == strlen (result));
 178   }
 179
 180   { /* Rounding with precision 2.  */
 181     char result[1000];
 182     int retval =
 183       my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
 184     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 185             || strcmp (result, "0x3.05p-1 33") == 0
 186             || strcmp (result, "0x6.0ap-2 33") == 0
 187             || strcmp (result, "0xc.14p-3 33") == 0);
 188     ASSERT (retval == strlen (result));
 189   }
 190
 191   { /* Rounding with precision 3.  */
 192     char result[1000];
 193     int retval =
 194       my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
 195     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 196             || strcmp (result, "0x3.052p-1 33") == 0
 197             || strcmp (result, "0x6.0a4p-2 33") == 0
 198             || strcmp (result, "0xc.148p-3 33") == 0);
 199     ASSERT (retval == strlen (result));
 200   }
 201
 202   { /* Rounding can turn a ...FFF into a ...000.  */
 203     char result[1000];
 204     int retval =
 205       my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
 206     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 207             || strcmp (result, "0x3.000p-1 33") == 0
 208             || strcmp (result, "0x6.000p-2 33") == 0
 209             || strcmp (result, "0xc.000p-3 33") == 0);
 210     ASSERT (retval == strlen (result));
 211   }
 212
 213   { /* Rounding can turn a ...FFF into a ...000.
 214        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 215     char result[1000];
 216     int retval =
 217       my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
 218     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 219             || strcmp (result, "0x2.0p+0 33") == 0
 220             || strcmp (result, "0x4.0p-1 33") == 0
 221             || strcmp (result, "0x8.0p-2 33") == 0);
 222     ASSERT (retval == strlen (result));
 223   }
 224
 225   { /* Width.  */
 226     char result[1000];
 227     int retval =
 228       my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
 229     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 230             || strcmp (result, "  0x3.8p-1 33") == 0
 231             || strcmp (result, "    0x7p-2 33") == 0
 232             || strcmp (result, "    0xep-3 33") == 0);
 233     ASSERT (retval == strlen (result));
 234   }
 235
 236   { /* Small precision.  */
 237     char result[1000];
 238     int retval =
 239       my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
 240     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 241             || strcmp (result, "0x3.8000000000p-1 33") == 0
 242             || strcmp (result, "0x7.0000000000p-2 33") == 0
 243             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 244     ASSERT (retval == strlen (result));
 245   }
 246
 247   { /* Large precision.  */
 248     char result[1000];
 249     int retval =
 250       my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
 251     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 252             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 253             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 254             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 255     ASSERT (retval == strlen (result));
 256   }
 257
 258   { /* FLAG_LEFT.  */
 259     char result[1000];
 260     int retval =
 261       my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
 262     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 263             || strcmp (result, "0x3.8p-1   33") == 0
 264             || strcmp (result, "0x7p-2     33") == 0
 265             || strcmp (result, "0xep-3     33") == 0);
 266     ASSERT (retval == strlen (result));
 267   }
 268
 269   { /* FLAG_SHOWSIGN.  */
 270     char result[1000];
 271     int retval =
 272       my_sprintf (result, "%+a %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_SPACE.  */
 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_ALT.  */
 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, "0x7.p-2 33") == 0
 298             || strcmp (result, "0xe.p-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.0, 33, 44, 55);
 306     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 307             || strcmp (result, "0x2.p-1 33") == 0
 308             || strcmp (result, "0x4.p-2 33") == 0
 309             || strcmp (result, "0x8.p-3 33") == 0);
 310     ASSERT (retval == strlen (result));
 311   }
 312
 313   { /* FLAG_ZERO with finite number.  */
 314     char result[1000];
 315     int retval =
 316       my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
 317     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 318             || strcmp (result, "0x003.8p-1 33") == 0
 319             || strcmp (result, "0x00007p-2 33") == 0
 320             || strcmp (result, "0x0000ep-3 33") == 0);
 321     ASSERT (retval == strlen (result));
 322   }
 323
 324   { /* FLAG_ZERO with infinite number.  */
 325     char result[1000];
 326     int retval =
 327       my_sprintf (result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 328     /* "0000000inf 33" is not a valid result; see
 329        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 330     ASSERT (strcmp (result, "       inf 33") == 0);
 331     ASSERT (retval == strlen (result));
 332   }
 333
 334   { /* FLAG_ZERO with NaN.  */
 335     char result[1000];
 336     int retval =
 337       my_sprintf (result, "%010a %d", NaN (), 33, 44, 55);
 338     /* "0000000nan 33" is not a valid result; see
 339        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 340     ASSERT (strcmp (result, "       nan 33") == 0);
 341     ASSERT (retval == strlen (result));
 342   }
 343
 344   { /* A positive number.  */
 345     char result[1000];
 346     int retval =
 347       my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
 348     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 349             || strcmp (result, "0x3.244p+0 33") == 0
 350             || strcmp (result, "0x6.488p-1 33") == 0
 351             || strcmp (result, "0xc.91p-2 33") == 0);
 352     ASSERT (retval == strlen (result));
 353   }
 354
 355   { /* A negative 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   { /* Positive zero.  */
 367     char result[1000];
 368     int retval =
 369       my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
 370     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 371     ASSERT (retval == strlen (result));
 372   }
 373
 374   { /* Negative zero.  */
 375     char result[1000];
 376     int retval =
 377       my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
 378     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 379     ASSERT (retval == strlen (result));
 380   }
 381
 382   { /* Positive infinity.  */
 383     char result[1000];
 384     int retval =
 385       my_sprintf (result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
 386     ASSERT (strcmp (result, "inf 33") == 0);
 387     ASSERT (retval == strlen (result));
 388   }
 389
 390   { /* Negative infinity.  */
 391     char result[1000];
 392     int retval =
 393       my_sprintf (result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
 394     ASSERT (strcmp (result, "-inf 33") == 0);
 395     ASSERT (retval == strlen (result));
 396   }
 397
 398   { /* NaN.  */
 399     char result[1000];
 400     int retval =
 401       my_sprintf (result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
 402     ASSERT (strcmp (result, "nan 33") == 0);
 403     ASSERT (retval == strlen (result));
 404   }
 405
 406   { /* Rounding near the decimal point.  */
 407     char result[1000];
 408     int retval =
 409       my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
 410     ASSERT (strcmp (result, "0x2p+0 33") == 0
 411             || strcmp (result, "0x3p-1 33") == 0
 412             || strcmp (result, "0x6p-2 33") == 0
 413             || strcmp (result, "0xcp-3 33") == 0);
 414     ASSERT (retval == strlen (result));
 415   }
 416
 417   { /* Rounding with precision 0.  */
 418     char result[1000];
 419     int retval =
 420       my_sprintf (result, "%.0La %d", 1.51L, 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 1.  */
 429     char result[1000];
 430     int retval =
 431       my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
 432     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 433             || strcmp (result, "0x3.0p-1 33") == 0
 434             || strcmp (result, "0x6.1p-2 33") == 0
 435             || strcmp (result, "0xc.1p-3 33") == 0);
 436     ASSERT (retval == strlen (result));
 437   }
 438
 439   { /* Rounding with precision 2.  */
 440     char result[1000];
 441     int retval =
 442       my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
 443     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 444             || strcmp (result, "0x3.05p-1 33") == 0
 445             || strcmp (result, "0x6.0ap-2 33") == 0
 446             || strcmp (result, "0xc.14p-3 33") == 0);
 447     ASSERT (retval == strlen (result));
 448   }
 449
 450   { /* Rounding with precision 3.  */
 451     char result[1000];
 452     int retval =
 453       my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
 454     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 455             || strcmp (result, "0x3.052p-1 33") == 0
 456             || strcmp (result, "0x6.0a4p-2 33") == 0
 457             || strcmp (result, "0xc.148p-3 33") == 0);
 458     ASSERT (retval == strlen (result));
 459   }
 460
 461   { /* Rounding can turn a ...FFF into a ...000.  */
 462     char result[1000];
 463     int retval =
 464       my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
 465     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 466             || strcmp (result, "0x3.000p-1 33") == 0
 467             || strcmp (result, "0x6.000p-2 33") == 0
 468             || strcmp (result, "0xc.000p-3 33") == 0);
 469     ASSERT (retval == strlen (result));
 470   }
 471
 472   { /* Rounding can turn a ...FFF into a ...000.
 473        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 474        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 475     char result[1000];
 476     int retval =
 477       my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
 478     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 479             || strcmp (result, "0x2.0p+0 33") == 0
 480             || strcmp (result, "0x4.0p-1 33") == 0
 481             || strcmp (result, "0x8.0p-2 33") == 0);
 482     ASSERT (retval == strlen (result));
 483   }
 484
 485   { /* Width.  */
 486     char result[1000];
 487     int retval =
 488       my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
 489     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 490             || strcmp (result, "  0x3.8p-1 33") == 0
 491             || strcmp (result, "    0x7p-2 33") == 0
 492             || strcmp (result, "    0xep-3 33") == 0);
 493     ASSERT (retval == strlen (result));
 494   }
 495
 496   { /* Small precision.  */
 497     char result[1000];
 498     int retval =
 499       my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
 500     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 501             || strcmp (result, "0x3.8000000000p-1 33") == 0
 502             || strcmp (result, "0x7.0000000000p-2 33") == 0
 503             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 504     ASSERT (retval == strlen (result));
 505   }
 506
 507   { /* Large precision.  */
 508     char result[1000];
 509     int retval =
 510       my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
 511     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 512             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 513             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 514             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 515     ASSERT (retval == strlen (result));
 516   }
 517
 518   { /* FLAG_LEFT.  */
 519     char result[1000];
 520     int retval =
 521       my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
 522     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 523             || strcmp (result, "0x3.8p-1   33") == 0
 524             || strcmp (result, "0x7p-2     33") == 0
 525             || strcmp (result, "0xep-3     33") == 0);
 526     ASSERT (retval == strlen (result));
 527   }
 528
 529   { /* FLAG_SHOWSIGN.  */
 530     char result[1000];
 531     int retval =
 532       my_sprintf (result, "%+La %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_SPACE.  */
 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_ALT.  */
 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, "0x7.p-2 33") == 0
 558             || strcmp (result, "0xe.p-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.0L, 33, 44, 55);
 566     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 567             || strcmp (result, "0x2.p-1 33") == 0
 568             || strcmp (result, "0x4.p-2 33") == 0
 569             || strcmp (result, "0x8.p-3 33") == 0);
 570     ASSERT (retval == strlen (result));
 571   }
 572
 573   { /* FLAG_ZERO with finite number.  */
 574     char result[1000];
 575     int retval =
 576       my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
 577     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 578             || strcmp (result, "0x003.8p-1 33") == 0
 579             || strcmp (result, "0x00007p-2 33") == 0
 580             || strcmp (result, "0x0000ep-3 33") == 0);
 581     ASSERT (retval == strlen (result));
 582   }
 583
 584   { /* FLAG_ZERO with infinite number.  */
 585     char result[1000];
 586     int retval =
 587       my_sprintf (result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 588     /* "0000000inf 33" is not a valid result; see
 589        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 590     ASSERT (strcmp (result, "       inf 33") == 0);
 591     ASSERT (retval == strlen (result));
 592   }
 593
 594   { /* FLAG_ZERO with NaN.  */
 595     char result[1000];
 596     int retval =
 597       my_sprintf (result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 598     /* "0000000nan 33" is not a valid result; see
 599        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 600     ASSERT (strcmp (result, "       nan 33") == 0);
 601     ASSERT (retval == strlen (result));
 602   }
 603
 604   /* Test the support of the %f format directive.  */
 605
 606   { /* A positive number.  */
 607     char result[1000];
 608     int retval =
 609       my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
 610     ASSERT (strcmp (result, "12.750000 33") == 0);
 611     ASSERT (retval == strlen (result));
 612   }
 613
 614   { /* A larger positive number.  */
 615     char result[1000];
 616     int retval =
 617       my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
 618     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 619     ASSERT (retval == strlen (result));
 620   }
 621
 622   { /* A negative number.  */
 623     char result[1000];
 624     int retval =
 625       my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
 626     ASSERT (strcmp (result, "-0.031250 33") == 0);
 627     ASSERT (retval == strlen (result));
 628   }
 629
 630   { /* Positive zero.  */
 631     char result[1000];
 632     int retval =
 633       my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
 634     ASSERT (strcmp (result, "0.000000 33") == 0);
 635     ASSERT (retval == strlen (result));
 636   }
 637
 638   { /* Negative zero.  */
 639     char result[1000];
 640     int retval =
 641       my_sprintf (result, "%f %d", -0.0, 33, 44, 55);
 642     ASSERT (strcmp (result, "-0.000000 33") == 0);
 643     ASSERT (retval == strlen (result));
 644   }
 645
 646   { /* Positive infinity.  */
 647     char result[1000];
 648     int retval =
 649       my_sprintf (result, "%f %d", 1.0 / 0.0, 33, 44, 55);
 650     ASSERT (strcmp (result, "inf 33") == 0
 651             || strcmp (result, "infinity 33") == 0);
 652     ASSERT (retval == strlen (result));
 653   }
 654
 655   { /* Negative infinity.  */
 656     char result[1000];
 657     int retval =
 658       my_sprintf (result, "%f %d", -1.0 / 0.0, 33, 44, 55);
 659     ASSERT (strcmp (result, "-inf 33") == 0
 660             || strcmp (result, "-infinity 33") == 0);
 661     ASSERT (retval == strlen (result));
 662   }
 663
 664   { /* NaN.  */
 665     char result[1000];
 666     int retval =
 667       my_sprintf (result, "%f %d", NaN (), 33, 44, 55);
 668     ASSERT (strcmp (result, "nan 33") == 0);
 669     ASSERT (retval == strlen (result));
 670   }
 671
 672   { /* Width.  */
 673     char result[1000];
 674     int retval =
 675       my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
 676     ASSERT (strcmp (result, "  1.750000 33") == 0);
 677     ASSERT (retval == strlen (result));
 678   }
 679
 680   { /* FLAG_LEFT.  */
 681     char result[1000];
 682     int retval =
 683       my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
 684     ASSERT (strcmp (result, "1.750000   33") == 0);
 685     ASSERT (retval == strlen (result));
 686   }
 687
 688   { /* FLAG_SHOWSIGN.  */
 689     char result[1000];
 690     int retval =
 691       my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
 692     ASSERT (strcmp (result, "+1.750000 33") == 0);
 693     ASSERT (retval == strlen (result));
 694   }
 695
 696   { /* FLAG_SPACE.  */
 697     char result[1000];
 698     int retval =
 699       my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
 700     ASSERT (strcmp (result, " 1.750000 33") == 0);
 701     ASSERT (retval == strlen (result));
 702   }
 703
 704   { /* FLAG_ALT.  */
 705     char result[1000];
 706     int retval =
 707       my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
 708     ASSERT (strcmp (result, "1.750000 33") == 0);
 709     ASSERT (retval == strlen (result));
 710   }
 711
 712   { /* FLAG_ALT.  */
 713     char result[1000];
 714     int retval =
 715       my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
 716     ASSERT (strcmp (result, "2. 33") == 0);
 717     ASSERT (retval == strlen (result));
 718   }
 719
 720   { /* FLAG_ZERO with finite number.  */
 721     char result[1000];
 722     int retval =
 723       my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
 724     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 725     ASSERT (retval == strlen (result));
 726   }
 727
 728   { /* FLAG_ZERO with infinite number.  */
 729     char result[1000];
 730     int retval =
 731       my_sprintf (result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
 732     ASSERT (strcmp (result, "           -inf 33") == 0
 733             || strcmp (result, "      -infinity 33") == 0);
 734     ASSERT (retval == strlen (result));
 735   }
 736
 737   { /* FLAG_ZERO with NaN.  */
 738     char result[1000];
 739     int retval =
 740       my_sprintf (result, "%015f %d", NaN (), 33, 44, 55);
 741     ASSERT (strcmp (result, "            nan 33") == 0);
 742     ASSERT (retval == strlen (result));
 743   }
 744
 745   { /* Precision.  */
 746     char result[1000];
 747     int retval =
 748       my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
 749     ASSERT (strcmp (result, "1234 33") == 0);
 750     ASSERT (retval == strlen (result));
 751   }
 752
 753   { /* A positive number.  */
 754     char result[1000];
 755     int retval =
 756       my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
 757     ASSERT (strcmp (result, "12.750000 33") == 0);
 758     ASSERT (retval == strlen (result));
 759   }
 760
 761   { /* A larger positive number.  */
 762     char result[1000];
 763     int retval =
 764       my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
 765     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 766     ASSERT (retval == strlen (result));
 767   }
 768
 769   { /* A negative number.  */
 770     char result[1000];
 771     int retval =
 772       my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
 773     ASSERT (strcmp (result, "-0.031250 33") == 0);
 774     ASSERT (retval == strlen (result));
 775   }
 776
 777   { /* Positive zero.  */
 778     char result[1000];
 779     int retval =
 780       my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
 781     ASSERT (strcmp (result, "0.000000 33") == 0);
 782     ASSERT (retval == strlen (result));
 783   }
 784
 785   { /* Negative zero.  */
 786     char result[1000];
 787     int retval =
 788       my_sprintf (result, "%Lf %d", -0.0L, 33, 44, 55);
 789     ASSERT (strcmp (result, "-0.000000 33") == 0);
 790     ASSERT (retval == strlen (result));
 791   }
 792
 793   { /* Positive infinity.  */
 794     char result[1000];
 795     int retval =
 796       my_sprintf (result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
 797     ASSERT (strcmp (result, "inf 33") == 0
 798             || strcmp (result, "infinity 33") == 0);
 799     ASSERT (retval == strlen (result));
 800   }
 801
 802   { /* Negative infinity.  */
 803     char result[1000];
 804     int retval =
 805       my_sprintf (result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
 806     ASSERT (strcmp (result, "-inf 33") == 0
 807             || strcmp (result, "-infinity 33") == 0);
 808     ASSERT (retval == strlen (result));
 809   }
 810
 811   { /* NaN.  */
 812     static long double zero = 0.0L;
 813     char result[1000];
 814     int retval =
 815       my_sprintf (result, "%Lf %d", zero / zero, 33, 44, 55);
 816     ASSERT (strcmp (result, "nan 33") == 0);
 817     ASSERT (retval == strlen (result));
 818   }
 819
 820   { /* Width.  */
 821     char result[1000];
 822     int retval =
 823       my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
 824     ASSERT (strcmp (result, "  1.750000 33") == 0);
 825     ASSERT (retval == strlen (result));
 826   }
 827
 828   { /* FLAG_LEFT.  */
 829     char result[1000];
 830     int retval =
 831       my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
 832     ASSERT (strcmp (result, "1.750000   33") == 0);
 833     ASSERT (retval == strlen (result));
 834   }
 835
 836   { /* FLAG_SHOWSIGN.  */
 837     char result[1000];
 838     int retval =
 839       my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
 840     ASSERT (strcmp (result, "+1.750000 33") == 0);
 841     ASSERT (retval == strlen (result));
 842   }
 843
 844   { /* FLAG_SPACE.  */
 845     char result[1000];
 846     int retval =
 847       my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
 848     ASSERT (strcmp (result, " 1.750000 33") == 0);
 849     ASSERT (retval == strlen (result));
 850   }
 851
 852   { /* FLAG_ALT.  */
 853     char result[1000];
 854     int retval =
 855       my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
 856     ASSERT (strcmp (result, "1.750000 33") == 0);
 857     ASSERT (retval == strlen (result));
 858   }
 859
 860   { /* FLAG_ALT.  */
 861     char result[1000];
 862     int retval =
 863       my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
 864     ASSERT (strcmp (result, "2. 33") == 0);
 865     ASSERT (retval == strlen (result));
 866   }
 867
 868   { /* FLAG_ZERO with finite number.  */
 869     char result[1000];
 870     int retval =
 871       my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
 872     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 873     ASSERT (retval == strlen (result));
 874   }
 875
 876   { /* FLAG_ZERO with infinite number.  */
 877     char result[1000];
 878     int retval =
 879       my_sprintf (result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
 880     ASSERT (strcmp (result, "           -inf 33") == 0
 881             || strcmp (result, "      -infinity 33") == 0);
 882     ASSERT (retval == strlen (result));
 883   }
 884
 885   { /* FLAG_ZERO with NaN.  */
 886     static long double zero = 0.0L;
 887     char result[1000];
 888     int retval =
 889       my_sprintf (result, "%015Lf %d", zero / zero, 33, 44, 55);
 890     ASSERT (strcmp (result, "            nan 33") == 0);
 891     ASSERT (retval == strlen (result));
 892   }
 893
 894   { /* Precision.  */
 895     char result[1000];
 896     int retval =
 897       my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
 898     ASSERT (strcmp (result, "1234 33") == 0);
 899     ASSERT (retval == strlen (result));
 900   }
 901
 902   /* Test the support of the %F format directive.  */
 903
 904   { /* A positive number.  */
 905     char result[1000];
 906     int retval =
 907       my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
 908     ASSERT (strcmp (result, "12.750000 33") == 0);
 909     ASSERT (retval == strlen (result));
 910   }
 911
 912   { /* A larger positive number.  */
 913     char result[1000];
 914     int retval =
 915       my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
 916     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 917     ASSERT (retval == strlen (result));
 918   }
 919
 920   { /* A negative number.  */
 921     char result[1000];
 922     int retval =
 923       my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
 924     ASSERT (strcmp (result, "-0.031250 33") == 0);
 925     ASSERT (retval == strlen (result));
 926   }
 927
 928   { /* Positive zero.  */
 929     char result[1000];
 930     int retval =
 931       my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
 932     ASSERT (strcmp (result, "0.000000 33") == 0);
 933     ASSERT (retval == strlen (result));
 934   }
 935
 936   { /* Negative zero.  */
 937     char result[1000];
 938     int retval =
 939       my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
 940     ASSERT (strcmp (result, "-0.000000 33") == 0);
 941     ASSERT (retval == strlen (result));
 942   }
 943
 944   { /* Positive infinity.  */
 945     char result[1000];
 946     int retval =
 947       my_sprintf (result, "%F %d", 1.0 / 0.0, 33, 44, 55);
 948     ASSERT (strcmp (result, "INF 33") == 0
 949             || strcmp (result, "INFINITY 33") == 0);
 950     ASSERT (retval == strlen (result));
 951   }
 952
 953   { /* Negative infinity.  */
 954     char result[1000];
 955     int retval =
 956       my_sprintf (result, "%F %d", -1.0 / 0.0, 33, 44, 55);
 957     ASSERT (strcmp (result, "-INF 33") == 0
 958             || strcmp (result, "-INFINITY 33") == 0);
 959     ASSERT (retval == strlen (result));
 960   }
 961
 962   { /* NaN.  */
 963     char result[1000];
 964     int retval =
 965       my_sprintf (result, "%F %d", NaN (), 33, 44, 55);
 966     ASSERT (strcmp (result, "NAN 33") == 0);
 967     ASSERT (retval == strlen (result));
 968   }
 969
 970   { /* FLAG_ZERO.  */
 971     char result[1000];
 972     int retval =
 973       my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
 974     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 975     ASSERT (retval == strlen (result));
 976   }
 977
 978   { /* FLAG_ZERO with infinite number.  */
 979     char result[1000];
 980     int retval =
 981       my_sprintf (result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
 982     ASSERT (strcmp (result, "           -INF 33") == 0
 983             || strcmp (result, "      -INFINITY 33") == 0);
 984     ASSERT (retval == strlen (result));
 985   }
 986
 987   { /* Precision.  */
 988     char result[1000];
 989     int retval =
 990       my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
 991     ASSERT (strcmp (result, "1234 33") == 0);
 992     ASSERT (retval == strlen (result));
 993   }
 994
 995   { /* A positive number.  */
 996     char result[1000];
 997     int retval =
 998       my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
 999     ASSERT (strcmp (result, "12.750000 33") == 0);
1000     ASSERT (retval == strlen (result));
1001   }
1002
1003   { /* A larger positive number.  */
1004     char result[1000];
1005     int retval =
1006       my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
1007     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1008     ASSERT (retval == strlen (result));
1009   }
1010
1011   { /* A negative number.  */
1012     char result[1000];
1013     int retval =
1014       my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
1015     ASSERT (strcmp (result, "-0.031250 33") == 0);
1016     ASSERT (retval == strlen (result));
1017   }
1018
1019   { /* Positive zero.  */
1020     char result[1000];
1021     int retval =
1022       my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
1023     ASSERT (strcmp (result, "0.000000 33") == 0);
1024     ASSERT (retval == strlen (result));
1025   }
1026
1027   { /* Negative zero.  */
1028     char result[1000];
1029     int retval =
1030       my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
1031     ASSERT (strcmp (result, "-0.000000 33") == 0);
1032     ASSERT (retval == strlen (result));
1033   }
1034
1035   { /* Positive infinity.  */
1036     char result[1000];
1037     int retval =
1038       my_sprintf (result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1039     ASSERT (strcmp (result, "INF 33") == 0
1040             || strcmp (result, "INFINITY 33") == 0);
1041     ASSERT (retval == strlen (result));
1042   }
1043
1044   { /* Negative infinity.  */
1045     char result[1000];
1046     int retval =
1047       my_sprintf (result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1048     ASSERT (strcmp (result, "-INF 33") == 0
1049             || strcmp (result, "-INFINITY 33") == 0);
1050     ASSERT (retval == strlen (result));
1051   }
1052
1053   { /* NaN.  */
1054     static long double zero = 0.0L;
1055     char result[1000];
1056     int retval =
1057       my_sprintf (result, "%LF %d", zero / zero, 33, 44, 55);
1058     ASSERT (strcmp (result, "NAN 33") == 0);
1059     ASSERT (retval == strlen (result));
1060   }
1061
1062   { /* FLAG_ZERO.  */
1063     char result[1000];
1064     int retval =
1065       my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
1066     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1067     ASSERT (retval == strlen (result));
1068   }
1069
1070   { /* FLAG_ZERO with infinite number.  */
1071     char result[1000];
1072     int retval =
1073       my_sprintf (result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1074     ASSERT (strcmp (result, "           -INF 33") == 0
1075             || strcmp (result, "      -INFINITY 33") == 0);
1076     ASSERT (retval == strlen (result));
1077   }
1078
1079   { /* Precision.  */
1080     char result[1000];
1081     int retval =
1082       my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
1083     ASSERT (strcmp (result, "1234 33") == 0);
1084     ASSERT (retval == strlen (result));
1085   }
1086
1087   /* Test the support of the %n format directive.  */
1088
1089   {
1090     int count = -1;
1091     char result[1000];
1092     int retval =
1093       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
1094     ASSERT (strcmp (result, "123 ") == 0);
1095     ASSERT (retval == strlen (result));
1096     ASSERT (count == 4);
1097   }
1098
1099   /* Test the support of the POSIX/XSI format strings with positions.  */
1100
1101   {
1102     char result[1000];
1103     int retval =
1104       my_sprintf (result, "%2$d %1$d", 33, 55);
1105     ASSERT (strcmp (result, "55 33") == 0);
1106     ASSERT (retval == strlen (result));
1107   }
1108
1109   /* Test the support of the grouping flag.  */
1110
1111   {
1112     char result[1000];
1113     int retval =
1114       my_sprintf (result, "%'d %d", 1234567, 99);
1115     ASSERT (result[strlen (result) - 1] == '9');
1116     ASSERT (retval == strlen (result));
1117   }
1118 }