tests/test-vasprintf-posix.c

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