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 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0.  */
  33 static int
  34 have_minus_zero ()
  35 {
  36   static double plus_zero = 0.0;
  37   static double minus_zero = -0.0;
  38   return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  39 }
  40
  41 static int
  42 strmatch (const char *pattern, const char *string)
  43 {
  44   if (strlen (pattern) != strlen (string))
  45     return 0;
  46   for (; *pattern != '\0'; pattern++, string++)
  47     if (*pattern != '*' && *string != *pattern)
  48       return 0;
  49   return 1;
  50 }
  51
  52 static void
  53 test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
  54 {
  55   char buf[8];
  56   int size;
  57
  58   /* Test return value convention.  */
  59
  60   for (size = 0; size <= 8; size++)
  61     {
  62       int retval;
  63
  64       memcpy (buf, "DEADBEEF", 8);
  65       retval = my_snprintf (buf, size, "%d", 12345);
  66       ASSERT (retval == 5);
  67       if (size < 6)
  68         {
  69           if (size > 0)
  70             {
  71               ASSERT (memcmp (buf, "12345", size - 1) == 0);
  72               ASSERT (buf[size - 1] == '\0');
  73             }
  74           ASSERT (memcmp (buf + size, "DEADBEEF" + size, 8 - size) == 0);
  75         }
  76       else
  77         {
  78           ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
  79         }
  80     }
  81
  82   /* Test support of size specifiers as in C99.  */
  83
  84   {
  85     char result[100];
  86     int retval =
  87       my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  88     ASSERT (strcmp (result, "12345671 33") == 0);
  89     ASSERT (retval == strlen (result));
  90   }
  91
  92   {
  93     char result[100];
  94     int retval =
  95       my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
  96     ASSERT (strcmp (result, "12345672 33") == 0);
  97     ASSERT (retval == strlen (result));
  98   }
  99
 100   {
 101     char result[100];
 102     int retval =
 103       my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
 104     ASSERT (strcmp (result, "12345673 33") == 0);
 105     ASSERT (retval == strlen (result));
 106   }
 107
 108   {
 109     char result[100];
 110     int retval =
 111       my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
 112     ASSERT (strcmp (result, "1.5 33") == 0);
 113     ASSERT (retval == strlen (result));
 114   }
 115
 116   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 117      output of floating-point numbers.  */
 118
 119   { /* A positive number.  */
 120     char result[100];
 121     int retval =
 122       my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
 123     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 124             || strcmp (result, "0x3.244p+0 33") == 0
 125             || strcmp (result, "0x6.488p-1 33") == 0
 126             || strcmp (result, "0xc.91p-2 33") == 0);
 127     ASSERT (retval == strlen (result));
 128   }
 129
 130   { /* A negative number.  */
 131     char result[100];
 132     int retval =
 133       my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
 134     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 135             || strcmp (result, "-0X3.244P+0 33") == 0
 136             || strcmp (result, "-0X6.488P-1 33") == 0
 137             || strcmp (result, "-0XC.91P-2 33") == 0);
 138     ASSERT (retval == strlen (result));
 139   }
 140
 141   { /* Positive zero.  */
 142     char result[100];
 143     int retval =
 144       my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
 145     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 146     ASSERT (retval == strlen (result));
 147   }
 148
 149   { /* Negative zero.  */
 150     char result[100];
 151     int retval =
 152       my_snprintf (result, sizeof (result), "%a %d", -0.0, 33, 44, 55);
 153     if (have_minus_zero ())
 154       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 155     ASSERT (retval == strlen (result));
 156   }
 157
 158   { /* Positive infinity.  */
 159     char result[100];
 160     int retval =
 161       my_snprintf (result, sizeof (result), "%a %d", 1.0 / 0.0, 33, 44, 55);
 162     ASSERT (strcmp (result, "inf 33") == 0);
 163     ASSERT (retval == strlen (result));
 164   }
 165
 166   { /* Negative infinity.  */
 167     char result[100];
 168     int retval =
 169       my_snprintf (result, sizeof (result), "%a %d", -1.0 / 0.0, 33, 44, 55);
 170     ASSERT (strcmp (result, "-inf 33") == 0);
 171     ASSERT (retval == strlen (result));
 172   }
 173
 174   { /* NaN.  */
 175     char result[100];
 176     int retval =
 177       my_snprintf (result, sizeof (result), "%a %d", NaN (), 33, 44, 55);
 178     ASSERT (strlen (result) >= 3 + 3
 179             && memcmp (result, "nan", 3) == 0
 180             && strcmp (result + strlen (result) - 3, " 33") == 0);
 181     ASSERT (retval == strlen (result));
 182   }
 183
 184   { /* Rounding near the decimal point.  */
 185     char result[100];
 186     int retval =
 187       my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
 188     ASSERT (strcmp (result, "0x2p+0 33") == 0
 189             || strcmp (result, "0x3p-1 33") == 0
 190             || strcmp (result, "0x6p-2 33") == 0
 191             || strcmp (result, "0xcp-3 33") == 0);
 192     ASSERT (retval == strlen (result));
 193   }
 194
 195   { /* Rounding with precision 0.  */
 196     char result[100];
 197     int retval =
 198       my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
 199     ASSERT (strcmp (result, "0x2p+0 33") == 0
 200             || strcmp (result, "0x3p-1 33") == 0
 201             || strcmp (result, "0x6p-2 33") == 0
 202             || strcmp (result, "0xcp-3 33") == 0);
 203     ASSERT (retval == strlen (result));
 204   }
 205
 206   { /* Rounding with precision 1.  */
 207     char result[100];
 208     int retval =
 209       my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
 210     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 211             || strcmp (result, "0x3.0p-1 33") == 0
 212             || strcmp (result, "0x6.1p-2 33") == 0
 213             || strcmp (result, "0xc.1p-3 33") == 0);
 214     ASSERT (retval == strlen (result));
 215   }
 216
 217   { /* Rounding with precision 2.  */
 218     char result[100];
 219     int retval =
 220       my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
 221     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 222             || strcmp (result, "0x3.05p-1 33") == 0
 223             || strcmp (result, "0x6.0ap-2 33") == 0
 224             || strcmp (result, "0xc.14p-3 33") == 0);
 225     ASSERT (retval == strlen (result));
 226   }
 227
 228   { /* Rounding with precision 3.  */
 229     char result[100];
 230     int retval =
 231       my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
 232     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 233             || strcmp (result, "0x3.052p-1 33") == 0
 234             || strcmp (result, "0x6.0a4p-2 33") == 0
 235             || strcmp (result, "0xc.148p-3 33") == 0);
 236     ASSERT (retval == strlen (result));
 237   }
 238
 239   { /* Rounding can turn a ...FFF into a ...000.  */
 240     char result[100];
 241     int retval =
 242       my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
 243     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 244             || strcmp (result, "0x3.000p-1 33") == 0
 245             || strcmp (result, "0x6.000p-2 33") == 0
 246             || strcmp (result, "0xc.000p-3 33") == 0);
 247     ASSERT (retval == strlen (result));
 248   }
 249
 250   { /* Rounding can turn a ...FFF into a ...000.
 251        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 252     char result[100];
 253     int retval =
 254       my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
 255     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 256             || strcmp (result, "0x2.0p+0 33") == 0
 257             || strcmp (result, "0x4.0p-1 33") == 0
 258             || strcmp (result, "0x8.0p-2 33") == 0);
 259     ASSERT (retval == strlen (result));
 260   }
 261
 262   { /* Width.  */
 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   { /* Small precision.  */
 274     char result[100];
 275     int retval =
 276       my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
 277     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 278             || strcmp (result, "0x3.8000000000p-1 33") == 0
 279             || strcmp (result, "0x7.0000000000p-2 33") == 0
 280             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 281     ASSERT (retval == strlen (result));
 282   }
 283
 284   { /* Large precision.  */
 285     char result[100];
 286     int retval =
 287       my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
 288     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 289             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 290             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 291             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 292     ASSERT (retval == strlen (result));
 293   }
 294
 295   { /* FLAG_LEFT.  */
 296     char result[100];
 297     int retval =
 298       my_snprintf (result, sizeof (result), "%-10a %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, "0x7p-2     33") == 0
 302             || strcmp (result, "0xep-3     33") == 0);
 303     ASSERT (retval == strlen (result));
 304   }
 305
 306   { /* FLAG_SHOWSIGN.  */
 307     char result[100];
 308     int retval =
 309       my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
 310     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 311             || strcmp (result, "+0x3.8p-1 33") == 0
 312             || strcmp (result, "+0x7p-2 33") == 0
 313             || strcmp (result, "+0xep-3 33") == 0);
 314     ASSERT (retval == strlen (result));
 315   }
 316
 317   { /* FLAG_SPACE.  */
 318     char result[100];
 319     int retval =
 320       my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
 321     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 322             || strcmp (result, " 0x3.8p-1 33") == 0
 323             || strcmp (result, " 0x7p-2 33") == 0
 324             || strcmp (result, " 0xep-3 33") == 0);
 325     ASSERT (retval == strlen (result));
 326   }
 327
 328   { /* FLAG_ALT.  */
 329     char result[100];
 330     int retval =
 331       my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
 332     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 333             || strcmp (result, "0x3.8p-1 33") == 0
 334             || strcmp (result, "0x7.p-2 33") == 0
 335             || strcmp (result, "0xe.p-3 33") == 0);
 336     ASSERT (retval == strlen (result));
 337   }
 338
 339   { /* FLAG_ALT.  */
 340     char result[100];
 341     int retval =
 342       my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
 343     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 344             || strcmp (result, "0x2.p-1 33") == 0
 345             || strcmp (result, "0x4.p-2 33") == 0
 346             || strcmp (result, "0x8.p-3 33") == 0);
 347     ASSERT (retval == strlen (result));
 348   }
 349
 350   { /* FLAG_ZERO with finite number.  */
 351     char result[100];
 352     int retval =
 353       my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
 354     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 355             || strcmp (result, "0x003.8p-1 33") == 0
 356             || strcmp (result, "0x00007p-2 33") == 0
 357             || strcmp (result, "0x0000ep-3 33") == 0);
 358     ASSERT (retval == strlen (result));
 359   }
 360
 361   { /* FLAG_ZERO with infinite number.  */
 362     char result[100];
 363     int retval =
 364       my_snprintf (result, sizeof (result), "%010a %d", 1.0 / 0.0, 33, 44, 55);
 365     /* "0000000inf 33" is not a valid result; see
 366        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 367     ASSERT (strcmp (result, "       inf 33") == 0);
 368     ASSERT (retval == strlen (result));
 369   }
 370
 371   { /* FLAG_ZERO with NaN.  */
 372     char result[100];
 373     int retval =
 374       my_snprintf (result, sizeof (result), "%020a %d", NaN (), 33, 44, 55);
 375     /* "0000000nan 33" is not a valid result; see
 376        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 377     ASSERT (strlen (result) == 20 + 3
 378             && memcmp (result + strspn (result, " "), "nan", 3) == 0
 379             && strcmp (result + strlen (result) - 3, " 33") == 0);
 380     ASSERT (retval == strlen (result));
 381   }
 382
 383   { /* A positive number.  */
 384     char result[100];
 385     int retval =
 386       my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
 387     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 388             || strcmp (result, "0x3.244p+0 33") == 0
 389             || strcmp (result, "0x6.488p-1 33") == 0
 390             || strcmp (result, "0xc.91p-2 33") == 0);
 391     ASSERT (retval == strlen (result));
 392   }
 393
 394   { /* A negative number.  */
 395     char result[100];
 396     int retval =
 397       my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
 398     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 399             || strcmp (result, "-0X3.244P+0 33") == 0
 400             || strcmp (result, "-0X6.488P-1 33") == 0
 401             || strcmp (result, "-0XC.91P-2 33") == 0);
 402     ASSERT (retval == strlen (result));
 403   }
 404
 405   { /* Positive zero.  */
 406     char result[100];
 407     int retval =
 408       my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
 409     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 410     ASSERT (retval == strlen (result));
 411   }
 412
 413   { /* Negative zero.  */
 414     char result[100];
 415     int retval =
 416       my_snprintf (result, sizeof (result), "%La %d", -0.0L, 33, 44, 55);
 417     if (have_minus_zero ())
 418       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 419     ASSERT (retval == strlen (result));
 420   }
 421
 422   { /* Positive infinity.  */
 423     char result[100];
 424     int retval =
 425       my_snprintf (result, sizeof (result), "%La %d", 1.0L / 0.0L, 33, 44, 55);
 426     ASSERT (strcmp (result, "inf 33") == 0);
 427     ASSERT (retval == strlen (result));
 428   }
 429
 430   { /* Negative infinity.  */
 431     char result[100];
 432     int retval =
 433       my_snprintf (result, sizeof (result), "%La %d", -1.0L / 0.0L, 33, 44, 55);
 434     ASSERT (strcmp (result, "-inf 33") == 0);
 435     ASSERT (retval == strlen (result));
 436   }
 437
 438   { /* NaN.  */
 439     char result[100];
 440     int retval =
 441       my_snprintf (result, sizeof (result), "%La %d", 0.0L / 0.0L, 33, 44, 55);
 442     ASSERT (strlen (result) >= 3 + 3
 443             && memcmp (result, "nan", 3) == 0
 444             && strcmp (result + strlen (result) - 3, " 33") == 0);
 445     ASSERT (retval == strlen (result));
 446   }
 447
 448   { /* Rounding near the decimal point.  */
 449     char result[100];
 450     int retval =
 451       my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
 452     ASSERT (strcmp (result, "0x2p+0 33") == 0
 453             || strcmp (result, "0x3p-1 33") == 0
 454             || strcmp (result, "0x6p-2 33") == 0
 455             || strcmp (result, "0xcp-3 33") == 0);
 456     ASSERT (retval == strlen (result));
 457   }
 458
 459   { /* Rounding with precision 0.  */
 460     char result[100];
 461     int retval =
 462       my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
 463     ASSERT (strcmp (result, "0x2p+0 33") == 0
 464             || strcmp (result, "0x3p-1 33") == 0
 465             || strcmp (result, "0x6p-2 33") == 0
 466             || strcmp (result, "0xcp-3 33") == 0);
 467     ASSERT (retval == strlen (result));
 468   }
 469
 470   { /* Rounding with precision 1.  */
 471     char result[100];
 472     int retval =
 473       my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
 474     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 475             || strcmp (result, "0x3.0p-1 33") == 0
 476             || strcmp (result, "0x6.1p-2 33") == 0
 477             || strcmp (result, "0xc.1p-3 33") == 0);
 478     ASSERT (retval == strlen (result));
 479   }
 480
 481   { /* Rounding with precision 2.  */
 482     char result[100];
 483     int retval =
 484       my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
 485     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 486             || strcmp (result, "0x3.05p-1 33") == 0
 487             || strcmp (result, "0x6.0ap-2 33") == 0
 488             || strcmp (result, "0xc.14p-3 33") == 0);
 489     ASSERT (retval == strlen (result));
 490   }
 491
 492   { /* Rounding with precision 3.  */
 493     char result[100];
 494     int retval =
 495       my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
 496     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 497             || strcmp (result, "0x3.052p-1 33") == 0
 498             || strcmp (result, "0x6.0a4p-2 33") == 0
 499             || strcmp (result, "0xc.148p-3 33") == 0);
 500     ASSERT (retval == strlen (result));
 501   }
 502
 503   { /* Rounding can turn a ...FFF into a ...000.  */
 504     char result[100];
 505     int retval =
 506       my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
 507     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 508             || strcmp (result, "0x3.000p-1 33") == 0
 509             || strcmp (result, "0x6.000p-2 33") == 0
 510             || strcmp (result, "0xc.000p-3 33") == 0);
 511     ASSERT (retval == strlen (result));
 512   }
 513
 514   { /* Rounding can turn a ...FFF into a ...000.
 515        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 516        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 517     char result[100];
 518     int retval =
 519       my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
 520     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 521             || strcmp (result, "0x2.0p+0 33") == 0
 522             || strcmp (result, "0x4.0p-1 33") == 0
 523             || strcmp (result, "0x8.0p-2 33") == 0);
 524     ASSERT (retval == strlen (result));
 525   }
 526
 527   { /* Width.  */
 528     char result[100];
 529     int retval =
 530       my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
 531     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 532             || strcmp (result, "  0x3.8p-1 33") == 0
 533             || strcmp (result, "    0x7p-2 33") == 0
 534             || strcmp (result, "    0xep-3 33") == 0);
 535     ASSERT (retval == strlen (result));
 536   }
 537
 538   { /* Small precision.  */
 539     char result[100];
 540     int retval =
 541       my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
 542     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 543             || strcmp (result, "0x3.8000000000p-1 33") == 0
 544             || strcmp (result, "0x7.0000000000p-2 33") == 0
 545             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 546     ASSERT (retval == strlen (result));
 547   }
 548
 549   { /* Large precision.  */
 550     char result[100];
 551     int retval =
 552       my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
 553     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 554             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 555             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 556             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 557     ASSERT (retval == strlen (result));
 558   }
 559
 560   { /* FLAG_LEFT.  */
 561     char result[100];
 562     int retval =
 563       my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
 564     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 565             || strcmp (result, "0x3.8p-1   33") == 0
 566             || strcmp (result, "0x7p-2     33") == 0
 567             || strcmp (result, "0xep-3     33") == 0);
 568     ASSERT (retval == strlen (result));
 569   }
 570
 571   { /* FLAG_SHOWSIGN.  */
 572     char result[100];
 573     int retval =
 574       my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
 575     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 576             || strcmp (result, "+0x3.8p-1 33") == 0
 577             || strcmp (result, "+0x7p-2 33") == 0
 578             || strcmp (result, "+0xep-3 33") == 0);
 579     ASSERT (retval == strlen (result));
 580   }
 581
 582   { /* FLAG_SPACE.  */
 583     char result[100];
 584     int retval =
 585       my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
 586     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 587             || strcmp (result, " 0x3.8p-1 33") == 0
 588             || strcmp (result, " 0x7p-2 33") == 0
 589             || strcmp (result, " 0xep-3 33") == 0);
 590     ASSERT (retval == strlen (result));
 591   }
 592
 593   { /* FLAG_ALT.  */
 594     char result[100];
 595     int retval =
 596       my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
 597     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 598             || strcmp (result, "0x3.8p-1 33") == 0
 599             || strcmp (result, "0x7.p-2 33") == 0
 600             || strcmp (result, "0xe.p-3 33") == 0);
 601     ASSERT (retval == strlen (result));
 602   }
 603
 604   { /* FLAG_ALT.  */
 605     char result[100];
 606     int retval =
 607       my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
 608     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 609             || strcmp (result, "0x2.p-1 33") == 0
 610             || strcmp (result, "0x4.p-2 33") == 0
 611             || strcmp (result, "0x8.p-3 33") == 0);
 612     ASSERT (retval == strlen (result));
 613   }
 614
 615   { /* FLAG_ZERO with finite number.  */
 616     char result[100];
 617     int retval =
 618       my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
 619     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 620             || strcmp (result, "0x003.8p-1 33") == 0
 621             || strcmp (result, "0x00007p-2 33") == 0
 622             || strcmp (result, "0x0000ep-3 33") == 0);
 623     ASSERT (retval == strlen (result));
 624   }
 625
 626   { /* FLAG_ZERO with infinite number.  */
 627     char result[100];
 628     int retval =
 629       my_snprintf (result, sizeof (result), "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 630     /* "0000000inf 33" is not a valid result; see
 631        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 632     ASSERT (strcmp (result, "       inf 33") == 0);
 633     ASSERT (retval == strlen (result));
 634   }
 635
 636   { /* FLAG_ZERO with NaN.  */
 637     char result[100];
 638     int retval =
 639       my_snprintf (result, sizeof (result), "%020La %d", 0.0L / 0.0L, 33, 44, 55);
 640     /* "0000000nan 33" is not a valid result; see
 641        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 642     ASSERT (strlen (result) == 20 + 3
 643             && memcmp (result + strspn (result, " "), "nan", 3) == 0
 644             && strcmp (result + strlen (result) - 3, " 33") == 0);
 645     ASSERT (retval == strlen (result));
 646   }
 647
 648   /* Test the support of the %f format directive.  */
 649
 650   { /* A positive number.  */
 651     char result[100];
 652     int retval =
 653       my_snprintf (result, sizeof (result), "%f %d", 12.75, 33, 44, 55);
 654     ASSERT (strcmp (result, "12.750000 33") == 0);
 655     ASSERT (retval == strlen (result));
 656   }
 657
 658   { /* A larger positive number.  */
 659     char result[100];
 660     int retval =
 661       my_snprintf (result, sizeof (result), "%f %d", 1234567.0, 33, 44, 55);
 662     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 663     ASSERT (retval == strlen (result));
 664   }
 665
 666   { /* Small and large positive numbers.  */
 667     static struct { double value; const char *string; } data[] =
 668       {
 669         { 1.234321234321234e-37, "0.000000" },
 670         { 1.234321234321234e-36, "0.000000" },
 671         { 1.234321234321234e-35, "0.000000" },
 672         { 1.234321234321234e-34, "0.000000" },
 673         { 1.234321234321234e-33, "0.000000" },
 674         { 1.234321234321234e-32, "0.000000" },
 675         { 1.234321234321234e-31, "0.000000" },
 676         { 1.234321234321234e-30, "0.000000" },
 677         { 1.234321234321234e-29, "0.000000" },
 678         { 1.234321234321234e-28, "0.000000" },
 679         { 1.234321234321234e-27, "0.000000" },
 680         { 1.234321234321234e-26, "0.000000" },
 681         { 1.234321234321234e-25, "0.000000" },
 682         { 1.234321234321234e-24, "0.000000" },
 683         { 1.234321234321234e-23, "0.000000" },
 684         { 1.234321234321234e-22, "0.000000" },
 685         { 1.234321234321234e-21, "0.000000" },
 686         { 1.234321234321234e-20, "0.000000" },
 687         { 1.234321234321234e-19, "0.000000" },
 688         { 1.234321234321234e-18, "0.000000" },
 689         { 1.234321234321234e-17, "0.000000" },
 690         { 1.234321234321234e-16, "0.000000" },
 691         { 1.234321234321234e-15, "0.000000" },
 692         { 1.234321234321234e-14, "0.000000" },
 693         { 1.234321234321234e-13, "0.000000" },
 694         { 1.234321234321234e-12, "0.000000" },
 695         { 1.234321234321234e-11, "0.000000" },
 696         { 1.234321234321234e-10, "0.000000" },
 697         { 1.234321234321234e-9, "0.000000" },
 698         { 1.234321234321234e-8, "0.000000" },
 699         { 1.234321234321234e-7, "0.000000" },
 700         { 1.234321234321234e-6, "0.000001" },
 701         { 1.234321234321234e-5, "0.000012" },
 702         { 1.234321234321234e-4, "0.000123" },
 703         { 1.234321234321234e-3, "0.001234" },
 704         { 1.234321234321234e-2, "0.012343" },
 705         { 1.234321234321234e-1, "0.123432" },
 706         { 1.234321234321234, "1.234321" },
 707         { 1.234321234321234e1, "12.343212" },
 708         { 1.234321234321234e2, "123.432123" },
 709         { 1.234321234321234e3, "1234.321234" },
 710         { 1.234321234321234e4, "12343.212343" },
 711         { 1.234321234321234e5, "123432.123432" },
 712         { 1.234321234321234e6, "1234321.234321" },
 713         { 1.234321234321234e7, "12343212.343212" },
 714         { 1.234321234321234e8, "123432123.432123" },
 715         { 1.234321234321234e9, "1234321234.321234" },
 716         { 1.234321234321234e10, "12343212343.2123**" },
 717         { 1.234321234321234e11, "123432123432.123***" },
 718         { 1.234321234321234e12, "1234321234321.23****" },
 719         { 1.234321234321234e13, "12343212343212.3*****" },
 720         { 1.234321234321234e14, "123432123432123.******" },
 721         { 1.234321234321234e15, "1234321234321234.000000" },
 722         { 1.234321234321234e16, "123432123432123**.000000" },
 723         { 1.234321234321234e17, "123432123432123***.000000" },
 724         { 1.234321234321234e18, "123432123432123****.000000" },
 725         { 1.234321234321234e19, "123432123432123*****.000000" },
 726         { 1.234321234321234e20, "123432123432123******.000000" },
 727         { 1.234321234321234e21, "123432123432123*******.000000" },
 728         { 1.234321234321234e22, "123432123432123********.000000" },
 729         { 1.234321234321234e23, "123432123432123*********.000000" },
 730         { 1.234321234321234e24, "123432123432123**********.000000" },
 731         { 1.234321234321234e25, "123432123432123***********.000000" },
 732         { 1.234321234321234e26, "123432123432123************.000000" },
 733         { 1.234321234321234e27, "123432123432123*************.000000" },
 734         { 1.234321234321234e28, "123432123432123**************.000000" },
 735         { 1.234321234321234e29, "123432123432123***************.000000" },
 736         { 1.234321234321234e30, "123432123432123****************.000000" },
 737         { 1.234321234321234e31, "123432123432123*****************.000000" },
 738         { 1.234321234321234e32, "123432123432123******************.000000" },
 739         { 1.234321234321234e33, "123432123432123*******************.000000" },
 740         { 1.234321234321234e34, "123432123432123********************.000000" },
 741         { 1.234321234321234e35, "123432123432123*********************.000000" },
 742         { 1.234321234321234e36, "123432123432123**********************.000000" }
 743       };
 744     size_t k;
 745     for (k = 0; k < SIZEOF (data); k++)
 746       {
 747         char result[100];
 748         int retval =
 749           my_snprintf (result, sizeof (result), "%f", data[k].value);
 750         ASSERT (strmatch (data[k].string, result));
 751         ASSERT (retval == strlen (result));
 752       }
 753   }
 754
 755   { /* A negative number.  */
 756     char result[100];
 757     int retval =
 758       my_snprintf (result, sizeof (result), "%f %d", -0.03125, 33, 44, 55);
 759     ASSERT (strcmp (result, "-0.031250 33") == 0);
 760     ASSERT (retval == strlen (result));
 761   }
 762
 763   { /* Positive zero.  */
 764     char result[100];
 765     int retval =
 766       my_snprintf (result, sizeof (result), "%f %d", 0.0, 33, 44, 55);
 767     ASSERT (strcmp (result, "0.000000 33") == 0);
 768     ASSERT (retval == strlen (result));
 769   }
 770
 771   { /* Negative zero.  */
 772     char result[100];
 773     int retval =
 774       my_snprintf (result, sizeof (result), "%f %d", -0.0, 33, 44, 55);
 775     if (have_minus_zero ())
 776       ASSERT (strcmp (result, "-0.000000 33") == 0);
 777     ASSERT (retval == strlen (result));
 778   }
 779
 780   { /* Positive infinity.  */
 781     char result[100];
 782     int retval =
 783       my_snprintf (result, sizeof (result), "%f %d", 1.0 / 0.0, 33, 44, 55);
 784     ASSERT (strcmp (result, "inf 33") == 0
 785             || strcmp (result, "infinity 33") == 0);
 786     ASSERT (retval == strlen (result));
 787   }
 788
 789   { /* Negative infinity.  */
 790     char result[100];
 791     int retval =
 792       my_snprintf (result, sizeof (result), "%f %d", -1.0 / 0.0, 33, 44, 55);
 793     ASSERT (strcmp (result, "-inf 33") == 0
 794             || strcmp (result, "-infinity 33") == 0);
 795     ASSERT (retval == strlen (result));
 796   }
 797
 798   { /* NaN.  */
 799     char result[100];
 800     int retval =
 801       my_snprintf (result, sizeof (result), "%f %d", NaN (), 33, 44, 55);
 802     ASSERT (strlen (result) >= 3 + 3
 803             && memcmp (result, "nan", 3) == 0
 804             && strcmp (result + strlen (result) - 3, " 33") == 0);
 805     ASSERT (retval == strlen (result));
 806   }
 807
 808   { /* Width.  */
 809     char result[100];
 810     int retval =
 811       my_snprintf (result, sizeof (result), "%10f %d", 1.75, 33, 44, 55);
 812     ASSERT (result != NULL);
 813     ASSERT (strcmp (result, "  1.750000 33") == 0);
 814     ASSERT (retval == strlen (result));
 815   }
 816
 817   { /* FLAG_LEFT.  */
 818     char result[100];
 819     int retval =
 820       my_snprintf (result, sizeof (result), "%-10f %d", 1.75, 33, 44, 55);
 821     ASSERT (result != NULL);
 822     ASSERT (strcmp (result, "1.750000   33") == 0);
 823     ASSERT (retval == strlen (result));
 824   }
 825
 826   { /* FLAG_SHOWSIGN.  */
 827     char result[100];
 828     int retval =
 829       my_snprintf (result, sizeof (result), "%+f %d", 1.75, 33, 44, 55);
 830     ASSERT (result != NULL);
 831     ASSERT (strcmp (result, "+1.750000 33") == 0);
 832     ASSERT (retval == strlen (result));
 833   }
 834
 835   { /* FLAG_SPACE.  */
 836     char result[100];
 837     int retval =
 838       my_snprintf (result, sizeof (result), "% f %d", 1.75, 33, 44, 55);
 839     ASSERT (result != NULL);
 840     ASSERT (strcmp (result, " 1.750000 33") == 0);
 841     ASSERT (retval == strlen (result));
 842   }
 843
 844   { /* FLAG_ALT.  */
 845     char result[100];
 846     int retval =
 847       my_snprintf (result, sizeof (result), "%#f %d", 1.75, 33, 44, 55);
 848     ASSERT (result != NULL);
 849     ASSERT (strcmp (result, "1.750000 33") == 0);
 850     ASSERT (retval == strlen (result));
 851   }
 852
 853   { /* FLAG_ALT.  */
 854     char result[100];
 855     int retval =
 856       my_snprintf (result, sizeof (result), "%#.f %d", 1.75, 33, 44, 55);
 857     ASSERT (result != NULL);
 858     ASSERT (strcmp (result, "2. 33") == 0);
 859     ASSERT (retval == strlen (result));
 860   }
 861
 862   { /* FLAG_ZERO with finite number.  */
 863     char result[100];
 864     int retval =
 865       my_snprintf (result, sizeof (result), "%015f %d", 1234.0, 33, 44, 55);
 866     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 867     ASSERT (retval == strlen (result));
 868   }
 869
 870   { /* FLAG_ZERO with infinite number.  */
 871     char result[100];
 872     int retval =
 873       my_snprintf (result, sizeof (result), "%015f %d", -1.0 / 0.0, 33, 44, 55);
 874     ASSERT (strcmp (result, "           -inf 33") == 0
 875             || strcmp (result, "      -infinity 33") == 0);
 876     ASSERT (retval == strlen (result));
 877   }
 878
 879   { /* FLAG_ZERO with NaN.  */
 880     char result[100];
 881     int retval =
 882       my_snprintf (result, sizeof (result), "%020f %d", NaN (), 33, 44, 55);
 883     ASSERT (strlen (result) == 20 + 3
 884             && memcmp (result + strspn (result, " "), "nan", 3) == 0
 885             && strcmp (result + strlen (result) - 3, " 33") == 0);
 886     ASSERT (retval == strlen (result));
 887   }
 888
 889   { /* Precision.  */
 890     char result[100];
 891     int retval =
 892       my_snprintf (result, sizeof (result), "%.f %d", 1234.0, 33, 44, 55);
 893     ASSERT (strcmp (result, "1234 33") == 0);
 894     ASSERT (retval == strlen (result));
 895   }
 896
 897   { /* A positive number.  */
 898     char result[100];
 899     int retval =
 900       my_snprintf (result, sizeof (result), "%Lf %d", 12.75L, 33, 44, 55);
 901     ASSERT (strcmp (result, "12.750000 33") == 0);
 902     ASSERT (retval == strlen (result));
 903   }
 904
 905   { /* A larger positive number.  */
 906     char result[100];
 907     int retval =
 908       my_snprintf (result, sizeof (result), "%Lf %d", 1234567.0L, 33, 44, 55);
 909     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 910     ASSERT (retval == strlen (result));
 911   }
 912
 913   { /* Small and large positive numbers.  */
 914     static struct { long double value; const char *string; } data[] =
 915       {
 916         { 1.234321234321234e-37L, "0.000000" },
 917         { 1.234321234321234e-36L, "0.000000" },
 918         { 1.234321234321234e-35L, "0.000000" },
 919         { 1.234321234321234e-34L, "0.000000" },
 920         { 1.234321234321234e-33L, "0.000000" },
 921         { 1.234321234321234e-32L, "0.000000" },
 922         { 1.234321234321234e-31L, "0.000000" },
 923         { 1.234321234321234e-30L, "0.000000" },
 924         { 1.234321234321234e-29L, "0.000000" },
 925         { 1.234321234321234e-28L, "0.000000" },
 926         { 1.234321234321234e-27L, "0.000000" },
 927         { 1.234321234321234e-26L, "0.000000" },
 928         { 1.234321234321234e-25L, "0.000000" },
 929         { 1.234321234321234e-24L, "0.000000" },
 930         { 1.234321234321234e-23L, "0.000000" },
 931         { 1.234321234321234e-22L, "0.000000" },
 932         { 1.234321234321234e-21L, "0.000000" },
 933         { 1.234321234321234e-20L, "0.000000" },
 934         { 1.234321234321234e-19L, "0.000000" },
 935         { 1.234321234321234e-18L, "0.000000" },
 936         { 1.234321234321234e-17L, "0.000000" },
 937         { 1.234321234321234e-16L, "0.000000" },
 938         { 1.234321234321234e-15L, "0.000000" },
 939         { 1.234321234321234e-14L, "0.000000" },
 940         { 1.234321234321234e-13L, "0.000000" },
 941         { 1.234321234321234e-12L, "0.000000" },
 942         { 1.234321234321234e-11L, "0.000000" },
 943         { 1.234321234321234e-10L, "0.000000" },
 944         { 1.234321234321234e-9L, "0.000000" },
 945         { 1.234321234321234e-8L, "0.000000" },
 946         { 1.234321234321234e-7L, "0.000000" },
 947         { 1.234321234321234e-6L, "0.000001" },
 948         { 1.234321234321234e-5L, "0.000012" },
 949         { 1.234321234321234e-4L, "0.000123" },
 950         { 1.234321234321234e-3L, "0.001234" },
 951         { 1.234321234321234e-2L, "0.012343" },
 952         { 1.234321234321234e-1L, "0.123432" },
 953         { 1.234321234321234L, "1.234321" },
 954         { 1.234321234321234e1L, "12.343212" },
 955         { 1.234321234321234e2L, "123.432123" },
 956         { 1.234321234321234e3L, "1234.321234" },
 957         { 1.234321234321234e4L, "12343.212343" },
 958         { 1.234321234321234e5L, "123432.123432" },
 959         { 1.234321234321234e6L, "1234321.234321" },
 960         { 1.234321234321234e7L, "12343212.343212" },
 961         { 1.234321234321234e8L, "123432123.432123" },
 962         { 1.234321234321234e9L, "1234321234.321234" },
 963         { 1.234321234321234e10L, "12343212343.2123**" },
 964         { 1.234321234321234e11L, "123432123432.123***" },
 965         { 1.234321234321234e12L, "1234321234321.23****" },
 966         { 1.234321234321234e13L, "12343212343212.3*****" },
 967         { 1.234321234321234e14L, "123432123432123.******" },
 968         { 1.234321234321234e15L, "1234321234321234.000000" },
 969         { 1.234321234321234e16L, "123432123432123**.000000" },
 970         { 1.234321234321234e17L, "123432123432123***.000000" },
 971         { 1.234321234321234e18L, "123432123432123****.000000" },
 972         { 1.234321234321234e19L, "123432123432123*****.000000" },
 973         { 1.234321234321234e20L, "123432123432123******.000000" },
 974         { 1.234321234321234e21L, "123432123432123*******.000000" },
 975         { 1.234321234321234e22L, "123432123432123********.000000" },
 976         { 1.234321234321234e23L, "123432123432123*********.000000" },
 977         { 1.234321234321234e24L, "123432123432123**********.000000" },
 978         { 1.234321234321234e25L, "123432123432123***********.000000" },
 979         { 1.234321234321234e26L, "123432123432123************.000000" },
 980         { 1.234321234321234e27L, "123432123432123*************.000000" },
 981         { 1.234321234321234e28L, "123432123432123**************.000000" },
 982         { 1.234321234321234e29L, "123432123432123***************.000000" },
 983         { 1.234321234321234e30L, "123432123432123****************.000000" },
 984         { 1.234321234321234e31L, "123432123432123*****************.000000" },
 985         { 1.234321234321234e32L, "123432123432123******************.000000" },
 986         { 1.234321234321234e33L, "123432123432123*******************.000000" },
 987         { 1.234321234321234e34L, "123432123432123********************.000000" },
 988         { 1.234321234321234e35L, "123432123432123*********************.000000" },
 989         { 1.234321234321234e36L, "123432123432123**********************.000000" }
 990       };
 991     size_t k;
 992     for (k = 0; k < SIZEOF (data); k++)
 993       {
 994         char result[100];
 995         int retval =
 996           my_snprintf (result, sizeof (result), "%Lf", data[k].value);
 997         ASSERT (strmatch (data[k].string, result));
 998         ASSERT (retval == strlen (result));
 999       }
1000   }
1001
1002   { /* A negative number.  */
1003     char result[100];
1004     int retval =
1005       my_snprintf (result, sizeof (result), "%Lf %d", -0.03125L, 33, 44, 55);
1006     ASSERT (strcmp (result, "-0.031250 33") == 0);
1007     ASSERT (retval == strlen (result));
1008   }
1009
1010   { /* Positive zero.  */
1011     char result[100];
1012     int retval =
1013       my_snprintf (result, sizeof (result), "%Lf %d", 0.0L, 33, 44, 55);
1014     ASSERT (strcmp (result, "0.000000 33") == 0);
1015     ASSERT (retval == strlen (result));
1016   }
1017
1018   { /* Negative zero.  */
1019     char result[100];
1020     int retval =
1021       my_snprintf (result, sizeof (result), "%Lf %d", -0.0L, 33, 44, 55);
1022     if (have_minus_zero ())
1023       ASSERT (strcmp (result, "-0.000000 33") == 0);
1024     ASSERT (retval == strlen (result));
1025   }
1026
1027   { /* Positive infinity.  */
1028     char result[100];
1029     int retval =
1030       my_snprintf (result, sizeof (result), "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1031     ASSERT (strcmp (result, "inf 33") == 0
1032             || strcmp (result, "infinity 33") == 0);
1033     ASSERT (retval == strlen (result));
1034   }
1035
1036   { /* Negative infinity.  */
1037     char result[100];
1038     int retval =
1039       my_snprintf (result, sizeof (result), "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1040     ASSERT (strcmp (result, "-inf 33") == 0
1041             || strcmp (result, "-infinity 33") == 0);
1042     ASSERT (retval == strlen (result));
1043   }
1044
1045   { /* NaN.  */
1046     static long double zero = 0.0L;
1047     char result[100];
1048     int retval =
1049       my_snprintf (result, sizeof (result), "%Lf %d", zero / zero, 33, 44, 55);
1050     ASSERT (strlen (result) >= 3 + 3
1051             && memcmp (result, "nan", 3) == 0
1052             && strcmp (result + strlen (result) - 3, " 33") == 0);
1053     ASSERT (retval == strlen (result));
1054   }
1055
1056   { /* Width.  */
1057     char result[100];
1058     int retval =
1059       my_snprintf (result, sizeof (result), "%10Lf %d", 1.75L, 33, 44, 55);
1060     ASSERT (result != NULL);
1061     ASSERT (strcmp (result, "  1.750000 33") == 0);
1062     ASSERT (retval == strlen (result));
1063   }
1064
1065   { /* FLAG_LEFT.  */
1066     char result[100];
1067     int retval =
1068       my_snprintf (result, sizeof (result), "%-10Lf %d", 1.75L, 33, 44, 55);
1069     ASSERT (result != NULL);
1070     ASSERT (strcmp (result, "1.750000   33") == 0);
1071     ASSERT (retval == strlen (result));
1072   }
1073
1074   { /* FLAG_SHOWSIGN.  */
1075     char result[100];
1076     int retval =
1077       my_snprintf (result, sizeof (result), "%+Lf %d", 1.75L, 33, 44, 55);
1078     ASSERT (result != NULL);
1079     ASSERT (strcmp (result, "+1.750000 33") == 0);
1080     ASSERT (retval == strlen (result));
1081   }
1082
1083   { /* FLAG_SPACE.  */
1084     char result[100];
1085     int retval =
1086       my_snprintf (result, sizeof (result), "% Lf %d", 1.75L, 33, 44, 55);
1087     ASSERT (result != NULL);
1088     ASSERT (strcmp (result, " 1.750000 33") == 0);
1089     ASSERT (retval == strlen (result));
1090   }
1091
1092   { /* FLAG_ALT.  */
1093     char result[100];
1094     int retval =
1095       my_snprintf (result, sizeof (result), "%#Lf %d", 1.75L, 33, 44, 55);
1096     ASSERT (result != NULL);
1097     ASSERT (strcmp (result, "1.750000 33") == 0);
1098     ASSERT (retval == strlen (result));
1099   }
1100
1101   { /* FLAG_ALT.  */
1102     char result[100];
1103     int retval =
1104       my_snprintf (result, sizeof (result), "%#.Lf %d", 1.75L, 33, 44, 55);
1105     ASSERT (result != NULL);
1106     ASSERT (strcmp (result, "2. 33") == 0);
1107     ASSERT (retval == strlen (result));
1108   }
1109
1110   { /* FLAG_ZERO with finite number.  */
1111     char result[100];
1112     int retval =
1113       my_snprintf (result, sizeof (result), "%015Lf %d", 1234.0L, 33, 44, 55);
1114     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1115     ASSERT (retval == strlen (result));
1116   }
1117
1118   { /* FLAG_ZERO with infinite number.  */
1119     char result[100];
1120     int retval =
1121       my_snprintf (result, sizeof (result), "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1122     ASSERT (strcmp (result, "           -inf 33") == 0
1123             || strcmp (result, "      -infinity 33") == 0);
1124     ASSERT (retval == strlen (result));
1125   }
1126
1127   { /* FLAG_ZERO with NaN.  */
1128     static long double zero = 0.0L;
1129     char result[100];
1130     int retval =
1131       my_snprintf (result, sizeof (result), "%020Lf %d", zero / zero, 33, 44, 55);
1132     ASSERT (strlen (result) == 20 + 3
1133             && memcmp (result + strspn (result, " "), "nan", 3) == 0
1134             && strcmp (result + strlen (result) - 3, " 33") == 0);
1135     ASSERT (retval == strlen (result));
1136   }
1137
1138   { /* Precision.  */
1139     char result[100];
1140     int retval =
1141       my_snprintf (result, sizeof (result), "%.Lf %d", 1234.0L, 33, 44, 55);
1142     ASSERT (strcmp (result, "1234 33") == 0);
1143     ASSERT (retval == strlen (result));
1144   }
1145
1146   /* Test the support of the %F format directive.  */
1147
1148   { /* A positive number.  */
1149     char result[100];
1150     int retval =
1151       my_snprintf (result, sizeof (result), "%F %d", 12.75, 33, 44, 55);
1152     ASSERT (strcmp (result, "12.750000 33") == 0);
1153     ASSERT (retval == strlen (result));
1154   }
1155
1156   { /* A larger positive number.  */
1157     char result[100];
1158     int retval =
1159       my_snprintf (result, sizeof (result), "%F %d", 1234567.0, 33, 44, 55);
1160     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1161     ASSERT (retval == strlen (result));
1162   }
1163
1164   { /* A negative number.  */
1165     char result[100];
1166     int retval =
1167       my_snprintf (result, sizeof (result), "%F %d", -0.03125, 33, 44, 55);
1168     ASSERT (strcmp (result, "-0.031250 33") == 0);
1169     ASSERT (retval == strlen (result));
1170   }
1171
1172   { /* Positive zero.  */
1173     char result[100];
1174     int retval =
1175       my_snprintf (result, sizeof (result), "%F %d", 0.0, 33, 44, 55);
1176     ASSERT (strcmp (result, "0.000000 33") == 0);
1177     ASSERT (retval == strlen (result));
1178   }
1179
1180   { /* Negative zero.  */
1181     char result[100];
1182     int retval =
1183       my_snprintf (result, sizeof (result), "%F %d", -0.0, 33, 44, 55);
1184     if (have_minus_zero ())
1185       ASSERT (strcmp (result, "-0.000000 33") == 0);
1186     ASSERT (retval == strlen (result));
1187   }
1188
1189   { /* Positive infinity.  */
1190     char result[100];
1191     int retval =
1192       my_snprintf (result, sizeof (result), "%F %d", 1.0 / 0.0, 33, 44, 55);
1193     ASSERT (strcmp (result, "INF 33") == 0
1194             || strcmp (result, "INFINITY 33") == 0);
1195     ASSERT (retval == strlen (result));
1196   }
1197
1198   { /* Negative infinity.  */
1199     char result[100];
1200     int retval =
1201       my_snprintf (result, sizeof (result), "%F %d", -1.0 / 0.0, 33, 44, 55);
1202     ASSERT (strcmp (result, "-INF 33") == 0
1203             || strcmp (result, "-INFINITY 33") == 0);
1204     ASSERT (retval == strlen (result));
1205   }
1206
1207   { /* NaN.  */
1208     char result[100];
1209     int retval =
1210       my_snprintf (result, sizeof (result), "%F %d", NaN (), 33, 44, 55);
1211     ASSERT (strlen (result) >= 3 + 3
1212             && memcmp (result, "NAN", 3) == 0
1213             && strcmp (result + strlen (result) - 3, " 33") == 0);
1214     ASSERT (retval == strlen (result));
1215   }
1216
1217   { /* FLAG_ZERO.  */
1218     char result[100];
1219     int retval =
1220       my_snprintf (result, sizeof (result), "%015F %d", 1234.0, 33, 44, 55);
1221     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1222     ASSERT (retval == strlen (result));
1223   }
1224
1225   { /* FLAG_ZERO with infinite number.  */
1226     char result[100];
1227     int retval =
1228       my_snprintf (result, sizeof (result), "%015F %d", -1.0 / 0.0, 33, 44, 55);
1229     ASSERT (strcmp (result, "           -INF 33") == 0
1230             || strcmp (result, "      -INFINITY 33") == 0);
1231     ASSERT (retval == strlen (result));
1232   }
1233
1234   { /* Precision.  */
1235     char result[100];
1236     int retval =
1237       my_snprintf (result, sizeof (result), "%.F %d", 1234.0, 33, 44, 55);
1238     ASSERT (strcmp (result, "1234 33") == 0);
1239     ASSERT (retval == strlen (result));
1240   }
1241
1242   { /* A positive number.  */
1243     char result[100];
1244     int retval =
1245       my_snprintf (result, sizeof (result), "%LF %d", 12.75L, 33, 44, 55);
1246     ASSERT (strcmp (result, "12.750000 33") == 0);
1247     ASSERT (retval == strlen (result));
1248   }
1249
1250   { /* A larger positive number.  */
1251     char result[100];
1252     int retval =
1253       my_snprintf (result, sizeof (result), "%LF %d", 1234567.0L, 33, 44, 55);
1254     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1255     ASSERT (retval == strlen (result));
1256   }
1257
1258   { /* A negative number.  */
1259     char result[100];
1260     int retval =
1261       my_snprintf (result, sizeof (result), "%LF %d", -0.03125L, 33, 44, 55);
1262     ASSERT (strcmp (result, "-0.031250 33") == 0);
1263     ASSERT (retval == strlen (result));
1264   }
1265
1266   { /* Positive zero.  */
1267     char result[100];
1268     int retval =
1269       my_snprintf (result, sizeof (result), "%LF %d", 0.0L, 33, 44, 55);
1270     ASSERT (strcmp (result, "0.000000 33") == 0);
1271     ASSERT (retval == strlen (result));
1272   }
1273
1274   { /* Negative zero.  */
1275     char result[100];
1276     int retval =
1277       my_snprintf (result, sizeof (result), "%LF %d", -0.0L, 33, 44, 55);
1278     if (have_minus_zero ())
1279       ASSERT (strcmp (result, "-0.000000 33") == 0);
1280     ASSERT (retval == strlen (result));
1281   }
1282
1283   { /* Positive infinity.  */
1284     char result[100];
1285     int retval =
1286       my_snprintf (result, sizeof (result), "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1287     ASSERT (strcmp (result, "INF 33") == 0
1288             || strcmp (result, "INFINITY 33") == 0);
1289     ASSERT (retval == strlen (result));
1290   }
1291
1292   { /* Negative infinity.  */
1293     char result[100];
1294     int retval =
1295       my_snprintf (result, sizeof (result), "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1296     ASSERT (strcmp (result, "-INF 33") == 0
1297             || strcmp (result, "-INFINITY 33") == 0);
1298     ASSERT (retval == strlen (result));
1299   }
1300
1301   { /* NaN.  */
1302     static long double zero = 0.0L;
1303     char result[100];
1304     int retval =
1305       my_snprintf (result, sizeof (result), "%LF %d", zero / zero, 33, 44, 55);
1306     ASSERT (strlen (result) >= 3 + 3
1307             && memcmp (result, "NAN", 3) == 0
1308             && strcmp (result + strlen (result) - 3, " 33") == 0);
1309     ASSERT (retval == strlen (result));
1310   }
1311
1312   { /* FLAG_ZERO.  */
1313     char result[100];
1314     int retval =
1315       my_snprintf (result, sizeof (result), "%015LF %d", 1234.0L, 33, 44, 55);
1316     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1317     ASSERT (retval == strlen (result));
1318   }
1319
1320   { /* FLAG_ZERO with infinite number.  */
1321     char result[100];
1322     int retval =
1323       my_snprintf (result, sizeof (result), "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1324     ASSERT (strcmp (result, "           -INF 33") == 0
1325             || strcmp (result, "      -INFINITY 33") == 0);
1326     ASSERT (retval == strlen (result));
1327   }
1328
1329   { /* Precision.  */
1330     char result[100];
1331     int retval =
1332       my_snprintf (result, sizeof (result), "%.LF %d", 1234.0L, 33, 44, 55);
1333     ASSERT (strcmp (result, "1234 33") == 0);
1334     ASSERT (retval == strlen (result));
1335   }
1336
1337   /* Test the support of the %e format directive.  */
1338
1339   { /* A positive number.  */
1340     char result[100];
1341     int retval =
1342       my_snprintf (result, sizeof (result), "%e %d", 12.75, 33, 44, 55);
1343     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1344             || strcmp (result, "1.275000e+001 33") == 0);
1345     ASSERT (retval == strlen (result));
1346   }
1347
1348   { /* A larger positive number.  */
1349     char result[100];
1350     int retval =
1351       my_snprintf (result, sizeof (result), "%e %d", 1234567.0, 33, 44, 55);
1352     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1353             || strcmp (result, "1.234567e+006 33") == 0);
1354     ASSERT (retval == strlen (result));
1355   }
1356
1357   { /* Small and large positive numbers.  */
1358     static struct { double value; const char *string; } data[] =
1359       {
1360         { 1.234321234321234e-37, "1.234321e-37" },
1361         { 1.234321234321234e-36, "1.234321e-36" },
1362         { 1.234321234321234e-35, "1.234321e-35" },
1363         { 1.234321234321234e-34, "1.234321e-34" },
1364         { 1.234321234321234e-33, "1.234321e-33" },
1365         { 1.234321234321234e-32, "1.234321e-32" },
1366         { 1.234321234321234e-31, "1.234321e-31" },
1367         { 1.234321234321234e-30, "1.234321e-30" },
1368         { 1.234321234321234e-29, "1.234321e-29" },
1369         { 1.234321234321234e-28, "1.234321e-28" },
1370         { 1.234321234321234e-27, "1.234321e-27" },
1371         { 1.234321234321234e-26, "1.234321e-26" },
1372         { 1.234321234321234e-25, "1.234321e-25" },
1373         { 1.234321234321234e-24, "1.234321e-24" },
1374         { 1.234321234321234e-23, "1.234321e-23" },
1375         { 1.234321234321234e-22, "1.234321e-22" },
1376         { 1.234321234321234e-21, "1.234321e-21" },
1377         { 1.234321234321234e-20, "1.234321e-20" },
1378         { 1.234321234321234e-19, "1.234321e-19" },
1379         { 1.234321234321234e-18, "1.234321e-18" },
1380         { 1.234321234321234e-17, "1.234321e-17" },
1381         { 1.234321234321234e-16, "1.234321e-16" },
1382         { 1.234321234321234e-15, "1.234321e-15" },
1383         { 1.234321234321234e-14, "1.234321e-14" },
1384         { 1.234321234321234e-13, "1.234321e-13" },
1385         { 1.234321234321234e-12, "1.234321e-12" },
1386         { 1.234321234321234e-11, "1.234321e-11" },
1387         { 1.234321234321234e-10, "1.234321e-10" },
1388         { 1.234321234321234e-9, "1.234321e-09" },
1389         { 1.234321234321234e-8, "1.234321e-08" },
1390         { 1.234321234321234e-7, "1.234321e-07" },
1391         { 1.234321234321234e-6, "1.234321e-06" },
1392         { 1.234321234321234e-5, "1.234321e-05" },
1393         { 1.234321234321234e-4, "1.234321e-04" },
1394         { 1.234321234321234e-3, "1.234321e-03" },
1395         { 1.234321234321234e-2, "1.234321e-02" },
1396         { 1.234321234321234e-1, "1.234321e-01" },
1397         { 1.234321234321234, "1.234321e+00" },
1398         { 1.234321234321234e1, "1.234321e+01" },
1399         { 1.234321234321234e2, "1.234321e+02" },
1400         { 1.234321234321234e3, "1.234321e+03" },
1401         { 1.234321234321234e4, "1.234321e+04" },
1402         { 1.234321234321234e5, "1.234321e+05" },
1403         { 1.234321234321234e6, "1.234321e+06" },
1404         { 1.234321234321234e7, "1.234321e+07" },
1405         { 1.234321234321234e8, "1.234321e+08" },
1406         { 1.234321234321234e9, "1.234321e+09" },
1407         { 1.234321234321234e10, "1.234321e+10" },
1408         { 1.234321234321234e11, "1.234321e+11" },
1409         { 1.234321234321234e12, "1.234321e+12" },
1410         { 1.234321234321234e13, "1.234321e+13" },
1411         { 1.234321234321234e14, "1.234321e+14" },
1412         { 1.234321234321234e15, "1.234321e+15" },
1413         { 1.234321234321234e16, "1.234321e+16" },
1414         { 1.234321234321234e17, "1.234321e+17" },
1415         { 1.234321234321234e18, "1.234321e+18" },
1416         { 1.234321234321234e19, "1.234321e+19" },
1417         { 1.234321234321234e20, "1.234321e+20" },
1418         { 1.234321234321234e21, "1.234321e+21" },
1419         { 1.234321234321234e22, "1.234321e+22" },
1420         { 1.234321234321234e23, "1.234321e+23" },
1421         { 1.234321234321234e24, "1.234321e+24" },
1422         { 1.234321234321234e25, "1.234321e+25" },
1423         { 1.234321234321234e26, "1.234321e+26" },
1424         { 1.234321234321234e27, "1.234321e+27" },
1425         { 1.234321234321234e28, "1.234321e+28" },
1426         { 1.234321234321234e29, "1.234321e+29" },
1427         { 1.234321234321234e30, "1.234321e+30" },
1428         { 1.234321234321234e31, "1.234321e+31" },
1429         { 1.234321234321234e32, "1.234321e+32" },
1430         { 1.234321234321234e33, "1.234321e+33" },
1431         { 1.234321234321234e34, "1.234321e+34" },
1432         { 1.234321234321234e35, "1.234321e+35" },
1433         { 1.234321234321234e36, "1.234321e+36" }
1434       };
1435     size_t k;
1436     for (k = 0; k < SIZEOF (data); k++)
1437       {
1438         char result[100];
1439         int retval =
1440           my_snprintf (result, sizeof (result), "%e", data[k].value);
1441         const char *expected = data[k].string;
1442         ASSERT (result != NULL);
1443         ASSERT (strcmp (result, expected) == 0
1444                 /* Some implementations produce exponents with 3 digits.  */
1445                 || (strlen (result) == strlen (expected) + 1
1446                     && memcmp (result, expected, strlen (expected) - 2) == 0
1447                     && result[strlen (expected) - 2] == '0'
1448                     && strcmp (result + strlen (expected) - 1,
1449                                expected + strlen (expected) - 2)
1450                        == 0));
1451         ASSERT (retval == strlen (result));
1452       }
1453   }
1454
1455   { /* A negative number.  */
1456     char result[100];
1457     int retval =
1458       my_snprintf (result, sizeof (result), "%e %d", -0.03125, 33, 44, 55);
1459     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1460             || strcmp (result, "-3.125000e-002 33") == 0);
1461     ASSERT (retval == strlen (result));
1462   }
1463
1464   { /* Positive zero.  */
1465     char result[100];
1466     int retval =
1467       my_snprintf (result, sizeof (result), "%e %d", 0.0, 33, 44, 55);
1468     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1469             || strcmp (result, "0.000000e+000 33") == 0);
1470     ASSERT (retval == strlen (result));
1471   }
1472
1473   { /* Negative zero.  */
1474     char result[100];
1475     int retval =
1476       my_snprintf (result, sizeof (result), "%e %d", -0.0, 33, 44, 55);
1477     if (have_minus_zero ())
1478       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1479               || strcmp (result, "-0.000000e+000 33") == 0);
1480     ASSERT (retval == strlen (result));
1481   }
1482
1483   { /* Positive infinity.  */
1484     char result[100];
1485     int retval =
1486       my_snprintf (result, sizeof (result), "%e %d", 1.0 / 0.0, 33, 44, 55);
1487     ASSERT (strcmp (result, "inf 33") == 0
1488             || strcmp (result, "infinity 33") == 0);
1489     ASSERT (retval == strlen (result));
1490   }
1491
1492   { /* Negative infinity.  */
1493     char result[100];
1494     int retval =
1495       my_snprintf (result, sizeof (result), "%e %d", -1.0 / 0.0, 33, 44, 55);
1496     ASSERT (strcmp (result, "-inf 33") == 0
1497             || strcmp (result, "-infinity 33") == 0);
1498     ASSERT (retval == strlen (result));
1499   }
1500
1501   { /* NaN.  */
1502     char result[100];
1503     int retval =
1504       my_snprintf (result, sizeof (result), "%e %d", NaN (), 33, 44, 55);
1505     ASSERT (strlen (result) >= 3 + 3
1506             && memcmp (result, "nan", 3) == 0
1507             && strcmp (result + strlen (result) - 3, " 33") == 0);
1508     ASSERT (retval == strlen (result));
1509   }
1510
1511   { /* Width.  */
1512     char result[100];
1513     int retval =
1514       my_snprintf (result, sizeof (result), "%15e %d", 1.75, 33, 44, 55);
1515     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
1516             || strcmp (result, "  1.750000e+000 33") == 0);
1517     ASSERT (retval == strlen (result));
1518   }
1519
1520   { /* FLAG_LEFT.  */
1521     char result[100];
1522     int retval =
1523       my_snprintf (result, sizeof (result), "%-15e %d", 1.75, 33, 44, 55);
1524     ASSERT (strcmp (result, "1.750000e+00    33") == 0
1525             || strcmp (result, "1.750000e+000   33") == 0);
1526     ASSERT (retval == strlen (result));
1527   }
1528
1529   { /* FLAG_SHOWSIGN.  */
1530     char result[100];
1531     int retval =
1532       my_snprintf (result, sizeof (result), "%+e %d", 1.75, 33, 44, 55);
1533     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1534             || strcmp (result, "+1.750000e+000 33") == 0);
1535     ASSERT (retval == strlen (result));
1536   }
1537
1538   { /* FLAG_SPACE.  */
1539     char result[100];
1540     int retval =
1541       my_snprintf (result, sizeof (result), "% e %d", 1.75, 33, 44, 55);
1542     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1543             || strcmp (result, " 1.750000e+000 33") == 0);
1544     ASSERT (retval == strlen (result));
1545   }
1546
1547   { /* FLAG_ALT.  */
1548     char result[100];
1549     int retval =
1550       my_snprintf (result, sizeof (result), "%#e %d", 1.75, 33, 44, 55);
1551     ASSERT (strcmp (result, "1.750000e+00 33") == 0
1552             || strcmp (result, "1.750000e+000 33") == 0);
1553     ASSERT (retval == strlen (result));
1554   }
1555
1556   { /* FLAG_ALT.  */
1557     char result[100];
1558     int retval =
1559       my_snprintf (result, sizeof (result), "%#.e %d", 1.75, 33, 44, 55);
1560     ASSERT (strcmp (result, "2.e+00 33") == 0
1561             || strcmp (result, "2.e+000 33") == 0);
1562     ASSERT (retval == strlen (result));
1563   }
1564
1565   { /* FLAG_ALT.  */
1566     char result[100];
1567     int retval =
1568       my_snprintf (result, sizeof (result), "%#.e %d", 9.75, 33, 44, 55);
1569     ASSERT (strcmp (result, "1.e+01 33") == 0
1570             || strcmp (result, "1.e+001 33") == 0);
1571     ASSERT (retval == strlen (result));
1572   }
1573
1574   { /* FLAG_ZERO with finite number.  */
1575     char result[100];
1576     int retval =
1577       my_snprintf (result, sizeof (result), "%015e %d", 1234.0, 33, 44, 55);
1578     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1579             || strcmp (result, "001.234000e+003 33") == 0);
1580     ASSERT (retval == strlen (result));
1581   }
1582
1583   { /* FLAG_ZERO with infinite number.  */
1584     char result[100];
1585     int retval =
1586       my_snprintf (result, sizeof (result), "%015e %d", -1.0 / 0.0, 33, 44, 55);
1587     ASSERT (strcmp (result, "           -inf 33") == 0
1588             || strcmp (result, "      -infinity 33") == 0);
1589     ASSERT (retval == strlen (result));
1590   }
1591
1592   { /* FLAG_ZERO with NaN.  */
1593     char result[100];
1594     int retval =
1595       my_snprintf (result, sizeof (result), "%020e %d", NaN (), 33, 44, 55);
1596     ASSERT (strlen (result) == 20 + 3
1597             && memcmp (result + strspn (result, " "), "nan", 3) == 0
1598             && strcmp (result + strlen (result) - 3, " 33") == 0);
1599     ASSERT (retval == strlen (result));
1600   }
1601
1602   { /* Precision.  */
1603     char result[100];
1604     int retval =
1605       my_snprintf (result, sizeof (result), "%.e %d", 1234.0, 33, 44, 55);
1606     ASSERT (strcmp (result, "1e+03 33") == 0
1607             || strcmp (result, "1e+003 33") == 0);
1608     ASSERT (retval == strlen (result));
1609   }
1610
1611   { /* A positive number.  */
1612     char result[100];
1613     int retval =
1614       my_snprintf (result, sizeof (result), "%Le %d", 12.75L, 33, 44, 55);
1615     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1616     ASSERT (retval == strlen (result));
1617   }
1618
1619   { /* A larger positive number.  */
1620     char result[100];
1621     int retval =
1622       my_snprintf (result, sizeof (result), "%Le %d", 1234567.0L, 33, 44, 55);
1623     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1624     ASSERT (retval == strlen (result));
1625   }
1626
1627   { /* Small and large positive numbers.  */
1628     static struct { long double value; const char *string; } data[] =
1629       {
1630         { 1.234321234321234e-37L, "1.234321e-37" },
1631         { 1.234321234321234e-36L, "1.234321e-36" },
1632         { 1.234321234321234e-35L, "1.234321e-35" },
1633         { 1.234321234321234e-34L, "1.234321e-34" },
1634         { 1.234321234321234e-33L, "1.234321e-33" },
1635         { 1.234321234321234e-32L, "1.234321e-32" },
1636         { 1.234321234321234e-31L, "1.234321e-31" },
1637         { 1.234321234321234e-30L, "1.234321e-30" },
1638         { 1.234321234321234e-29L, "1.234321e-29" },
1639         { 1.234321234321234e-28L, "1.234321e-28" },
1640         { 1.234321234321234e-27L, "1.234321e-27" },
1641         { 1.234321234321234e-26L, "1.234321e-26" },
1642         { 1.234321234321234e-25L, "1.234321e-25" },
1643         { 1.234321234321234e-24L, "1.234321e-24" },
1644         { 1.234321234321234e-23L, "1.234321e-23" },
1645         { 1.234321234321234e-22L, "1.234321e-22" },
1646         { 1.234321234321234e-21L, "1.234321e-21" },
1647         { 1.234321234321234e-20L, "1.234321e-20" },
1648         { 1.234321234321234e-19L, "1.234321e-19" },
1649         { 1.234321234321234e-18L, "1.234321e-18" },
1650         { 1.234321234321234e-17L, "1.234321e-17" },
1651         { 1.234321234321234e-16L, "1.234321e-16" },
1652         { 1.234321234321234e-15L, "1.234321e-15" },
1653         { 1.234321234321234e-14L, "1.234321e-14" },
1654         { 1.234321234321234e-13L, "1.234321e-13" },
1655         { 1.234321234321234e-12L, "1.234321e-12" },
1656         { 1.234321234321234e-11L, "1.234321e-11" },
1657         { 1.234321234321234e-10L, "1.234321e-10" },
1658         { 1.234321234321234e-9L, "1.234321e-09" },
1659         { 1.234321234321234e-8L, "1.234321e-08" },
1660         { 1.234321234321234e-7L, "1.234321e-07" },
1661         { 1.234321234321234e-6L, "1.234321e-06" },
1662         { 1.234321234321234e-5L, "1.234321e-05" },
1663         { 1.234321234321234e-4L, "1.234321e-04" },
1664         { 1.234321234321234e-3L, "1.234321e-03" },
1665         { 1.234321234321234e-2L, "1.234321e-02" },
1666         { 1.234321234321234e-1L, "1.234321e-01" },
1667         { 1.234321234321234L, "1.234321e+00" },
1668         { 1.234321234321234e1L, "1.234321e+01" },
1669         { 1.234321234321234e2L, "1.234321e+02" },
1670         { 1.234321234321234e3L, "1.234321e+03" },
1671         { 1.234321234321234e4L, "1.234321e+04" },
1672         { 1.234321234321234e5L, "1.234321e+05" },
1673         { 1.234321234321234e6L, "1.234321e+06" },
1674         { 1.234321234321234e7L, "1.234321e+07" },
1675         { 1.234321234321234e8L, "1.234321e+08" },
1676         { 1.234321234321234e9L, "1.234321e+09" },
1677         { 1.234321234321234e10L, "1.234321e+10" },
1678         { 1.234321234321234e11L, "1.234321e+11" },
1679         { 1.234321234321234e12L, "1.234321e+12" },
1680         { 1.234321234321234e13L, "1.234321e+13" },
1681         { 1.234321234321234e14L, "1.234321e+14" },
1682         { 1.234321234321234e15L, "1.234321e+15" },
1683         { 1.234321234321234e16L, "1.234321e+16" },
1684         { 1.234321234321234e17L, "1.234321e+17" },
1685         { 1.234321234321234e18L, "1.234321e+18" },
1686         { 1.234321234321234e19L, "1.234321e+19" },
1687         { 1.234321234321234e20L, "1.234321e+20" },
1688         { 1.234321234321234e21L, "1.234321e+21" },
1689         { 1.234321234321234e22L, "1.234321e+22" },
1690         { 1.234321234321234e23L, "1.234321e+23" },
1691         { 1.234321234321234e24L, "1.234321e+24" },
1692         { 1.234321234321234e25L, "1.234321e+25" },
1693         { 1.234321234321234e26L, "1.234321e+26" },
1694         { 1.234321234321234e27L, "1.234321e+27" },
1695         { 1.234321234321234e28L, "1.234321e+28" },
1696         { 1.234321234321234e29L, "1.234321e+29" },
1697         { 1.234321234321234e30L, "1.234321e+30" },
1698         { 1.234321234321234e31L, "1.234321e+31" },
1699         { 1.234321234321234e32L, "1.234321e+32" },
1700         { 1.234321234321234e33L, "1.234321e+33" },
1701         { 1.234321234321234e34L, "1.234321e+34" },
1702         { 1.234321234321234e35L, "1.234321e+35" },
1703         { 1.234321234321234e36L, "1.234321e+36" }
1704       };
1705     size_t k;
1706     for (k = 0; k < SIZEOF (data); k++)
1707       {
1708         char result[100];
1709         int retval =
1710           my_snprintf (result, sizeof (result), "%Le", data[k].value);
1711         ASSERT (strcmp (result, data[k].string) == 0);
1712         ASSERT (retval == strlen (result));
1713       }
1714   }
1715
1716   { /* A negative number.  */
1717     char result[100];
1718     int retval =
1719       my_snprintf (result, sizeof (result), "%Le %d", -0.03125L, 33, 44, 55);
1720     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1721     ASSERT (retval == strlen (result));
1722   }
1723
1724   { /* Positive zero.  */
1725     char result[100];
1726     int retval =
1727       my_snprintf (result, sizeof (result), "%Le %d", 0.0L, 33, 44, 55);
1728     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1729     ASSERT (retval == strlen (result));
1730   }
1731
1732   { /* Negative zero.  */
1733     char result[100];
1734     int retval =
1735       my_snprintf (result, sizeof (result), "%Le %d", -0.0L, 33, 44, 55);
1736     if (have_minus_zero ())
1737       ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1738     ASSERT (retval == strlen (result));
1739   }
1740
1741   { /* Positive infinity.  */
1742     char result[100];
1743     int retval =
1744       my_snprintf (result, sizeof (result), "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1745     ASSERT (strcmp (result, "inf 33") == 0
1746             || strcmp (result, "infinity 33") == 0);
1747     ASSERT (retval == strlen (result));
1748   }
1749
1750   { /* Negative infinity.  */
1751     char result[100];
1752     int retval =
1753       my_snprintf (result, sizeof (result), "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1754     ASSERT (strcmp (result, "-inf 33") == 0
1755             || strcmp (result, "-infinity 33") == 0);
1756     ASSERT (retval == strlen (result));
1757   }
1758
1759   { /* NaN.  */
1760     static long double zero = 0.0L;
1761     char result[100];
1762     int retval =
1763       my_snprintf (result, sizeof (result), "%Le %d", zero / zero, 33, 44, 55);
1764     ASSERT (strlen (result) >= 3 + 3
1765             && memcmp (result, "nan", 3) == 0
1766             && strcmp (result + strlen (result) - 3, " 33") == 0);
1767     ASSERT (retval == strlen (result));
1768   }
1769
1770   { /* Width.  */
1771     char result[100];
1772     int retval =
1773       my_snprintf (result, sizeof (result), "%15Le %d", 1.75L, 33, 44, 55);
1774     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
1775     ASSERT (retval == strlen (result));
1776   }
1777
1778   { /* FLAG_LEFT.  */
1779     char result[100];
1780     int retval =
1781       my_snprintf (result, sizeof (result), "%-15Le %d", 1.75L, 33, 44, 55);
1782     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
1783     ASSERT (retval == strlen (result));
1784   }
1785
1786   { /* FLAG_SHOWSIGN.  */
1787     char result[100];
1788     int retval =
1789       my_snprintf (result, sizeof (result), "%+Le %d", 1.75L, 33, 44, 55);
1790     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
1791     ASSERT (retval == strlen (result));
1792   }
1793
1794   { /* FLAG_SPACE.  */
1795     char result[100];
1796     int retval =
1797       my_snprintf (result, sizeof (result), "% Le %d", 1.75L, 33, 44, 55);
1798     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1799     ASSERT (retval == strlen (result));
1800   }
1801
1802   { /* FLAG_ALT.  */
1803     char result[100];
1804     int retval =
1805       my_snprintf (result, sizeof (result), "%#Le %d", 1.75L, 33, 44, 55);
1806     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1807     ASSERT (retval == strlen (result));
1808   }
1809
1810   { /* FLAG_ALT.  */
1811     char result[100];
1812     int retval =
1813       my_snprintf (result, sizeof (result), "%#.Le %d", 1.75L, 33, 44, 55);
1814     ASSERT (strcmp (result, "2.e+00 33") == 0);
1815     ASSERT (retval == strlen (result));
1816   }
1817
1818   { /* FLAG_ALT.  */
1819     char result[100];
1820     int retval =
1821       my_snprintf (result, sizeof (result), "%#.Le %d", 9.75L, 33, 44, 55);
1822     ASSERT (strcmp (result, "1.e+01 33") == 0);
1823     ASSERT (retval == strlen (result));
1824   }
1825
1826   { /* FLAG_ZERO with finite number.  */
1827     char result[100];
1828     int retval =
1829       my_snprintf (result, sizeof (result), "%015Le %d", 1234.0L, 33, 44, 55);
1830     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
1831     ASSERT (retval == strlen (result));
1832   }
1833
1834   { /* FLAG_ZERO with infinite number.  */
1835     char result[100];
1836     int retval =
1837       my_snprintf (result, sizeof (result), "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
1838     ASSERT (strcmp (result, "           -inf 33") == 0
1839             || strcmp (result, "      -infinity 33") == 0);
1840     ASSERT (retval == strlen (result));
1841   }
1842
1843   { /* FLAG_ZERO with NaN.  */
1844     static long double zero = 0.0L;
1845     char result[100];
1846     int retval =
1847       my_snprintf (result, sizeof (result), "%020Le %d", zero / zero, 33, 44, 55);
1848     ASSERT (strlen (result) == 20 + 3
1849             && memcmp (result + strspn (result, " "), "nan", 3) == 0
1850             && strcmp (result + strlen (result) - 3, " 33") == 0);
1851     ASSERT (retval == strlen (result));
1852   }
1853
1854   { /* Precision.  */
1855     char result[100];
1856     int retval =
1857       my_snprintf (result, sizeof (result), "%.Le %d", 1234.0L, 33, 44, 55);
1858     ASSERT (strcmp (result, "1e+03 33") == 0);
1859     ASSERT (retval == strlen (result));
1860   }
1861
1862   /* Test the support of the %g format directive.  */
1863
1864   { /* A positive number.  */
1865     char result[100];
1866     int retval =
1867       my_snprintf (result, sizeof (result), "%g %d", 12.75, 33, 44, 55);
1868     ASSERT (strcmp (result, "12.75 33") == 0);
1869     ASSERT (retval == strlen (result));
1870   }
1871
1872   { /* A larger positive number.  */
1873     char result[100];
1874     int retval =
1875       my_snprintf (result, sizeof (result), "%g %d", 1234567.0, 33, 44, 55);
1876     ASSERT (strcmp (result, "1.23457e+06 33") == 0
1877             || strcmp (result, "1.23457e+006 33") == 0);
1878     ASSERT (retval == strlen (result));
1879   }
1880
1881   { /* Small and large positive numbers.  */
1882     static struct { double value; const char *string; } data[] =
1883       {
1884         { 1.234321234321234e-37, "1.23432e-37" },
1885         { 1.234321234321234e-36, "1.23432e-36" },
1886         { 1.234321234321234e-35, "1.23432e-35" },
1887         { 1.234321234321234e-34, "1.23432e-34" },
1888         { 1.234321234321234e-33, "1.23432e-33" },
1889         { 1.234321234321234e-32, "1.23432e-32" },
1890         { 1.234321234321234e-31, "1.23432e-31" },
1891         { 1.234321234321234e-30, "1.23432e-30" },
1892         { 1.234321234321234e-29, "1.23432e-29" },
1893         { 1.234321234321234e-28, "1.23432e-28" },
1894         { 1.234321234321234e-27, "1.23432e-27" },
1895         { 1.234321234321234e-26, "1.23432e-26" },
1896         { 1.234321234321234e-25, "1.23432e-25" },
1897         { 1.234321234321234e-24, "1.23432e-24" },
1898         { 1.234321234321234e-23, "1.23432e-23" },
1899         { 1.234321234321234e-22, "1.23432e-22" },
1900         { 1.234321234321234e-21, "1.23432e-21" },
1901         { 1.234321234321234e-20, "1.23432e-20" },
1902         { 1.234321234321234e-19, "1.23432e-19" },
1903         { 1.234321234321234e-18, "1.23432e-18" },
1904         { 1.234321234321234e-17, "1.23432e-17" },
1905         { 1.234321234321234e-16, "1.23432e-16" },
1906         { 1.234321234321234e-15, "1.23432e-15" },
1907         { 1.234321234321234e-14, "1.23432e-14" },
1908         { 1.234321234321234e-13, "1.23432e-13" },
1909         { 1.234321234321234e-12, "1.23432e-12" },
1910         { 1.234321234321234e-11, "1.23432e-11" },
1911         { 1.234321234321234e-10, "1.23432e-10" },
1912         { 1.234321234321234e-9, "1.23432e-09" },
1913         { 1.234321234321234e-8, "1.23432e-08" },
1914         { 1.234321234321234e-7, "1.23432e-07" },
1915         { 1.234321234321234e-6, "1.23432e-06" },
1916         { 1.234321234321234e-5, "1.23432e-05" },
1917         { 1.234321234321234e-4, "0.000123432" },
1918         { 1.234321234321234e-3, "0.00123432" },
1919         { 1.234321234321234e-2, "0.0123432" },
1920         { 1.234321234321234e-1, "0.123432" },
1921         { 1.234321234321234, "1.23432" },
1922         { 1.234321234321234e1, "12.3432" },
1923         { 1.234321234321234e2, "123.432" },
1924         { 1.234321234321234e3, "1234.32" },
1925         { 1.234321234321234e4, "12343.2" },
1926         { 1.234321234321234e5, "123432" },
1927         { 1.234321234321234e6, "1.23432e+06" },
1928         { 1.234321234321234e7, "1.23432e+07" },
1929         { 1.234321234321234e8, "1.23432e+08" },
1930         { 1.234321234321234e9, "1.23432e+09" },
1931         { 1.234321234321234e10, "1.23432e+10" },
1932         { 1.234321234321234e11, "1.23432e+11" },
1933         { 1.234321234321234e12, "1.23432e+12" },
1934         { 1.234321234321234e13, "1.23432e+13" },
1935         { 1.234321234321234e14, "1.23432e+14" },
1936         { 1.234321234321234e15, "1.23432e+15" },
1937         { 1.234321234321234e16, "1.23432e+16" },
1938         { 1.234321234321234e17, "1.23432e+17" },
1939         { 1.234321234321234e18, "1.23432e+18" },
1940         { 1.234321234321234e19, "1.23432e+19" },
1941         { 1.234321234321234e20, "1.23432e+20" },
1942         { 1.234321234321234e21, "1.23432e+21" },
1943         { 1.234321234321234e22, "1.23432e+22" },
1944         { 1.234321234321234e23, "1.23432e+23" },
1945         { 1.234321234321234e24, "1.23432e+24" },
1946         { 1.234321234321234e25, "1.23432e+25" },
1947         { 1.234321234321234e26, "1.23432e+26" },
1948         { 1.234321234321234e27, "1.23432e+27" },
1949         { 1.234321234321234e28, "1.23432e+28" },
1950         { 1.234321234321234e29, "1.23432e+29" },
1951         { 1.234321234321234e30, "1.23432e+30" },
1952         { 1.234321234321234e31, "1.23432e+31" },
1953         { 1.234321234321234e32, "1.23432e+32" },
1954         { 1.234321234321234e33, "1.23432e+33" },
1955         { 1.234321234321234e34, "1.23432e+34" },
1956         { 1.234321234321234e35, "1.23432e+35" },
1957         { 1.234321234321234e36, "1.23432e+36" }
1958       };
1959     size_t k;
1960     for (k = 0; k < SIZEOF (data); k++)
1961       {
1962         char result[100];
1963         int retval =
1964           my_snprintf (result, sizeof (result), "%g", data[k].value);
1965         const char *expected = data[k].string;
1966         ASSERT (strcmp (result, expected) == 0
1967                 /* Some implementations produce exponents with 3 digits.  */
1968                 || (expected[strlen (expected) - 4] == 'e'
1969                     && strlen (result) == strlen (expected) + 1
1970                     && memcmp (result, expected, strlen (expected) - 2) == 0
1971                     && result[strlen (expected) - 2] == '0'
1972                     && strcmp (result + strlen (expected) - 1,
1973                                expected + strlen (expected) - 2)
1974                        == 0));
1975         ASSERT (retval == strlen (result));
1976       }
1977   }
1978
1979   { /* A negative number.  */
1980     char result[100];
1981     int retval =
1982       my_snprintf (result, sizeof (result), "%g %d", -0.03125, 33, 44, 55);
1983     ASSERT (strcmp (result, "-0.03125 33") == 0);
1984     ASSERT (retval == strlen (result));
1985   }
1986
1987   { /* Positive zero.  */
1988     char result[100];
1989     int retval =
1990       my_snprintf (result, sizeof (result), "%g %d", 0.0, 33, 44, 55);
1991     ASSERT (strcmp (result, "0 33") == 0);
1992     ASSERT (retval == strlen (result));
1993   }
1994
1995   { /* Negative zero.  */
1996     char result[100];
1997     int retval =
1998       my_snprintf (result, sizeof (result), "%g %d", -0.0, 33, 44, 55);
1999     if (have_minus_zero ())
2000       ASSERT (strcmp (result, "-0 33") == 0);
2001     ASSERT (retval == strlen (result));
2002   }
2003
2004   { /* Positive infinity.  */
2005     char result[100];
2006     int retval =
2007       my_snprintf (result, sizeof (result), "%g %d", 1.0 / 0.0, 33, 44, 55);
2008     ASSERT (strcmp (result, "inf 33") == 0
2009             || strcmp (result, "infinity 33") == 0);
2010     ASSERT (retval == strlen (result));
2011   }
2012
2013   { /* Negative infinity.  */
2014     char result[100];
2015     int retval =
2016       my_snprintf (result, sizeof (result), "%g %d", -1.0 / 0.0, 33, 44, 55);
2017     ASSERT (strcmp (result, "-inf 33") == 0
2018             || strcmp (result, "-infinity 33") == 0);
2019     ASSERT (retval == strlen (result));
2020   }
2021
2022   { /* NaN.  */
2023     char result[100];
2024     int retval =
2025       my_snprintf (result, sizeof (result), "%g %d", NaN (), 33, 44, 55);
2026     ASSERT (strlen (result) >= 3 + 3
2027             && memcmp (result, "nan", 3) == 0
2028             && strcmp (result + strlen (result) - 3, " 33") == 0);
2029     ASSERT (retval == strlen (result));
2030   }
2031
2032   { /* Width.  */
2033     char result[100];
2034     int retval =
2035       my_snprintf (result, sizeof (result), "%10g %d", 1.75, 33, 44, 55);
2036     ASSERT (strcmp (result, "      1.75 33") == 0);
2037     ASSERT (retval == strlen (result));
2038   }
2039
2040   { /* FLAG_LEFT.  */
2041     char result[100];
2042     int retval =
2043       my_snprintf (result, sizeof (result), "%-10g %d", 1.75, 33, 44, 55);
2044     ASSERT (strcmp (result, "1.75       33") == 0);
2045     ASSERT (retval == strlen (result));
2046   }
2047
2048   { /* FLAG_SHOWSIGN.  */
2049     char result[100];
2050     int retval =
2051       my_snprintf (result, sizeof (result), "%+g %d", 1.75, 33, 44, 55);
2052     ASSERT (strcmp (result, "+1.75 33") == 0);
2053     ASSERT (retval == strlen (result));
2054   }
2055
2056   { /* FLAG_SPACE.  */
2057     char result[100];
2058     int retval =
2059       my_snprintf (result, sizeof (result), "% g %d", 1.75, 33, 44, 55);
2060     ASSERT (strcmp (result, " 1.75 33") == 0);
2061     ASSERT (retval == strlen (result));
2062   }
2063
2064   { /* FLAG_ALT.  */
2065     char result[100];
2066     int retval =
2067       my_snprintf (result, sizeof (result), "%#g %d", 1.75, 33, 44, 55);
2068     ASSERT (strcmp (result, "1.75000 33") == 0);
2069     ASSERT (retval == strlen (result));
2070   }
2071
2072   { /* FLAG_ALT.  */
2073     char result[100];
2074     int retval =
2075       my_snprintf (result, sizeof (result), "%#.g %d", 1.75, 33, 44, 55);
2076     ASSERT (strcmp (result, "2. 33") == 0);
2077     ASSERT (retval == strlen (result));
2078   }
2079
2080   { /* FLAG_ALT.  */
2081     char result[100];
2082     int retval =
2083       my_snprintf (result, sizeof (result), "%#.g %d", 9.75, 33, 44, 55);
2084     ASSERT (strcmp (result, "1.e+01 33") == 0
2085             || strcmp (result, "1.e+001 33") == 0);
2086     ASSERT (retval == strlen (result));
2087   }
2088
2089   { /* FLAG_ZERO with finite number.  */
2090     char result[100];
2091     int retval =
2092       my_snprintf (result, sizeof (result), "%010g %d", 1234.0, 33, 44, 55);
2093     ASSERT (strcmp (result, "0000001234 33") == 0);
2094     ASSERT (retval == strlen (result));
2095   }
2096
2097   { /* FLAG_ZERO with infinite number.  */
2098     char result[100];
2099     int retval =
2100       my_snprintf (result, sizeof (result), "%015g %d", -1.0 / 0.0, 33, 44, 55);
2101     ASSERT (strcmp (result, "           -inf 33") == 0
2102             || strcmp (result, "      -infinity 33") == 0);
2103     ASSERT (retval == strlen (result));
2104   }
2105
2106   { /* FLAG_ZERO with NaN.  */
2107     char result[100];
2108     int retval =
2109       my_snprintf (result, sizeof (result), "%020g %d", NaN (), 33, 44, 55);
2110     ASSERT (strlen (result) == 20 + 3
2111             && memcmp (result + strspn (result, " "), "nan", 3) == 0
2112             && strcmp (result + strlen (result) - 3, " 33") == 0);
2113     ASSERT (retval == strlen (result));
2114   }
2115
2116   { /* Precision.  */
2117     char result[100];
2118     int retval =
2119       my_snprintf (result, sizeof (result), "%.g %d", 1234.0, 33, 44, 55);
2120     ASSERT (strcmp (result, "1e+03 33") == 0
2121             || strcmp (result, "1e+003 33") == 0);
2122     ASSERT (retval == strlen (result));
2123   }
2124
2125   { /* A positive number.  */
2126     char result[100];
2127     int retval =
2128       my_snprintf (result, sizeof (result), "%Lg %d", 12.75L, 33, 44, 55);
2129     ASSERT (strcmp (result, "12.75 33") == 0);
2130     ASSERT (retval == strlen (result));
2131   }
2132
2133   { /* A larger positive number.  */
2134     char result[100];
2135     int retval =
2136       my_snprintf (result, sizeof (result), "%Lg %d", 1234567.0L, 33, 44, 55);
2137     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2138     ASSERT (retval == strlen (result));
2139   }
2140
2141   { /* Small and large positive numbers.  */
2142     static struct { long double value; const char *string; } data[] =
2143       {
2144         { 1.234321234321234e-37L, "1.23432e-37" },
2145         { 1.234321234321234e-36L, "1.23432e-36" },
2146         { 1.234321234321234e-35L, "1.23432e-35" },
2147         { 1.234321234321234e-34L, "1.23432e-34" },
2148         { 1.234321234321234e-33L, "1.23432e-33" },
2149         { 1.234321234321234e-32L, "1.23432e-32" },
2150         { 1.234321234321234e-31L, "1.23432e-31" },
2151         { 1.234321234321234e-30L, "1.23432e-30" },
2152         { 1.234321234321234e-29L, "1.23432e-29" },
2153         { 1.234321234321234e-28L, "1.23432e-28" },
2154         { 1.234321234321234e-27L, "1.23432e-27" },
2155         { 1.234321234321234e-26L, "1.23432e-26" },
2156         { 1.234321234321234e-25L, "1.23432e-25" },
2157         { 1.234321234321234e-24L, "1.23432e-24" },
2158         { 1.234321234321234e-23L, "1.23432e-23" },
2159         { 1.234321234321234e-22L, "1.23432e-22" },
2160         { 1.234321234321234e-21L, "1.23432e-21" },
2161         { 1.234321234321234e-20L, "1.23432e-20" },
2162         { 1.234321234321234e-19L, "1.23432e-19" },
2163         { 1.234321234321234e-18L, "1.23432e-18" },
2164         { 1.234321234321234e-17L, "1.23432e-17" },
2165         { 1.234321234321234e-16L, "1.23432e-16" },
2166         { 1.234321234321234e-15L, "1.23432e-15" },
2167         { 1.234321234321234e-14L, "1.23432e-14" },
2168         { 1.234321234321234e-13L, "1.23432e-13" },
2169         { 1.234321234321234e-12L, "1.23432e-12" },
2170         { 1.234321234321234e-11L, "1.23432e-11" },
2171         { 1.234321234321234e-10L, "1.23432e-10" },
2172         { 1.234321234321234e-9L, "1.23432e-09" },
2173         { 1.234321234321234e-8L, "1.23432e-08" },
2174         { 1.234321234321234e-7L, "1.23432e-07" },
2175         { 1.234321234321234e-6L, "1.23432e-06" },
2176         { 1.234321234321234e-5L, "1.23432e-05" },
2177         { 1.234321234321234e-4L, "0.000123432" },
2178         { 1.234321234321234e-3L, "0.00123432" },
2179         { 1.234321234321234e-2L, "0.0123432" },
2180         { 1.234321234321234e-1L, "0.123432" },
2181         { 1.234321234321234L, "1.23432" },
2182         { 1.234321234321234e1L, "12.3432" },
2183         { 1.234321234321234e2L, "123.432" },
2184         { 1.234321234321234e3L, "1234.32" },
2185         { 1.234321234321234e4L, "12343.2" },
2186         { 1.234321234321234e5L, "123432" },
2187         { 1.234321234321234e6L, "1.23432e+06" },
2188         { 1.234321234321234e7L, "1.23432e+07" },
2189         { 1.234321234321234e8L, "1.23432e+08" },
2190         { 1.234321234321234e9L, "1.23432e+09" },
2191         { 1.234321234321234e10L, "1.23432e+10" },
2192         { 1.234321234321234e11L, "1.23432e+11" },
2193         { 1.234321234321234e12L, "1.23432e+12" },
2194         { 1.234321234321234e13L, "1.23432e+13" },
2195         { 1.234321234321234e14L, "1.23432e+14" },
2196         { 1.234321234321234e15L, "1.23432e+15" },
2197         { 1.234321234321234e16L, "1.23432e+16" },
2198         { 1.234321234321234e17L, "1.23432e+17" },
2199         { 1.234321234321234e18L, "1.23432e+18" },
2200         { 1.234321234321234e19L, "1.23432e+19" },
2201         { 1.234321234321234e20L, "1.23432e+20" },
2202         { 1.234321234321234e21L, "1.23432e+21" },
2203         { 1.234321234321234e22L, "1.23432e+22" },
2204         { 1.234321234321234e23L, "1.23432e+23" },
2205         { 1.234321234321234e24L, "1.23432e+24" },
2206         { 1.234321234321234e25L, "1.23432e+25" },
2207         { 1.234321234321234e26L, "1.23432e+26" },
2208         { 1.234321234321234e27L, "1.23432e+27" },
2209         { 1.234321234321234e28L, "1.23432e+28" },
2210         { 1.234321234321234e29L, "1.23432e+29" },
2211         { 1.234321234321234e30L, "1.23432e+30" },
2212         { 1.234321234321234e31L, "1.23432e+31" },
2213         { 1.234321234321234e32L, "1.23432e+32" },
2214         { 1.234321234321234e33L, "1.23432e+33" },
2215         { 1.234321234321234e34L, "1.23432e+34" },
2216         { 1.234321234321234e35L, "1.23432e+35" },
2217         { 1.234321234321234e36L, "1.23432e+36" }
2218       };
2219     size_t k;
2220     for (k = 0; k < SIZEOF (data); k++)
2221       {
2222         char result[100];
2223         int retval =
2224           my_snprintf (result, sizeof (result), "%Lg", data[k].value);
2225         ASSERT (strcmp (result, data[k].string) == 0);
2226         ASSERT (retval == strlen (result));
2227       }
2228   }
2229
2230   { /* A negative number.  */
2231     char result[100];
2232     int retval =
2233       my_snprintf (result, sizeof (result), "%Lg %d", -0.03125L, 33, 44, 55);
2234     ASSERT (strcmp (result, "-0.03125 33") == 0);
2235     ASSERT (retval == strlen (result));
2236   }
2237
2238   { /* Positive zero.  */
2239     char result[100];
2240     int retval =
2241       my_snprintf (result, sizeof (result), "%Lg %d", 0.0L, 33, 44, 55);
2242     ASSERT (strcmp (result, "0 33") == 0);
2243     ASSERT (retval == strlen (result));
2244   }
2245
2246   { /* Negative zero.  */
2247     char result[100];
2248     int retval =
2249       my_snprintf (result, sizeof (result), "%Lg %d", -0.0L, 33, 44, 55);
2250     if (have_minus_zero ())
2251       ASSERT (strcmp (result, "-0 33") == 0);
2252     ASSERT (retval == strlen (result));
2253   }
2254
2255   { /* Positive infinity.  */
2256     char result[100];
2257     int retval =
2258       my_snprintf (result, sizeof (result), "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2259     ASSERT (strcmp (result, "inf 33") == 0
2260             || strcmp (result, "infinity 33") == 0);
2261     ASSERT (retval == strlen (result));
2262   }
2263
2264   { /* Negative infinity.  */
2265     char result[100];
2266     int retval =
2267       my_snprintf (result, sizeof (result), "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2268     ASSERT (strcmp (result, "-inf 33") == 0
2269             || strcmp (result, "-infinity 33") == 0);
2270     ASSERT (retval == strlen (result));
2271   }
2272
2273   { /* NaN.  */
2274     static long double zero = 0.0L;
2275     char result[100];
2276     int retval =
2277       my_snprintf (result, sizeof (result), "%Lg %d", zero / zero, 33, 44, 55);
2278     ASSERT (strlen (result) >= 3 + 3
2279             && memcmp (result, "nan", 3) == 0
2280             && strcmp (result + strlen (result) - 3, " 33") == 0);
2281     ASSERT (retval == strlen (result));
2282   }
2283
2284   { /* Width.  */
2285     char result[100];
2286     int retval =
2287       my_snprintf (result, sizeof (result), "%10Lg %d", 1.75L, 33, 44, 55);
2288     ASSERT (strcmp (result, "      1.75 33") == 0);
2289     ASSERT (retval == strlen (result));
2290   }
2291
2292   { /* FLAG_LEFT.  */
2293     char result[100];
2294     int retval =
2295       my_snprintf (result, sizeof (result), "%-10Lg %d", 1.75L, 33, 44, 55);
2296     ASSERT (strcmp (result, "1.75       33") == 0);
2297     ASSERT (retval == strlen (result));
2298   }
2299
2300   { /* FLAG_SHOWSIGN.  */
2301     char result[100];
2302     int retval =
2303       my_snprintf (result, sizeof (result), "%+Lg %d", 1.75L, 33, 44, 55);
2304     ASSERT (strcmp (result, "+1.75 33") == 0);
2305     ASSERT (retval == strlen (result));
2306   }
2307
2308   { /* FLAG_SPACE.  */
2309     char result[100];
2310     int retval =
2311       my_snprintf (result, sizeof (result), "% Lg %d", 1.75L, 33, 44, 55);
2312     ASSERT (strcmp (result, " 1.75 33") == 0);
2313     ASSERT (retval == strlen (result));
2314   }
2315
2316   { /* FLAG_ALT.  */
2317     char result[100];
2318     int retval =
2319       my_snprintf (result, sizeof (result), "%#Lg %d", 1.75L, 33, 44, 55);
2320     ASSERT (strcmp (result, "1.75000 33") == 0);
2321     ASSERT (retval == strlen (result));
2322   }
2323
2324   { /* FLAG_ALT.  */
2325     char result[100];
2326     int retval =
2327       my_snprintf (result, sizeof (result), "%#.Lg %d", 1.75L, 33, 44, 55);
2328     ASSERT (strcmp (result, "2. 33") == 0);
2329     ASSERT (retval == strlen (result));
2330   }
2331
2332   { /* FLAG_ALT.  */
2333     char result[100];
2334     int retval =
2335       my_snprintf (result, sizeof (result), "%#.Lg %d", 9.75L, 33, 44, 55);
2336     ASSERT (strcmp (result, "1.e+01 33") == 0);
2337     ASSERT (retval == strlen (result));
2338   }
2339
2340   { /* FLAG_ZERO with finite number.  */
2341     char result[100];
2342     int retval =
2343       my_snprintf (result, sizeof (result), "%010Lg %d", 1234.0L, 33, 44, 55);
2344     ASSERT (strcmp (result, "0000001234 33") == 0);
2345     ASSERT (retval == strlen (result));
2346   }
2347
2348   { /* FLAG_ZERO with infinite number.  */
2349     char result[100];
2350     int retval =
2351       my_snprintf (result, sizeof (result), "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2352     ASSERT (strcmp (result, "           -inf 33") == 0
2353             || strcmp (result, "      -infinity 33") == 0);
2354     ASSERT (retval == strlen (result));
2355   }
2356
2357   { /* FLAG_ZERO with NaN.  */
2358     static long double zero = 0.0L;
2359     char result[100];
2360     int retval =
2361       my_snprintf (result, sizeof (result), "%020Lg %d", zero / zero, 33, 44, 55);
2362     ASSERT (strlen (result) == 20 + 3
2363             && memcmp (result + strspn (result, " "), "nan", 3) == 0
2364             && strcmp (result + strlen (result) - 3, " 33") == 0);
2365     ASSERT (retval == strlen (result));
2366   }
2367
2368   { /* Precision.  */
2369     char result[100];
2370     int retval =
2371       my_snprintf (result, sizeof (result), "%.Lg %d", 1234.0L, 33, 44, 55);
2372     ASSERT (strcmp (result, "1e+03 33") == 0);
2373     ASSERT (retval == strlen (result));
2374   }
2375
2376   /* Test the support of the %n format directive.  */
2377
2378   {
2379     int count = -1;
2380     char result[100];
2381     int retval =
2382       my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
2383     ASSERT (strcmp (result, "123 ") == 0);
2384     ASSERT (retval == strlen (result));
2385     ASSERT (count == 4);
2386   }
2387
2388   /* Test the support of the POSIX/XSI format strings with positions.  */
2389
2390   {
2391     char result[100];
2392     int retval =
2393       my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
2394     ASSERT (strcmp (result, "55 33") == 0);
2395     ASSERT (retval == strlen (result));
2396   }
2397
2398   /* Test the support of the grouping flag.  */
2399
2400   {
2401     char result[100];
2402     int retval =
2403       my_snprintf (result, sizeof (result), "%'d %d", 1234567, 99);
2404     ASSERT (result[strlen (result) - 1] == '9');
2405     ASSERT (retval == strlen (result));
2406   }
2407 }