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     ASSERT (strcmp (result, "       inf 33") == 0
 329             || strcmp (result, "0000000inf 33") == 0);
 330     ASSERT (retval == strlen (result));
 331   }
 332
 333   { /* FLAG_ZERO with NaN.  */
 334     char result[1000];
 335     int retval =
 336       my_sprintf (result, "%010a %d", NaN (), 33, 44, 55);
 337     ASSERT (strcmp (result, "       nan 33") == 0
 338             || strcmp (result, "0000000nan 33") == 0);
 339     ASSERT (retval == strlen (result));
 340   }
 341
 342   { /* A positive number.  */
 343     char result[1000];
 344     int retval =
 345       my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
 346     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 347             || strcmp (result, "0x3.244p+0 33") == 0
 348             || strcmp (result, "0x6.488p-1 33") == 0
 349             || strcmp (result, "0xc.91p-2 33") == 0);
 350     ASSERT (retval == strlen (result));
 351   }
 352
 353   { /* A negative number.  */
 354     char result[1000];
 355     int retval =
 356       my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
 357     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 358             || strcmp (result, "-0X3.244P+0 33") == 0
 359             || strcmp (result, "-0X6.488P-1 33") == 0
 360             || strcmp (result, "-0XC.91P-2 33") == 0);
 361     ASSERT (retval == strlen (result));
 362   }
 363
 364   { /* Positive zero.  */
 365     char result[1000];
 366     int retval =
 367       my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
 368     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 369     ASSERT (retval == strlen (result));
 370   }
 371
 372   { /* Negative zero.  */
 373     char result[1000];
 374     int retval =
 375       my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
 376     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 377     ASSERT (retval == strlen (result));
 378   }
 379
 380   { /* Positive infinity.  */
 381     char result[1000];
 382     int retval =
 383       my_sprintf (result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
 384     ASSERT (strcmp (result, "inf 33") == 0);
 385     ASSERT (retval == strlen (result));
 386   }
 387
 388   { /* Negative infinity.  */
 389     char result[1000];
 390     int retval =
 391       my_sprintf (result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
 392     ASSERT (strcmp (result, "-inf 33") == 0);
 393     ASSERT (retval == strlen (result));
 394   }
 395
 396   { /* NaN.  */
 397     char result[1000];
 398     int retval =
 399       my_sprintf (result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
 400     ASSERT (strcmp (result, "nan 33") == 0);
 401     ASSERT (retval == strlen (result));
 402   }
 403
 404   { /* Rounding near the decimal point.  */
 405     char result[1000];
 406     int retval =
 407       my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
 408     ASSERT (strcmp (result, "0x2p+0 33") == 0
 409             || strcmp (result, "0x3p-1 33") == 0
 410             || strcmp (result, "0x6p-2 33") == 0
 411             || strcmp (result, "0xcp-3 33") == 0);
 412     ASSERT (retval == strlen (result));
 413   }
 414
 415   { /* Rounding with precision 0.  */
 416     char result[1000];
 417     int retval =
 418       my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
 419     ASSERT (strcmp (result, "0x2p+0 33") == 0
 420             || strcmp (result, "0x3p-1 33") == 0
 421             || strcmp (result, "0x6p-2 33") == 0
 422             || strcmp (result, "0xcp-3 33") == 0);
 423     ASSERT (retval == strlen (result));
 424   }
 425
 426   { /* Rounding with precision 1.  */
 427     char result[1000];
 428     int retval =
 429       my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
 430     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 431             || strcmp (result, "0x3.0p-1 33") == 0
 432             || strcmp (result, "0x6.1p-2 33") == 0
 433             || strcmp (result, "0xc.1p-3 33") == 0);
 434     ASSERT (retval == strlen (result));
 435   }
 436
 437   { /* Rounding with precision 2.  */
 438     char result[1000];
 439     int retval =
 440       my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
 441     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 442             || strcmp (result, "0x3.05p-1 33") == 0
 443             || strcmp (result, "0x6.0ap-2 33") == 0
 444             || strcmp (result, "0xc.14p-3 33") == 0);
 445     ASSERT (retval == strlen (result));
 446   }
 447
 448   { /* Rounding with precision 3.  */
 449     char result[1000];
 450     int retval =
 451       my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
 452     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 453             || strcmp (result, "0x3.052p-1 33") == 0
 454             || strcmp (result, "0x6.0a4p-2 33") == 0
 455             || strcmp (result, "0xc.148p-3 33") == 0);
 456     ASSERT (retval == strlen (result));
 457   }
 458
 459   { /* Rounding can turn a ...FFF into a ...000.  */
 460     char result[1000];
 461     int retval =
 462       my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
 463     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 464             || strcmp (result, "0x3.000p-1 33") == 0
 465             || strcmp (result, "0x6.000p-2 33") == 0
 466             || strcmp (result, "0xc.000p-3 33") == 0);
 467     ASSERT (retval == strlen (result));
 468   }
 469
 470   { /* Rounding can turn a ...FFF into a ...000.
 471        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 472        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 473     char result[1000];
 474     int retval =
 475       my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
 476     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 477             || strcmp (result, "0x2.0p+0 33") == 0
 478             || strcmp (result, "0x4.0p-1 33") == 0
 479             || strcmp (result, "0x8.0p-2 33") == 0);
 480     ASSERT (retval == strlen (result));
 481   }
 482
 483   { /* Width.  */
 484     char result[1000];
 485     int retval =
 486       my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
 487     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 488             || strcmp (result, "  0x3.8p-1 33") == 0
 489             || strcmp (result, "    0x7p-2 33") == 0
 490             || strcmp (result, "    0xep-3 33") == 0);
 491     ASSERT (retval == strlen (result));
 492   }
 493
 494   { /* Small precision.  */
 495     char result[1000];
 496     int retval =
 497       my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
 498     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 499             || strcmp (result, "0x3.8000000000p-1 33") == 0
 500             || strcmp (result, "0x7.0000000000p-2 33") == 0
 501             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 502     ASSERT (retval == strlen (result));
 503   }
 504
 505   { /* Large precision.  */
 506     char result[1000];
 507     int retval =
 508       my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
 509     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 510             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 511             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 512             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 513     ASSERT (retval == strlen (result));
 514   }
 515
 516   { /* FLAG_LEFT.  */
 517     char result[1000];
 518     int retval =
 519       my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
 520     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 521             || strcmp (result, "0x3.8p-1   33") == 0
 522             || strcmp (result, "0x7p-2     33") == 0
 523             || strcmp (result, "0xep-3     33") == 0);
 524     ASSERT (retval == strlen (result));
 525   }
 526
 527   { /* FLAG_SHOWSIGN.  */
 528     char result[1000];
 529     int retval =
 530       my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
 531     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 532             || strcmp (result, "+0x3.8p-1 33") == 0
 533             || strcmp (result, "+0x7p-2 33") == 0
 534             || strcmp (result, "+0xep-3 33") == 0);
 535     ASSERT (retval == strlen (result));
 536   }
 537
 538   { /* FLAG_SPACE.  */
 539     char result[1000];
 540     int retval =
 541       my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
 542     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 543             || strcmp (result, " 0x3.8p-1 33") == 0
 544             || strcmp (result, " 0x7p-2 33") == 0
 545             || strcmp (result, " 0xep-3 33") == 0);
 546     ASSERT (retval == strlen (result));
 547   }
 548
 549   { /* FLAG_ALT.  */
 550     char result[1000];
 551     int retval =
 552       my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
 553     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 554             || strcmp (result, "0x3.8p-1 33") == 0
 555             || strcmp (result, "0x7.p-2 33") == 0
 556             || strcmp (result, "0xe.p-3 33") == 0);
 557     ASSERT (retval == strlen (result));
 558   }
 559
 560   { /* FLAG_ALT.  */
 561     char result[1000];
 562     int retval =
 563       my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
 564     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 565             || strcmp (result, "0x2.p-1 33") == 0
 566             || strcmp (result, "0x4.p-2 33") == 0
 567             || strcmp (result, "0x8.p-3 33") == 0);
 568     ASSERT (retval == strlen (result));
 569   }
 570
 571   { /* FLAG_ZERO with finite number.  */
 572     char result[1000];
 573     int retval =
 574       my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
 575     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 576             || strcmp (result, "0x003.8p-1 33") == 0
 577             || strcmp (result, "0x00007p-2 33") == 0
 578             || strcmp (result, "0x0000ep-3 33") == 0);
 579     ASSERT (retval == strlen (result));
 580   }
 581
 582   { /* FLAG_ZERO with infinite number.  */
 583     char result[1000];
 584     int retval =
 585       my_sprintf (result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 586     ASSERT (strcmp (result, "       inf 33") == 0
 587             || strcmp (result, "0000000inf 33") == 0);
 588     ASSERT (retval == strlen (result));
 589   }
 590
 591   { /* FLAG_ZERO with NaN.  */
 592     char result[1000];
 593     int retval =
 594       my_sprintf (result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 595     ASSERT (strcmp (result, "       nan 33") == 0
 596             || strcmp (result, "0000000nan 33") == 0);
 597     ASSERT (retval == strlen (result));
 598   }
 599
 600   /* Test the support of the %n format directive.  */
 601
 602   {
 603     int count = -1;
 604     char result[1000];
 605     int retval =
 606       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
 607     ASSERT (strcmp (result, "123 ") == 0);
 608     ASSERT (retval == strlen (result));
 609     ASSERT (count == 4);
 610   }
 611
 612   /* Test the support of the POSIX/XSI format strings with positions.  */
 613
 614   {
 615     char result[1000];
 616     int retval =
 617       my_sprintf (result, "%2$d %1$d", 33, 55);
 618     ASSERT (strcmp (result, "55 33") == 0);
 619     ASSERT (retval == strlen (result));
 620   }
 621 }