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     /* "0000000inf 33" is not a valid result; see
 343        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 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     /* "0000000nan 33" is not a valid result; see
 353        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 354     ASSERT (strcmp (result, "       nan 33") == 0);
 355     ASSERT (retval == strlen (result));
 356   }
 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     /* "0000000inf 33" is not a valid result; see
 603        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 604     ASSERT (strcmp (result, "       inf 33") == 0);
 605     ASSERT (retval == strlen (result));
 606   }
 607
 608   { /* FLAG_ZERO with NaN.  */
 609     char result[100];
 610     int retval =
 611       my_snprintf (result, sizeof (result), "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 612     /* "0000000nan 33" is not a valid result; see
 613        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 614     ASSERT (strcmp (result, "       nan 33") == 0);
 615     ASSERT (retval == strlen (result));
 616   }
 617
 618   /* Test the support of the %n format directive.  */
 619
 620   {
 621     int count = -1;
 622     char result[100];
 623     int retval =
 624       my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
 625     ASSERT (strcmp (result, "123 ") == 0);
 626     ASSERT (retval == strlen (result));
 627     ASSERT (count == 4);
 628   }
 629
 630   /* Test the support of the POSIX/XSI format strings with positions.  */
 631
 632   {
 633     char result[100];
 634     int retval =
 635       my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
 636     ASSERT (strcmp (result, "55 33") == 0);
 637     ASSERT (retval == strlen (result));
 638   }
 639 }