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             || strcmp (result, "0000000inf 33") == 0);
 346     ASSERT (retval == strlen (result));
 347   }
 348
 349   { /* FLAG_ZERO with NaN.  */
 350     char result[100];
 351     int retval =
 352       my_snprintf (result, sizeof (result), "%010a %d", NaN (), 33, 44, 55);
 353     ASSERT (strcmp (result, "       nan 33") == 0
 354             || strcmp (result, "0000000nan 33") == 0);
 355     ASSERT (retval == strlen (result));
 356   }
 357
 358 #if HAVE_LONG_DOUBLE
 359
 360   { /* A positive number.  */
 361     char result[100];
 362     int retval =
 363       my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
 364     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 365             || strcmp (result, "0x3.244p+0 33") == 0
 366             || strcmp (result, "0x6.488p-1 33") == 0
 367             || strcmp (result, "0xc.91p-2 33") == 0);
 368     ASSERT (retval == strlen (result));
 369   }
 370
 371   { /* A negative number.  */
 372     char result[100];
 373     int retval =
 374       my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
 375     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 376             || strcmp (result, "-0X3.244P+0 33") == 0
 377             || strcmp (result, "-0X6.488P-1 33") == 0
 378             || strcmp (result, "-0XC.91P-2 33") == 0);
 379     ASSERT (retval == strlen (result));
 380   }
 381
 382   { /* Positive zero.  */
 383     char result[100];
 384     int retval =
 385       my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
 386     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 387     ASSERT (retval == strlen (result));
 388   }
 389
 390   { /* Negative zero.  */
 391     char result[100];
 392     int retval =
 393       my_snprintf (result, sizeof (result), "%La %d", -0.0L, 33, 44, 55);
 394     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 395     ASSERT (retval == strlen (result));
 396   }
 397
 398   { /* Positive infinity.  */
 399     char result[100];
 400     int retval =
 401       my_snprintf (result, sizeof (result), "%La %d", 1.0L / 0.0L, 33, 44, 55);
 402     ASSERT (strcmp (result, "inf 33") == 0);
 403     ASSERT (retval == strlen (result));
 404   }
 405
 406   { /* Negative infinity.  */
 407     char result[100];
 408     int retval =
 409       my_snprintf (result, sizeof (result), "%La %d", -1.0L / 0.0L, 33, 44, 55);
 410     ASSERT (strcmp (result, "-inf 33") == 0);
 411     ASSERT (retval == strlen (result));
 412   }
 413
 414   { /* NaN.  */
 415     char result[100];
 416     int retval =
 417       my_snprintf (result, sizeof (result), "%La %d", 0.0L / 0.0L, 33, 44, 55);
 418     ASSERT (strcmp (result, "nan 33") == 0);
 419     ASSERT (retval == strlen (result));
 420   }
 421
 422   { /* Rounding near the decimal point.  */
 423     char result[100];
 424     int retval =
 425       my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
 426     ASSERT (strcmp (result, "0x2p+0 33") == 0
 427             || strcmp (result, "0x3p-1 33") == 0
 428             || strcmp (result, "0x6p-2 33") == 0
 429             || strcmp (result, "0xcp-3 33") == 0);
 430     ASSERT (retval == strlen (result));
 431   }
 432
 433   { /* Rounding with precision 0.  */
 434     char result[100];
 435     int retval =
 436       my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
 437     ASSERT (strcmp (result, "0x2p+0 33") == 0
 438             || strcmp (result, "0x3p-1 33") == 0
 439             || strcmp (result, "0x6p-2 33") == 0
 440             || strcmp (result, "0xcp-3 33") == 0);
 441     ASSERT (retval == strlen (result));
 442   }
 443
 444   { /* Rounding with precision 1.  */
 445     char result[100];
 446     int retval =
 447       my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
 448     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 449             || strcmp (result, "0x3.0p-1 33") == 0
 450             || strcmp (result, "0x6.1p-2 33") == 0
 451             || strcmp (result, "0xc.1p-3 33") == 0);
 452     ASSERT (retval == strlen (result));
 453   }
 454
 455   { /* Rounding with precision 2.  */
 456     char result[100];
 457     int retval =
 458       my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
 459     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 460             || strcmp (result, "0x3.05p-1 33") == 0
 461             || strcmp (result, "0x6.0ap-2 33") == 0
 462             || strcmp (result, "0xc.14p-3 33") == 0);
 463     ASSERT (retval == strlen (result));
 464   }
 465
 466   { /* Rounding with precision 3.  */
 467     char result[100];
 468     int retval =
 469       my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
 470     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 471             || strcmp (result, "0x3.052p-1 33") == 0
 472             || strcmp (result, "0x6.0a4p-2 33") == 0
 473             || strcmp (result, "0xc.148p-3 33") == 0);
 474     ASSERT (retval == strlen (result));
 475   }
 476
 477   { /* Rounding can turn a ...FFF into a ...000.  */
 478     char result[100];
 479     int retval =
 480       my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
 481     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 482             || strcmp (result, "0x3.000p-1 33") == 0
 483             || strcmp (result, "0x6.000p-2 33") == 0
 484             || strcmp (result, "0xc.000p-3 33") == 0);
 485     ASSERT (retval == strlen (result));
 486   }
 487
 488   { /* Rounding can turn a ...FFF into a ...000.
 489        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 490        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 491     char result[100];
 492     int retval =
 493       my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
 494     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 495             || strcmp (result, "0x2.0p+0 33") == 0
 496             || strcmp (result, "0x4.0p-1 33") == 0
 497             || strcmp (result, "0x8.0p-2 33") == 0);
 498     ASSERT (retval == strlen (result));
 499   }
 500
 501   { /* Width.  */
 502     char result[100];
 503     int retval =
 504       my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
 505     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 506             || strcmp (result, "  0x3.8p-1 33") == 0
 507             || strcmp (result, "    0x7p-2 33") == 0
 508             || strcmp (result, "    0xep-3 33") == 0);
 509     ASSERT (retval == strlen (result));
 510   }
 511
 512   { /* Small precision.  */
 513     char result[100];
 514     int retval =
 515       my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
 516     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 517             || strcmp (result, "0x3.8000000000p-1 33") == 0
 518             || strcmp (result, "0x7.0000000000p-2 33") == 0
 519             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 520     ASSERT (retval == strlen (result));
 521   }
 522
 523   { /* Large precision.  */
 524     char result[100];
 525     int retval =
 526       my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
 527     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 528             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 529             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 530             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 531     ASSERT (retval == strlen (result));
 532   }
 533
 534   { /* FLAG_LEFT.  */
 535     char result[100];
 536     int retval =
 537       my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
 538     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 539             || strcmp (result, "0x3.8p-1   33") == 0
 540             || strcmp (result, "0x7p-2     33") == 0
 541             || strcmp (result, "0xep-3     33") == 0);
 542     ASSERT (retval == strlen (result));
 543   }
 544
 545   { /* FLAG_SHOWSIGN.  */
 546     char result[100];
 547     int retval =
 548       my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
 549     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 550             || strcmp (result, "+0x3.8p-1 33") == 0
 551             || strcmp (result, "+0x7p-2 33") == 0
 552             || strcmp (result, "+0xep-3 33") == 0);
 553     ASSERT (retval == strlen (result));
 554   }
 555
 556   { /* FLAG_SPACE.  */
 557     char result[100];
 558     int retval =
 559       my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
 560     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 561             || strcmp (result, " 0x3.8p-1 33") == 0
 562             || strcmp (result, " 0x7p-2 33") == 0
 563             || strcmp (result, " 0xep-3 33") == 0);
 564     ASSERT (retval == strlen (result));
 565   }
 566
 567   { /* FLAG_ALT.  */
 568     char result[100];
 569     int retval =
 570       my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
 571     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 572             || strcmp (result, "0x3.8p-1 33") == 0
 573             || strcmp (result, "0x7.p-2 33") == 0
 574             || strcmp (result, "0xe.p-3 33") == 0);
 575     ASSERT (retval == strlen (result));
 576   }
 577
 578   { /* FLAG_ALT.  */
 579     char result[100];
 580     int retval =
 581       my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
 582     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 583             || strcmp (result, "0x2.p-1 33") == 0
 584             || strcmp (result, "0x4.p-2 33") == 0
 585             || strcmp (result, "0x8.p-3 33") == 0);
 586     ASSERT (retval == strlen (result));
 587   }
 588
 589   { /* FLAG_ZERO with finite number.  */
 590     char result[100];
 591     int retval =
 592       my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
 593     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 594             || strcmp (result, "0x003.8p-1 33") == 0
 595             || strcmp (result, "0x00007p-2 33") == 0
 596             || strcmp (result, "0x0000ep-3 33") == 0);
 597     ASSERT (retval == strlen (result));
 598   }
 599
 600   { /* FLAG_ZERO with infinite number.  */
 601     char result[100];
 602     int retval =
 603       my_snprintf (result, sizeof (result), "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 604     ASSERT (strcmp (result, "       inf 33") == 0
 605             || strcmp (result, "0000000inf 33") == 0);
 606     ASSERT (retval == strlen (result));
 607   }
 608
 609   { /* FLAG_ZERO with NaN.  */
 610     char result[100];
 611     int retval =
 612       my_snprintf (result, sizeof (result), "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 613     ASSERT (strcmp (result, "       nan 33") == 0
 614             || strcmp (result, "0000000nan 33") == 0);
 615     ASSERT (retval == strlen (result));
 616   }
 617
 618 #endif
 619
 620   /* Test the support of the %n format directive.  */
 621
 622   {
 623     int count = -1;
 624     char result[100];
 625     int retval =
 626       my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
 627     ASSERT (strcmp (result, "123 ") == 0);
 628     ASSERT (retval == strlen (result));
 629     ASSERT (count == 4);
 630   }
 631
 632   /* Test the support of the POSIX/XSI format strings with positions.  */
 633
 634   {
 635     char result[100];
 636     int retval =
 637       my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
 638     ASSERT (strcmp (result, "55 33") == 0);
 639     ASSERT (retval == strlen (result));
 640   }
 641 }