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 #if HAVE_LONG_DOUBLE
  75   {
  76     char result[1000];
  77     int retval =
  78       my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
  79     ASSERT (strcmp (result, "1.5 33") == 0);
  80     ASSERT (retval == strlen (result));
  81   }
  82 #endif
  83
  84   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
  85      output of floating-point numbers.  */
  86
  87   { /* A positive number.  */
  88     char result[1000];
  89     int retval =
  90       my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
  91     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
  92             || strcmp (result, "0x3.244p+0 33") == 0
  93             || strcmp (result, "0x6.488p-1 33") == 0
  94             || strcmp (result, "0xc.91p-2 33") == 0);
  95     ASSERT (retval == strlen (result));
  96   }
  97
  98   { /* A negative number.  */
  99     char result[1000];
 100     int retval =
 101       my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
 102     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 103             || strcmp (result, "-0X3.244P+0 33") == 0
 104             || strcmp (result, "-0X6.488P-1 33") == 0
 105             || strcmp (result, "-0XC.91P-2 33") == 0);
 106     ASSERT (retval == strlen (result));
 107   }
 108
 109   { /* Positive zero.  */
 110     char result[1000];
 111     int retval =
 112       my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
 113     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 114     ASSERT (retval == strlen (result));
 115   }
 116
 117   { /* Negative zero.  */
 118     char result[1000];
 119     int retval =
 120       my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
 121     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 122     ASSERT (retval == strlen (result));
 123   }
 124
 125   { /* Positive infinity.  */
 126     char result[1000];
 127     int retval =
 128       my_sprintf (result, "%a %d", 1.0 / 0.0, 33, 44, 55);
 129     ASSERT (strcmp (result, "inf 33") == 0);
 130     ASSERT (retval == strlen (result));
 131   }
 132
 133   { /* Negative infinity.  */
 134     char result[1000];
 135     int retval =
 136       my_sprintf (result, "%a %d", -1.0 / 0.0, 33, 44, 55);
 137     ASSERT (strcmp (result, "-inf 33") == 0);
 138     ASSERT (retval == strlen (result));
 139   }
 140
 141   { /* NaN.  */
 142     char result[1000];
 143     int retval =
 144       my_sprintf (result, "%a %d", NaN (), 33, 44, 55);
 145     ASSERT (strcmp (result, "nan 33") == 0);
 146     ASSERT (retval == strlen (result));
 147   }
 148
 149   { /* Rounding near the decimal point.  */
 150     char result[1000];
 151     int retval =
 152       my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
 153     ASSERT (strcmp (result, "0x2p+0 33") == 0
 154             || strcmp (result, "0x3p-1 33") == 0
 155             || strcmp (result, "0x6p-2 33") == 0
 156             || strcmp (result, "0xcp-3 33") == 0);
 157     ASSERT (retval == strlen (result));
 158   }
 159
 160   { /* Rounding with precision 0.  */
 161     char result[1000];
 162     int retval =
 163       my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
 164     ASSERT (strcmp (result, "0x2p+0 33") == 0
 165             || strcmp (result, "0x3p-1 33") == 0
 166             || strcmp (result, "0x6p-2 33") == 0
 167             || strcmp (result, "0xcp-3 33") == 0);
 168     ASSERT (retval == strlen (result));
 169   }
 170
 171   { /* Rounding with precision 1.  */
 172     char result[1000];
 173     int retval =
 174       my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
 175     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 176             || strcmp (result, "0x3.0p-1 33") == 0
 177             || strcmp (result, "0x6.1p-2 33") == 0
 178             || strcmp (result, "0xc.1p-3 33") == 0);
 179     ASSERT (retval == strlen (result));
 180   }
 181
 182   { /* Rounding with precision 2.  */
 183     char result[1000];
 184     int retval =
 185       my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
 186     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 187             || strcmp (result, "0x3.05p-1 33") == 0
 188             || strcmp (result, "0x6.0ap-2 33") == 0
 189             || strcmp (result, "0xc.14p-3 33") == 0);
 190     ASSERT (retval == strlen (result));
 191   }
 192
 193   { /* Rounding with precision 3.  */
 194     char result[1000];
 195     int retval =
 196       my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
 197     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 198             || strcmp (result, "0x3.052p-1 33") == 0
 199             || strcmp (result, "0x6.0a4p-2 33") == 0
 200             || strcmp (result, "0xc.148p-3 33") == 0);
 201     ASSERT (retval == strlen (result));
 202   }
 203
 204   { /* Rounding can turn a ...FFF into a ...000.  */
 205     char result[1000];
 206     int retval =
 207       my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
 208     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 209             || strcmp (result, "0x3.000p-1 33") == 0
 210             || strcmp (result, "0x6.000p-2 33") == 0
 211             || strcmp (result, "0xc.000p-3 33") == 0);
 212     ASSERT (retval == strlen (result));
 213   }
 214
 215   { /* Rounding can turn a ...FFF into a ...000.
 216        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 217     char result[1000];
 218     int retval =
 219       my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
 220     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 221             || strcmp (result, "0x2.0p+0 33") == 0
 222             || strcmp (result, "0x4.0p-1 33") == 0
 223             || strcmp (result, "0x8.0p-2 33") == 0);
 224     ASSERT (retval == strlen (result));
 225   }
 226
 227   { /* Width.  */
 228     char result[1000];
 229     int retval =
 230       my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
 231     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 232             || strcmp (result, "  0x3.8p-1 33") == 0
 233             || strcmp (result, "    0x7p-2 33") == 0
 234             || strcmp (result, "    0xep-3 33") == 0);
 235     ASSERT (retval == strlen (result));
 236   }
 237
 238   { /* Small precision.  */
 239     char result[1000];
 240     int retval =
 241       my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
 242     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 243             || strcmp (result, "0x3.8000000000p-1 33") == 0
 244             || strcmp (result, "0x7.0000000000p-2 33") == 0
 245             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 246     ASSERT (retval == strlen (result));
 247   }
 248
 249   { /* Large precision.  */
 250     char result[1000];
 251     int retval =
 252       my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
 253     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 254             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 255             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 256             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 257     ASSERT (retval == strlen (result));
 258   }
 259
 260   { /* FLAG_LEFT.  */
 261     char result[1000];
 262     int retval =
 263       my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
 264     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 265             || strcmp (result, "0x3.8p-1   33") == 0
 266             || strcmp (result, "0x7p-2     33") == 0
 267             || strcmp (result, "0xep-3     33") == 0);
 268     ASSERT (retval == strlen (result));
 269   }
 270
 271   { /* FLAG_SHOWSIGN.  */
 272     char result[1000];
 273     int retval =
 274       my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
 275     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 276             || strcmp (result, "+0x3.8p-1 33") == 0
 277             || strcmp (result, "+0x7p-2 33") == 0
 278             || strcmp (result, "+0xep-3 33") == 0);
 279     ASSERT (retval == strlen (result));
 280   }
 281
 282   { /* FLAG_SPACE.  */
 283     char result[1000];
 284     int retval =
 285       my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
 286     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 287             || strcmp (result, " 0x3.8p-1 33") == 0
 288             || strcmp (result, " 0x7p-2 33") == 0
 289             || strcmp (result, " 0xep-3 33") == 0);
 290     ASSERT (retval == strlen (result));
 291   }
 292
 293   { /* FLAG_ALT.  */
 294     char result[1000];
 295     int retval =
 296       my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
 297     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 298             || strcmp (result, "0x3.8p-1 33") == 0
 299             || strcmp (result, "0x7.p-2 33") == 0
 300             || strcmp (result, "0xe.p-3 33") == 0);
 301     ASSERT (retval == strlen (result));
 302   }
 303
 304   { /* FLAG_ALT.  */
 305     char result[1000];
 306     int retval =
 307       my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
 308     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 309             || strcmp (result, "0x2.p-1 33") == 0
 310             || strcmp (result, "0x4.p-2 33") == 0
 311             || strcmp (result, "0x8.p-3 33") == 0);
 312     ASSERT (retval == strlen (result));
 313   }
 314
 315   { /* FLAG_ZERO with finite number.  */
 316     char result[1000];
 317     int retval =
 318       my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
 319     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 320             || strcmp (result, "0x003.8p-1 33") == 0
 321             || strcmp (result, "0x00007p-2 33") == 0
 322             || strcmp (result, "0x0000ep-3 33") == 0);
 323     ASSERT (retval == strlen (result));
 324   }
 325
 326   { /* FLAG_ZERO with infinite number.  */
 327     char result[1000];
 328     int retval =
 329       my_sprintf (result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 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     ASSERT (strcmp (result, "       nan 33") == 0);
 339     ASSERT (retval == strlen (result));
 340   }
 341
 342 #if HAVE_LONG_DOUBLE
 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     ASSERT (strcmp (result, "       inf 33") == 0);
 589     ASSERT (retval == strlen (result));
 590   }
 591
 592   { /* FLAG_ZERO with NaN.  */
 593     char result[1000];
 594     int retval =
 595       my_sprintf (result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 596     ASSERT (strcmp (result, "       nan 33") == 0);
 597     ASSERT (retval == strlen (result));
 598   }
 599
 600 #endif
 601
 602   /* Test the support of the %n format directive.  */
 603
 604   {
 605     int count = -1;
 606     char result[1000];
 607     int retval =
 608       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
 609     ASSERT (strcmp (result, "123 ") == 0);
 610     ASSERT (retval == strlen (result));
 611     ASSERT (count == 4);
 612   }
 613
 614   /* Test the support of the POSIX/XSI format strings with positions.  */
 615
 616   {
 617     char result[1000];
 618     int retval =
 619       my_sprintf (result, "%2$d %1$d", 33, 55);
 620     ASSERT (strcmp (result, "55 33") == 0);
 621     ASSERT (retval == strlen (result));
 622   }
 623 }