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