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