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