tests/test-vasprintf-posix.c

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