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 %n format directive.  */
 605
 606   {
 607     int count = -1;
 608     char result[1000];
 609     int retval =
 610       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
 611     ASSERT (strcmp (result, "123 ") == 0);
 612     ASSERT (retval == strlen (result));
 613     ASSERT (count == 4);
 614   }
 615
 616   /* Test the support of the POSIX/XSI format strings with positions.  */
 617
 618   {
 619     char result[1000];
 620     int retval =
 621       my_sprintf (result, "%2$d %1$d", 33, 55);
 622     ASSERT (strcmp (result, "55 33") == 0);
 623     ASSERT (retval == strlen (result));
 624   }
 625 }