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