tests/test-snprintf-posix.h

   1 /* Test of POSIX compatible vsnprintf() and snprintf() functions.
   2    Copyright (C) 2007-2008 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 3 of the License, or
   7    (at your option) 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, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18
  19 #include "nan.h"
  20
  21 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0.  */
  22 static int
  23 have_minus_zero ()
  24 {
  25   static double plus_zero = 0.0;
  26   double minus_zero = - plus_zero;
  27   return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  28 }
  29
  30 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
  31    So we use -zero instead.  */
  32 double zerod = 0.0;
  33
  34 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
  35    So we use -zero instead.  */
  36 long double zerol = 0.0L;
  37
  38 /* Representation of an 80-bit 'long double' as an initializer for a sequence
  39    of 'unsigned int' words.  */
  40 #ifdef WORDS_BIGENDIAN
  41 # define LDBL80_WORDS(exponent,manthi,mantlo) \
  42     { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
  43       ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16),    \
  44       (unsigned int) (mantlo) << 16                                        \
  45     }
  46 #else
  47 # define LDBL80_WORDS(exponent,manthi,mantlo) \
  48     { mantlo, manthi, exponent }
  49 #endif
  50
  51 static int
  52 strmatch (const char *pattern, const char *string)
  53 {
  54   if (strlen (pattern) != strlen (string))
  55     return 0;
  56   for (; *pattern != '\0'; pattern++, string++)
  57     if (*pattern != '*' && *string != *pattern)
  58       return 0;
  59   return 1;
  60 }
  61
  62 /* Test whether string[start_index..end_index-1] is a valid textual
  63    representation of NaN.  */
  64 static int
  65 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
  66 {
  67   if (start_index < end_index)
  68     {
  69       if (string[start_index] == '-')
  70         start_index++;
  71       if (start_index + 3 <= end_index
  72           && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
  73         {
  74           start_index += 3;
  75           if (start_index == end_index
  76               || (string[start_index] == '(' && string[end_index - 1] == ')'))
  77             return 1;
  78         }
  79     }
  80   return 0;
  81 }
  82
  83 static void
  84 test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
  85 {
  86   char buf[8];
  87   int size;
  88
  89   /* Test return value convention.  */
  90
  91   for (size = 0; size <= 8; size++)
  92     {
  93       int retval;
  94
  95       memcpy (buf, "DEADBEEF", 8);
  96       retval = my_snprintf (buf, size, "%d", 12345);
  97       ASSERT (retval == 5);
  98       if (size < 6)
  99         {
 100           if (size > 0)
 101             {
 102               ASSERT (memcmp (buf, "12345", size - 1) == 0);
 103               ASSERT (buf[size - 1] == '\0');
 104             }
 105           ASSERT (memcmp (buf + size, "DEADBEEF" + size, 8 - size) == 0);
 106         }
 107       else
 108         {
 109           ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
 110         }
 111     }
 112
 113   /* Test support of size specifiers as in C99.  */
 114
 115   {
 116     char result[100];
 117     int retval =
 118       my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
 119     ASSERT (strcmp (result, "12345671 33") == 0);
 120     ASSERT (retval == strlen (result));
 121   }
 122
 123   {
 124     char result[100];
 125     int retval =
 126       my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
 127     ASSERT (strcmp (result, "12345672 33") == 0);
 128     ASSERT (retval == strlen (result));
 129   }
 130
 131   {
 132     char result[100];
 133     int retval =
 134       my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
 135     ASSERT (strcmp (result, "12345673 33") == 0);
 136     ASSERT (retval == strlen (result));
 137   }
 138
 139   {
 140     char result[100];
 141     int retval =
 142       my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
 143     ASSERT (strcmp (result, "1.5 33") == 0);
 144     ASSERT (retval == strlen (result));
 145   }
 146
 147   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 148      output of floating-point numbers.  */
 149
 150   { /* A positive number.  */
 151     char result[100];
 152     int retval =
 153       my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
 154     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 155             || strcmp (result, "0x3.244p+0 33") == 0
 156             || strcmp (result, "0x6.488p-1 33") == 0
 157             || strcmp (result, "0xc.91p-2 33") == 0);
 158     ASSERT (retval == strlen (result));
 159   }
 160
 161   { /* A negative number.  */
 162     char result[100];
 163     int retval =
 164       my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
 165     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 166             || strcmp (result, "-0X3.244P+0 33") == 0
 167             || strcmp (result, "-0X6.488P-1 33") == 0
 168             || strcmp (result, "-0XC.91P-2 33") == 0);
 169     ASSERT (retval == strlen (result));
 170   }
 171
 172   { /* Positive zero.  */
 173     char result[100];
 174     int retval =
 175       my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
 176     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 177     ASSERT (retval == strlen (result));
 178   }
 179
 180   { /* Negative zero.  */
 181     char result[100];
 182     int retval =
 183       my_snprintf (result, sizeof (result), "%a %d", -zerod, 33, 44, 55);
 184     if (have_minus_zero ())
 185       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 186     ASSERT (retval == strlen (result));
 187   }
 188
 189   { /* Positive infinity.  */
 190     char result[100];
 191     int retval =
 192       my_snprintf (result, sizeof (result), "%a %d", 1.0 / 0.0, 33, 44, 55);
 193     ASSERT (strcmp (result, "inf 33") == 0);
 194     ASSERT (retval == strlen (result));
 195   }
 196
 197   { /* Negative infinity.  */
 198     char result[100];
 199     int retval =
 200       my_snprintf (result, sizeof (result), "%a %d", -1.0 / 0.0, 33, 44, 55);
 201     ASSERT (strcmp (result, "-inf 33") == 0);
 202     ASSERT (retval == strlen (result));
 203   }
 204
 205   { /* NaN.  */
 206     char result[100];
 207     int retval =
 208       my_snprintf (result, sizeof (result), "%a %d", NaNd (), 33, 44, 55);
 209     ASSERT (strlen (result) >= 3 + 3
 210             && strisnan (result, 0, strlen (result) - 3, 0)
 211             && strcmp (result + strlen (result) - 3, " 33") == 0);
 212     ASSERT (retval == strlen (result));
 213   }
 214
 215   { /* Rounding near the decimal point.  */
 216     char result[100];
 217     int retval =
 218       my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
 219     ASSERT (strcmp (result, "0x2p+0 33") == 0
 220             || strcmp (result, "0x3p-1 33") == 0
 221             || strcmp (result, "0x6p-2 33") == 0
 222             || strcmp (result, "0xcp-3 33") == 0);
 223     ASSERT (retval == strlen (result));
 224   }
 225
 226   { /* Rounding with precision 0.  */
 227     char result[100];
 228     int retval =
 229       my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
 230     ASSERT (strcmp (result, "0x2p+0 33") == 0
 231             || strcmp (result, "0x3p-1 33") == 0
 232             || strcmp (result, "0x6p-2 33") == 0
 233             || strcmp (result, "0xcp-3 33") == 0);
 234     ASSERT (retval == strlen (result));
 235   }
 236
 237   { /* Rounding with precision 1.  */
 238     char result[100];
 239     int retval =
 240       my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
 241     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 242             || strcmp (result, "0x3.0p-1 33") == 0
 243             || strcmp (result, "0x6.1p-2 33") == 0
 244             || strcmp (result, "0xc.1p-3 33") == 0);
 245     ASSERT (retval == strlen (result));
 246   }
 247
 248   { /* Rounding with precision 2.  */
 249     char result[100];
 250     int retval =
 251       my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
 252     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 253             || strcmp (result, "0x3.05p-1 33") == 0
 254             || strcmp (result, "0x6.0ap-2 33") == 0
 255             || strcmp (result, "0xc.14p-3 33") == 0);
 256     ASSERT (retval == strlen (result));
 257   }
 258
 259   { /* Rounding with precision 3.  */
 260     char result[100];
 261     int retval =
 262       my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
 263     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 264             || strcmp (result, "0x3.052p-1 33") == 0
 265             || strcmp (result, "0x6.0a4p-2 33") == 0
 266             || strcmp (result, "0xc.148p-3 33") == 0);
 267     ASSERT (retval == strlen (result));
 268   }
 269
 270   { /* Rounding can turn a ...FFF into a ...000.  */
 271     char result[100];
 272     int retval =
 273       my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
 274     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 275             || strcmp (result, "0x3.000p-1 33") == 0
 276             || strcmp (result, "0x6.000p-2 33") == 0
 277             || strcmp (result, "0xc.000p-3 33") == 0);
 278     ASSERT (retval == strlen (result));
 279   }
 280
 281   { /* Rounding can turn a ...FFF into a ...000.
 282        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 283     char result[100];
 284     int retval =
 285       my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
 286     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 287             || strcmp (result, "0x2.0p+0 33") == 0
 288             || strcmp (result, "0x4.0p-1 33") == 0
 289             || strcmp (result, "0x8.0p-2 33") == 0);
 290     ASSERT (retval == strlen (result));
 291   }
 292
 293   { /* Width.  */
 294     char result[100];
 295     int retval =
 296       my_snprintf (result, sizeof (result), "%10a %d", 1.75, 33, 44, 55);
 297     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 298             || strcmp (result, "  0x3.8p-1 33") == 0
 299             || strcmp (result, "    0x7p-2 33") == 0
 300             || strcmp (result, "    0xep-3 33") == 0);
 301     ASSERT (retval == strlen (result));
 302   }
 303
 304   { /* Small precision.  */
 305     char result[100];
 306     int retval =
 307       my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
 308     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 309             || strcmp (result, "0x3.8000000000p-1 33") == 0
 310             || strcmp (result, "0x7.0000000000p-2 33") == 0
 311             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 312     ASSERT (retval == strlen (result));
 313   }
 314
 315   { /* Large precision.  */
 316     char result[100];
 317     int retval =
 318       my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
 319     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 320             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 321             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 322             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 323     ASSERT (retval == strlen (result));
 324   }
 325
 326   { /* FLAG_LEFT.  */
 327     char result[100];
 328     int retval =
 329       my_snprintf (result, sizeof (result), "%-10a %d", 1.75, 33, 44, 55);
 330     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 331             || strcmp (result, "0x3.8p-1   33") == 0
 332             || strcmp (result, "0x7p-2     33") == 0
 333             || strcmp (result, "0xep-3     33") == 0);
 334     ASSERT (retval == strlen (result));
 335   }
 336
 337   { /* FLAG_SHOWSIGN.  */
 338     char result[100];
 339     int retval =
 340       my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
 341     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 342             || strcmp (result, "+0x3.8p-1 33") == 0
 343             || strcmp (result, "+0x7p-2 33") == 0
 344             || strcmp (result, "+0xep-3 33") == 0);
 345     ASSERT (retval == strlen (result));
 346   }
 347
 348   { /* FLAG_SPACE.  */
 349     char result[100];
 350     int retval =
 351       my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
 352     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 353             || strcmp (result, " 0x3.8p-1 33") == 0
 354             || strcmp (result, " 0x7p-2 33") == 0
 355             || strcmp (result, " 0xep-3 33") == 0);
 356     ASSERT (retval == strlen (result));
 357   }
 358
 359   { /* FLAG_ALT.  */
 360     char result[100];
 361     int retval =
 362       my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
 363     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 364             || strcmp (result, "0x3.8p-1 33") == 0
 365             || strcmp (result, "0x7.p-2 33") == 0
 366             || strcmp (result, "0xe.p-3 33") == 0);
 367     ASSERT (retval == strlen (result));
 368   }
 369
 370   { /* FLAG_ALT.  */
 371     char result[100];
 372     int retval =
 373       my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
 374     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 375             || strcmp (result, "0x2.p-1 33") == 0
 376             || strcmp (result, "0x4.p-2 33") == 0
 377             || strcmp (result, "0x8.p-3 33") == 0);
 378     ASSERT (retval == strlen (result));
 379   }
 380
 381   { /* FLAG_ZERO with finite number.  */
 382     char result[100];
 383     int retval =
 384       my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
 385     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 386             || strcmp (result, "0x003.8p-1 33") == 0
 387             || strcmp (result, "0x00007p-2 33") == 0
 388             || strcmp (result, "0x0000ep-3 33") == 0);
 389     ASSERT (retval == strlen (result));
 390   }
 391
 392   { /* FLAG_ZERO with infinite number.  */
 393     char result[100];
 394     int retval =
 395       my_snprintf (result, sizeof (result), "%010a %d", 1.0 / 0.0, 33, 44, 55);
 396     /* "0000000inf 33" is not a valid result; see
 397        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 398     ASSERT (strcmp (result, "       inf 33") == 0);
 399     ASSERT (retval == strlen (result));
 400   }
 401
 402   { /* FLAG_ZERO with NaN.  */
 403     char result[100];
 404     int retval =
 405       my_snprintf (result, sizeof (result), "%050a %d", NaNd (), 33, 44, 55);
 406     /* "0000000nan 33" is not a valid result; see
 407        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 408     ASSERT (strlen (result) == 50 + 3
 409             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 410             && strcmp (result + strlen (result) - 3, " 33") == 0);
 411     ASSERT (retval == strlen (result));
 412   }
 413
 414   { /* A positive number.  */
 415     char result[100];
 416     int retval =
 417       my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
 418     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 419             || strcmp (result, "0x3.244p+0 33") == 0
 420             || strcmp (result, "0x6.488p-1 33") == 0
 421             || strcmp (result, "0xc.91p-2 33") == 0);
 422     ASSERT (retval == strlen (result));
 423   }
 424
 425   { /* A negative number.  */
 426     char result[100];
 427     int retval =
 428       my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
 429     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 430             || strcmp (result, "-0X3.244P+0 33") == 0
 431             || strcmp (result, "-0X6.488P-1 33") == 0
 432             || strcmp (result, "-0XC.91P-2 33") == 0);
 433     ASSERT (retval == strlen (result));
 434   }
 435
 436   { /* Positive zero.  */
 437     char result[100];
 438     int retval =
 439       my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
 440     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 441     ASSERT (retval == strlen (result));
 442   }
 443
 444   { /* Negative zero.  */
 445     char result[100];
 446     int retval =
 447       my_snprintf (result, sizeof (result), "%La %d", -zerol, 33, 44, 55);
 448     if (have_minus_zero ())
 449       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 450     ASSERT (retval == strlen (result));
 451   }
 452
 453   { /* Positive infinity.  */
 454     char result[100];
 455     int retval =
 456       my_snprintf (result, sizeof (result), "%La %d", 1.0L / 0.0L, 33, 44, 55);
 457     ASSERT (strcmp (result, "inf 33") == 0);
 458     ASSERT (retval == strlen (result));
 459   }
 460
 461   { /* Negative infinity.  */
 462     char result[100];
 463     int retval =
 464       my_snprintf (result, sizeof (result), "%La %d", -1.0L / 0.0L, 33, 44, 55);
 465     ASSERT (strcmp (result, "-inf 33") == 0);
 466     ASSERT (retval == strlen (result));
 467   }
 468
 469   { /* NaN.  */
 470     char result[100];
 471     int retval =
 472       my_snprintf (result, sizeof (result), "%La %d", NaNl (), 33, 44, 55);
 473     ASSERT (strlen (result) >= 3 + 3
 474             && strisnan (result, 0, strlen (result) - 3, 0)
 475             && strcmp (result + strlen (result) - 3, " 33") == 0);
 476     ASSERT (retval == strlen (result));
 477   }
 478 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
 479   { /* Quiet NaN.  */
 480     static union { unsigned int word[4]; long double value; } x =
 481       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
 482     char result[100];
 483     int retval =
 484       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 485     ASSERT (strlen (result) >= 3 + 3
 486             && strisnan (result, 0, strlen (result) - 3, 0)
 487             && strcmp (result + strlen (result) - 3, " 33") == 0);
 488     ASSERT (retval == strlen (result));
 489   }
 490   {
 491     /* Signalling NaN.  */
 492     static union { unsigned int word[4]; long double value; } x =
 493       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
 494     char result[100];
 495     int retval =
 496       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 497     ASSERT (strlen (result) >= 3 + 3
 498             && strisnan (result, 0, strlen (result) - 3, 0)
 499             && strcmp (result + strlen (result) - 3, " 33") == 0);
 500     ASSERT (retval == strlen (result));
 501   }
 502   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
 503      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
 504        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
 505        Application Architecture.
 506        Table 5-2 "Floating-Point Register Encodings"
 507        Figure 5-6 "Memory to Floating-Point Register Data Translation"
 508    */
 509   { /* Pseudo-NaN.  */
 510     static union { unsigned int word[4]; long double value; } x =
 511       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
 512     char result[100];
 513     int retval =
 514       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 515     ASSERT (strlen (result) >= 3 + 3
 516             && strisnan (result, 0, strlen (result) - 3, 0)
 517             && strcmp (result + strlen (result) - 3, " 33") == 0);
 518     ASSERT (retval == strlen (result));
 519   }
 520   { /* Pseudo-Infinity.  */
 521     static union { unsigned int word[4]; long double value; } x =
 522       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
 523     char result[100];
 524     int retval =
 525       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 526     ASSERT (strlen (result) >= 3 + 3
 527             && strisnan (result, 0, strlen (result) - 3, 0)
 528             && strcmp (result + strlen (result) - 3, " 33") == 0);
 529     ASSERT (retval == strlen (result));
 530   }
 531   { /* Pseudo-Zero.  */
 532     static union { unsigned int word[4]; long double value; } x =
 533       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
 534     char result[100];
 535     int retval =
 536       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 537     ASSERT (strlen (result) >= 3 + 3
 538             && strisnan (result, 0, strlen (result) - 3, 0)
 539             && strcmp (result + strlen (result) - 3, " 33") == 0);
 540     ASSERT (retval == strlen (result));
 541   }
 542   { /* Unnormalized number.  */
 543     static union { unsigned int word[4]; long double value; } x =
 544       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
 545     char result[100];
 546     int retval =
 547       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 548     ASSERT (strlen (result) >= 3 + 3
 549             && strisnan (result, 0, strlen (result) - 3, 0)
 550             && strcmp (result + strlen (result) - 3, " 33") == 0);
 551     ASSERT (retval == strlen (result));
 552   }
 553   { /* Pseudo-Denormal.  */
 554     static union { unsigned int word[4]; long double value; } x =
 555       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
 556     char result[100];
 557     int retval =
 558       my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
 559     ASSERT (strlen (result) >= 3 + 3
 560             && strisnan (result, 0, strlen (result) - 3, 0)
 561             && strcmp (result + strlen (result) - 3, " 33") == 0);
 562     ASSERT (retval == strlen (result));
 563   }
 564 #endif
 565
 566   { /* Rounding near the decimal point.  */
 567     char result[100];
 568     int retval =
 569       my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
 570     ASSERT (strcmp (result, "0x2p+0 33") == 0
 571             || strcmp (result, "0x3p-1 33") == 0
 572             || strcmp (result, "0x6p-2 33") == 0
 573             || strcmp (result, "0xcp-3 33") == 0);
 574     ASSERT (retval == strlen (result));
 575   }
 576
 577   { /* Rounding with precision 0.  */
 578     char result[100];
 579     int retval =
 580       my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
 581     ASSERT (strcmp (result, "0x2p+0 33") == 0
 582             || strcmp (result, "0x3p-1 33") == 0
 583             || strcmp (result, "0x6p-2 33") == 0
 584             || strcmp (result, "0xcp-3 33") == 0);
 585     ASSERT (retval == strlen (result));
 586   }
 587
 588   { /* Rounding with precision 1.  */
 589     char result[100];
 590     int retval =
 591       my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
 592     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 593             || strcmp (result, "0x3.0p-1 33") == 0
 594             || strcmp (result, "0x6.1p-2 33") == 0
 595             || strcmp (result, "0xc.1p-3 33") == 0);
 596     ASSERT (retval == strlen (result));
 597   }
 598
 599   { /* Rounding with precision 2.  */
 600     char result[100];
 601     int retval =
 602       my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
 603     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 604             || strcmp (result, "0x3.05p-1 33") == 0
 605             || strcmp (result, "0x6.0ap-2 33") == 0
 606             || strcmp (result, "0xc.14p-3 33") == 0);
 607     ASSERT (retval == strlen (result));
 608   }
 609
 610   { /* Rounding with precision 3.  */
 611     char result[100];
 612     int retval =
 613       my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
 614     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 615             || strcmp (result, "0x3.052p-1 33") == 0
 616             || strcmp (result, "0x6.0a4p-2 33") == 0
 617             || strcmp (result, "0xc.148p-3 33") == 0);
 618     ASSERT (retval == strlen (result));
 619   }
 620
 621   { /* Rounding can turn a ...FFF into a ...000.  */
 622     char result[100];
 623     int retval =
 624       my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
 625     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 626             || strcmp (result, "0x3.000p-1 33") == 0
 627             || strcmp (result, "0x6.000p-2 33") == 0
 628             || strcmp (result, "0xc.000p-3 33") == 0);
 629     ASSERT (retval == strlen (result));
 630   }
 631
 632   { /* Rounding can turn a ...FFF into a ...000.
 633        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 634        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 635     char result[100];
 636     int retval =
 637       my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
 638     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 639             || strcmp (result, "0x2.0p+0 33") == 0
 640             || strcmp (result, "0x4.0p-1 33") == 0
 641             || strcmp (result, "0x8.0p-2 33") == 0);
 642     ASSERT (retval == strlen (result));
 643   }
 644
 645   { /* Width.  */
 646     char result[100];
 647     int retval =
 648       my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
 649     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 650             || strcmp (result, "  0x3.8p-1 33") == 0
 651             || strcmp (result, "    0x7p-2 33") == 0
 652             || strcmp (result, "    0xep-3 33") == 0);
 653     ASSERT (retval == strlen (result));
 654   }
 655
 656   { /* Small precision.  */
 657     char result[100];
 658     int retval =
 659       my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
 660     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 661             || strcmp (result, "0x3.8000000000p-1 33") == 0
 662             || strcmp (result, "0x7.0000000000p-2 33") == 0
 663             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 664     ASSERT (retval == strlen (result));
 665   }
 666
 667   { /* Large precision.  */
 668     char result[100];
 669     int retval =
 670       my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
 671     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 672             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 673             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 674             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 675     ASSERT (retval == strlen (result));
 676   }
 677
 678   { /* FLAG_LEFT.  */
 679     char result[100];
 680     int retval =
 681       my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
 682     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 683             || strcmp (result, "0x3.8p-1   33") == 0
 684             || strcmp (result, "0x7p-2     33") == 0
 685             || strcmp (result, "0xep-3     33") == 0);
 686     ASSERT (retval == strlen (result));
 687   }
 688
 689   { /* FLAG_SHOWSIGN.  */
 690     char result[100];
 691     int retval =
 692       my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
 693     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 694             || strcmp (result, "+0x3.8p-1 33") == 0
 695             || strcmp (result, "+0x7p-2 33") == 0
 696             || strcmp (result, "+0xep-3 33") == 0);
 697     ASSERT (retval == strlen (result));
 698   }
 699
 700   { /* FLAG_SPACE.  */
 701     char result[100];
 702     int retval =
 703       my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
 704     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 705             || strcmp (result, " 0x3.8p-1 33") == 0
 706             || strcmp (result, " 0x7p-2 33") == 0
 707             || strcmp (result, " 0xep-3 33") == 0);
 708     ASSERT (retval == strlen (result));
 709   }
 710
 711   { /* FLAG_ALT.  */
 712     char result[100];
 713     int retval =
 714       my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
 715     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 716             || strcmp (result, "0x3.8p-1 33") == 0
 717             || strcmp (result, "0x7.p-2 33") == 0
 718             || strcmp (result, "0xe.p-3 33") == 0);
 719     ASSERT (retval == strlen (result));
 720   }
 721
 722   { /* FLAG_ALT.  */
 723     char result[100];
 724     int retval =
 725       my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
 726     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 727             || strcmp (result, "0x2.p-1 33") == 0
 728             || strcmp (result, "0x4.p-2 33") == 0
 729             || strcmp (result, "0x8.p-3 33") == 0);
 730     ASSERT (retval == strlen (result));
 731   }
 732
 733   { /* FLAG_ZERO with finite number.  */
 734     char result[100];
 735     int retval =
 736       my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
 737     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 738             || strcmp (result, "0x003.8p-1 33") == 0
 739             || strcmp (result, "0x00007p-2 33") == 0
 740             || strcmp (result, "0x0000ep-3 33") == 0);
 741     ASSERT (retval == strlen (result));
 742   }
 743
 744   { /* FLAG_ZERO with infinite number.  */
 745     char result[100];
 746     int retval =
 747       my_snprintf (result, sizeof (result), "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 748     /* "0000000inf 33" is not a valid result; see
 749        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 750     ASSERT (strcmp (result, "       inf 33") == 0);
 751     ASSERT (retval == strlen (result));
 752   }
 753
 754   { /* FLAG_ZERO with NaN.  */
 755     char result[100];
 756     int retval =
 757       my_snprintf (result, sizeof (result), "%050La %d", NaNl (), 33, 44, 55);
 758     /* "0000000nan 33" is not a valid result; see
 759        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 760     ASSERT (strlen (result) == 50 + 3
 761             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 762             && strcmp (result + strlen (result) - 3, " 33") == 0);
 763     ASSERT (retval == strlen (result));
 764   }
 765
 766   /* Test the support of the %f format directive.  */
 767
 768   { /* A positive number.  */
 769     char result[100];
 770     int retval =
 771       my_snprintf (result, sizeof (result), "%f %d", 12.75, 33, 44, 55);
 772     ASSERT (strcmp (result, "12.750000 33") == 0);
 773     ASSERT (retval == strlen (result));
 774   }
 775
 776   { /* A larger positive number.  */
 777     char result[100];
 778     int retval =
 779       my_snprintf (result, sizeof (result), "%f %d", 1234567.0, 33, 44, 55);
 780     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 781     ASSERT (retval == strlen (result));
 782   }
 783
 784   { /* Small and large positive numbers.  */
 785     static struct { double value; const char *string; } data[] =
 786       {
 787         { 1.234321234321234e-37, "0.000000" },
 788         { 1.234321234321234e-36, "0.000000" },
 789         { 1.234321234321234e-35, "0.000000" },
 790         { 1.234321234321234e-34, "0.000000" },
 791         { 1.234321234321234e-33, "0.000000" },
 792         { 1.234321234321234e-32, "0.000000" },
 793         { 1.234321234321234e-31, "0.000000" },
 794         { 1.234321234321234e-30, "0.000000" },
 795         { 1.234321234321234e-29, "0.000000" },
 796         { 1.234321234321234e-28, "0.000000" },
 797         { 1.234321234321234e-27, "0.000000" },
 798         { 1.234321234321234e-26, "0.000000" },
 799         { 1.234321234321234e-25, "0.000000" },
 800         { 1.234321234321234e-24, "0.000000" },
 801         { 1.234321234321234e-23, "0.000000" },
 802         { 1.234321234321234e-22, "0.000000" },
 803         { 1.234321234321234e-21, "0.000000" },
 804         { 1.234321234321234e-20, "0.000000" },
 805         { 1.234321234321234e-19, "0.000000" },
 806         { 1.234321234321234e-18, "0.000000" },
 807         { 1.234321234321234e-17, "0.000000" },
 808         { 1.234321234321234e-16, "0.000000" },
 809         { 1.234321234321234e-15, "0.000000" },
 810         { 1.234321234321234e-14, "0.000000" },
 811         { 1.234321234321234e-13, "0.000000" },
 812         { 1.234321234321234e-12, "0.000000" },
 813         { 1.234321234321234e-11, "0.000000" },
 814         { 1.234321234321234e-10, "0.000000" },
 815         { 1.234321234321234e-9, "0.000000" },
 816         { 1.234321234321234e-8, "0.000000" },
 817         { 1.234321234321234e-7, "0.000000" },
 818         { 1.234321234321234e-6, "0.000001" },
 819         { 1.234321234321234e-5, "0.000012" },
 820         { 1.234321234321234e-4, "0.000123" },
 821         { 1.234321234321234e-3, "0.001234" },
 822         { 1.234321234321234e-2, "0.012343" },
 823         { 1.234321234321234e-1, "0.123432" },
 824         { 1.234321234321234, "1.234321" },
 825         { 1.234321234321234e1, "12.343212" },
 826         { 1.234321234321234e2, "123.432123" },
 827         { 1.234321234321234e3, "1234.321234" },
 828         { 1.234321234321234e4, "12343.212343" },
 829         { 1.234321234321234e5, "123432.123432" },
 830         { 1.234321234321234e6, "1234321.234321" },
 831         { 1.234321234321234e7, "12343212.343212" },
 832         { 1.234321234321234e8, "123432123.432123" },
 833         { 1.234321234321234e9, "1234321234.321234" },
 834         { 1.234321234321234e10, "12343212343.2123**" },
 835         { 1.234321234321234e11, "123432123432.123***" },
 836         { 1.234321234321234e12, "1234321234321.23****" },
 837         { 1.234321234321234e13, "12343212343212.3*****" },
 838         { 1.234321234321234e14, "123432123432123.******" },
 839         { 1.234321234321234e15, "1234321234321234.000000" },
 840         { 1.234321234321234e16, "123432123432123**.000000" },
 841         { 1.234321234321234e17, "123432123432123***.000000" },
 842         { 1.234321234321234e18, "123432123432123****.000000" },
 843         { 1.234321234321234e19, "123432123432123*****.000000" },
 844         { 1.234321234321234e20, "123432123432123******.000000" },
 845         { 1.234321234321234e21, "123432123432123*******.000000" },
 846         { 1.234321234321234e22, "123432123432123********.000000" },
 847         { 1.234321234321234e23, "123432123432123*********.000000" },
 848         { 1.234321234321234e24, "123432123432123**********.000000" },
 849         { 1.234321234321234e25, "123432123432123***********.000000" },
 850         { 1.234321234321234e26, "123432123432123************.000000" },
 851         { 1.234321234321234e27, "123432123432123*************.000000" },
 852         { 1.234321234321234e28, "123432123432123**************.000000" },
 853         { 1.234321234321234e29, "123432123432123***************.000000" },
 854         { 1.234321234321234e30, "123432123432123****************.000000" },
 855         { 1.234321234321234e31, "123432123432123*****************.000000" },
 856         { 1.234321234321234e32, "123432123432123******************.000000" },
 857         { 1.234321234321234e33, "123432123432123*******************.000000" },
 858         { 1.234321234321234e34, "123432123432123********************.000000" },
 859         { 1.234321234321234e35, "123432123432123*********************.000000" },
 860         { 1.234321234321234e36, "123432123432123**********************.000000" }
 861       };
 862     size_t k;
 863     for (k = 0; k < SIZEOF (data); k++)
 864       {
 865         char result[100];
 866         int retval =
 867           my_snprintf (result, sizeof (result), "%f", data[k].value);
 868         ASSERT (strmatch (data[k].string, result));
 869         ASSERT (retval == strlen (result));
 870       }
 871   }
 872
 873   { /* A negative number.  */
 874     char result[100];
 875     int retval =
 876       my_snprintf (result, sizeof (result), "%f %d", -0.03125, 33, 44, 55);
 877     ASSERT (strcmp (result, "-0.031250 33") == 0);
 878     ASSERT (retval == strlen (result));
 879   }
 880
 881   { /* Positive zero.  */
 882     char result[100];
 883     int retval =
 884       my_snprintf (result, sizeof (result), "%f %d", 0.0, 33, 44, 55);
 885     ASSERT (strcmp (result, "0.000000 33") == 0);
 886     ASSERT (retval == strlen (result));
 887   }
 888
 889   { /* Negative zero.  */
 890     char result[100];
 891     int retval =
 892       my_snprintf (result, sizeof (result), "%f %d", -zerod, 33, 44, 55);
 893     if (have_minus_zero ())
 894       ASSERT (strcmp (result, "-0.000000 33") == 0);
 895     ASSERT (retval == strlen (result));
 896   }
 897
 898   { /* Positive infinity.  */
 899     char result[100];
 900     int retval =
 901       my_snprintf (result, sizeof (result), "%f %d", 1.0 / 0.0, 33, 44, 55);
 902     ASSERT (strcmp (result, "inf 33") == 0
 903             || strcmp (result, "infinity 33") == 0);
 904     ASSERT (retval == strlen (result));
 905   }
 906
 907   { /* Negative infinity.  */
 908     char result[100];
 909     int retval =
 910       my_snprintf (result, sizeof (result), "%f %d", -1.0 / 0.0, 33, 44, 55);
 911     ASSERT (strcmp (result, "-inf 33") == 0
 912             || strcmp (result, "-infinity 33") == 0);
 913     ASSERT (retval == strlen (result));
 914   }
 915
 916   { /* NaN.  */
 917     char result[100];
 918     int retval =
 919       my_snprintf (result, sizeof (result), "%f %d", NaNd (), 33, 44, 55);
 920     ASSERT (strlen (result) >= 3 + 3
 921             && strisnan (result, 0, strlen (result) - 3, 0)
 922             && strcmp (result + strlen (result) - 3, " 33") == 0);
 923     ASSERT (retval == strlen (result));
 924   }
 925
 926   { /* Width.  */
 927     char result[100];
 928     int retval =
 929       my_snprintf (result, sizeof (result), "%10f %d", 1.75, 33, 44, 55);
 930     ASSERT (result != NULL);
 931     ASSERT (strcmp (result, "  1.750000 33") == 0);
 932     ASSERT (retval == strlen (result));
 933   }
 934
 935   { /* FLAG_LEFT.  */
 936     char result[100];
 937     int retval =
 938       my_snprintf (result, sizeof (result), "%-10f %d", 1.75, 33, 44, 55);
 939     ASSERT (result != NULL);
 940     ASSERT (strcmp (result, "1.750000   33") == 0);
 941     ASSERT (retval == strlen (result));
 942   }
 943
 944   { /* FLAG_SHOWSIGN.  */
 945     char result[100];
 946     int retval =
 947       my_snprintf (result, sizeof (result), "%+f %d", 1.75, 33, 44, 55);
 948     ASSERT (result != NULL);
 949     ASSERT (strcmp (result, "+1.750000 33") == 0);
 950     ASSERT (retval == strlen (result));
 951   }
 952
 953   { /* FLAG_SPACE.  */
 954     char result[100];
 955     int retval =
 956       my_snprintf (result, sizeof (result), "% f %d", 1.75, 33, 44, 55);
 957     ASSERT (result != NULL);
 958     ASSERT (strcmp (result, " 1.750000 33") == 0);
 959     ASSERT (retval == strlen (result));
 960   }
 961
 962   { /* FLAG_ALT.  */
 963     char result[100];
 964     int retval =
 965       my_snprintf (result, sizeof (result), "%#f %d", 1.75, 33, 44, 55);
 966     ASSERT (result != NULL);
 967     ASSERT (strcmp (result, "1.750000 33") == 0);
 968     ASSERT (retval == strlen (result));
 969   }
 970
 971   { /* FLAG_ALT.  */
 972     char result[100];
 973     int retval =
 974       my_snprintf (result, sizeof (result), "%#.f %d", 1.75, 33, 44, 55);
 975     ASSERT (result != NULL);
 976     ASSERT (strcmp (result, "2. 33") == 0);
 977     ASSERT (retval == strlen (result));
 978   }
 979
 980   { /* FLAG_ZERO with finite number.  */
 981     char result[100];
 982     int retval =
 983       my_snprintf (result, sizeof (result), "%015f %d", 1234.0, 33, 44, 55);
 984     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 985     ASSERT (retval == strlen (result));
 986   }
 987
 988   { /* FLAG_ZERO with infinite number.  */
 989     char result[100];
 990     int retval =
 991       my_snprintf (result, sizeof (result), "%015f %d", -1.0 / 0.0, 33, 44, 55);
 992     ASSERT (strcmp (result, "           -inf 33") == 0
 993             || strcmp (result, "      -infinity 33") == 0);
 994     ASSERT (retval == strlen (result));
 995   }
 996
 997   { /* FLAG_ZERO with NaN.  */
 998     char result[100];
 999     int retval =
1000       my_snprintf (result, sizeof (result), "%050f %d", NaNd (), 33, 44, 55);
1001     ASSERT (strlen (result) == 50 + 3
1002             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1003             && strcmp (result + strlen (result) - 3, " 33") == 0);
1004     ASSERT (retval == strlen (result));
1005   }
1006
1007   { /* Precision.  */
1008     char result[100];
1009     int retval =
1010       my_snprintf (result, sizeof (result), "%.f %d", 1234.0, 33, 44, 55);
1011     ASSERT (strcmp (result, "1234 33") == 0);
1012     ASSERT (retval == strlen (result));
1013   }
1014
1015   { /* Precision with no rounding.  */
1016     char result[100];
1017     int retval =
1018       my_snprintf (result, sizeof (result), "%.2f %d", 999.951, 33, 44, 55);
1019     ASSERT (strcmp (result, "999.95 33") == 0);
1020     ASSERT (retval == strlen (result));
1021   }
1022
1023   { /* Precision with rounding.  */
1024     char result[100];
1025     int retval =
1026       my_snprintf (result, sizeof (result), "%.2f %d", 999.996, 33, 44, 55);
1027     ASSERT (strcmp (result, "1000.00 33") == 0);
1028     ASSERT (retval == strlen (result));
1029   }
1030
1031   { /* A positive number.  */
1032     char result[100];
1033     int retval =
1034       my_snprintf (result, sizeof (result), "%Lf %d", 12.75L, 33, 44, 55);
1035     ASSERT (strcmp (result, "12.750000 33") == 0);
1036     ASSERT (retval == strlen (result));
1037   }
1038
1039   { /* A larger positive number.  */
1040     char result[100];
1041     int retval =
1042       my_snprintf (result, sizeof (result), "%Lf %d", 1234567.0L, 33, 44, 55);
1043     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1044     ASSERT (retval == strlen (result));
1045   }
1046
1047   { /* Small and large positive numbers.  */
1048     static struct { long double value; const char *string; } data[] =
1049       {
1050         { 1.234321234321234e-37L, "0.000000" },
1051         { 1.234321234321234e-36L, "0.000000" },
1052         { 1.234321234321234e-35L, "0.000000" },
1053         { 1.234321234321234e-34L, "0.000000" },
1054         { 1.234321234321234e-33L, "0.000000" },
1055         { 1.234321234321234e-32L, "0.000000" },
1056         { 1.234321234321234e-31L, "0.000000" },
1057         { 1.234321234321234e-30L, "0.000000" },
1058         { 1.234321234321234e-29L, "0.000000" },
1059         { 1.234321234321234e-28L, "0.000000" },
1060         { 1.234321234321234e-27L, "0.000000" },
1061         { 1.234321234321234e-26L, "0.000000" },
1062         { 1.234321234321234e-25L, "0.000000" },
1063         { 1.234321234321234e-24L, "0.000000" },
1064         { 1.234321234321234e-23L, "0.000000" },
1065         { 1.234321234321234e-22L, "0.000000" },
1066         { 1.234321234321234e-21L, "0.000000" },
1067         { 1.234321234321234e-20L, "0.000000" },
1068         { 1.234321234321234e-19L, "0.000000" },
1069         { 1.234321234321234e-18L, "0.000000" },
1070         { 1.234321234321234e-17L, "0.000000" },
1071         { 1.234321234321234e-16L, "0.000000" },
1072         { 1.234321234321234e-15L, "0.000000" },
1073         { 1.234321234321234e-14L, "0.000000" },
1074         { 1.234321234321234e-13L, "0.000000" },
1075         { 1.234321234321234e-12L, "0.000000" },
1076         { 1.234321234321234e-11L, "0.000000" },
1077         { 1.234321234321234e-10L, "0.000000" },
1078         { 1.234321234321234e-9L, "0.000000" },
1079         { 1.234321234321234e-8L, "0.000000" },
1080         { 1.234321234321234e-7L, "0.000000" },
1081         { 1.234321234321234e-6L, "0.000001" },
1082         { 1.234321234321234e-5L, "0.000012" },
1083         { 1.234321234321234e-4L, "0.000123" },
1084         { 1.234321234321234e-3L, "0.001234" },
1085         { 1.234321234321234e-2L, "0.012343" },
1086         { 1.234321234321234e-1L, "0.123432" },
1087         { 1.234321234321234L, "1.234321" },
1088         { 1.234321234321234e1L, "12.343212" },
1089         { 1.234321234321234e2L, "123.432123" },
1090         { 1.234321234321234e3L, "1234.321234" },
1091         { 1.234321234321234e4L, "12343.212343" },
1092         { 1.234321234321234e5L, "123432.123432" },
1093         { 1.234321234321234e6L, "1234321.234321" },
1094         { 1.234321234321234e7L, "12343212.343212" },
1095         { 1.234321234321234e8L, "123432123.432123" },
1096         { 1.234321234321234e9L, "1234321234.321234" },
1097         { 1.234321234321234e10L, "12343212343.2123**" },
1098         { 1.234321234321234e11L, "123432123432.123***" },
1099         { 1.234321234321234e12L, "1234321234321.23****" },
1100         { 1.234321234321234e13L, "12343212343212.3*****" },
1101         { 1.234321234321234e14L, "123432123432123.******" },
1102         { 1.234321234321234e15L, "1234321234321234.000000" },
1103         { 1.234321234321234e16L, "123432123432123**.000000" },
1104         { 1.234321234321234e17L, "123432123432123***.000000" },
1105         { 1.234321234321234e18L, "123432123432123****.000000" },
1106         { 1.234321234321234e19L, "123432123432123*****.000000" },
1107         { 1.234321234321234e20L, "123432123432123******.000000" },
1108         { 1.234321234321234e21L, "123432123432123*******.000000" },
1109         { 1.234321234321234e22L, "123432123432123********.000000" },
1110         { 1.234321234321234e23L, "123432123432123*********.000000" },
1111         { 1.234321234321234e24L, "123432123432123**********.000000" },
1112         { 1.234321234321234e25L, "123432123432123***********.000000" },
1113         { 1.234321234321234e26L, "123432123432123************.000000" },
1114         { 1.234321234321234e27L, "123432123432123*************.000000" },
1115         { 1.234321234321234e28L, "123432123432123**************.000000" },
1116         { 1.234321234321234e29L, "123432123432123***************.000000" },
1117         { 1.234321234321234e30L, "123432123432123****************.000000" },
1118         { 1.234321234321234e31L, "123432123432123*****************.000000" },
1119         { 1.234321234321234e32L, "123432123432123******************.000000" },
1120         { 1.234321234321234e33L, "123432123432123*******************.000000" },
1121         { 1.234321234321234e34L, "123432123432123********************.000000" },
1122         { 1.234321234321234e35L, "123432123432123*********************.000000" },
1123         { 1.234321234321234e36L, "123432123432123**********************.000000" }
1124       };
1125     size_t k;
1126     for (k = 0; k < SIZEOF (data); k++)
1127       {
1128         char result[100];
1129         int retval =
1130           my_snprintf (result, sizeof (result), "%Lf", data[k].value);
1131         ASSERT (strmatch (data[k].string, result));
1132         ASSERT (retval == strlen (result));
1133       }
1134   }
1135
1136   { /* A negative number.  */
1137     char result[100];
1138     int retval =
1139       my_snprintf (result, sizeof (result), "%Lf %d", -0.03125L, 33, 44, 55);
1140     ASSERT (strcmp (result, "-0.031250 33") == 0);
1141     ASSERT (retval == strlen (result));
1142   }
1143
1144   { /* Positive zero.  */
1145     char result[100];
1146     int retval =
1147       my_snprintf (result, sizeof (result), "%Lf %d", 0.0L, 33, 44, 55);
1148     ASSERT (strcmp (result, "0.000000 33") == 0);
1149     ASSERT (retval == strlen (result));
1150   }
1151
1152   { /* Negative zero.  */
1153     char result[100];
1154     int retval =
1155       my_snprintf (result, sizeof (result), "%Lf %d", -zerol, 33, 44, 55);
1156     if (have_minus_zero ())
1157       ASSERT (strcmp (result, "-0.000000 33") == 0);
1158     ASSERT (retval == strlen (result));
1159   }
1160
1161   { /* Positive infinity.  */
1162     char result[100];
1163     int retval =
1164       my_snprintf (result, sizeof (result), "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1165     ASSERT (strcmp (result, "inf 33") == 0
1166             || strcmp (result, "infinity 33") == 0);
1167     ASSERT (retval == strlen (result));
1168   }
1169
1170   { /* Negative infinity.  */
1171     char result[100];
1172     int retval =
1173       my_snprintf (result, sizeof (result), "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1174     ASSERT (strcmp (result, "-inf 33") == 0
1175             || strcmp (result, "-infinity 33") == 0);
1176     ASSERT (retval == strlen (result));
1177   }
1178
1179   { /* NaN.  */
1180     char result[100];
1181     int retval =
1182       my_snprintf (result, sizeof (result), "%Lf %d", NaNl (), 33, 44, 55);
1183     ASSERT (strlen (result) >= 3 + 3
1184             && strisnan (result, 0, strlen (result) - 3, 0)
1185             && strcmp (result + strlen (result) - 3, " 33") == 0);
1186     ASSERT (retval == strlen (result));
1187   }
1188 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
1189   { /* Quiet NaN.  */
1190     static union { unsigned int word[4]; long double value; } x =
1191       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1192     char result[100];
1193     int retval =
1194       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1195     ASSERT (strlen (result) >= 3 + 3
1196             && strisnan (result, 0, strlen (result) - 3, 0)
1197             && strcmp (result + strlen (result) - 3, " 33") == 0);
1198     ASSERT (retval == strlen (result));
1199   }
1200   {
1201     /* Signalling NaN.  */
1202     static union { unsigned int word[4]; long double value; } x =
1203       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1204     char result[100];
1205     int retval =
1206       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1207     ASSERT (strlen (result) >= 3 + 3
1208             && strisnan (result, 0, strlen (result) - 3, 0)
1209             && strcmp (result + strlen (result) - 3, " 33") == 0);
1210     ASSERT (retval == strlen (result));
1211   }
1212   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1213      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1214        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1215        Application Architecture.
1216        Table 5-2 "Floating-Point Register Encodings"
1217        Figure 5-6 "Memory to Floating-Point Register Data Translation"
1218    */
1219   { /* Pseudo-NaN.  */
1220     static union { unsigned int word[4]; long double value; } x =
1221       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1222     char result[100];
1223     int retval =
1224       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1225     ASSERT (strlen (result) >= 3 + 3
1226             && strisnan (result, 0, strlen (result) - 3, 0)
1227             && strcmp (result + strlen (result) - 3, " 33") == 0);
1228     ASSERT (retval == strlen (result));
1229   }
1230   { /* Pseudo-Infinity.  */
1231     static union { unsigned int word[4]; long double value; } x =
1232       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1233     char result[100];
1234     int retval =
1235       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1236     ASSERT (strlen (result) >= 3 + 3
1237             && strisnan (result, 0, strlen (result) - 3, 0)
1238             && strcmp (result + strlen (result) - 3, " 33") == 0);
1239     ASSERT (retval == strlen (result));
1240   }
1241   { /* Pseudo-Zero.  */
1242     static union { unsigned int word[4]; long double value; } x =
1243       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1244     char result[100];
1245     int retval =
1246       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1247     ASSERT (strlen (result) >= 3 + 3
1248             && strisnan (result, 0, strlen (result) - 3, 0)
1249             && strcmp (result + strlen (result) - 3, " 33") == 0);
1250     ASSERT (retval == strlen (result));
1251   }
1252   { /* Unnormalized number.  */
1253     static union { unsigned int word[4]; long double value; } x =
1254       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1255     char result[100];
1256     int retval =
1257       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1258     ASSERT (strlen (result) >= 3 + 3
1259             && strisnan (result, 0, strlen (result) - 3, 0)
1260             && strcmp (result + strlen (result) - 3, " 33") == 0);
1261     ASSERT (retval == strlen (result));
1262   }
1263   { /* Pseudo-Denormal.  */
1264     static union { unsigned int word[4]; long double value; } x =
1265       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1266     char result[100];
1267     int retval =
1268       my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1269     ASSERT (strlen (result) >= 3 + 3
1270             && strisnan (result, 0, strlen (result) - 3, 0)
1271             && strcmp (result + strlen (result) - 3, " 33") == 0);
1272     ASSERT (retval == strlen (result));
1273   }
1274 #endif
1275
1276   { /* Width.  */
1277     char result[100];
1278     int retval =
1279       my_snprintf (result, sizeof (result), "%10Lf %d", 1.75L, 33, 44, 55);
1280     ASSERT (result != NULL);
1281     ASSERT (strcmp (result, "  1.750000 33") == 0);
1282     ASSERT (retval == strlen (result));
1283   }
1284
1285   { /* FLAG_LEFT.  */
1286     char result[100];
1287     int retval =
1288       my_snprintf (result, sizeof (result), "%-10Lf %d", 1.75L, 33, 44, 55);
1289     ASSERT (result != NULL);
1290     ASSERT (strcmp (result, "1.750000   33") == 0);
1291     ASSERT (retval == strlen (result));
1292   }
1293
1294   { /* FLAG_SHOWSIGN.  */
1295     char result[100];
1296     int retval =
1297       my_snprintf (result, sizeof (result), "%+Lf %d", 1.75L, 33, 44, 55);
1298     ASSERT (result != NULL);
1299     ASSERT (strcmp (result, "+1.750000 33") == 0);
1300     ASSERT (retval == strlen (result));
1301   }
1302
1303   { /* FLAG_SPACE.  */
1304     char result[100];
1305     int retval =
1306       my_snprintf (result, sizeof (result), "% Lf %d", 1.75L, 33, 44, 55);
1307     ASSERT (result != NULL);
1308     ASSERT (strcmp (result, " 1.750000 33") == 0);
1309     ASSERT (retval == strlen (result));
1310   }
1311
1312   { /* FLAG_ALT.  */
1313     char result[100];
1314     int retval =
1315       my_snprintf (result, sizeof (result), "%#Lf %d", 1.75L, 33, 44, 55);
1316     ASSERT (result != NULL);
1317     ASSERT (strcmp (result, "1.750000 33") == 0);
1318     ASSERT (retval == strlen (result));
1319   }
1320
1321   { /* FLAG_ALT.  */
1322     char result[100];
1323     int retval =
1324       my_snprintf (result, sizeof (result), "%#.Lf %d", 1.75L, 33, 44, 55);
1325     ASSERT (result != NULL);
1326     ASSERT (strcmp (result, "2. 33") == 0);
1327     ASSERT (retval == strlen (result));
1328   }
1329
1330   { /* FLAG_ZERO with finite number.  */
1331     char result[100];
1332     int retval =
1333       my_snprintf (result, sizeof (result), "%015Lf %d", 1234.0L, 33, 44, 55);
1334     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1335     ASSERT (retval == strlen (result));
1336   }
1337
1338   { /* FLAG_ZERO with infinite number.  */
1339     char result[100];
1340     int retval =
1341       my_snprintf (result, sizeof (result), "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1342     ASSERT (strcmp (result, "           -inf 33") == 0
1343             || strcmp (result, "      -infinity 33") == 0);
1344     ASSERT (retval == strlen (result));
1345   }
1346
1347   { /* FLAG_ZERO with NaN.  */
1348     char result[100];
1349     int retval =
1350       my_snprintf (result, sizeof (result), "%050Lf %d", NaNl (), 33, 44, 55);
1351     ASSERT (strlen (result) == 50 + 3
1352             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1353             && strcmp (result + strlen (result) - 3, " 33") == 0);
1354     ASSERT (retval == strlen (result));
1355   }
1356
1357   { /* Precision.  */
1358     char result[100];
1359     int retval =
1360       my_snprintf (result, sizeof (result), "%.Lf %d", 1234.0L, 33, 44, 55);
1361     ASSERT (strcmp (result, "1234 33") == 0);
1362     ASSERT (retval == strlen (result));
1363   }
1364
1365   { /* Precision with no rounding.  */
1366     char result[100];
1367     int retval =
1368       my_snprintf (result, sizeof (result), "%.2Lf %d", 999.951L, 33, 44, 55);
1369     ASSERT (strcmp (result, "999.95 33") == 0);
1370     ASSERT (retval == strlen (result));
1371   }
1372
1373   { /* Precision with rounding.  */
1374     char result[100];
1375     int retval =
1376       my_snprintf (result, sizeof (result), "%.2Lf %d", 999.996L, 33, 44, 55);
1377     ASSERT (strcmp (result, "1000.00 33") == 0);
1378     ASSERT (retval == strlen (result));
1379   }
1380
1381   /* Test the support of the %F format directive.  */
1382
1383   { /* A positive number.  */
1384     char result[100];
1385     int retval =
1386       my_snprintf (result, sizeof (result), "%F %d", 12.75, 33, 44, 55);
1387     ASSERT (strcmp (result, "12.750000 33") == 0);
1388     ASSERT (retval == strlen (result));
1389   }
1390
1391   { /* A larger positive number.  */
1392     char result[100];
1393     int retval =
1394       my_snprintf (result, sizeof (result), "%F %d", 1234567.0, 33, 44, 55);
1395     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1396     ASSERT (retval == strlen (result));
1397   }
1398
1399   { /* A negative number.  */
1400     char result[100];
1401     int retval =
1402       my_snprintf (result, sizeof (result), "%F %d", -0.03125, 33, 44, 55);
1403     ASSERT (strcmp (result, "-0.031250 33") == 0);
1404     ASSERT (retval == strlen (result));
1405   }
1406
1407   { /* Positive zero.  */
1408     char result[100];
1409     int retval =
1410       my_snprintf (result, sizeof (result), "%F %d", 0.0, 33, 44, 55);
1411     ASSERT (strcmp (result, "0.000000 33") == 0);
1412     ASSERT (retval == strlen (result));
1413   }
1414
1415   { /* Negative zero.  */
1416     char result[100];
1417     int retval =
1418       my_snprintf (result, sizeof (result), "%F %d", -zerod, 33, 44, 55);
1419     if (have_minus_zero ())
1420       ASSERT (strcmp (result, "-0.000000 33") == 0);
1421     ASSERT (retval == strlen (result));
1422   }
1423
1424   { /* Positive infinity.  */
1425     char result[100];
1426     int retval =
1427       my_snprintf (result, sizeof (result), "%F %d", 1.0 / 0.0, 33, 44, 55);
1428     ASSERT (strcmp (result, "INF 33") == 0
1429             || strcmp (result, "INFINITY 33") == 0);
1430     ASSERT (retval == strlen (result));
1431   }
1432
1433   { /* Negative infinity.  */
1434     char result[100];
1435     int retval =
1436       my_snprintf (result, sizeof (result), "%F %d", -1.0 / 0.0, 33, 44, 55);
1437     ASSERT (strcmp (result, "-INF 33") == 0
1438             || strcmp (result, "-INFINITY 33") == 0);
1439     ASSERT (retval == strlen (result));
1440   }
1441
1442   { /* NaN.  */
1443     char result[100];
1444     int retval =
1445       my_snprintf (result, sizeof (result), "%F %d", NaNd (), 33, 44, 55);
1446     ASSERT (strlen (result) >= 3 + 3
1447             && strisnan (result, 0, strlen (result) - 3, 1)
1448             && strcmp (result + strlen (result) - 3, " 33") == 0);
1449     ASSERT (retval == strlen (result));
1450   }
1451
1452   { /* FLAG_ZERO.  */
1453     char result[100];
1454     int retval =
1455       my_snprintf (result, sizeof (result), "%015F %d", 1234.0, 33, 44, 55);
1456     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1457     ASSERT (retval == strlen (result));
1458   }
1459
1460   { /* FLAG_ZERO with infinite number.  */
1461     char result[100];
1462     int retval =
1463       my_snprintf (result, sizeof (result), "%015F %d", -1.0 / 0.0, 33, 44, 55);
1464     ASSERT (strcmp (result, "           -INF 33") == 0
1465             || strcmp (result, "      -INFINITY 33") == 0);
1466     ASSERT (retval == strlen (result));
1467   }
1468
1469   { /* Precision.  */
1470     char result[100];
1471     int retval =
1472       my_snprintf (result, sizeof (result), "%.F %d", 1234.0, 33, 44, 55);
1473     ASSERT (strcmp (result, "1234 33") == 0);
1474     ASSERT (retval == strlen (result));
1475   }
1476
1477   { /* Precision with no rounding.  */
1478     char result[100];
1479     int retval =
1480       my_snprintf (result, sizeof (result), "%.2F %d", 999.951, 33, 44, 55);
1481     ASSERT (strcmp (result, "999.95 33") == 0);
1482     ASSERT (retval == strlen (result));
1483   }
1484
1485   { /* Precision with rounding.  */
1486     char result[100];
1487     int retval =
1488       my_snprintf (result, sizeof (result), "%.2F %d", 999.996, 33, 44, 55);
1489     ASSERT (strcmp (result, "1000.00 33") == 0);
1490     ASSERT (retval == strlen (result));
1491   }
1492
1493   { /* A positive number.  */
1494     char result[100];
1495     int retval =
1496       my_snprintf (result, sizeof (result), "%LF %d", 12.75L, 33, 44, 55);
1497     ASSERT (strcmp (result, "12.750000 33") == 0);
1498     ASSERT (retval == strlen (result));
1499   }
1500
1501   { /* A larger positive number.  */
1502     char result[100];
1503     int retval =
1504       my_snprintf (result, sizeof (result), "%LF %d", 1234567.0L, 33, 44, 55);
1505     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1506     ASSERT (retval == strlen (result));
1507   }
1508
1509   { /* A negative number.  */
1510     char result[100];
1511     int retval =
1512       my_snprintf (result, sizeof (result), "%LF %d", -0.03125L, 33, 44, 55);
1513     ASSERT (strcmp (result, "-0.031250 33") == 0);
1514     ASSERT (retval == strlen (result));
1515   }
1516
1517   { /* Positive zero.  */
1518     char result[100];
1519     int retval =
1520       my_snprintf (result, sizeof (result), "%LF %d", 0.0L, 33, 44, 55);
1521     ASSERT (strcmp (result, "0.000000 33") == 0);
1522     ASSERT (retval == strlen (result));
1523   }
1524
1525   { /* Negative zero.  */
1526     char result[100];
1527     int retval =
1528       my_snprintf (result, sizeof (result), "%LF %d", -zerol, 33, 44, 55);
1529     if (have_minus_zero ())
1530       ASSERT (strcmp (result, "-0.000000 33") == 0);
1531     ASSERT (retval == strlen (result));
1532   }
1533
1534   { /* Positive infinity.  */
1535     char result[100];
1536     int retval =
1537       my_snprintf (result, sizeof (result), "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1538     ASSERT (strcmp (result, "INF 33") == 0
1539             || strcmp (result, "INFINITY 33") == 0);
1540     ASSERT (retval == strlen (result));
1541   }
1542
1543   { /* Negative infinity.  */
1544     char result[100];
1545     int retval =
1546       my_snprintf (result, sizeof (result), "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1547     ASSERT (strcmp (result, "-INF 33") == 0
1548             || strcmp (result, "-INFINITY 33") == 0);
1549     ASSERT (retval == strlen (result));
1550   }
1551
1552   { /* NaN.  */
1553     char result[100];
1554     int retval =
1555       my_snprintf (result, sizeof (result), "%LF %d", NaNl (), 33, 44, 55);
1556     ASSERT (strlen (result) >= 3 + 3
1557             && strisnan (result, 0, strlen (result) - 3, 1)
1558             && strcmp (result + strlen (result) - 3, " 33") == 0);
1559     ASSERT (retval == strlen (result));
1560   }
1561
1562   { /* FLAG_ZERO.  */
1563     char result[100];
1564     int retval =
1565       my_snprintf (result, sizeof (result), "%015LF %d", 1234.0L, 33, 44, 55);
1566     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1567     ASSERT (retval == strlen (result));
1568   }
1569
1570   { /* FLAG_ZERO with infinite number.  */
1571     char result[100];
1572     int retval =
1573       my_snprintf (result, sizeof (result), "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1574     ASSERT (strcmp (result, "           -INF 33") == 0
1575             || strcmp (result, "      -INFINITY 33") == 0);
1576     ASSERT (retval == strlen (result));
1577   }
1578
1579   { /* Precision.  */
1580     char result[100];
1581     int retval =
1582       my_snprintf (result, sizeof (result), "%.LF %d", 1234.0L, 33, 44, 55);
1583     ASSERT (strcmp (result, "1234 33") == 0);
1584     ASSERT (retval == strlen (result));
1585   }
1586
1587   { /* Precision with no rounding.  */
1588     char result[100];
1589     int retval =
1590       my_snprintf (result, sizeof (result), "%.2LF %d", 999.951L, 33, 44, 55);
1591     ASSERT (strcmp (result, "999.95 33") == 0);
1592     ASSERT (retval == strlen (result));
1593   }
1594
1595   { /* Precision with rounding.  */
1596     char result[100];
1597     int retval =
1598       my_snprintf (result, sizeof (result), "%.2LF %d", 999.996L, 33, 44, 55);
1599     ASSERT (strcmp (result, "1000.00 33") == 0);
1600     ASSERT (retval == strlen (result));
1601   }
1602
1603   /* Test the support of the %e format directive.  */
1604
1605   { /* A positive number.  */
1606     char result[100];
1607     int retval =
1608       my_snprintf (result, sizeof (result), "%e %d", 12.75, 33, 44, 55);
1609     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1610             || strcmp (result, "1.275000e+001 33") == 0);
1611     ASSERT (retval == strlen (result));
1612   }
1613
1614   { /* A larger positive number.  */
1615     char result[100];
1616     int retval =
1617       my_snprintf (result, sizeof (result), "%e %d", 1234567.0, 33, 44, 55);
1618     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1619             || strcmp (result, "1.234567e+006 33") == 0);
1620     ASSERT (retval == strlen (result));
1621   }
1622
1623   { /* Small and large positive numbers.  */
1624     static struct { double value; const char *string; } data[] =
1625       {
1626         { 1.234321234321234e-37, "1.234321e-37" },
1627         { 1.234321234321234e-36, "1.234321e-36" },
1628         { 1.234321234321234e-35, "1.234321e-35" },
1629         { 1.234321234321234e-34, "1.234321e-34" },
1630         { 1.234321234321234e-33, "1.234321e-33" },
1631         { 1.234321234321234e-32, "1.234321e-32" },
1632         { 1.234321234321234e-31, "1.234321e-31" },
1633         { 1.234321234321234e-30, "1.234321e-30" },
1634         { 1.234321234321234e-29, "1.234321e-29" },
1635         { 1.234321234321234e-28, "1.234321e-28" },
1636         { 1.234321234321234e-27, "1.234321e-27" },
1637         { 1.234321234321234e-26, "1.234321e-26" },
1638         { 1.234321234321234e-25, "1.234321e-25" },
1639         { 1.234321234321234e-24, "1.234321e-24" },
1640         { 1.234321234321234e-23, "1.234321e-23" },
1641         { 1.234321234321234e-22, "1.234321e-22" },
1642         { 1.234321234321234e-21, "1.234321e-21" },
1643         { 1.234321234321234e-20, "1.234321e-20" },
1644         { 1.234321234321234e-19, "1.234321e-19" },
1645         { 1.234321234321234e-18, "1.234321e-18" },
1646         { 1.234321234321234e-17, "1.234321e-17" },
1647         { 1.234321234321234e-16, "1.234321e-16" },
1648         { 1.234321234321234e-15, "1.234321e-15" },
1649         { 1.234321234321234e-14, "1.234321e-14" },
1650         { 1.234321234321234e-13, "1.234321e-13" },
1651         { 1.234321234321234e-12, "1.234321e-12" },
1652         { 1.234321234321234e-11, "1.234321e-11" },
1653         { 1.234321234321234e-10, "1.234321e-10" },
1654         { 1.234321234321234e-9, "1.234321e-09" },
1655         { 1.234321234321234e-8, "1.234321e-08" },
1656         { 1.234321234321234e-7, "1.234321e-07" },
1657         { 1.234321234321234e-6, "1.234321e-06" },
1658         { 1.234321234321234e-5, "1.234321e-05" },
1659         { 1.234321234321234e-4, "1.234321e-04" },
1660         { 1.234321234321234e-3, "1.234321e-03" },
1661         { 1.234321234321234e-2, "1.234321e-02" },
1662         { 1.234321234321234e-1, "1.234321e-01" },
1663         { 1.234321234321234, "1.234321e+00" },
1664         { 1.234321234321234e1, "1.234321e+01" },
1665         { 1.234321234321234e2, "1.234321e+02" },
1666         { 1.234321234321234e3, "1.234321e+03" },
1667         { 1.234321234321234e4, "1.234321e+04" },
1668         { 1.234321234321234e5, "1.234321e+05" },
1669         { 1.234321234321234e6, "1.234321e+06" },
1670         { 1.234321234321234e7, "1.234321e+07" },
1671         { 1.234321234321234e8, "1.234321e+08" },
1672         { 1.234321234321234e9, "1.234321e+09" },
1673         { 1.234321234321234e10, "1.234321e+10" },
1674         { 1.234321234321234e11, "1.234321e+11" },
1675         { 1.234321234321234e12, "1.234321e+12" },
1676         { 1.234321234321234e13, "1.234321e+13" },
1677         { 1.234321234321234e14, "1.234321e+14" },
1678         { 1.234321234321234e15, "1.234321e+15" },
1679         { 1.234321234321234e16, "1.234321e+16" },
1680         { 1.234321234321234e17, "1.234321e+17" },
1681         { 1.234321234321234e18, "1.234321e+18" },
1682         { 1.234321234321234e19, "1.234321e+19" },
1683         { 1.234321234321234e20, "1.234321e+20" },
1684         { 1.234321234321234e21, "1.234321e+21" },
1685         { 1.234321234321234e22, "1.234321e+22" },
1686         { 1.234321234321234e23, "1.234321e+23" },
1687         { 1.234321234321234e24, "1.234321e+24" },
1688         { 1.234321234321234e25, "1.234321e+25" },
1689         { 1.234321234321234e26, "1.234321e+26" },
1690         { 1.234321234321234e27, "1.234321e+27" },
1691         { 1.234321234321234e28, "1.234321e+28" },
1692         { 1.234321234321234e29, "1.234321e+29" },
1693         { 1.234321234321234e30, "1.234321e+30" },
1694         { 1.234321234321234e31, "1.234321e+31" },
1695         { 1.234321234321234e32, "1.234321e+32" },
1696         { 1.234321234321234e33, "1.234321e+33" },
1697         { 1.234321234321234e34, "1.234321e+34" },
1698         { 1.234321234321234e35, "1.234321e+35" },
1699         { 1.234321234321234e36, "1.234321e+36" }
1700       };
1701     size_t k;
1702     for (k = 0; k < SIZEOF (data); k++)
1703       {
1704         char result[100];
1705         int retval =
1706           my_snprintf (result, sizeof (result), "%e", data[k].value);
1707         const char *expected = data[k].string;
1708         ASSERT (result != NULL);
1709         ASSERT (strcmp (result, expected) == 0
1710                 /* Some implementations produce exponents with 3 digits.  */
1711                 || (strlen (result) == strlen (expected) + 1
1712                     && memcmp (result, expected, strlen (expected) - 2) == 0
1713                     && result[strlen (expected) - 2] == '0'
1714                     && strcmp (result + strlen (expected) - 1,
1715                                expected + strlen (expected) - 2)
1716                        == 0));
1717         ASSERT (retval == strlen (result));
1718       }
1719   }
1720
1721   { /* A negative number.  */
1722     char result[100];
1723     int retval =
1724       my_snprintf (result, sizeof (result), "%e %d", -0.03125, 33, 44, 55);
1725     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1726             || strcmp (result, "-3.125000e-002 33") == 0);
1727     ASSERT (retval == strlen (result));
1728   }
1729
1730   { /* Positive zero.  */
1731     char result[100];
1732     int retval =
1733       my_snprintf (result, sizeof (result), "%e %d", 0.0, 33, 44, 55);
1734     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1735             || strcmp (result, "0.000000e+000 33") == 0);
1736     ASSERT (retval == strlen (result));
1737   }
1738
1739   { /* Negative zero.  */
1740     char result[100];
1741     int retval =
1742       my_snprintf (result, sizeof (result), "%e %d", -zerod, 33, 44, 55);
1743     if (have_minus_zero ())
1744       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1745               || strcmp (result, "-0.000000e+000 33") == 0);
1746     ASSERT (retval == strlen (result));
1747   }
1748
1749   { /* Positive infinity.  */
1750     char result[100];
1751     int retval =
1752       my_snprintf (result, sizeof (result), "%e %d", 1.0 / 0.0, 33, 44, 55);
1753     ASSERT (strcmp (result, "inf 33") == 0
1754             || strcmp (result, "infinity 33") == 0);
1755     ASSERT (retval == strlen (result));
1756   }
1757
1758   { /* Negative infinity.  */
1759     char result[100];
1760     int retval =
1761       my_snprintf (result, sizeof (result), "%e %d", -1.0 / 0.0, 33, 44, 55);
1762     ASSERT (strcmp (result, "-inf 33") == 0
1763             || strcmp (result, "-infinity 33") == 0);
1764     ASSERT (retval == strlen (result));
1765   }
1766
1767   { /* NaN.  */
1768     char result[100];
1769     int retval =
1770       my_snprintf (result, sizeof (result), "%e %d", NaNd (), 33, 44, 55);
1771     ASSERT (strlen (result) >= 3 + 3
1772             && strisnan (result, 0, strlen (result) - 3, 0)
1773             && strcmp (result + strlen (result) - 3, " 33") == 0);
1774     ASSERT (retval == strlen (result));
1775   }
1776
1777   { /* Width.  */
1778     char result[100];
1779     int retval =
1780       my_snprintf (result, sizeof (result), "%15e %d", 1.75, 33, 44, 55);
1781     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
1782             || strcmp (result, "  1.750000e+000 33") == 0);
1783     ASSERT (retval == strlen (result));
1784   }
1785
1786   { /* FLAG_LEFT.  */
1787     char result[100];
1788     int retval =
1789       my_snprintf (result, sizeof (result), "%-15e %d", 1.75, 33, 44, 55);
1790     ASSERT (strcmp (result, "1.750000e+00    33") == 0
1791             || strcmp (result, "1.750000e+000   33") == 0);
1792     ASSERT (retval == strlen (result));
1793   }
1794
1795   { /* FLAG_SHOWSIGN.  */
1796     char result[100];
1797     int retval =
1798       my_snprintf (result, sizeof (result), "%+e %d", 1.75, 33, 44, 55);
1799     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1800             || strcmp (result, "+1.750000e+000 33") == 0);
1801     ASSERT (retval == strlen (result));
1802   }
1803
1804   { /* FLAG_SPACE.  */
1805     char result[100];
1806     int retval =
1807       my_snprintf (result, sizeof (result), "% e %d", 1.75, 33, 44, 55);
1808     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1809             || strcmp (result, " 1.750000e+000 33") == 0);
1810     ASSERT (retval == strlen (result));
1811   }
1812
1813   { /* FLAG_ALT.  */
1814     char result[100];
1815     int retval =
1816       my_snprintf (result, sizeof (result), "%#e %d", 1.75, 33, 44, 55);
1817     ASSERT (strcmp (result, "1.750000e+00 33") == 0
1818             || strcmp (result, "1.750000e+000 33") == 0);
1819     ASSERT (retval == strlen (result));
1820   }
1821
1822   { /* FLAG_ALT.  */
1823     char result[100];
1824     int retval =
1825       my_snprintf (result, sizeof (result), "%#.e %d", 1.75, 33, 44, 55);
1826     ASSERT (strcmp (result, "2.e+00 33") == 0
1827             || strcmp (result, "2.e+000 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), "%#.e %d", 9.75, 33, 44, 55);
1835     ASSERT (strcmp (result, "1.e+01 33") == 0
1836             || strcmp (result, "1.e+001 33") == 0);
1837     ASSERT (retval == strlen (result));
1838   }
1839
1840   { /* FLAG_ZERO with finite number.  */
1841     char result[100];
1842     int retval =
1843       my_snprintf (result, sizeof (result), "%015e %d", 1234.0, 33, 44, 55);
1844     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1845             || strcmp (result, "001.234000e+003 33") == 0);
1846     ASSERT (retval == strlen (result));
1847   }
1848
1849   { /* FLAG_ZERO with infinite number.  */
1850     char result[100];
1851     int retval =
1852       my_snprintf (result, sizeof (result), "%015e %d", -1.0 / 0.0, 33, 44, 55);
1853     ASSERT (strcmp (result, "           -inf 33") == 0
1854             || strcmp (result, "      -infinity 33") == 0);
1855     ASSERT (retval == strlen (result));
1856   }
1857
1858   { /* FLAG_ZERO with NaN.  */
1859     char result[100];
1860     int retval =
1861       my_snprintf (result, sizeof (result), "%050e %d", NaNd (), 33, 44, 55);
1862     ASSERT (strlen (result) == 50 + 3
1863             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1864             && strcmp (result + strlen (result) - 3, " 33") == 0);
1865     ASSERT (retval == strlen (result));
1866   }
1867
1868   { /* Precision.  */
1869     char result[100];
1870     int retval =
1871       my_snprintf (result, sizeof (result), "%.e %d", 1234.0, 33, 44, 55);
1872     ASSERT (strcmp (result, "1e+03 33") == 0
1873             || strcmp (result, "1e+003 33") == 0);
1874     ASSERT (retval == strlen (result));
1875   }
1876
1877   { /* Precision with no rounding.  */
1878     char result[100];
1879     int retval =
1880       my_snprintf (result, sizeof (result), "%.4e %d", 999.951, 33, 44, 55);
1881     ASSERT (strcmp (result, "9.9995e+02 33") == 0
1882             || strcmp (result, "9.9995e+002 33") == 0);
1883     ASSERT (retval == strlen (result));
1884   }
1885
1886   { /* Precision with rounding.  */
1887     char result[100];
1888     int retval =
1889       my_snprintf (result, sizeof (result), "%.4e %d", 999.996, 33, 44, 55);
1890     ASSERT (strcmp (result, "1.0000e+03 33") == 0
1891             || strcmp (result, "1.0000e+003 33") == 0);
1892     ASSERT (retval == strlen (result));
1893   }
1894
1895   { /* A positive number.  */
1896     char result[100];
1897     int retval =
1898       my_snprintf (result, sizeof (result), "%Le %d", 12.75L, 33, 44, 55);
1899     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1900     ASSERT (retval == strlen (result));
1901   }
1902
1903   { /* A larger positive number.  */
1904     char result[100];
1905     int retval =
1906       my_snprintf (result, sizeof (result), "%Le %d", 1234567.0L, 33, 44, 55);
1907     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1908     ASSERT (retval == strlen (result));
1909   }
1910
1911   { /* Small and large positive numbers.  */
1912     static struct { long double value; const char *string; } data[] =
1913       {
1914         { 1.234321234321234e-37L, "1.234321e-37" },
1915         { 1.234321234321234e-36L, "1.234321e-36" },
1916         { 1.234321234321234e-35L, "1.234321e-35" },
1917         { 1.234321234321234e-34L, "1.234321e-34" },
1918         { 1.234321234321234e-33L, "1.234321e-33" },
1919         { 1.234321234321234e-32L, "1.234321e-32" },
1920         { 1.234321234321234e-31L, "1.234321e-31" },
1921         { 1.234321234321234e-30L, "1.234321e-30" },
1922         { 1.234321234321234e-29L, "1.234321e-29" },
1923         { 1.234321234321234e-28L, "1.234321e-28" },
1924         { 1.234321234321234e-27L, "1.234321e-27" },
1925         { 1.234321234321234e-26L, "1.234321e-26" },
1926         { 1.234321234321234e-25L, "1.234321e-25" },
1927         { 1.234321234321234e-24L, "1.234321e-24" },
1928         { 1.234321234321234e-23L, "1.234321e-23" },
1929         { 1.234321234321234e-22L, "1.234321e-22" },
1930         { 1.234321234321234e-21L, "1.234321e-21" },
1931         { 1.234321234321234e-20L, "1.234321e-20" },
1932         { 1.234321234321234e-19L, "1.234321e-19" },
1933         { 1.234321234321234e-18L, "1.234321e-18" },
1934         { 1.234321234321234e-17L, "1.234321e-17" },
1935         { 1.234321234321234e-16L, "1.234321e-16" },
1936         { 1.234321234321234e-15L, "1.234321e-15" },
1937         { 1.234321234321234e-14L, "1.234321e-14" },
1938         { 1.234321234321234e-13L, "1.234321e-13" },
1939         { 1.234321234321234e-12L, "1.234321e-12" },
1940         { 1.234321234321234e-11L, "1.234321e-11" },
1941         { 1.234321234321234e-10L, "1.234321e-10" },
1942         { 1.234321234321234e-9L, "1.234321e-09" },
1943         { 1.234321234321234e-8L, "1.234321e-08" },
1944         { 1.234321234321234e-7L, "1.234321e-07" },
1945         { 1.234321234321234e-6L, "1.234321e-06" },
1946         { 1.234321234321234e-5L, "1.234321e-05" },
1947         { 1.234321234321234e-4L, "1.234321e-04" },
1948         { 1.234321234321234e-3L, "1.234321e-03" },
1949         { 1.234321234321234e-2L, "1.234321e-02" },
1950         { 1.234321234321234e-1L, "1.234321e-01" },
1951         { 1.234321234321234L, "1.234321e+00" },
1952         { 1.234321234321234e1L, "1.234321e+01" },
1953         { 1.234321234321234e2L, "1.234321e+02" },
1954         { 1.234321234321234e3L, "1.234321e+03" },
1955         { 1.234321234321234e4L, "1.234321e+04" },
1956         { 1.234321234321234e5L, "1.234321e+05" },
1957         { 1.234321234321234e6L, "1.234321e+06" },
1958         { 1.234321234321234e7L, "1.234321e+07" },
1959         { 1.234321234321234e8L, "1.234321e+08" },
1960         { 1.234321234321234e9L, "1.234321e+09" },
1961         { 1.234321234321234e10L, "1.234321e+10" },
1962         { 1.234321234321234e11L, "1.234321e+11" },
1963         { 1.234321234321234e12L, "1.234321e+12" },
1964         { 1.234321234321234e13L, "1.234321e+13" },
1965         { 1.234321234321234e14L, "1.234321e+14" },
1966         { 1.234321234321234e15L, "1.234321e+15" },
1967         { 1.234321234321234e16L, "1.234321e+16" },
1968         { 1.234321234321234e17L, "1.234321e+17" },
1969         { 1.234321234321234e18L, "1.234321e+18" },
1970         { 1.234321234321234e19L, "1.234321e+19" },
1971         { 1.234321234321234e20L, "1.234321e+20" },
1972         { 1.234321234321234e21L, "1.234321e+21" },
1973         { 1.234321234321234e22L, "1.234321e+22" },
1974         { 1.234321234321234e23L, "1.234321e+23" },
1975         { 1.234321234321234e24L, "1.234321e+24" },
1976         { 1.234321234321234e25L, "1.234321e+25" },
1977         { 1.234321234321234e26L, "1.234321e+26" },
1978         { 1.234321234321234e27L, "1.234321e+27" },
1979         { 1.234321234321234e28L, "1.234321e+28" },
1980         { 1.234321234321234e29L, "1.234321e+29" },
1981         { 1.234321234321234e30L, "1.234321e+30" },
1982         { 1.234321234321234e31L, "1.234321e+31" },
1983         { 1.234321234321234e32L, "1.234321e+32" },
1984         { 1.234321234321234e33L, "1.234321e+33" },
1985         { 1.234321234321234e34L, "1.234321e+34" },
1986         { 1.234321234321234e35L, "1.234321e+35" },
1987         { 1.234321234321234e36L, "1.234321e+36" }
1988       };
1989     size_t k;
1990     for (k = 0; k < SIZEOF (data); k++)
1991       {
1992         char result[100];
1993         int retval =
1994           my_snprintf (result, sizeof (result), "%Le", data[k].value);
1995         ASSERT (strcmp (result, data[k].string) == 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), "%Le %d", -0.03125L, 33, 44, 55);
2004     ASSERT (strcmp (result, "-3.125000e-02 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), "%Le %d", 0.0L, 33, 44, 55);
2012     ASSERT (strcmp (result, "0.000000e+00 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), "%Le %d", -zerol, 33, 44, 55);
2020     if (have_minus_zero ())
2021       ASSERT (strcmp (result, "-0.000000e+00 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), "%Le %d", 1.0L / 0.0L, 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), "%Le %d", -1.0L / 0.0L, 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), "%Le %d", NaNl (), 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 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
2053   { /* Quiet NaN.  */
2054     static union { unsigned int word[4]; long double value; } x =
2055       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2056     char result[100];
2057     int retval =
2058       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2059     ASSERT (strlen (result) >= 3 + 3
2060             && strisnan (result, 0, strlen (result) - 3, 0)
2061             && strcmp (result + strlen (result) - 3, " 33") == 0);
2062     ASSERT (retval == strlen (result));
2063   }
2064   {
2065     /* Signalling NaN.  */
2066     static union { unsigned int word[4]; long double value; } x =
2067       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2068     char result[100];
2069     int retval =
2070       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2071     ASSERT (strlen (result) >= 3 + 3
2072             && strisnan (result, 0, strlen (result) - 3, 0)
2073             && strcmp (result + strlen (result) - 3, " 33") == 0);
2074     ASSERT (retval == strlen (result));
2075   }
2076   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2077      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2078        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2079        Application Architecture.
2080        Table 5-2 "Floating-Point Register Encodings"
2081        Figure 5-6 "Memory to Floating-Point Register Data Translation"
2082    */
2083   { /* Pseudo-NaN.  */
2084     static union { unsigned int word[4]; long double value; } x =
2085       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2086     char result[100];
2087     int retval =
2088       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2089     ASSERT (strlen (result) >= 3 + 3
2090             && strisnan (result, 0, strlen (result) - 3, 0)
2091             && strcmp (result + strlen (result) - 3, " 33") == 0);
2092     ASSERT (retval == strlen (result));
2093   }
2094   { /* Pseudo-Infinity.  */
2095     static union { unsigned int word[4]; long double value; } x =
2096       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2097     char result[100];
2098     int retval =
2099       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2100     ASSERT (strlen (result) >= 3 + 3
2101             && strisnan (result, 0, strlen (result) - 3, 0)
2102             && strcmp (result + strlen (result) - 3, " 33") == 0);
2103     ASSERT (retval == strlen (result));
2104   }
2105   { /* Pseudo-Zero.  */
2106     static union { unsigned int word[4]; long double value; } x =
2107       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2108     char result[100];
2109     int retval =
2110       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2111     ASSERT (strlen (result) >= 3 + 3
2112             && strisnan (result, 0, strlen (result) - 3, 0)
2113             && strcmp (result + strlen (result) - 3, " 33") == 0);
2114     ASSERT (retval == strlen (result));
2115   }
2116   { /* Unnormalized number.  */
2117     static union { unsigned int word[4]; long double value; } x =
2118       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2119     char result[100];
2120     int retval =
2121       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2122     ASSERT (strlen (result) >= 3 + 3
2123             && strisnan (result, 0, strlen (result) - 3, 0)
2124             && strcmp (result + strlen (result) - 3, " 33") == 0);
2125     ASSERT (retval == strlen (result));
2126   }
2127   { /* Pseudo-Denormal.  */
2128     static union { unsigned int word[4]; long double value; } x =
2129       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2130     char result[100];
2131     int retval =
2132       my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2133     ASSERT (strlen (result) >= 3 + 3
2134             && strisnan (result, 0, strlen (result) - 3, 0)
2135             && strcmp (result + strlen (result) - 3, " 33") == 0);
2136     ASSERT (retval == strlen (result));
2137   }
2138 #endif
2139
2140   { /* Width.  */
2141     char result[100];
2142     int retval =
2143       my_snprintf (result, sizeof (result), "%15Le %d", 1.75L, 33, 44, 55);
2144     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
2145     ASSERT (retval == strlen (result));
2146   }
2147
2148   { /* FLAG_LEFT.  */
2149     char result[100];
2150     int retval =
2151       my_snprintf (result, sizeof (result), "%-15Le %d", 1.75L, 33, 44, 55);
2152     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
2153     ASSERT (retval == strlen (result));
2154   }
2155
2156   { /* FLAG_SHOWSIGN.  */
2157     char result[100];
2158     int retval =
2159       my_snprintf (result, sizeof (result), "%+Le %d", 1.75L, 33, 44, 55);
2160     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2161     ASSERT (retval == strlen (result));
2162   }
2163
2164   { /* FLAG_SPACE.  */
2165     char result[100];
2166     int retval =
2167       my_snprintf (result, sizeof (result), "% Le %d", 1.75L, 33, 44, 55);
2168     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2169     ASSERT (retval == strlen (result));
2170   }
2171
2172   { /* FLAG_ALT.  */
2173     char result[100];
2174     int retval =
2175       my_snprintf (result, sizeof (result), "%#Le %d", 1.75L, 33, 44, 55);
2176     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2177     ASSERT (retval == strlen (result));
2178   }
2179
2180   { /* FLAG_ALT.  */
2181     char result[100];
2182     int retval =
2183       my_snprintf (result, sizeof (result), "%#.Le %d", 1.75L, 33, 44, 55);
2184     ASSERT (strcmp (result, "2.e+00 33") == 0);
2185     ASSERT (retval == strlen (result));
2186   }
2187
2188   { /* FLAG_ALT.  */
2189     char result[100];
2190     int retval =
2191       my_snprintf (result, sizeof (result), "%#.Le %d", 9.75L, 33, 44, 55);
2192     ASSERT (strcmp (result, "1.e+01 33") == 0);
2193     ASSERT (retval == strlen (result));
2194   }
2195
2196   { /* FLAG_ZERO with finite number.  */
2197     char result[100];
2198     int retval =
2199       my_snprintf (result, sizeof (result), "%015Le %d", 1234.0L, 33, 44, 55);
2200     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2201     ASSERT (retval == strlen (result));
2202   }
2203
2204   { /* FLAG_ZERO with infinite number.  */
2205     char result[100];
2206     int retval =
2207       my_snprintf (result, sizeof (result), "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2208     ASSERT (strcmp (result, "           -inf 33") == 0
2209             || strcmp (result, "      -infinity 33") == 0);
2210     ASSERT (retval == strlen (result));
2211   }
2212
2213   { /* FLAG_ZERO with NaN.  */
2214     char result[100];
2215     int retval =
2216       my_snprintf (result, sizeof (result), "%050Le %d", NaNl (), 33, 44, 55);
2217     ASSERT (strlen (result) == 50 + 3
2218             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2219             && strcmp (result + strlen (result) - 3, " 33") == 0);
2220     ASSERT (retval == strlen (result));
2221   }
2222
2223   { /* Precision.  */
2224     char result[100];
2225     int retval =
2226       my_snprintf (result, sizeof (result), "%.Le %d", 1234.0L, 33, 44, 55);
2227     ASSERT (strcmp (result, "1e+03 33") == 0);
2228     ASSERT (retval == strlen (result));
2229   }
2230
2231   { /* Precision with no rounding.  */
2232     char result[100];
2233     int retval =
2234       my_snprintf (result, sizeof (result), "%.4Le %d", 999.951L, 33, 44, 55);
2235     ASSERT (strcmp (result, "9.9995e+02 33") == 0);
2236     ASSERT (retval == strlen (result));
2237   }
2238
2239   { /* Precision with rounding.  */
2240     char result[100];
2241     int retval =
2242       my_snprintf (result, sizeof (result), "%.4Le %d", 999.996L, 33, 44, 55);
2243     ASSERT (strcmp (result, "1.0000e+03 33") == 0);
2244     ASSERT (retval == strlen (result));
2245   }
2246
2247   /* Test the support of the %g format directive.  */
2248
2249   { /* A positive number.  */
2250     char result[100];
2251     int retval =
2252       my_snprintf (result, sizeof (result), "%g %d", 12.75, 33, 44, 55);
2253     ASSERT (strcmp (result, "12.75 33") == 0);
2254     ASSERT (retval == strlen (result));
2255   }
2256
2257   { /* A larger positive number.  */
2258     char result[100];
2259     int retval =
2260       my_snprintf (result, sizeof (result), "%g %d", 1234567.0, 33, 44, 55);
2261     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2262             || strcmp (result, "1.23457e+006 33") == 0);
2263     ASSERT (retval == strlen (result));
2264   }
2265
2266   { /* Small and large positive numbers.  */
2267     static struct { double value; const char *string; } data[] =
2268       {
2269         { 1.234321234321234e-37, "1.23432e-37" },
2270         { 1.234321234321234e-36, "1.23432e-36" },
2271         { 1.234321234321234e-35, "1.23432e-35" },
2272         { 1.234321234321234e-34, "1.23432e-34" },
2273         { 1.234321234321234e-33, "1.23432e-33" },
2274         { 1.234321234321234e-32, "1.23432e-32" },
2275         { 1.234321234321234e-31, "1.23432e-31" },
2276         { 1.234321234321234e-30, "1.23432e-30" },
2277         { 1.234321234321234e-29, "1.23432e-29" },
2278         { 1.234321234321234e-28, "1.23432e-28" },
2279         { 1.234321234321234e-27, "1.23432e-27" },
2280         { 1.234321234321234e-26, "1.23432e-26" },
2281         { 1.234321234321234e-25, "1.23432e-25" },
2282         { 1.234321234321234e-24, "1.23432e-24" },
2283         { 1.234321234321234e-23, "1.23432e-23" },
2284         { 1.234321234321234e-22, "1.23432e-22" },
2285         { 1.234321234321234e-21, "1.23432e-21" },
2286         { 1.234321234321234e-20, "1.23432e-20" },
2287         { 1.234321234321234e-19, "1.23432e-19" },
2288         { 1.234321234321234e-18, "1.23432e-18" },
2289         { 1.234321234321234e-17, "1.23432e-17" },
2290         { 1.234321234321234e-16, "1.23432e-16" },
2291         { 1.234321234321234e-15, "1.23432e-15" },
2292         { 1.234321234321234e-14, "1.23432e-14" },
2293         { 1.234321234321234e-13, "1.23432e-13" },
2294         { 1.234321234321234e-12, "1.23432e-12" },
2295         { 1.234321234321234e-11, "1.23432e-11" },
2296         { 1.234321234321234e-10, "1.23432e-10" },
2297         { 1.234321234321234e-9, "1.23432e-09" },
2298         { 1.234321234321234e-8, "1.23432e-08" },
2299         { 1.234321234321234e-7, "1.23432e-07" },
2300         { 1.234321234321234e-6, "1.23432e-06" },
2301         { 1.234321234321234e-5, "1.23432e-05" },
2302         { 1.234321234321234e-4, "0.000123432" },
2303         { 1.234321234321234e-3, "0.00123432" },
2304         { 1.234321234321234e-2, "0.0123432" },
2305         { 1.234321234321234e-1, "0.123432" },
2306         { 1.234321234321234, "1.23432" },
2307         { 1.234321234321234e1, "12.3432" },
2308         { 1.234321234321234e2, "123.432" },
2309         { 1.234321234321234e3, "1234.32" },
2310         { 1.234321234321234e4, "12343.2" },
2311         { 1.234321234321234e5, "123432" },
2312         { 1.234321234321234e6, "1.23432e+06" },
2313         { 1.234321234321234e7, "1.23432e+07" },
2314         { 1.234321234321234e8, "1.23432e+08" },
2315         { 1.234321234321234e9, "1.23432e+09" },
2316         { 1.234321234321234e10, "1.23432e+10" },
2317         { 1.234321234321234e11, "1.23432e+11" },
2318         { 1.234321234321234e12, "1.23432e+12" },
2319         { 1.234321234321234e13, "1.23432e+13" },
2320         { 1.234321234321234e14, "1.23432e+14" },
2321         { 1.234321234321234e15, "1.23432e+15" },
2322         { 1.234321234321234e16, "1.23432e+16" },
2323         { 1.234321234321234e17, "1.23432e+17" },
2324         { 1.234321234321234e18, "1.23432e+18" },
2325         { 1.234321234321234e19, "1.23432e+19" },
2326         { 1.234321234321234e20, "1.23432e+20" },
2327         { 1.234321234321234e21, "1.23432e+21" },
2328         { 1.234321234321234e22, "1.23432e+22" },
2329         { 1.234321234321234e23, "1.23432e+23" },
2330         { 1.234321234321234e24, "1.23432e+24" },
2331         { 1.234321234321234e25, "1.23432e+25" },
2332         { 1.234321234321234e26, "1.23432e+26" },
2333         { 1.234321234321234e27, "1.23432e+27" },
2334         { 1.234321234321234e28, "1.23432e+28" },
2335         { 1.234321234321234e29, "1.23432e+29" },
2336         { 1.234321234321234e30, "1.23432e+30" },
2337         { 1.234321234321234e31, "1.23432e+31" },
2338         { 1.234321234321234e32, "1.23432e+32" },
2339         { 1.234321234321234e33, "1.23432e+33" },
2340         { 1.234321234321234e34, "1.23432e+34" },
2341         { 1.234321234321234e35, "1.23432e+35" },
2342         { 1.234321234321234e36, "1.23432e+36" }
2343       };
2344     size_t k;
2345     for (k = 0; k < SIZEOF (data); k++)
2346       {
2347         char result[100];
2348         int retval =
2349           my_snprintf (result, sizeof (result), "%g", data[k].value);
2350         const char *expected = data[k].string;
2351         ASSERT (strcmp (result, expected) == 0
2352                 /* Some implementations produce exponents with 3 digits.  */
2353                 || (expected[strlen (expected) - 4] == 'e'
2354                     && strlen (result) == strlen (expected) + 1
2355                     && memcmp (result, expected, strlen (expected) - 2) == 0
2356                     && result[strlen (expected) - 2] == '0'
2357                     && strcmp (result + strlen (expected) - 1,
2358                                expected + strlen (expected) - 2)
2359                        == 0));
2360         ASSERT (retval == strlen (result));
2361       }
2362   }
2363
2364   { /* A negative number.  */
2365     char result[100];
2366     int retval =
2367       my_snprintf (result, sizeof (result), "%g %d", -0.03125, 33, 44, 55);
2368     ASSERT (strcmp (result, "-0.03125 33") == 0);
2369     ASSERT (retval == strlen (result));
2370   }
2371
2372   { /* Positive zero.  */
2373     char result[100];
2374     int retval =
2375       my_snprintf (result, sizeof (result), "%g %d", 0.0, 33, 44, 55);
2376     ASSERT (strcmp (result, "0 33") == 0);
2377     ASSERT (retval == strlen (result));
2378   }
2379
2380   { /* Negative zero.  */
2381     char result[100];
2382     int retval =
2383       my_snprintf (result, sizeof (result), "%g %d", -zerod, 33, 44, 55);
2384     if (have_minus_zero ())
2385       ASSERT (strcmp (result, "-0 33") == 0);
2386     ASSERT (retval == strlen (result));
2387   }
2388
2389   { /* Positive infinity.  */
2390     char result[100];
2391     int retval =
2392       my_snprintf (result, sizeof (result), "%g %d", 1.0 / 0.0, 33, 44, 55);
2393     ASSERT (strcmp (result, "inf 33") == 0
2394             || strcmp (result, "infinity 33") == 0);
2395     ASSERT (retval == strlen (result));
2396   }
2397
2398   { /* Negative infinity.  */
2399     char result[100];
2400     int retval =
2401       my_snprintf (result, sizeof (result), "%g %d", -1.0 / 0.0, 33, 44, 55);
2402     ASSERT (strcmp (result, "-inf 33") == 0
2403             || strcmp (result, "-infinity 33") == 0);
2404     ASSERT (retval == strlen (result));
2405   }
2406
2407   { /* NaN.  */
2408     char result[100];
2409     int retval =
2410       my_snprintf (result, sizeof (result), "%g %d", NaNd (), 33, 44, 55);
2411     ASSERT (strlen (result) >= 3 + 3
2412             && strisnan (result, 0, strlen (result) - 3, 0)
2413             && strcmp (result + strlen (result) - 3, " 33") == 0);
2414     ASSERT (retval == strlen (result));
2415   }
2416
2417   { /* Width.  */
2418     char result[100];
2419     int retval =
2420       my_snprintf (result, sizeof (result), "%10g %d", 1.75, 33, 44, 55);
2421     ASSERT (strcmp (result, "      1.75 33") == 0);
2422     ASSERT (retval == strlen (result));
2423   }
2424
2425   { /* FLAG_LEFT.  */
2426     char result[100];
2427     int retval =
2428       my_snprintf (result, sizeof (result), "%-10g %d", 1.75, 33, 44, 55);
2429     ASSERT (strcmp (result, "1.75       33") == 0);
2430     ASSERT (retval == strlen (result));
2431   }
2432
2433   { /* FLAG_SHOWSIGN.  */
2434     char result[100];
2435     int retval =
2436       my_snprintf (result, sizeof (result), "%+g %d", 1.75, 33, 44, 55);
2437     ASSERT (strcmp (result, "+1.75 33") == 0);
2438     ASSERT (retval == strlen (result));
2439   }
2440
2441   { /* FLAG_SPACE.  */
2442     char result[100];
2443     int retval =
2444       my_snprintf (result, sizeof (result), "% g %d", 1.75, 33, 44, 55);
2445     ASSERT (strcmp (result, " 1.75 33") == 0);
2446     ASSERT (retval == strlen (result));
2447   }
2448
2449   { /* FLAG_ALT.  */
2450     char result[100];
2451     int retval =
2452       my_snprintf (result, sizeof (result), "%#g %d", 1.75, 33, 44, 55);
2453     ASSERT (strcmp (result, "1.75000 33") == 0);
2454     ASSERT (retval == strlen (result));
2455   }
2456
2457   { /* FLAG_ALT.  */
2458     char result[100];
2459     int retval =
2460       my_snprintf (result, sizeof (result), "%#.g %d", 1.75, 33, 44, 55);
2461     ASSERT (strcmp (result, "2. 33") == 0);
2462     ASSERT (retval == strlen (result));
2463   }
2464
2465   { /* FLAG_ALT.  */
2466     char result[100];
2467     int retval =
2468       my_snprintf (result, sizeof (result), "%#.g %d", 9.75, 33, 44, 55);
2469     ASSERT (strcmp (result, "1.e+01 33") == 0
2470             || strcmp (result, "1.e+001 33") == 0);
2471     ASSERT (retval == strlen (result));
2472   }
2473
2474   { /* FLAG_ZERO with finite number.  */
2475     char result[100];
2476     int retval =
2477       my_snprintf (result, sizeof (result), "%010g %d", 1234.0, 33, 44, 55);
2478     ASSERT (strcmp (result, "0000001234 33") == 0);
2479     ASSERT (retval == strlen (result));
2480   }
2481
2482   { /* FLAG_ZERO with infinite number.  */
2483     char result[100];
2484     int retval =
2485       my_snprintf (result, sizeof (result), "%015g %d", -1.0 / 0.0, 33, 44, 55);
2486     ASSERT (strcmp (result, "           -inf 33") == 0
2487             || strcmp (result, "      -infinity 33") == 0);
2488     ASSERT (retval == strlen (result));
2489   }
2490
2491   { /* FLAG_ZERO with NaN.  */
2492     char result[100];
2493     int retval =
2494       my_snprintf (result, sizeof (result), "%050g %d", NaNd (), 33, 44, 55);
2495     ASSERT (strlen (result) == 50 + 3
2496             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2497             && strcmp (result + strlen (result) - 3, " 33") == 0);
2498     ASSERT (retval == strlen (result));
2499   }
2500
2501   { /* Precision.  */
2502     char result[100];
2503     int retval =
2504       my_snprintf (result, sizeof (result), "%.g %d", 1234.0, 33, 44, 55);
2505     ASSERT (strcmp (result, "1e+03 33") == 0
2506             || strcmp (result, "1e+003 33") == 0);
2507     ASSERT (retval == strlen (result));
2508   }
2509
2510   { /* Precision with no rounding.  */
2511     char result[100];
2512     int retval =
2513       my_snprintf (result, sizeof (result), "%.5g %d", 999.951, 33, 44, 55);
2514     ASSERT (strcmp (result, "999.95 33") == 0);
2515     ASSERT (retval == strlen (result));
2516   }
2517
2518   { /* Precision with rounding.  */
2519     char result[100];
2520     int retval =
2521       my_snprintf (result, sizeof (result), "%.5g %d", 999.996, 33, 44, 55);
2522     ASSERT (strcmp (result, "1000 33") == 0);
2523     ASSERT (retval == strlen (result));
2524   }
2525
2526   { /* A positive number.  */
2527     char result[100];
2528     int retval =
2529       my_snprintf (result, sizeof (result), "%Lg %d", 12.75L, 33, 44, 55);
2530     ASSERT (strcmp (result, "12.75 33") == 0);
2531     ASSERT (retval == strlen (result));
2532   }
2533
2534   { /* A larger positive number.  */
2535     char result[100];
2536     int retval =
2537       my_snprintf (result, sizeof (result), "%Lg %d", 1234567.0L, 33, 44, 55);
2538     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2539     ASSERT (retval == strlen (result));
2540   }
2541
2542   { /* Small and large positive numbers.  */
2543     static struct { long double value; const char *string; } data[] =
2544       {
2545         { 1.234321234321234e-37L, "1.23432e-37" },
2546         { 1.234321234321234e-36L, "1.23432e-36" },
2547         { 1.234321234321234e-35L, "1.23432e-35" },
2548         { 1.234321234321234e-34L, "1.23432e-34" },
2549         { 1.234321234321234e-33L, "1.23432e-33" },
2550         { 1.234321234321234e-32L, "1.23432e-32" },
2551         { 1.234321234321234e-31L, "1.23432e-31" },
2552         { 1.234321234321234e-30L, "1.23432e-30" },
2553         { 1.234321234321234e-29L, "1.23432e-29" },
2554         { 1.234321234321234e-28L, "1.23432e-28" },
2555         { 1.234321234321234e-27L, "1.23432e-27" },
2556         { 1.234321234321234e-26L, "1.23432e-26" },
2557         { 1.234321234321234e-25L, "1.23432e-25" },
2558         { 1.234321234321234e-24L, "1.23432e-24" },
2559         { 1.234321234321234e-23L, "1.23432e-23" },
2560         { 1.234321234321234e-22L, "1.23432e-22" },
2561         { 1.234321234321234e-21L, "1.23432e-21" },
2562         { 1.234321234321234e-20L, "1.23432e-20" },
2563         { 1.234321234321234e-19L, "1.23432e-19" },
2564         { 1.234321234321234e-18L, "1.23432e-18" },
2565         { 1.234321234321234e-17L, "1.23432e-17" },
2566         { 1.234321234321234e-16L, "1.23432e-16" },
2567         { 1.234321234321234e-15L, "1.23432e-15" },
2568         { 1.234321234321234e-14L, "1.23432e-14" },
2569         { 1.234321234321234e-13L, "1.23432e-13" },
2570         { 1.234321234321234e-12L, "1.23432e-12" },
2571         { 1.234321234321234e-11L, "1.23432e-11" },
2572         { 1.234321234321234e-10L, "1.23432e-10" },
2573         { 1.234321234321234e-9L, "1.23432e-09" },
2574         { 1.234321234321234e-8L, "1.23432e-08" },
2575         { 1.234321234321234e-7L, "1.23432e-07" },
2576         { 1.234321234321234e-6L, "1.23432e-06" },
2577         { 1.234321234321234e-5L, "1.23432e-05" },
2578         { 1.234321234321234e-4L, "0.000123432" },
2579         { 1.234321234321234e-3L, "0.00123432" },
2580         { 1.234321234321234e-2L, "0.0123432" },
2581         { 1.234321234321234e-1L, "0.123432" },
2582         { 1.234321234321234L, "1.23432" },
2583         { 1.234321234321234e1L, "12.3432" },
2584         { 1.234321234321234e2L, "123.432" },
2585         { 1.234321234321234e3L, "1234.32" },
2586         { 1.234321234321234e4L, "12343.2" },
2587         { 1.234321234321234e5L, "123432" },
2588         { 1.234321234321234e6L, "1.23432e+06" },
2589         { 1.234321234321234e7L, "1.23432e+07" },
2590         { 1.234321234321234e8L, "1.23432e+08" },
2591         { 1.234321234321234e9L, "1.23432e+09" },
2592         { 1.234321234321234e10L, "1.23432e+10" },
2593         { 1.234321234321234e11L, "1.23432e+11" },
2594         { 1.234321234321234e12L, "1.23432e+12" },
2595         { 1.234321234321234e13L, "1.23432e+13" },
2596         { 1.234321234321234e14L, "1.23432e+14" },
2597         { 1.234321234321234e15L, "1.23432e+15" },
2598         { 1.234321234321234e16L, "1.23432e+16" },
2599         { 1.234321234321234e17L, "1.23432e+17" },
2600         { 1.234321234321234e18L, "1.23432e+18" },
2601         { 1.234321234321234e19L, "1.23432e+19" },
2602         { 1.234321234321234e20L, "1.23432e+20" },
2603         { 1.234321234321234e21L, "1.23432e+21" },
2604         { 1.234321234321234e22L, "1.23432e+22" },
2605         { 1.234321234321234e23L, "1.23432e+23" },
2606         { 1.234321234321234e24L, "1.23432e+24" },
2607         { 1.234321234321234e25L, "1.23432e+25" },
2608         { 1.234321234321234e26L, "1.23432e+26" },
2609         { 1.234321234321234e27L, "1.23432e+27" },
2610         { 1.234321234321234e28L, "1.23432e+28" },
2611         { 1.234321234321234e29L, "1.23432e+29" },
2612         { 1.234321234321234e30L, "1.23432e+30" },
2613         { 1.234321234321234e31L, "1.23432e+31" },
2614         { 1.234321234321234e32L, "1.23432e+32" },
2615         { 1.234321234321234e33L, "1.23432e+33" },
2616         { 1.234321234321234e34L, "1.23432e+34" },
2617         { 1.234321234321234e35L, "1.23432e+35" },
2618         { 1.234321234321234e36L, "1.23432e+36" }
2619       };
2620     size_t k;
2621     for (k = 0; k < SIZEOF (data); k++)
2622       {
2623         char result[100];
2624         int retval =
2625           my_snprintf (result, sizeof (result), "%Lg", data[k].value);
2626         ASSERT (strcmp (result, data[k].string) == 0);
2627         ASSERT (retval == strlen (result));
2628       }
2629   }
2630
2631   { /* A negative number.  */
2632     char result[100];
2633     int retval =
2634       my_snprintf (result, sizeof (result), "%Lg %d", -0.03125L, 33, 44, 55);
2635     ASSERT (strcmp (result, "-0.03125 33") == 0);
2636     ASSERT (retval == strlen (result));
2637   }
2638
2639   { /* Positive zero.  */
2640     char result[100];
2641     int retval =
2642       my_snprintf (result, sizeof (result), "%Lg %d", 0.0L, 33, 44, 55);
2643     ASSERT (strcmp (result, "0 33") == 0);
2644     ASSERT (retval == strlen (result));
2645   }
2646
2647   { /* Negative zero.  */
2648     char result[100];
2649     int retval =
2650       my_snprintf (result, sizeof (result), "%Lg %d", -zerol, 33, 44, 55);
2651     if (have_minus_zero ())
2652       ASSERT (strcmp (result, "-0 33") == 0);
2653     ASSERT (retval == strlen (result));
2654   }
2655
2656   { /* Positive infinity.  */
2657     char result[100];
2658     int retval =
2659       my_snprintf (result, sizeof (result), "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2660     ASSERT (strcmp (result, "inf 33") == 0
2661             || strcmp (result, "infinity 33") == 0);
2662     ASSERT (retval == strlen (result));
2663   }
2664
2665   { /* Negative infinity.  */
2666     char result[100];
2667     int retval =
2668       my_snprintf (result, sizeof (result), "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2669     ASSERT (strcmp (result, "-inf 33") == 0
2670             || strcmp (result, "-infinity 33") == 0);
2671     ASSERT (retval == strlen (result));
2672   }
2673
2674   { /* NaN.  */
2675     char result[100];
2676     int retval =
2677       my_snprintf (result, sizeof (result), "%Lg %d", NaNl (), 33, 44, 55);
2678     ASSERT (strlen (result) >= 3 + 3
2679             && strisnan (result, 0, strlen (result) - 3, 0)
2680             && strcmp (result + strlen (result) - 3, " 33") == 0);
2681     ASSERT (retval == strlen (result));
2682   }
2683 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
2684   { /* Quiet NaN.  */
2685     static union { unsigned int word[4]; long double value; } x =
2686       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2687     char result[100];
2688     int retval =
2689       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2690     ASSERT (strlen (result) >= 3 + 3
2691             && strisnan (result, 0, strlen (result) - 3, 0)
2692             && strcmp (result + strlen (result) - 3, " 33") == 0);
2693     ASSERT (retval == strlen (result));
2694   }
2695   {
2696     /* Signalling NaN.  */
2697     static union { unsigned int word[4]; long double value; } x =
2698       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2699     char result[100];
2700     int retval =
2701       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2702     ASSERT (strlen (result) >= 3 + 3
2703             && strisnan (result, 0, strlen (result) - 3, 0)
2704             && strcmp (result + strlen (result) - 3, " 33") == 0);
2705     ASSERT (retval == strlen (result));
2706   }
2707   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2708      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2709        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2710        Application Architecture.
2711        Table 5-2 "Floating-Point Register Encodings"
2712        Figure 5-6 "Memory to Floating-Point Register Data Translation"
2713    */
2714   { /* Pseudo-NaN.  */
2715     static union { unsigned int word[4]; long double value; } x =
2716       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2717     char result[100];
2718     int retval =
2719       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2720     ASSERT (strlen (result) >= 3 + 3
2721             && strisnan (result, 0, strlen (result) - 3, 0)
2722             && strcmp (result + strlen (result) - 3, " 33") == 0);
2723     ASSERT (retval == strlen (result));
2724   }
2725   { /* Pseudo-Infinity.  */
2726     static union { unsigned int word[4]; long double value; } x =
2727       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2728     char result[100];
2729     int retval =
2730       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2731     ASSERT (strlen (result) >= 3 + 3
2732             && strisnan (result, 0, strlen (result) - 3, 0)
2733             && strcmp (result + strlen (result) - 3, " 33") == 0);
2734     ASSERT (retval == strlen (result));
2735   }
2736   { /* Pseudo-Zero.  */
2737     static union { unsigned int word[4]; long double value; } x =
2738       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2739     char result[100];
2740     int retval =
2741       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2742     ASSERT (strlen (result) >= 3 + 3
2743             && strisnan (result, 0, strlen (result) - 3, 0)
2744             && strcmp (result + strlen (result) - 3, " 33") == 0);
2745     ASSERT (retval == strlen (result));
2746   }
2747   { /* Unnormalized number.  */
2748     static union { unsigned int word[4]; long double value; } x =
2749       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2750     char result[100];
2751     int retval =
2752       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2753     ASSERT (strlen (result) >= 3 + 3
2754             && strisnan (result, 0, strlen (result) - 3, 0)
2755             && strcmp (result + strlen (result) - 3, " 33") == 0);
2756     ASSERT (retval == strlen (result));
2757   }
2758   { /* Pseudo-Denormal.  */
2759     static union { unsigned int word[4]; long double value; } x =
2760       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2761     char result[100];
2762     int retval =
2763       my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2764     ASSERT (strlen (result) >= 3 + 3
2765             && strisnan (result, 0, strlen (result) - 3, 0)
2766             && strcmp (result + strlen (result) - 3, " 33") == 0);
2767     ASSERT (retval == strlen (result));
2768   }
2769 #endif
2770
2771   { /* Width.  */
2772     char result[100];
2773     int retval =
2774       my_snprintf (result, sizeof (result), "%10Lg %d", 1.75L, 33, 44, 55);
2775     ASSERT (strcmp (result, "      1.75 33") == 0);
2776     ASSERT (retval == strlen (result));
2777   }
2778
2779   { /* FLAG_LEFT.  */
2780     char result[100];
2781     int retval =
2782       my_snprintf (result, sizeof (result), "%-10Lg %d", 1.75L, 33, 44, 55);
2783     ASSERT (strcmp (result, "1.75       33") == 0);
2784     ASSERT (retval == strlen (result));
2785   }
2786
2787   { /* FLAG_SHOWSIGN.  */
2788     char result[100];
2789     int retval =
2790       my_snprintf (result, sizeof (result), "%+Lg %d", 1.75L, 33, 44, 55);
2791     ASSERT (strcmp (result, "+1.75 33") == 0);
2792     ASSERT (retval == strlen (result));
2793   }
2794
2795   { /* FLAG_SPACE.  */
2796     char result[100];
2797     int retval =
2798       my_snprintf (result, sizeof (result), "% Lg %d", 1.75L, 33, 44, 55);
2799     ASSERT (strcmp (result, " 1.75 33") == 0);
2800     ASSERT (retval == strlen (result));
2801   }
2802
2803   { /* FLAG_ALT.  */
2804     char result[100];
2805     int retval =
2806       my_snprintf (result, sizeof (result), "%#Lg %d", 1.75L, 33, 44, 55);
2807     ASSERT (strcmp (result, "1.75000 33") == 0);
2808     ASSERT (retval == strlen (result));
2809   }
2810
2811   { /* FLAG_ALT.  */
2812     char result[100];
2813     int retval =
2814       my_snprintf (result, sizeof (result), "%#.Lg %d", 1.75L, 33, 44, 55);
2815     ASSERT (strcmp (result, "2. 33") == 0);
2816     ASSERT (retval == strlen (result));
2817   }
2818
2819   { /* FLAG_ALT.  */
2820     char result[100];
2821     int retval =
2822       my_snprintf (result, sizeof (result), "%#.Lg %d", 9.75L, 33, 44, 55);
2823     ASSERT (strcmp (result, "1.e+01 33") == 0);
2824     ASSERT (retval == strlen (result));
2825   }
2826
2827   { /* FLAG_ZERO with finite number.  */
2828     char result[100];
2829     int retval =
2830       my_snprintf (result, sizeof (result), "%010Lg %d", 1234.0L, 33, 44, 55);
2831     ASSERT (strcmp (result, "0000001234 33") == 0);
2832     ASSERT (retval == strlen (result));
2833   }
2834
2835   { /* FLAG_ZERO with infinite number.  */
2836     char result[100];
2837     int retval =
2838       my_snprintf (result, sizeof (result), "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2839     ASSERT (strcmp (result, "           -inf 33") == 0
2840             || strcmp (result, "      -infinity 33") == 0);
2841     ASSERT (retval == strlen (result));
2842   }
2843
2844   { /* FLAG_ZERO with NaN.  */
2845     char result[100];
2846     int retval =
2847       my_snprintf (result, sizeof (result), "%050Lg %d", NaNl (), 33, 44, 55);
2848     ASSERT (strlen (result) == 50 + 3
2849             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2850             && strcmp (result + strlen (result) - 3, " 33") == 0);
2851     ASSERT (retval == strlen (result));
2852   }
2853
2854   { /* Precision.  */
2855     char result[100];
2856     int retval =
2857       my_snprintf (result, sizeof (result), "%.Lg %d", 1234.0L, 33, 44, 55);
2858     ASSERT (strcmp (result, "1e+03 33") == 0);
2859     ASSERT (retval == strlen (result));
2860   }
2861
2862   { /* Precision with no rounding.  */
2863     char result[100];
2864     int retval =
2865       my_snprintf (result, sizeof (result), "%.5Lg %d", 999.951L, 33, 44, 55);
2866     ASSERT (strcmp (result, "999.95 33") == 0);
2867     ASSERT (retval == strlen (result));
2868   }
2869
2870   { /* Precision with rounding.  */
2871     char result[100];
2872     int retval =
2873       my_snprintf (result, sizeof (result), "%.5Lg %d", 999.996L, 33, 44, 55);
2874     ASSERT (strcmp (result, "1000 33") == 0);
2875     ASSERT (retval == strlen (result));
2876   }
2877
2878   /* Test the support of the %n format directive.  */
2879
2880   {
2881     int count = -1;
2882     char result[100];
2883     int retval =
2884       my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
2885     ASSERT (strcmp (result, "123 ") == 0);
2886     ASSERT (retval == strlen (result));
2887     ASSERT (count == 4);
2888   }
2889
2890   /* Test the support of the POSIX/XSI format strings with positions.  */
2891
2892   {
2893     char result[100];
2894     int retval =
2895       my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
2896     ASSERT (strcmp (result, "55 33") == 0);
2897     ASSERT (retval == strlen (result));
2898   }
2899
2900   /* Test the support of the grouping flag.  */
2901
2902   {
2903     char result[100];
2904     int retval =
2905       my_snprintf (result, sizeof (result), "%'d %d", 1234567, 99);
2906     ASSERT (result[strlen (result) - 1] == '9');
2907     ASSERT (retval == strlen (result));
2908   }
2909
2910   /* Test the support of the left-adjust flag.  */
2911
2912   {
2913     char result[100];
2914     int retval =
2915       my_snprintf (result, sizeof (result), "a%*sc", -3, "b");
2916     ASSERT (strcmp (result, "ab  c") == 0);
2917     ASSERT (retval == strlen (result));
2918   }
2919
2920   {
2921     char result[100];
2922     int retval =
2923       my_snprintf (result, sizeof (result), "a%-*sc", 3, "b");
2924     ASSERT (strcmp (result, "ab  c") == 0);
2925     ASSERT (retval == strlen (result));
2926   }
2927
2928   {
2929     char result[100];
2930     int retval =
2931       my_snprintf (result, sizeof (result), "a%-*sc", -3, "b");
2932     ASSERT (strcmp (result, "ab  c") == 0);
2933     ASSERT (retval == strlen (result));
2934   }
2935
2936   /* Test the support of large precision.  */
2937
2938   {
2939     char result[5000];
2940     int retval =
2941       my_snprintf (result, sizeof (result), "%.4000d %d", 1234567, 99);
2942     size_t i;
2943     ASSERT (result != NULL);
2944     for (i = 0; i < 4000 - 7; i++)
2945       ASSERT (result[i] == '0');
2946     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2947     ASSERT (retval == strlen (result));
2948   }
2949
2950   {
2951     char result[5000];
2952     int retval =
2953       my_snprintf (result, sizeof (result), "%.*d %d", 4000, 1234567, 99);
2954     size_t i;
2955     ASSERT (result != NULL);
2956     for (i = 0; i < 4000 - 7; i++)
2957       ASSERT (result[i] == '0');
2958     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2959     ASSERT (retval == strlen (result));
2960   }
2961
2962   {
2963     char result[5000];
2964     int retval =
2965       my_snprintf (result, sizeof (result), "%.4000d %d", -1234567, 99);
2966     size_t i;
2967     ASSERT (result != NULL);
2968     ASSERT (result[0] == '-');
2969     for (i = 0; i < 4000 - 7; i++)
2970       ASSERT (result[1 + i] == '0');
2971     ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
2972     ASSERT (retval == strlen (result));
2973   }
2974
2975   {
2976     char result[5000];
2977     int retval =
2978       my_snprintf (result, sizeof (result), "%.4000u %d", 1234567, 99);
2979     size_t i;
2980     ASSERT (result != NULL);
2981     for (i = 0; i < 4000 - 7; i++)
2982       ASSERT (result[i] == '0');
2983     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2984     ASSERT (retval == strlen (result));
2985   }
2986
2987   {
2988     char result[5000];
2989     int retval =
2990       my_snprintf (result, sizeof (result), "%.4000o %d", 1234567, 99);
2991     size_t i;
2992     ASSERT (result != NULL);
2993     for (i = 0; i < 4000 - 7; i++)
2994       ASSERT (result[i] == '0');
2995     ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
2996     ASSERT (retval == strlen (result));
2997   }
2998
2999   {
3000     char result[5000];
3001     int retval =
3002       my_snprintf (result, sizeof (result), "%.4000x %d", 1234567, 99);
3003     size_t i;
3004     ASSERT (result != NULL);
3005     for (i = 0; i < 4000 - 6; i++)
3006       ASSERT (result[i] == '0');
3007     ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
3008     ASSERT (retval == strlen (result));
3009   }
3010
3011   {
3012     char result[5000];
3013     int retval =
3014       my_snprintf (result, sizeof (result), "%#.4000x %d", 1234567, 99);
3015     size_t i;
3016     ASSERT (result != NULL);
3017     ASSERT (result[0] == '0');
3018     ASSERT (result[1] == 'x');
3019     for (i = 0; i < 4000 - 6; i++)
3020       ASSERT (result[2 + i] == '0');
3021     ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
3022     ASSERT (retval == strlen (result));
3023   }
3024
3025   {
3026     char input[5000];
3027     char result[5000];
3028     int retval;
3029     size_t i;
3030
3031     for (i = 0; i < sizeof (input) - 1; i++)
3032       input[i] = 'a' + ((1000000 / (i + 1)) % 26);
3033     input[i] = '\0';
3034     retval = my_snprintf (result, sizeof (result), "%.4000s %d", input, 99);
3035     ASSERT (result != NULL);
3036     ASSERT (memcmp (result, input, 4000) == 0);
3037     ASSERT (strcmp (result + 4000, " 99") == 0);
3038     ASSERT (retval == strlen (result));
3039   }
3040 }