tests/test-snprintf-posix.h

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