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