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 static void
  21 test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
  22 {
  23   char buf[8];
  24   int size;
  25
  26   /* Test return value convention.  */
  27
  28   for (size = 0; size <= 8; size++)
  29     {
  30       int retval;
  31
  32       memcpy (buf, "DEADBEEF", 8);
  33       retval = my_snprintf (buf, size, "%d", 12345);
  34       ASSERT (retval == 5);
  35       if (size < 6)
  36         {
  37           if (size > 0)
  38             {
  39               ASSERT (memcmp (buf, "12345", size - 1) == 0);
  40               ASSERT (buf[size - 1] == '\0');
  41             }
  42           ASSERT (memcmp (buf + size, "DEADBEEF" + size, 8 - size) == 0);
  43         }
  44       else
  45         {
  46           ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
  47         }
  48     }
  49
  50   /* Test support of size specifiers as in C99.  */
  51
  52   {
  53     char result[100];
  54     int retval =
  55       my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  56     ASSERT (strcmp (result, "12345671 33") == 0);
  57     ASSERT (retval == strlen (result));
  58   }
  59
  60   {
  61     char result[100];
  62     int retval =
  63       my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
  64     ASSERT (strcmp (result, "12345672 33") == 0);
  65     ASSERT (retval == strlen (result));
  66   }
  67
  68   {
  69     char result[100];
  70     int retval =
  71       my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
  72     ASSERT (strcmp (result, "12345673 33") == 0);
  73     ASSERT (retval == strlen (result));
  74   }
  75
  76 #if HAVE_LONG_DOUBLE
  77   {
  78     char result[100];
  79     int retval =
  80       my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
  81     ASSERT (strcmp (result, "1.5 33") == 0);
  82     ASSERT (retval == strlen (result));
  83   }
  84 #endif
  85
  86   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
  87      output of floating-point numbers.  */
  88
  89   { /* A positive number.  */
  90     char result[100];
  91     int retval =
  92       my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
  93     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
  94             || strcmp (result, "0x3.244p+0 33") == 0
  95             || strcmp (result, "0x6.488p-1 33") == 0
  96             || strcmp (result, "0xc.91p-2 33") == 0);
  97     ASSERT (retval == strlen (result));
  98   }
  99
 100   { /* A negative number.  */
 101     char result[100];
 102     int retval =
 103       my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
 104     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 105             || strcmp (result, "-0X3.244P+0 33") == 0
 106             || strcmp (result, "-0X6.488P-1 33") == 0
 107             || strcmp (result, "-0XC.91P-2 33") == 0);
 108     ASSERT (retval == strlen (result));
 109   }
 110
 111   { /* Positive zero.  */
 112     char result[100];
 113     int retval =
 114       my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
 115     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 116     ASSERT (retval == strlen (result));
 117   }
 118
 119   { /* Negative zero.  */
 120     char result[100];
 121     int retval =
 122       my_snprintf (result, sizeof (result), "%a %d", -0.0, 33, 44, 55);
 123     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 124     ASSERT (retval == strlen (result));
 125   }
 126
 127   { /* Positive infinity.  */
 128     char result[100];
 129     int retval =
 130       my_snprintf (result, sizeof (result), "%a %d", 1.0 / 0.0, 33, 44, 55);
 131     ASSERT (strcmp (result, "inf 33") == 0);
 132     ASSERT (retval == strlen (result));
 133   }
 134
 135   { /* Negative infinity.  */
 136     char result[100];
 137     int retval =
 138       my_snprintf (result, sizeof (result), "%a %d", -1.0 / 0.0, 33, 44, 55);
 139     ASSERT (strcmp (result, "-inf 33") == 0);
 140     ASSERT (retval == strlen (result));
 141   }
 142
 143   { /* NaN.  */
 144     char result[100];
 145     int retval =
 146       my_snprintf (result, sizeof (result), "%a %d", 0.0 / 0.0, 33, 44, 55);
 147     ASSERT (strcmp (result, "nan 33") == 0);
 148     ASSERT (retval == strlen (result));
 149   }
 150
 151   { /* Rounding near the decimal point.  */
 152     char result[100];
 153     int retval =
 154       my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
 155     ASSERT (strcmp (result, "0x2p+0 33") == 0
 156             || strcmp (result, "0x3p-1 33") == 0
 157             || strcmp (result, "0x6p-2 33") == 0
 158             || strcmp (result, "0xcp-3 33") == 0);
 159     ASSERT (retval == strlen (result));
 160   }
 161
 162   { /* Rounding with precision 0.  */
 163     char result[100];
 164     int retval =
 165       my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
 166     ASSERT (strcmp (result, "0x2p+0 33") == 0
 167             || strcmp (result, "0x3p-1 33") == 0
 168             || strcmp (result, "0x6p-2 33") == 0
 169             || strcmp (result, "0xcp-3 33") == 0);
 170     ASSERT (retval == strlen (result));
 171   }
 172
 173   { /* Rounding with precision 1.  */
 174     char result[100];
 175     int retval =
 176       my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
 177     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 178             || strcmp (result, "0x3.0p-1 33") == 0
 179             || strcmp (result, "0x6.1p-2 33") == 0
 180             || strcmp (result, "0xc.1p-3 33") == 0);
 181     ASSERT (retval == strlen (result));
 182   }
 183
 184   { /* Rounding with precision 2.  */
 185     char result[100];
 186     int retval =
 187       my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
 188     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 189             || strcmp (result, "0x3.05p-1 33") == 0
 190             || strcmp (result, "0x6.0ap-2 33") == 0
 191             || strcmp (result, "0xc.14p-3 33") == 0);
 192     ASSERT (retval == strlen (result));
 193   }
 194
 195   { /* Rounding with precision 3.  */
 196     char result[100];
 197     int retval =
 198       my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
 199     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 200             || strcmp (result, "0x3.052p-1 33") == 0
 201             || strcmp (result, "0x6.0a4p-2 33") == 0
 202             || strcmp (result, "0xc.148p-3 33") == 0);
 203     ASSERT (retval == strlen (result));
 204   }
 205
 206   { /* Rounding can turn a ...FFF into a ...000.  */
 207     char result[100];
 208     int retval =
 209       my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
 210     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 211             || strcmp (result, "0x3.000p-1 33") == 0
 212             || strcmp (result, "0x6.000p-2 33") == 0
 213             || strcmp (result, "0xc.000p-3 33") == 0);
 214     ASSERT (retval == strlen (result));
 215   }
 216
 217   { /* Rounding can turn a ...FFF into a ...000.
 218        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 219     char result[100];
 220     int retval =
 221       my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
 222     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 223             || strcmp (result, "0x2.0p+0 33") == 0
 224             || strcmp (result, "0x4.0p-1 33") == 0
 225             || strcmp (result, "0x8.0p-2 33") == 0);
 226     ASSERT (retval == strlen (result));
 227   }
 228
 229   { /* Width.  */
 230     char result[100];
 231     int retval =
 232       my_snprintf (result, sizeof (result), "%10a %d", 1.75, 33, 44, 55);
 233     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 234             || strcmp (result, "  0x3.8p-1 33") == 0
 235             || strcmp (result, "    0x7p-2 33") == 0
 236             || strcmp (result, "    0xep-3 33") == 0);
 237     ASSERT (retval == strlen (result));
 238   }
 239
 240   { /* Small precision.  */
 241     char result[100];
 242     int retval =
 243       my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
 244     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 245             || strcmp (result, "0x3.8000000000p-1 33") == 0
 246             || strcmp (result, "0x7.0000000000p-2 33") == 0
 247             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 248     ASSERT (retval == strlen (result));
 249   }
 250
 251   { /* Large precision.  */
 252     char result[100];
 253     int retval =
 254       my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
 255     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 256             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 257             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 258             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 259     ASSERT (retval == strlen (result));
 260   }
 261
 262   { /* FLAG_LEFT.  */
 263     char result[100];
 264     int retval =
 265       my_snprintf (result, sizeof (result), "%-10a %d", 1.75, 33, 44, 55);
 266     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 267             || strcmp (result, "0x3.8p-1   33") == 0
 268             || strcmp (result, "0x7p-2     33") == 0
 269             || strcmp (result, "0xep-3     33") == 0);
 270     ASSERT (retval == strlen (result));
 271   }
 272
 273   { /* FLAG_SHOWSIGN.  */
 274     char result[100];
 275     int retval =
 276       my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
 277     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 278             || strcmp (result, "+0x3.8p-1 33") == 0
 279             || strcmp (result, "+0x7p-2 33") == 0
 280             || strcmp (result, "+0xep-3 33") == 0);
 281     ASSERT (retval == strlen (result));
 282   }
 283
 284   { /* FLAG_SPACE.  */
 285     char result[100];
 286     int retval =
 287       my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
 288     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 289             || strcmp (result, " 0x3.8p-1 33") == 0
 290             || strcmp (result, " 0x7p-2 33") == 0
 291             || strcmp (result, " 0xep-3 33") == 0);
 292     ASSERT (retval == strlen (result));
 293   }
 294
 295   { /* FLAG_ALT.  */
 296     char result[100];
 297     int retval =
 298       my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
 299     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 300             || strcmp (result, "0x3.8p-1 33") == 0
 301             || strcmp (result, "0x7.p-2 33") == 0
 302             || strcmp (result, "0xe.p-3 33") == 0);
 303     ASSERT (retval == strlen (result));
 304   }
 305
 306   { /* FLAG_ALT.  */
 307     char result[100];
 308     int retval =
 309       my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
 310     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 311             || strcmp (result, "0x2.p-1 33") == 0
 312             || strcmp (result, "0x4.p-2 33") == 0
 313             || strcmp (result, "0x8.p-3 33") == 0);
 314     ASSERT (retval == strlen (result));
 315   }
 316
 317   { /* FLAG_ZERO with finite number.  */
 318     char result[100];
 319     int retval =
 320       my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
 321     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 322             || strcmp (result, "0x003.8p-1 33") == 0
 323             || strcmp (result, "0x00007p-2 33") == 0
 324             || strcmp (result, "0x0000ep-3 33") == 0);
 325     ASSERT (retval == strlen (result));
 326   }
 327
 328   { /* FLAG_ZERO with infinite number.  */
 329     char result[100];
 330     int retval =
 331       my_snprintf (result, sizeof (result), "%010a %d", 1.0 / 0.0, 33, 44, 55);
 332     ASSERT (strcmp (result, "       inf 33") == 0);
 333     ASSERT (retval == strlen (result));
 334   }
 335
 336   { /* FLAG_ZERO with NaN.  */
 337     char result[100];
 338     int retval =
 339       my_snprintf (result, sizeof (result), "%010a %d", 0.0 / 0.0, 33, 44, 55);
 340     ASSERT (strcmp (result, "       nan 33") == 0);
 341     ASSERT (retval == strlen (result));
 342   }
 343
 344 #if HAVE_LONG_DOUBLE
 345
 346   { /* A positive number.  */
 347     char result[100];
 348     int retval =
 349       my_snprintf (result, sizeof (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[100];
 359     int retval =
 360       my_snprintf (result, sizeof (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[100];
 370     int retval =
 371       my_snprintf (result, sizeof (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[100];
 378     int retval =
 379       my_snprintf (result, sizeof (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[100];
 386     int retval =
 387       my_snprintf (result, sizeof (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[100];
 394     int retval =
 395       my_snprintf (result, sizeof (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[100];
 402     int retval =
 403       my_snprintf (result, sizeof (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[100];
 410     int retval =
 411       my_snprintf (result, sizeof (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[100];
 421     int retval =
 422       my_snprintf (result, sizeof (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[100];
 432     int retval =
 433       my_snprintf (result, sizeof (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[100];
 443     int retval =
 444       my_snprintf (result, sizeof (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[100];
 454     int retval =
 455       my_snprintf (result, sizeof (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[100];
 465     int retval =
 466       my_snprintf (result, sizeof (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[100];
 478     int retval =
 479       my_snprintf (result, sizeof (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[100];
 489     int retval =
 490       my_snprintf (result, sizeof (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[100];
 500     int retval =
 501       my_snprintf (result, sizeof (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[100];
 511     int retval =
 512       my_snprintf (result, sizeof (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[100];
 522     int retval =
 523       my_snprintf (result, sizeof (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[100];
 533     int retval =
 534       my_snprintf (result, sizeof (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[100];
 544     int retval =
 545       my_snprintf (result, sizeof (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[100];
 555     int retval =
 556       my_snprintf (result, sizeof (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[100];
 566     int retval =
 567       my_snprintf (result, sizeof (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[100];
 577     int retval =
 578       my_snprintf (result, sizeof (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[100];
 588     int retval =
 589       my_snprintf (result, sizeof (result), "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 590     ASSERT (strcmp (result, "       inf 33") == 0);
 591     ASSERT (retval == strlen (result));
 592   }
 593
 594   { /* FLAG_ZERO with NaN.  */
 595     char result[100];
 596     int retval =
 597       my_snprintf (result, sizeof (result), "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 598     ASSERT (strcmp (result, "       nan 33") == 0);
 599     ASSERT (retval == strlen (result));
 600   }
 601
 602 #endif
 603
 604   /* Test the support of the %n format directive.  */
 605
 606   {
 607     int count = -1;
 608     char result[100];
 609     int retval =
 610       my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
 611     ASSERT (strcmp (result, "123 ") == 0);
 612     ASSERT (retval == strlen (result));
 613     ASSERT (count == 4);
 614   }
 615
 616   /* Test the support of the POSIX/XSI format strings with positions.  */
 617
 618   {
 619     char result[100];
 620     int retval =
 621       my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
 622     ASSERT (strcmp (result, "55 33") == 0);
 623     ASSERT (retval == strlen (result));
 624   }
 625 }