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 static void
  21 test_function (int (*my_sprintf) (char *, const char *, ...))
  22 {
  23   char buf[8];
  24
  25   /* Test return value convention.  */
  26
  27   {
  28     int retval;
  29
  30     memcpy (buf, "DEADBEEF", 8);
  31     retval = my_sprintf (buf, "%d", 12345);
  32     ASSERT (retval == 5);
  33     ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
  34   }
  35
  36   /* Test support of size specifiers as in C99.  */
  37
  38   {
  39     char result[1000];
  40     int retval =
  41       my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  42     ASSERT (strcmp (result, "12345671 33") == 0);
  43     ASSERT (retval == strlen (result));
  44   }
  45
  46   {
  47     char result[1000];
  48     int retval =
  49       my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
  50     ASSERT (strcmp (result, "12345672 33") == 0);
  51     ASSERT (retval == strlen (result));
  52   }
  53
  54   {
  55     char result[1000];
  56     int retval =
  57       my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
  58     ASSERT (strcmp (result, "12345673 33") == 0);
  59     ASSERT (retval == strlen (result));
  60   }
  61
  62 #if HAVE_LONG_DOUBLE
  63   {
  64     char result[1000];
  65     int retval =
  66       my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
  67     ASSERT (strcmp (result, "1.5 33") == 0);
  68     ASSERT (retval == strlen (result));
  69   }
  70 #endif
  71
  72   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
  73      output of floating-point numbers.  */
  74
  75   { /* A positive number.  */
  76     char result[1000];
  77     int retval =
  78       my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
  79     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
  80             || strcmp (result, "0x3.244p+0 33") == 0
  81             || strcmp (result, "0x6.488p-1 33") == 0
  82             || strcmp (result, "0xc.91p-2 33") == 0);
  83     ASSERT (retval == strlen (result));
  84   }
  85
  86   { /* A negative number.  */
  87     char result[1000];
  88     int retval =
  89       my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
  90     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
  91             || strcmp (result, "-0X3.244P+0 33") == 0
  92             || strcmp (result, "-0X6.488P-1 33") == 0
  93             || strcmp (result, "-0XC.91P-2 33") == 0);
  94     ASSERT (retval == strlen (result));
  95   }
  96
  97   { /* Positive zero.  */
  98     char result[1000];
  99     int retval =
 100       my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
 101     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 102     ASSERT (retval == strlen (result));
 103   }
 104
 105   { /* Negative zero.  */
 106     char result[1000];
 107     int retval =
 108       my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
 109     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 110     ASSERT (retval == strlen (result));
 111   }
 112
 113   { /* Positive infinity.  */
 114     char result[1000];
 115     int retval =
 116       my_sprintf (result, "%a %d", 1.0 / 0.0, 33, 44, 55);
 117     ASSERT (strcmp (result, "inf 33") == 0);
 118     ASSERT (retval == strlen (result));
 119   }
 120
 121   { /* Negative infinity.  */
 122     char result[1000];
 123     int retval =
 124       my_sprintf (result, "%a %d", -1.0 / 0.0, 33, 44, 55);
 125     ASSERT (strcmp (result, "-inf 33") == 0);
 126     ASSERT (retval == strlen (result));
 127   }
 128
 129   { /* NaN.  */
 130     char result[1000];
 131     int retval =
 132       my_sprintf (result, "%a %d", 0.0 / 0.0, 33, 44, 55);
 133     ASSERT (strcmp (result, "nan 33") == 0);
 134     ASSERT (retval == strlen (result));
 135   }
 136
 137   { /* Rounding near the decimal point.  */
 138     char result[1000];
 139     int retval =
 140       my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
 141     ASSERT (strcmp (result, "0x2p+0 33") == 0
 142             || strcmp (result, "0x3p-1 33") == 0
 143             || strcmp (result, "0x6p-2 33") == 0
 144             || strcmp (result, "0xcp-3 33") == 0);
 145     ASSERT (retval == strlen (result));
 146   }
 147
 148   { /* Rounding with precision 0.  */
 149     char result[1000];
 150     int retval =
 151       my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
 152     ASSERT (strcmp (result, "0x2p+0 33") == 0
 153             || strcmp (result, "0x3p-1 33") == 0
 154             || strcmp (result, "0x6p-2 33") == 0
 155             || strcmp (result, "0xcp-3 33") == 0);
 156     ASSERT (retval == strlen (result));
 157   }
 158
 159   { /* Rounding with precision 1.  */
 160     char result[1000];
 161     int retval =
 162       my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
 163     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 164             || strcmp (result, "0x3.0p-1 33") == 0
 165             || strcmp (result, "0x6.1p-2 33") == 0
 166             || strcmp (result, "0xc.1p-3 33") == 0);
 167     ASSERT (retval == strlen (result));
 168   }
 169
 170   { /* Rounding with precision 2.  */
 171     char result[1000];
 172     int retval =
 173       my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
 174     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 175             || strcmp (result, "0x3.05p-1 33") == 0
 176             || strcmp (result, "0x6.0ap-2 33") == 0
 177             || strcmp (result, "0xc.14p-3 33") == 0);
 178     ASSERT (retval == strlen (result));
 179   }
 180
 181   { /* Rounding with precision 3.  */
 182     char result[1000];
 183     int retval =
 184       my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
 185     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 186             || strcmp (result, "0x3.052p-1 33") == 0
 187             || strcmp (result, "0x6.0a4p-2 33") == 0
 188             || strcmp (result, "0xc.148p-3 33") == 0);
 189     ASSERT (retval == strlen (result));
 190   }
 191
 192   { /* Rounding can turn a ...FFF into a ...000.  */
 193     char result[1000];
 194     int retval =
 195       my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
 196     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 197             || strcmp (result, "0x3.000p-1 33") == 0
 198             || strcmp (result, "0x6.000p-2 33") == 0
 199             || strcmp (result, "0xc.000p-3 33") == 0);
 200     ASSERT (retval == strlen (result));
 201   }
 202
 203   { /* Rounding can turn a ...FFF into a ...000.
 204        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 205     char result[1000];
 206     int retval =
 207       my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
 208     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 209             || strcmp (result, "0x2.0p+0 33") == 0
 210             || strcmp (result, "0x4.0p-1 33") == 0
 211             || strcmp (result, "0x8.0p-2 33") == 0);
 212     ASSERT (retval == strlen (result));
 213   }
 214
 215   { /* Width.  */
 216     char result[1000];
 217     int retval =
 218       my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
 219     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 220             || strcmp (result, "  0x3.8p-1 33") == 0
 221             || strcmp (result, "    0x7p-2 33") == 0
 222             || strcmp (result, "    0xep-3 33") == 0);
 223     ASSERT (retval == strlen (result));
 224   }
 225
 226   { /* Small precision.  */
 227     char result[1000];
 228     int retval =
 229       my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
 230     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 231             || strcmp (result, "0x3.8000000000p-1 33") == 0
 232             || strcmp (result, "0x7.0000000000p-2 33") == 0
 233             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 234     ASSERT (retval == strlen (result));
 235   }
 236
 237   { /* Large precision.  */
 238     char result[1000];
 239     int retval =
 240       my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
 241     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 242             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 243             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 244             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 245     ASSERT (retval == strlen (result));
 246   }
 247
 248   { /* FLAG_LEFT.  */
 249     char result[1000];
 250     int retval =
 251       my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
 252     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 253             || strcmp (result, "0x3.8p-1   33") == 0
 254             || strcmp (result, "0x7p-2     33") == 0
 255             || strcmp (result, "0xep-3     33") == 0);
 256     ASSERT (retval == strlen (result));
 257   }
 258
 259   { /* FLAG_SHOWSIGN.  */
 260     char result[1000];
 261     int retval =
 262       my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
 263     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 264             || strcmp (result, "+0x3.8p-1 33") == 0
 265             || strcmp (result, "+0x7p-2 33") == 0
 266             || strcmp (result, "+0xep-3 33") == 0);
 267     ASSERT (retval == strlen (result));
 268   }
 269
 270   { /* FLAG_SPACE.  */
 271     char result[1000];
 272     int retval =
 273       my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
 274     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 275             || strcmp (result, " 0x3.8p-1 33") == 0
 276             || strcmp (result, " 0x7p-2 33") == 0
 277             || strcmp (result, " 0xep-3 33") == 0);
 278     ASSERT (retval == strlen (result));
 279   }
 280
 281   { /* FLAG_ALT.  */
 282     char result[1000];
 283     int retval =
 284       my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
 285     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 286             || strcmp (result, "0x3.8p-1 33") == 0
 287             || strcmp (result, "0x7.p-2 33") == 0
 288             || strcmp (result, "0xe.p-3 33") == 0);
 289     ASSERT (retval == strlen (result));
 290   }
 291
 292   { /* FLAG_ALT.  */
 293     char result[1000];
 294     int retval =
 295       my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
 296     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 297             || strcmp (result, "0x2.p-1 33") == 0
 298             || strcmp (result, "0x4.p-2 33") == 0
 299             || strcmp (result, "0x8.p-3 33") == 0);
 300     ASSERT (retval == strlen (result));
 301   }
 302
 303   { /* FLAG_ZERO with finite number.  */
 304     char result[1000];
 305     int retval =
 306       my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
 307     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 308             || strcmp (result, "0x003.8p-1 33") == 0
 309             || strcmp (result, "0x00007p-2 33") == 0
 310             || strcmp (result, "0x0000ep-3 33") == 0);
 311     ASSERT (retval == strlen (result));
 312   }
 313
 314   { /* FLAG_ZERO with infinite number.  */
 315     char result[1000];
 316     int retval =
 317       my_sprintf (result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 318     ASSERT (strcmp (result, "       inf 33") == 0);
 319     ASSERT (retval == strlen (result));
 320   }
 321
 322   { /* FLAG_ZERO with NaN.  */
 323     char result[1000];
 324     int retval =
 325       my_sprintf (result, "%010a %d", 0.0 / 0.0, 33, 44, 55);
 326     ASSERT (strcmp (result, "       nan 33") == 0);
 327     ASSERT (retval == strlen (result));
 328   }
 329
 330 #if HAVE_LONG_DOUBLE
 331
 332   { /* A positive number.  */
 333     char result[1000];
 334     int retval =
 335       my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
 336     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 337             || strcmp (result, "0x3.244p+0 33") == 0
 338             || strcmp (result, "0x6.488p-1 33") == 0
 339             || strcmp (result, "0xc.91p-2 33") == 0);
 340     ASSERT (retval == strlen (result));
 341   }
 342
 343   { /* A negative number.  */
 344     char result[1000];
 345     int retval =
 346       my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
 347     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 348             || strcmp (result, "-0X3.244P+0 33") == 0
 349             || strcmp (result, "-0X6.488P-1 33") == 0
 350             || strcmp (result, "-0XC.91P-2 33") == 0);
 351     ASSERT (retval == strlen (result));
 352   }
 353
 354   { /* Positive zero.  */
 355     char result[1000];
 356     int retval =
 357       my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
 358     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 359     ASSERT (retval == strlen (result));
 360   }
 361
 362   { /* Negative zero.  */
 363     char result[1000];
 364     int retval =
 365       my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
 366     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 367     ASSERT (retval == strlen (result));
 368   }
 369
 370   { /* Positive infinity.  */
 371     char result[1000];
 372     int retval =
 373       my_sprintf (result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
 374     ASSERT (strcmp (result, "inf 33") == 0);
 375     ASSERT (retval == strlen (result));
 376   }
 377
 378   { /* Negative infinity.  */
 379     char result[1000];
 380     int retval =
 381       my_sprintf (result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
 382     ASSERT (strcmp (result, "-inf 33") == 0);
 383     ASSERT (retval == strlen (result));
 384   }
 385
 386   { /* NaN.  */
 387     char result[1000];
 388     int retval =
 389       my_sprintf (result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
 390     ASSERT (strcmp (result, "nan 33") == 0);
 391     ASSERT (retval == strlen (result));
 392   }
 393
 394   { /* Rounding near the decimal point.  */
 395     char result[1000];
 396     int retval =
 397       my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
 398     ASSERT (strcmp (result, "0x2p+0 33") == 0
 399             || strcmp (result, "0x3p-1 33") == 0
 400             || strcmp (result, "0x6p-2 33") == 0
 401             || strcmp (result, "0xcp-3 33") == 0);
 402     ASSERT (retval == strlen (result));
 403   }
 404
 405   { /* Rounding with precision 0.  */
 406     char result[1000];
 407     int retval =
 408       my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
 409     ASSERT (strcmp (result, "0x2p+0 33") == 0
 410             || strcmp (result, "0x3p-1 33") == 0
 411             || strcmp (result, "0x6p-2 33") == 0
 412             || strcmp (result, "0xcp-3 33") == 0);
 413     ASSERT (retval == strlen (result));
 414   }
 415
 416   { /* Rounding with precision 1.  */
 417     char result[1000];
 418     int retval =
 419       my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
 420     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 421             || strcmp (result, "0x3.0p-1 33") == 0
 422             || strcmp (result, "0x6.1p-2 33") == 0
 423             || strcmp (result, "0xc.1p-3 33") == 0);
 424     ASSERT (retval == strlen (result));
 425   }
 426
 427   { /* Rounding with precision 2.  */
 428     char result[1000];
 429     int retval =
 430       my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
 431     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 432             || strcmp (result, "0x3.05p-1 33") == 0
 433             || strcmp (result, "0x6.0ap-2 33") == 0
 434             || strcmp (result, "0xc.14p-3 33") == 0);
 435     ASSERT (retval == strlen (result));
 436   }
 437
 438   { /* Rounding with precision 3.  */
 439     char result[1000];
 440     int retval =
 441       my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
 442     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 443             || strcmp (result, "0x3.052p-1 33") == 0
 444             || strcmp (result, "0x6.0a4p-2 33") == 0
 445             || strcmp (result, "0xc.148p-3 33") == 0);
 446     ASSERT (retval == strlen (result));
 447   }
 448
 449   { /* Rounding can turn a ...FFF into a ...000.  */
 450     char result[1000];
 451     int retval =
 452       my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
 453     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 454             || strcmp (result, "0x3.000p-1 33") == 0
 455             || strcmp (result, "0x6.000p-2 33") == 0
 456             || strcmp (result, "0xc.000p-3 33") == 0);
 457     ASSERT (retval == strlen (result));
 458   }
 459
 460   { /* Rounding can turn a ...FFF into a ...000.
 461        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 462        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 463     char result[1000];
 464     int retval =
 465       my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
 466     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 467             || strcmp (result, "0x2.0p+0 33") == 0
 468             || strcmp (result, "0x4.0p-1 33") == 0
 469             || strcmp (result, "0x8.0p-2 33") == 0);
 470     ASSERT (retval == strlen (result));
 471   }
 472
 473   { /* Width.  */
 474     char result[1000];
 475     int retval =
 476       my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
 477     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 478             || strcmp (result, "  0x3.8p-1 33") == 0
 479             || strcmp (result, "    0x7p-2 33") == 0
 480             || strcmp (result, "    0xep-3 33") == 0);
 481     ASSERT (retval == strlen (result));
 482   }
 483
 484   { /* Small precision.  */
 485     char result[1000];
 486     int retval =
 487       my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
 488     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 489             || strcmp (result, "0x3.8000000000p-1 33") == 0
 490             || strcmp (result, "0x7.0000000000p-2 33") == 0
 491             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 492     ASSERT (retval == strlen (result));
 493   }
 494
 495   { /* Large precision.  */
 496     char result[1000];
 497     int retval =
 498       my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
 499     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 500             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 501             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 502             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 503     ASSERT (retval == strlen (result));
 504   }
 505
 506   { /* FLAG_LEFT.  */
 507     char result[1000];
 508     int retval =
 509       my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
 510     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 511             || strcmp (result, "0x3.8p-1   33") == 0
 512             || strcmp (result, "0x7p-2     33") == 0
 513             || strcmp (result, "0xep-3     33") == 0);
 514     ASSERT (retval == strlen (result));
 515   }
 516
 517   { /* FLAG_SHOWSIGN.  */
 518     char result[1000];
 519     int retval =
 520       my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
 521     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 522             || strcmp (result, "+0x3.8p-1 33") == 0
 523             || strcmp (result, "+0x7p-2 33") == 0
 524             || strcmp (result, "+0xep-3 33") == 0);
 525     ASSERT (retval == strlen (result));
 526   }
 527
 528   { /* FLAG_SPACE.  */
 529     char result[1000];
 530     int retval =
 531       my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
 532     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 533             || strcmp (result, " 0x3.8p-1 33") == 0
 534             || strcmp (result, " 0x7p-2 33") == 0
 535             || strcmp (result, " 0xep-3 33") == 0);
 536     ASSERT (retval == strlen (result));
 537   }
 538
 539   { /* FLAG_ALT.  */
 540     char result[1000];
 541     int retval =
 542       my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
 543     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 544             || strcmp (result, "0x3.8p-1 33") == 0
 545             || strcmp (result, "0x7.p-2 33") == 0
 546             || strcmp (result, "0xe.p-3 33") == 0);
 547     ASSERT (retval == strlen (result));
 548   }
 549
 550   { /* FLAG_ALT.  */
 551     char result[1000];
 552     int retval =
 553       my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
 554     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 555             || strcmp (result, "0x2.p-1 33") == 0
 556             || strcmp (result, "0x4.p-2 33") == 0
 557             || strcmp (result, "0x8.p-3 33") == 0);
 558     ASSERT (retval == strlen (result));
 559   }
 560
 561   { /* FLAG_ZERO with finite number.  */
 562     char result[1000];
 563     int retval =
 564       my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
 565     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 566             || strcmp (result, "0x003.8p-1 33") == 0
 567             || strcmp (result, "0x00007p-2 33") == 0
 568             || strcmp (result, "0x0000ep-3 33") == 0);
 569     ASSERT (retval == strlen (result));
 570   }
 571
 572   { /* FLAG_ZERO with infinite number.  */
 573     char result[1000];
 574     int retval =
 575       my_sprintf (result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 576     ASSERT (strcmp (result, "       inf 33") == 0);
 577     ASSERT (retval == strlen (result));
 578   }
 579
 580   { /* FLAG_ZERO with NaN.  */
 581     char result[1000];
 582     int retval =
 583       my_sprintf (result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 584     ASSERT (strcmp (result, "       nan 33") == 0);
 585     ASSERT (retval == strlen (result));
 586   }
 587
 588 #endif
 589
 590   /* Test the support of the %n format directive.  */
 591
 592   {
 593     int count = -1;
 594     char result[1000];
 595     int retval =
 596       my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
 597     ASSERT (strcmp (result, "123 ") == 0);
 598     ASSERT (retval == strlen (result));
 599     ASSERT (count == 4);
 600   }
 601
 602   /* Test the support of the POSIX/XSI format strings with positions.  */
 603
 604   {
 605     char result[1000];
 606     int retval =
 607       my_sprintf (result, "%2$d %1$d", 33, 55);
 608     ASSERT (strcmp (result, "55 33") == 0);
 609     ASSERT (retval == strlen (result));
 610   }
 611 }