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