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