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             || strcmp (result, "1.275000e+001 33") == 0);
1539     ASSERT (retval == strlen (result));
1540     free (result);
1541   }
1542
1543   { /* A larger positive number.  */
1544     char *result;
1545     int retval =
1546       my_asprintf (&result, "%e %d", 1234567.0, 33, 44, 55);
1547     ASSERT (result != NULL);
1548     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1549             || strcmp (result, "1.234567e+006 33") == 0);
1550     ASSERT (retval == strlen (result));
1551     free (result);
1552   }
1553
1554   { /* Small and large positive numbers.  */
1555     static struct { double value; const char *string; } data[] =
1556       {
1557         { 1.234321234321234e-37, "1.234321e-37" },
1558         { 1.234321234321234e-36, "1.234321e-36" },
1559         { 1.234321234321234e-35, "1.234321e-35" },
1560         { 1.234321234321234e-34, "1.234321e-34" },
1561         { 1.234321234321234e-33, "1.234321e-33" },
1562         { 1.234321234321234e-32, "1.234321e-32" },
1563         { 1.234321234321234e-31, "1.234321e-31" },
1564         { 1.234321234321234e-30, "1.234321e-30" },
1565         { 1.234321234321234e-29, "1.234321e-29" },
1566         { 1.234321234321234e-28, "1.234321e-28" },
1567         { 1.234321234321234e-27, "1.234321e-27" },
1568         { 1.234321234321234e-26, "1.234321e-26" },
1569         { 1.234321234321234e-25, "1.234321e-25" },
1570         { 1.234321234321234e-24, "1.234321e-24" },
1571         { 1.234321234321234e-23, "1.234321e-23" },
1572         { 1.234321234321234e-22, "1.234321e-22" },
1573         { 1.234321234321234e-21, "1.234321e-21" },
1574         { 1.234321234321234e-20, "1.234321e-20" },
1575         { 1.234321234321234e-19, "1.234321e-19" },
1576         { 1.234321234321234e-18, "1.234321e-18" },
1577         { 1.234321234321234e-17, "1.234321e-17" },
1578         { 1.234321234321234e-16, "1.234321e-16" },
1579         { 1.234321234321234e-15, "1.234321e-15" },
1580         { 1.234321234321234e-14, "1.234321e-14" },
1581         { 1.234321234321234e-13, "1.234321e-13" },
1582         { 1.234321234321234e-12, "1.234321e-12" },
1583         { 1.234321234321234e-11, "1.234321e-11" },
1584         { 1.234321234321234e-10, "1.234321e-10" },
1585         { 1.234321234321234e-9, "1.234321e-09" },
1586         { 1.234321234321234e-8, "1.234321e-08" },
1587         { 1.234321234321234e-7, "1.234321e-07" },
1588         { 1.234321234321234e-6, "1.234321e-06" },
1589         { 1.234321234321234e-5, "1.234321e-05" },
1590         { 1.234321234321234e-4, "1.234321e-04" },
1591         { 1.234321234321234e-3, "1.234321e-03" },
1592         { 1.234321234321234e-2, "1.234321e-02" },
1593         { 1.234321234321234e-1, "1.234321e-01" },
1594         { 1.234321234321234, "1.234321e+00" },
1595         { 1.234321234321234e1, "1.234321e+01" },
1596         { 1.234321234321234e2, "1.234321e+02" },
1597         { 1.234321234321234e3, "1.234321e+03" },
1598         { 1.234321234321234e4, "1.234321e+04" },
1599         { 1.234321234321234e5, "1.234321e+05" },
1600         { 1.234321234321234e6, "1.234321e+06" },
1601         { 1.234321234321234e7, "1.234321e+07" },
1602         { 1.234321234321234e8, "1.234321e+08" },
1603         { 1.234321234321234e9, "1.234321e+09" },
1604         { 1.234321234321234e10, "1.234321e+10" },
1605         { 1.234321234321234e11, "1.234321e+11" },
1606         { 1.234321234321234e12, "1.234321e+12" },
1607         { 1.234321234321234e13, "1.234321e+13" },
1608         { 1.234321234321234e14, "1.234321e+14" },
1609         { 1.234321234321234e15, "1.234321e+15" },
1610         { 1.234321234321234e16, "1.234321e+16" },
1611         { 1.234321234321234e17, "1.234321e+17" },
1612         { 1.234321234321234e18, "1.234321e+18" },
1613         { 1.234321234321234e19, "1.234321e+19" },
1614         { 1.234321234321234e20, "1.234321e+20" },
1615         { 1.234321234321234e21, "1.234321e+21" },
1616         { 1.234321234321234e22, "1.234321e+22" },
1617         { 1.234321234321234e23, "1.234321e+23" },
1618         { 1.234321234321234e24, "1.234321e+24" },
1619         { 1.234321234321234e25, "1.234321e+25" },
1620         { 1.234321234321234e26, "1.234321e+26" },
1621         { 1.234321234321234e27, "1.234321e+27" },
1622         { 1.234321234321234e28, "1.234321e+28" },
1623         { 1.234321234321234e29, "1.234321e+29" },
1624         { 1.234321234321234e30, "1.234321e+30" },
1625         { 1.234321234321234e31, "1.234321e+31" },
1626         { 1.234321234321234e32, "1.234321e+32" },
1627         { 1.234321234321234e33, "1.234321e+33" },
1628         { 1.234321234321234e34, "1.234321e+34" },
1629         { 1.234321234321234e35, "1.234321e+35" },
1630         { 1.234321234321234e36, "1.234321e+36" }
1631       };
1632     size_t k;
1633     for (k = 0; k < SIZEOF (data); k++)
1634       {
1635         char *result;
1636         int retval =
1637           my_asprintf (&result, "%e", data[k].value);
1638         const char *expected = data[k].string;
1639         ASSERT (result != NULL);
1640         ASSERT (strcmp (result, expected) == 0
1641                 /* Some implementations produce exponents with 3 digits.  */
1642                 || (strlen (result) == strlen (expected) + 1
1643                     && memcmp (result, expected, strlen (expected) - 2) == 0
1644                     && result[strlen (expected) - 2] == '0'
1645                     && strcmp (result + strlen (expected) - 1,
1646                                expected + strlen (expected) - 2)
1647                        == 0));
1648         ASSERT (retval == strlen (result));
1649         free (result);
1650       }
1651   }
1652
1653   { /* A negative number.  */
1654     char *result;
1655     int retval =
1656       my_asprintf (&result, "%e %d", -0.03125, 33, 44, 55);
1657     ASSERT (result != NULL);
1658     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1659             || strcmp (result, "-3.125000e-002 33") == 0);
1660     ASSERT (retval == strlen (result));
1661     free (result);
1662   }
1663
1664   { /* Positive zero.  */
1665     char *result;
1666     int retval =
1667       my_asprintf (&result, "%e %d", 0.0, 33, 44, 55);
1668     ASSERT (result != NULL);
1669     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1670             || strcmp (result, "0.000000e+000 33") == 0);
1671     ASSERT (retval == strlen (result));
1672     free (result);
1673   }
1674
1675   { /* Negative zero.  */
1676     char *result;
1677     int retval =
1678       my_asprintf (&result, "%e %d", -0.0, 33, 44, 55);
1679     ASSERT (result != NULL);
1680     ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1681             || strcmp (result, "-0.000000e+000 33") == 0);
1682     ASSERT (retval == strlen (result));
1683     free (result);
1684   }
1685
1686   { /* Positive infinity.  */
1687     char *result;
1688     int retval =
1689       my_asprintf (&result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1690     ASSERT (result != NULL);
1691     ASSERT (strcmp (result, "inf 33") == 0
1692             || strcmp (result, "infinity 33") == 0);
1693     ASSERT (retval == strlen (result));
1694     free (result);
1695   }
1696
1697   { /* Negative infinity.  */
1698     char *result;
1699     int retval =
1700       my_asprintf (&result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1701     ASSERT (result != NULL);
1702     ASSERT (strcmp (result, "-inf 33") == 0
1703             || strcmp (result, "-infinity 33") == 0);
1704     ASSERT (retval == strlen (result));
1705     free (result);
1706   }
1707
1708   { /* NaN.  */
1709     char *result;
1710     int retval =
1711       my_asprintf (&result, "%e %d", NaN (), 33, 44, 55);
1712     ASSERT (result != NULL);
1713     ASSERT (strcmp (result, "nan 33") == 0);
1714     ASSERT (retval == strlen (result));
1715     free (result);
1716   }
1717
1718   { /* Width.  */
1719     char *result;
1720     int retval =
1721       my_asprintf (&result, "%15e %d", 1.75, 33, 44, 55);
1722     ASSERT (result != NULL);
1723     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
1724             || strcmp (result, "  1.750000e+000 33") == 0);
1725     ASSERT (retval == strlen (result));
1726     free (result);
1727   }
1728
1729   { /* FLAG_LEFT.  */
1730     char *result;
1731     int retval =
1732       my_asprintf (&result, "%-15e %d", 1.75, 33, 44, 55);
1733     ASSERT (result != NULL);
1734     ASSERT (strcmp (result, "1.750000e+00    33") == 0
1735             || strcmp (result, "1.750000e+000   33") == 0);
1736     ASSERT (retval == strlen (result));
1737     free (result);
1738   }
1739
1740   { /* FLAG_SHOWSIGN.  */
1741     char *result;
1742     int retval =
1743       my_asprintf (&result, "%+e %d", 1.75, 33, 44, 55);
1744     ASSERT (result != NULL);
1745     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1746             || strcmp (result, "+1.750000e+000 33") == 0);
1747     ASSERT (retval == strlen (result));
1748     free (result);
1749   }
1750
1751   { /* FLAG_SPACE.  */
1752     char *result;
1753     int retval =
1754       my_asprintf (&result, "% e %d", 1.75, 33, 44, 55);
1755     ASSERT (result != NULL);
1756     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1757             || strcmp (result, " 1.750000e+000 33") == 0);
1758     ASSERT (retval == strlen (result));
1759     free (result);
1760   }
1761
1762   { /* FLAG_ALT.  */
1763     char *result;
1764     int retval =
1765       my_asprintf (&result, "%#e %d", 1.75, 33, 44, 55);
1766     ASSERT (result != NULL);
1767     ASSERT (strcmp (result, "1.750000e+00 33") == 0
1768             || strcmp (result, "1.750000e+000 33") == 0);
1769     ASSERT (retval == strlen (result));
1770     free (result);
1771   }
1772
1773   { /* FLAG_ALT.  */
1774     char *result;
1775     int retval =
1776       my_asprintf (&result, "%#.e %d", 1.75, 33, 44, 55);
1777     ASSERT (result != NULL);
1778     ASSERT (strcmp (result, "2.e+00 33") == 0
1779             || strcmp (result, "2.e+000 33") == 0);
1780     ASSERT (retval == strlen (result));
1781     free (result);
1782   }
1783
1784   { /* FLAG_ALT.  */
1785     char *result;
1786     int retval =
1787       my_asprintf (&result, "%#.e %d", 9.75, 33, 44, 55);
1788     ASSERT (result != NULL);
1789     ASSERT (strcmp (result, "1.e+01 33") == 0
1790             || strcmp (result, "1.e+001 33") == 0);
1791     ASSERT (retval == strlen (result));
1792     free (result);
1793   }
1794
1795   { /* FLAG_ZERO with finite number.  */
1796     char *result;
1797     int retval =
1798       my_asprintf (&result, "%015e %d", 1234.0, 33, 44, 55);
1799     ASSERT (result != NULL);
1800     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1801             || strcmp (result, "001.234000e+003 33") == 0);
1802     ASSERT (retval == strlen (result));
1803     free (result);
1804   }
1805
1806   { /* FLAG_ZERO with infinite number.  */
1807     char *result;
1808     int retval =
1809       my_asprintf (&result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1810     ASSERT (result != NULL);
1811     ASSERT (strcmp (result, "           -inf 33") == 0
1812             || strcmp (result, "      -infinity 33") == 0);
1813     ASSERT (retval == strlen (result));
1814     free (result);
1815   }
1816
1817   { /* FLAG_ZERO with NaN.  */
1818     char *result;
1819     int retval =
1820       my_asprintf (&result, "%015e %d", NaN (), 33, 44, 55);
1821     ASSERT (result != NULL);
1822     ASSERT (strcmp (result, "            nan 33") == 0);
1823     ASSERT (retval == strlen (result));
1824     free (result);
1825   }
1826
1827   { /* Precision.  */
1828     char *result;
1829     int retval =
1830       my_asprintf (&result, "%.e %d", 1234.0, 33, 44, 55);
1831     ASSERT (result != NULL);
1832     ASSERT (strcmp (result, "1e+03 33") == 0
1833             || strcmp (result, "1e+003 33") == 0);
1834     ASSERT (retval == strlen (result));
1835     free (result);
1836   }
1837
1838   { /* A positive number.  */
1839     char *result;
1840     int retval =
1841       my_asprintf (&result, "%Le %d", 12.75L, 33, 44, 55);
1842     ASSERT (result != NULL);
1843     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1844     ASSERT (retval == strlen (result));
1845     free (result);
1846   }
1847
1848   { /* A larger positive number.  */
1849     char *result;
1850     int retval =
1851       my_asprintf (&result, "%Le %d", 1234567.0L, 33, 44, 55);
1852     ASSERT (result != NULL);
1853     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1854     ASSERT (retval == strlen (result));
1855     free (result);
1856   }
1857
1858   { /* Small and large positive numbers.  */
1859     static struct { long double value; const char *string; } data[] =
1860       {
1861         { 1.234321234321234e-37L, "1.234321e-37" },
1862         { 1.234321234321234e-36L, "1.234321e-36" },
1863         { 1.234321234321234e-35L, "1.234321e-35" },
1864         { 1.234321234321234e-34L, "1.234321e-34" },
1865         { 1.234321234321234e-33L, "1.234321e-33" },
1866         { 1.234321234321234e-32L, "1.234321e-32" },
1867         { 1.234321234321234e-31L, "1.234321e-31" },
1868         { 1.234321234321234e-30L, "1.234321e-30" },
1869         { 1.234321234321234e-29L, "1.234321e-29" },
1870         { 1.234321234321234e-28L, "1.234321e-28" },
1871         { 1.234321234321234e-27L, "1.234321e-27" },
1872         { 1.234321234321234e-26L, "1.234321e-26" },
1873         { 1.234321234321234e-25L, "1.234321e-25" },
1874         { 1.234321234321234e-24L, "1.234321e-24" },
1875         { 1.234321234321234e-23L, "1.234321e-23" },
1876         { 1.234321234321234e-22L, "1.234321e-22" },
1877         { 1.234321234321234e-21L, "1.234321e-21" },
1878         { 1.234321234321234e-20L, "1.234321e-20" },
1879         { 1.234321234321234e-19L, "1.234321e-19" },
1880         { 1.234321234321234e-18L, "1.234321e-18" },
1881         { 1.234321234321234e-17L, "1.234321e-17" },
1882         { 1.234321234321234e-16L, "1.234321e-16" },
1883         { 1.234321234321234e-15L, "1.234321e-15" },
1884         { 1.234321234321234e-14L, "1.234321e-14" },
1885         { 1.234321234321234e-13L, "1.234321e-13" },
1886         { 1.234321234321234e-12L, "1.234321e-12" },
1887         { 1.234321234321234e-11L, "1.234321e-11" },
1888         { 1.234321234321234e-10L, "1.234321e-10" },
1889         { 1.234321234321234e-9L, "1.234321e-09" },
1890         { 1.234321234321234e-8L, "1.234321e-08" },
1891         { 1.234321234321234e-7L, "1.234321e-07" },
1892         { 1.234321234321234e-6L, "1.234321e-06" },
1893         { 1.234321234321234e-5L, "1.234321e-05" },
1894         { 1.234321234321234e-4L, "1.234321e-04" },
1895         { 1.234321234321234e-3L, "1.234321e-03" },
1896         { 1.234321234321234e-2L, "1.234321e-02" },
1897         { 1.234321234321234e-1L, "1.234321e-01" },
1898         { 1.234321234321234L, "1.234321e+00" },
1899         { 1.234321234321234e1L, "1.234321e+01" },
1900         { 1.234321234321234e2L, "1.234321e+02" },
1901         { 1.234321234321234e3L, "1.234321e+03" },
1902         { 1.234321234321234e4L, "1.234321e+04" },
1903         { 1.234321234321234e5L, "1.234321e+05" },
1904         { 1.234321234321234e6L, "1.234321e+06" },
1905         { 1.234321234321234e7L, "1.234321e+07" },
1906         { 1.234321234321234e8L, "1.234321e+08" },
1907         { 1.234321234321234e9L, "1.234321e+09" },
1908         { 1.234321234321234e10L, "1.234321e+10" },
1909         { 1.234321234321234e11L, "1.234321e+11" },
1910         { 1.234321234321234e12L, "1.234321e+12" },
1911         { 1.234321234321234e13L, "1.234321e+13" },
1912         { 1.234321234321234e14L, "1.234321e+14" },
1913         { 1.234321234321234e15L, "1.234321e+15" },
1914         { 1.234321234321234e16L, "1.234321e+16" },
1915         { 1.234321234321234e17L, "1.234321e+17" },
1916         { 1.234321234321234e18L, "1.234321e+18" },
1917         { 1.234321234321234e19L, "1.234321e+19" },
1918         { 1.234321234321234e20L, "1.234321e+20" },
1919         { 1.234321234321234e21L, "1.234321e+21" },
1920         { 1.234321234321234e22L, "1.234321e+22" },
1921         { 1.234321234321234e23L, "1.234321e+23" },
1922         { 1.234321234321234e24L, "1.234321e+24" },
1923         { 1.234321234321234e25L, "1.234321e+25" },
1924         { 1.234321234321234e26L, "1.234321e+26" },
1925         { 1.234321234321234e27L, "1.234321e+27" },
1926         { 1.234321234321234e28L, "1.234321e+28" },
1927         { 1.234321234321234e29L, "1.234321e+29" },
1928         { 1.234321234321234e30L, "1.234321e+30" },
1929         { 1.234321234321234e31L, "1.234321e+31" },
1930         { 1.234321234321234e32L, "1.234321e+32" },
1931         { 1.234321234321234e33L, "1.234321e+33" },
1932         { 1.234321234321234e34L, "1.234321e+34" },
1933         { 1.234321234321234e35L, "1.234321e+35" },
1934         { 1.234321234321234e36L, "1.234321e+36" }
1935       };
1936     size_t k;
1937     for (k = 0; k < SIZEOF (data); k++)
1938       {
1939         char *result;
1940         int retval =
1941           my_asprintf (&result, "%Le", data[k].value);
1942         ASSERT (result != NULL);
1943         ASSERT (strcmp (result, data[k].string) == 0);
1944         ASSERT (retval == strlen (result));
1945         free (result);
1946       }
1947   }
1948
1949   { /* A negative number.  */
1950     char *result;
1951     int retval =
1952       my_asprintf (&result, "%Le %d", -0.03125L, 33, 44, 55);
1953     ASSERT (result != NULL);
1954     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1955     ASSERT (retval == strlen (result));
1956     free (result);
1957   }
1958
1959   { /* Positive zero.  */
1960     char *result;
1961     int retval =
1962       my_asprintf (&result, "%Le %d", 0.0L, 33, 44, 55);
1963     ASSERT (result != NULL);
1964     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1965     ASSERT (retval == strlen (result));
1966     free (result);
1967   }
1968
1969   { /* Negative zero.  */
1970     char *result;
1971     int retval =
1972       my_asprintf (&result, "%Le %d", -0.0L, 33, 44, 55);
1973     ASSERT (result != NULL);
1974     ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1975     ASSERT (retval == strlen (result));
1976     free (result);
1977   }
1978
1979   { /* Positive infinity.  */
1980     char *result;
1981     int retval =
1982       my_asprintf (&result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1983     ASSERT (result != NULL);
1984     ASSERT (strcmp (result, "inf 33") == 0
1985             || strcmp (result, "infinity 33") == 0);
1986     ASSERT (retval == strlen (result));
1987     free (result);
1988   }
1989
1990   { /* Negative infinity.  */
1991     char *result;
1992     int retval =
1993       my_asprintf (&result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1994     ASSERT (result != NULL);
1995     ASSERT (strcmp (result, "-inf 33") == 0
1996             || strcmp (result, "-infinity 33") == 0);
1997     ASSERT (retval == strlen (result));
1998     free (result);
1999   }
2000
2001   { /* NaN.  */
2002     static long double zero = 0.0L;
2003     char *result;
2004     int retval =
2005       my_asprintf (&result, "%Le %d", zero / zero, 33, 44, 55);
2006     ASSERT (result != NULL);
2007     ASSERT (strcmp (result, "nan 33") == 0);
2008     ASSERT (retval == strlen (result));
2009     free (result);
2010   }
2011
2012   { /* Width.  */
2013     char *result;
2014     int retval =
2015       my_asprintf (&result, "%15Le %d", 1.75L, 33, 44, 55);
2016     ASSERT (result != NULL);
2017     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
2018     ASSERT (retval == strlen (result));
2019     free (result);
2020   }
2021
2022   { /* FLAG_LEFT.  */
2023     char *result;
2024     int retval =
2025       my_asprintf (&result, "%-15Le %d", 1.75L, 33, 44, 55);
2026     ASSERT (result != NULL);
2027     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
2028     ASSERT (retval == strlen (result));
2029     free (result);
2030   }
2031
2032   { /* FLAG_SHOWSIGN.  */
2033     char *result;
2034     int retval =
2035       my_asprintf (&result, "%+Le %d", 1.75L, 33, 44, 55);
2036     ASSERT (result != NULL);
2037     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2038     ASSERT (retval == strlen (result));
2039     free (result);
2040   }
2041
2042   { /* FLAG_SPACE.  */
2043     char *result;
2044     int retval =
2045       my_asprintf (&result, "% Le %d", 1.75L, 33, 44, 55);
2046     ASSERT (result != NULL);
2047     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2048     ASSERT (retval == strlen (result));
2049     free (result);
2050   }
2051
2052   { /* FLAG_ALT.  */
2053     char *result;
2054     int retval =
2055       my_asprintf (&result, "%#Le %d", 1.75L, 33, 44, 55);
2056     ASSERT (result != NULL);
2057     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2058     ASSERT (retval == strlen (result));
2059     free (result);
2060   }
2061
2062   { /* FLAG_ALT.  */
2063     char *result;
2064     int retval =
2065       my_asprintf (&result, "%#.Le %d", 1.75L, 33, 44, 55);
2066     ASSERT (result != NULL);
2067     ASSERT (strcmp (result, "2.e+00 33") == 0);
2068     ASSERT (retval == strlen (result));
2069     free (result);
2070   }
2071
2072   { /* FLAG_ALT.  */
2073     char *result;
2074     int retval =
2075       my_asprintf (&result, "%#.Le %d", 9.75L, 33, 44, 55);
2076     ASSERT (result != NULL);
2077     ASSERT (strcmp (result, "1.e+01 33") == 0);
2078     ASSERT (retval == strlen (result));
2079     free (result);
2080   }
2081
2082   { /* FLAG_ZERO with finite number.  */
2083     char *result;
2084     int retval =
2085       my_asprintf (&result, "%015Le %d", 1234.0L, 33, 44, 55);
2086     ASSERT (result != NULL);
2087     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2088     ASSERT (retval == strlen (result));
2089     free (result);
2090   }
2091
2092   { /* FLAG_ZERO with infinite number.  */
2093     char *result;
2094     int retval =
2095       my_asprintf (&result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2096     ASSERT (result != NULL);
2097     ASSERT (strcmp (result, "           -inf 33") == 0
2098             || strcmp (result, "      -infinity 33") == 0);
2099     ASSERT (retval == strlen (result));
2100     free (result);
2101   }
2102
2103   { /* FLAG_ZERO with NaN.  */
2104     static long double zero = 0.0L;
2105     char *result;
2106     int retval =
2107       my_asprintf (&result, "%015Le %d", zero / zero, 33, 44, 55);
2108     ASSERT (result != NULL);
2109     ASSERT (strcmp (result, "            nan 33") == 0);
2110     ASSERT (retval == strlen (result));
2111     free (result);
2112   }
2113
2114   { /* Precision.  */
2115     char *result;
2116     int retval =
2117       my_asprintf (&result, "%.Le %d", 1234.0L, 33, 44, 55);
2118     ASSERT (result != NULL);
2119     ASSERT (strcmp (result, "1e+03 33") == 0);
2120     ASSERT (retval == strlen (result));
2121     free (result);
2122   }
2123
2124   /* Test the support of the %g format directive.  */
2125
2126   { /* A positive number.  */
2127     char *result;
2128     int retval =
2129       my_asprintf (&result, "%g %d", 12.75, 33, 44, 55);
2130     ASSERT (result != NULL);
2131     ASSERT (strcmp (result, "12.75 33") == 0);
2132     ASSERT (retval == strlen (result));
2133     free (result);
2134   }
2135
2136   { /* A larger positive number.  */
2137     char *result;
2138     int retval =
2139       my_asprintf (&result, "%g %d", 1234567.0, 33, 44, 55);
2140     ASSERT (result != NULL);
2141     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2142             || strcmp (result, "1.23457e+006 33") == 0);
2143     ASSERT (retval == strlen (result));
2144     free (result);
2145   }
2146
2147   { /* Small and large positive numbers.  */
2148     static struct { double value; const char *string; } data[] =
2149       {
2150         { 1.234321234321234e-37, "1.23432e-37" },
2151         { 1.234321234321234e-36, "1.23432e-36" },
2152         { 1.234321234321234e-35, "1.23432e-35" },
2153         { 1.234321234321234e-34, "1.23432e-34" },
2154         { 1.234321234321234e-33, "1.23432e-33" },
2155         { 1.234321234321234e-32, "1.23432e-32" },
2156         { 1.234321234321234e-31, "1.23432e-31" },
2157         { 1.234321234321234e-30, "1.23432e-30" },
2158         { 1.234321234321234e-29, "1.23432e-29" },
2159         { 1.234321234321234e-28, "1.23432e-28" },
2160         { 1.234321234321234e-27, "1.23432e-27" },
2161         { 1.234321234321234e-26, "1.23432e-26" },
2162         { 1.234321234321234e-25, "1.23432e-25" },
2163         { 1.234321234321234e-24, "1.23432e-24" },
2164         { 1.234321234321234e-23, "1.23432e-23" },
2165         { 1.234321234321234e-22, "1.23432e-22" },
2166         { 1.234321234321234e-21, "1.23432e-21" },
2167         { 1.234321234321234e-20, "1.23432e-20" },
2168         { 1.234321234321234e-19, "1.23432e-19" },
2169         { 1.234321234321234e-18, "1.23432e-18" },
2170         { 1.234321234321234e-17, "1.23432e-17" },
2171         { 1.234321234321234e-16, "1.23432e-16" },
2172         { 1.234321234321234e-15, "1.23432e-15" },
2173         { 1.234321234321234e-14, "1.23432e-14" },
2174         { 1.234321234321234e-13, "1.23432e-13" },
2175         { 1.234321234321234e-12, "1.23432e-12" },
2176         { 1.234321234321234e-11, "1.23432e-11" },
2177         { 1.234321234321234e-10, "1.23432e-10" },
2178         { 1.234321234321234e-9, "1.23432e-09" },
2179         { 1.234321234321234e-8, "1.23432e-08" },
2180         { 1.234321234321234e-7, "1.23432e-07" },
2181         { 1.234321234321234e-6, "1.23432e-06" },
2182         { 1.234321234321234e-5, "1.23432e-05" },
2183         { 1.234321234321234e-4, "0.000123432" },
2184         { 1.234321234321234e-3, "0.00123432" },
2185         { 1.234321234321234e-2, "0.0123432" },
2186         { 1.234321234321234e-1, "0.123432" },
2187         { 1.234321234321234, "1.23432" },
2188         { 1.234321234321234e1, "12.3432" },
2189         { 1.234321234321234e2, "123.432" },
2190         { 1.234321234321234e3, "1234.32" },
2191         { 1.234321234321234e4, "12343.2" },
2192         { 1.234321234321234e5, "123432" },
2193         { 1.234321234321234e6, "1.23432e+06" },
2194         { 1.234321234321234e7, "1.23432e+07" },
2195         { 1.234321234321234e8, "1.23432e+08" },
2196         { 1.234321234321234e9, "1.23432e+09" },
2197         { 1.234321234321234e10, "1.23432e+10" },
2198         { 1.234321234321234e11, "1.23432e+11" },
2199         { 1.234321234321234e12, "1.23432e+12" },
2200         { 1.234321234321234e13, "1.23432e+13" },
2201         { 1.234321234321234e14, "1.23432e+14" },
2202         { 1.234321234321234e15, "1.23432e+15" },
2203         { 1.234321234321234e16, "1.23432e+16" },
2204         { 1.234321234321234e17, "1.23432e+17" },
2205         { 1.234321234321234e18, "1.23432e+18" },
2206         { 1.234321234321234e19, "1.23432e+19" },
2207         { 1.234321234321234e20, "1.23432e+20" },
2208         { 1.234321234321234e21, "1.23432e+21" },
2209         { 1.234321234321234e22, "1.23432e+22" },
2210         { 1.234321234321234e23, "1.23432e+23" },
2211         { 1.234321234321234e24, "1.23432e+24" },
2212         { 1.234321234321234e25, "1.23432e+25" },
2213         { 1.234321234321234e26, "1.23432e+26" },
2214         { 1.234321234321234e27, "1.23432e+27" },
2215         { 1.234321234321234e28, "1.23432e+28" },
2216         { 1.234321234321234e29, "1.23432e+29" },
2217         { 1.234321234321234e30, "1.23432e+30" },
2218         { 1.234321234321234e31, "1.23432e+31" },
2219         { 1.234321234321234e32, "1.23432e+32" },
2220         { 1.234321234321234e33, "1.23432e+33" },
2221         { 1.234321234321234e34, "1.23432e+34" },
2222         { 1.234321234321234e35, "1.23432e+35" },
2223         { 1.234321234321234e36, "1.23432e+36" }
2224       };
2225     size_t k;
2226     for (k = 0; k < SIZEOF (data); k++)
2227       {
2228         char *result;
2229         int retval =
2230           my_asprintf (&result, "%g", data[k].value);
2231         const char *expected = data[k].string;
2232         ASSERT (result != NULL);
2233         ASSERT (strcmp (result, expected) == 0
2234                 /* Some implementations produce exponents with 3 digits.  */
2235                 || (expected[strlen (expected) - 4] == 'e'
2236                     && strlen (result) == strlen (expected) + 1
2237                     && memcmp (result, expected, strlen (expected) - 2) == 0
2238                     && result[strlen (expected) - 2] == '0'
2239                     && strcmp (result + strlen (expected) - 1,
2240                                expected + strlen (expected) - 2)
2241                        == 0));
2242         ASSERT (retval == strlen (result));
2243         free (result);
2244       }
2245   }
2246
2247   { /* A negative number.  */
2248     char *result;
2249     int retval =
2250       my_asprintf (&result, "%g %d", -0.03125, 33, 44, 55);
2251     ASSERT (result != NULL);
2252     ASSERT (strcmp (result, "-0.03125 33") == 0);
2253     ASSERT (retval == strlen (result));
2254     free (result);
2255   }
2256
2257   { /* Positive zero.  */
2258     char *result;
2259     int retval =
2260       my_asprintf (&result, "%g %d", 0.0, 33, 44, 55);
2261     ASSERT (result != NULL);
2262     ASSERT (strcmp (result, "0 33") == 0);
2263     ASSERT (retval == strlen (result));
2264     free (result);
2265   }
2266
2267   { /* Negative zero.  */
2268     char *result;
2269     int retval =
2270       my_asprintf (&result, "%g %d", -0.0, 33, 44, 55);
2271     ASSERT (result != NULL);
2272     ASSERT (strcmp (result, "-0 33") == 0);
2273     ASSERT (retval == strlen (result));
2274     free (result);
2275   }
2276
2277   { /* Positive infinity.  */
2278     char *result;
2279     int retval =
2280       my_asprintf (&result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2281     ASSERT (result != NULL);
2282     ASSERT (strcmp (result, "inf 33") == 0
2283             || strcmp (result, "infinity 33") == 0);
2284     ASSERT (retval == strlen (result));
2285     free (result);
2286   }
2287
2288   { /* Negative infinity.  */
2289     char *result;
2290     int retval =
2291       my_asprintf (&result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2292     ASSERT (result != NULL);
2293     ASSERT (strcmp (result, "-inf 33") == 0
2294             || strcmp (result, "-infinity 33") == 0);
2295     ASSERT (retval == strlen (result));
2296     free (result);
2297   }
2298
2299   { /* NaN.  */
2300     char *result;
2301     int retval =
2302       my_asprintf (&result, "%g %d", NaN (), 33, 44, 55);
2303     ASSERT (result != NULL);
2304     ASSERT (strcmp (result, "nan 33") == 0);
2305     ASSERT (retval == strlen (result));
2306     free (result);
2307   }
2308
2309   { /* Width.  */
2310     char *result;
2311     int retval =
2312       my_asprintf (&result, "%10g %d", 1.75, 33, 44, 55);
2313     ASSERT (result != NULL);
2314     ASSERT (strcmp (result, "      1.75 33") == 0);
2315     ASSERT (retval == strlen (result));
2316     free (result);
2317   }
2318
2319   { /* FLAG_LEFT.  */
2320     char *result;
2321     int retval =
2322       my_asprintf (&result, "%-10g %d", 1.75, 33, 44, 55);
2323     ASSERT (result != NULL);
2324     ASSERT (strcmp (result, "1.75       33") == 0);
2325     ASSERT (retval == strlen (result));
2326     free (result);
2327   }
2328
2329   { /* FLAG_SHOWSIGN.  */
2330     char *result;
2331     int retval =
2332       my_asprintf (&result, "%+g %d", 1.75, 33, 44, 55);
2333     ASSERT (result != NULL);
2334     ASSERT (strcmp (result, "+1.75 33") == 0);
2335     ASSERT (retval == strlen (result));
2336     free (result);
2337   }
2338
2339   { /* FLAG_SPACE.  */
2340     char *result;
2341     int retval =
2342       my_asprintf (&result, "% g %d", 1.75, 33, 44, 55);
2343     ASSERT (result != NULL);
2344     ASSERT (strcmp (result, " 1.75 33") == 0);
2345     ASSERT (retval == strlen (result));
2346     free (result);
2347   }
2348
2349   { /* FLAG_ALT.  */
2350     char *result;
2351     int retval =
2352       my_asprintf (&result, "%#g %d", 1.75, 33, 44, 55);
2353     ASSERT (result != NULL);
2354     ASSERT (strcmp (result, "1.75000 33") == 0);
2355     ASSERT (retval == strlen (result));
2356     free (result);
2357   }
2358
2359   { /* FLAG_ALT.  */
2360     char *result;
2361     int retval =
2362       my_asprintf (&result, "%#.g %d", 1.75, 33, 44, 55);
2363     ASSERT (result != NULL);
2364     ASSERT (strcmp (result, "2. 33") == 0);
2365     ASSERT (retval == strlen (result));
2366     free (result);
2367   }
2368
2369   { /* FLAG_ALT.  */
2370     char *result;
2371     int retval =
2372       my_asprintf (&result, "%#.g %d", 9.75, 33, 44, 55);
2373     ASSERT (result != NULL);
2374     ASSERT (strcmp (result, "1.e+01 33") == 0
2375             || strcmp (result, "1.e+001 33") == 0);
2376     ASSERT (retval == strlen (result));
2377     free (result);
2378   }
2379
2380   { /* FLAG_ZERO with finite number.  */
2381     char *result;
2382     int retval =
2383       my_asprintf (&result, "%010g %d", 1234.0, 33, 44, 55);
2384     ASSERT (result != NULL);
2385     ASSERT (strcmp (result, "0000001234 33") == 0);
2386     ASSERT (retval == strlen (result));
2387     free (result);
2388   }
2389
2390   { /* FLAG_ZERO with infinite number.  */
2391     char *result;
2392     int retval =
2393       my_asprintf (&result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2394     ASSERT (result != NULL);
2395     ASSERT (strcmp (result, "           -inf 33") == 0
2396             || strcmp (result, "      -infinity 33") == 0);
2397     ASSERT (retval == strlen (result));
2398     free (result);
2399   }
2400
2401   { /* FLAG_ZERO with NaN.  */
2402     char *result;
2403     int retval =
2404       my_asprintf (&result, "%015g %d", NaN (), 33, 44, 55);
2405     ASSERT (result != NULL);
2406     ASSERT (strcmp (result, "            nan 33") == 0);
2407     ASSERT (retval == strlen (result));
2408     free (result);
2409   }
2410
2411   { /* Precision.  */
2412     char *result;
2413     int retval =
2414       my_asprintf (&result, "%.g %d", 1234.0, 33, 44, 55);
2415     ASSERT (result != NULL);
2416     ASSERT (strcmp (result, "1e+03 33") == 0
2417             || strcmp (result, "1e+003 33") == 0);
2418     ASSERT (retval == strlen (result));
2419     free (result);
2420   }
2421
2422   { /* A positive number.  */
2423     char *result;
2424     int retval =
2425       my_asprintf (&result, "%Lg %d", 12.75L, 33, 44, 55);
2426     ASSERT (result != NULL);
2427     ASSERT (strcmp (result, "12.75 33") == 0);
2428     ASSERT (retval == strlen (result));
2429     free (result);
2430   }
2431
2432   { /* A larger positive number.  */
2433     char *result;
2434     int retval =
2435       my_asprintf (&result, "%Lg %d", 1234567.0L, 33, 44, 55);
2436     ASSERT (result != NULL);
2437     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2438     ASSERT (retval == strlen (result));
2439     free (result);
2440   }
2441
2442   { /* Small and large positive numbers.  */
2443     static struct { long double value; const char *string; } data[] =
2444       {
2445         { 1.234321234321234e-37L, "1.23432e-37" },
2446         { 1.234321234321234e-36L, "1.23432e-36" },
2447         { 1.234321234321234e-35L, "1.23432e-35" },
2448         { 1.234321234321234e-34L, "1.23432e-34" },
2449         { 1.234321234321234e-33L, "1.23432e-33" },
2450         { 1.234321234321234e-32L, "1.23432e-32" },
2451         { 1.234321234321234e-31L, "1.23432e-31" },
2452         { 1.234321234321234e-30L, "1.23432e-30" },
2453         { 1.234321234321234e-29L, "1.23432e-29" },
2454         { 1.234321234321234e-28L, "1.23432e-28" },
2455         { 1.234321234321234e-27L, "1.23432e-27" },
2456         { 1.234321234321234e-26L, "1.23432e-26" },
2457         { 1.234321234321234e-25L, "1.23432e-25" },
2458         { 1.234321234321234e-24L, "1.23432e-24" },
2459         { 1.234321234321234e-23L, "1.23432e-23" },
2460         { 1.234321234321234e-22L, "1.23432e-22" },
2461         { 1.234321234321234e-21L, "1.23432e-21" },
2462         { 1.234321234321234e-20L, "1.23432e-20" },
2463         { 1.234321234321234e-19L, "1.23432e-19" },
2464         { 1.234321234321234e-18L, "1.23432e-18" },
2465         { 1.234321234321234e-17L, "1.23432e-17" },
2466         { 1.234321234321234e-16L, "1.23432e-16" },
2467         { 1.234321234321234e-15L, "1.23432e-15" },
2468         { 1.234321234321234e-14L, "1.23432e-14" },
2469         { 1.234321234321234e-13L, "1.23432e-13" },
2470         { 1.234321234321234e-12L, "1.23432e-12" },
2471         { 1.234321234321234e-11L, "1.23432e-11" },
2472         { 1.234321234321234e-10L, "1.23432e-10" },
2473         { 1.234321234321234e-9L, "1.23432e-09" },
2474         { 1.234321234321234e-8L, "1.23432e-08" },
2475         { 1.234321234321234e-7L, "1.23432e-07" },
2476         { 1.234321234321234e-6L, "1.23432e-06" },
2477         { 1.234321234321234e-5L, "1.23432e-05" },
2478         { 1.234321234321234e-4L, "0.000123432" },
2479         { 1.234321234321234e-3L, "0.00123432" },
2480         { 1.234321234321234e-2L, "0.0123432" },
2481         { 1.234321234321234e-1L, "0.123432" },
2482         { 1.234321234321234L, "1.23432" },
2483         { 1.234321234321234e1L, "12.3432" },
2484         { 1.234321234321234e2L, "123.432" },
2485         { 1.234321234321234e3L, "1234.32" },
2486         { 1.234321234321234e4L, "12343.2" },
2487         { 1.234321234321234e5L, "123432" },
2488         { 1.234321234321234e6L, "1.23432e+06" },
2489         { 1.234321234321234e7L, "1.23432e+07" },
2490         { 1.234321234321234e8L, "1.23432e+08" },
2491         { 1.234321234321234e9L, "1.23432e+09" },
2492         { 1.234321234321234e10L, "1.23432e+10" },
2493         { 1.234321234321234e11L, "1.23432e+11" },
2494         { 1.234321234321234e12L, "1.23432e+12" },
2495         { 1.234321234321234e13L, "1.23432e+13" },
2496         { 1.234321234321234e14L, "1.23432e+14" },
2497         { 1.234321234321234e15L, "1.23432e+15" },
2498         { 1.234321234321234e16L, "1.23432e+16" },
2499         { 1.234321234321234e17L, "1.23432e+17" },
2500         { 1.234321234321234e18L, "1.23432e+18" },
2501         { 1.234321234321234e19L, "1.23432e+19" },
2502         { 1.234321234321234e20L, "1.23432e+20" },
2503         { 1.234321234321234e21L, "1.23432e+21" },
2504         { 1.234321234321234e22L, "1.23432e+22" },
2505         { 1.234321234321234e23L, "1.23432e+23" },
2506         { 1.234321234321234e24L, "1.23432e+24" },
2507         { 1.234321234321234e25L, "1.23432e+25" },
2508         { 1.234321234321234e26L, "1.23432e+26" },
2509         { 1.234321234321234e27L, "1.23432e+27" },
2510         { 1.234321234321234e28L, "1.23432e+28" },
2511         { 1.234321234321234e29L, "1.23432e+29" },
2512         { 1.234321234321234e30L, "1.23432e+30" },
2513         { 1.234321234321234e31L, "1.23432e+31" },
2514         { 1.234321234321234e32L, "1.23432e+32" },
2515         { 1.234321234321234e33L, "1.23432e+33" },
2516         { 1.234321234321234e34L, "1.23432e+34" },
2517         { 1.234321234321234e35L, "1.23432e+35" },
2518         { 1.234321234321234e36L, "1.23432e+36" }
2519       };
2520     size_t k;
2521     for (k = 0; k < SIZEOF (data); k++)
2522       {
2523         char *result;
2524         int retval =
2525           my_asprintf (&result, "%Lg", data[k].value);
2526         ASSERT (result != NULL);
2527         ASSERT (strcmp (result, data[k].string) == 0);
2528         ASSERT (retval == strlen (result));
2529         free (result);
2530       }
2531   }
2532
2533   { /* A negative number.  */
2534     char *result;
2535     int retval =
2536       my_asprintf (&result, "%Lg %d", -0.03125L, 33, 44, 55);
2537     ASSERT (result != NULL);
2538     ASSERT (strcmp (result, "-0.03125 33") == 0);
2539     ASSERT (retval == strlen (result));
2540     free (result);
2541   }
2542
2543   { /* Positive zero.  */
2544     char *result;
2545     int retval =
2546       my_asprintf (&result, "%Lg %d", 0.0L, 33, 44, 55);
2547     ASSERT (result != NULL);
2548     ASSERT (strcmp (result, "0 33") == 0);
2549     ASSERT (retval == strlen (result));
2550     free (result);
2551   }
2552
2553   { /* Negative zero.  */
2554     char *result;
2555     int retval =
2556       my_asprintf (&result, "%Lg %d", -0.0L, 33, 44, 55);
2557     ASSERT (result != NULL);
2558     ASSERT (strcmp (result, "-0 33") == 0);
2559     ASSERT (retval == strlen (result));
2560     free (result);
2561   }
2562
2563   { /* Positive infinity.  */
2564     char *result;
2565     int retval =
2566       my_asprintf (&result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2567     ASSERT (result != NULL);
2568     ASSERT (strcmp (result, "inf 33") == 0
2569             || strcmp (result, "infinity 33") == 0);
2570     ASSERT (retval == strlen (result));
2571     free (result);
2572   }
2573
2574   { /* Negative infinity.  */
2575     char *result;
2576     int retval =
2577       my_asprintf (&result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2578     ASSERT (result != NULL);
2579     ASSERT (strcmp (result, "-inf 33") == 0
2580             || strcmp (result, "-infinity 33") == 0);
2581     ASSERT (retval == strlen (result));
2582     free (result);
2583   }
2584
2585   { /* NaN.  */
2586     static long double zero = 0.0L;
2587     char *result;
2588     int retval =
2589       my_asprintf (&result, "%Lg %d", zero / zero, 33, 44, 55);
2590     ASSERT (result != NULL);
2591     ASSERT (strcmp (result, "nan 33") == 0);
2592     ASSERT (retval == strlen (result));
2593     free (result);
2594   }
2595
2596   { /* Width.  */
2597     char *result;
2598     int retval =
2599       my_asprintf (&result, "%10Lg %d", 1.75L, 33, 44, 55);
2600     ASSERT (result != NULL);
2601     ASSERT (strcmp (result, "      1.75 33") == 0);
2602     ASSERT (retval == strlen (result));
2603     free (result);
2604   }
2605
2606   { /* FLAG_LEFT.  */
2607     char *result;
2608     int retval =
2609       my_asprintf (&result, "%-10Lg %d", 1.75L, 33, 44, 55);
2610     ASSERT (result != NULL);
2611     ASSERT (strcmp (result, "1.75       33") == 0);
2612     ASSERT (retval == strlen (result));
2613     free (result);
2614   }
2615
2616   { /* FLAG_SHOWSIGN.  */
2617     char *result;
2618     int retval =
2619       my_asprintf (&result, "%+Lg %d", 1.75L, 33, 44, 55);
2620     ASSERT (result != NULL);
2621     ASSERT (strcmp (result, "+1.75 33") == 0);
2622     ASSERT (retval == strlen (result));
2623     free (result);
2624   }
2625
2626   { /* FLAG_SPACE.  */
2627     char *result;
2628     int retval =
2629       my_asprintf (&result, "% Lg %d", 1.75L, 33, 44, 55);
2630     ASSERT (result != NULL);
2631     ASSERT (strcmp (result, " 1.75 33") == 0);
2632     ASSERT (retval == strlen (result));
2633     free (result);
2634   }
2635
2636   { /* FLAG_ALT.  */
2637     char *result;
2638     int retval =
2639       my_asprintf (&result, "%#Lg %d", 1.75L, 33, 44, 55);
2640     ASSERT (result != NULL);
2641     ASSERT (strcmp (result, "1.75000 33") == 0);
2642     ASSERT (retval == strlen (result));
2643     free (result);
2644   }
2645
2646   { /* FLAG_ALT.  */
2647     char *result;
2648     int retval =
2649       my_asprintf (&result, "%#.Lg %d", 1.75L, 33, 44, 55);
2650     ASSERT (result != NULL);
2651     ASSERT (strcmp (result, "2. 33") == 0);
2652     ASSERT (retval == strlen (result));
2653     free (result);
2654   }
2655
2656   { /* FLAG_ALT.  */
2657     char *result;
2658     int retval =
2659       my_asprintf (&result, "%#.Lg %d", 9.75L, 33, 44, 55);
2660     ASSERT (result != NULL);
2661     ASSERT (strcmp (result, "1.e+01 33") == 0);
2662     ASSERT (retval == strlen (result));
2663     free (result);
2664   }
2665
2666   { /* FLAG_ZERO with finite number.  */
2667     char *result;
2668     int retval =
2669       my_asprintf (&result, "%010Lg %d", 1234.0L, 33, 44, 55);
2670     ASSERT (result != NULL);
2671     ASSERT (strcmp (result, "0000001234 33") == 0);
2672     ASSERT (retval == strlen (result));
2673     free (result);
2674   }
2675
2676   { /* FLAG_ZERO with infinite number.  */
2677     char *result;
2678     int retval =
2679       my_asprintf (&result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2680     ASSERT (result != NULL);
2681     ASSERT (strcmp (result, "           -inf 33") == 0
2682             || strcmp (result, "      -infinity 33") == 0);
2683     ASSERT (retval == strlen (result));
2684     free (result);
2685   }
2686
2687   { /* FLAG_ZERO with NaN.  */
2688     static long double zero = 0.0L;
2689     char *result;
2690     int retval =
2691       my_asprintf (&result, "%015Lg %d", zero / zero, 33, 44, 55);
2692     ASSERT (result != NULL);
2693     ASSERT (strcmp (result, "            nan 33") == 0);
2694     ASSERT (retval == strlen (result));
2695     free (result);
2696   }
2697
2698   { /* Precision.  */
2699     char *result;
2700     int retval =
2701       my_asprintf (&result, "%.Lg %d", 1234.0L, 33, 44, 55);
2702     ASSERT (result != NULL);
2703     ASSERT (strcmp (result, "1e+03 33") == 0);
2704     ASSERT (retval == strlen (result));
2705     free (result);
2706   }
2707
2708   /* Test the support of the %n format directive.  */
2709
2710   {
2711     int count = -1;
2712     char *result;
2713     int retval =
2714       my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
2715     ASSERT (result != NULL);
2716     ASSERT (strcmp (result, "123 ") == 0);
2717     ASSERT (retval == strlen (result));
2718     ASSERT (count == 4);
2719     free (result);
2720   }
2721
2722   /* Test the support of the POSIX/XSI format strings with positions.  */
2723
2724   {
2725     char *result;
2726     int retval =
2727       my_asprintf (&result, "%2$d %1$d", 33, 55);
2728     ASSERT (result != NULL);
2729     ASSERT (strcmp (result, "55 33") == 0);
2730     ASSERT (retval == strlen (result));
2731     free (result);
2732   }
2733
2734   /* Test the support of the grouping flag.  */
2735
2736   {
2737     char *result;
2738     int retval =
2739       my_asprintf (&result, "%'d %d", 1234567, 99);
2740     ASSERT (result != NULL);
2741     ASSERT (result[strlen (result) - 1] == '9');
2742     ASSERT (retval == strlen (result));
2743     free (result);
2744   }
2745 }
2746
2747 static int
2748 my_asprintf (char **result, const char *format, ...)
2749 {
2750   va_list args;
2751   int ret;
2752
2753   va_start (args, format);
2754   ret = vasprintf (result, format, args);
2755   va_end (args);
2756   return ret;
2757 }
2758
2759 static void
2760 test_vasprintf ()
2761 {
2762   test_function (my_asprintf);
2763 }
2764
2765 static void
2766 test_asprintf ()
2767 {
2768   test_function (asprintf);
2769 }
2770
2771 int
2772 main (int argc, char *argv[])
2773 {
2774   test_vasprintf ();
2775   test_asprintf ();
2776   return 0;
2777 }