tests/test-vasprintf-posix.c

   1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25
  26 #include <stdarg.h>
  27 #include <stddef.h>
  28 #include <stdio.h>
  29 #include <stdint.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
  34 #define ASSERT(expr) \
  35   do                                                                         \
  36     {                                                                        \
  37       if (!(expr))                                                           \
  38         {                                                                    \
  39           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
  40           abort ();                                                          \
  41         }                                                                    \
  42     }                                                                        \
  43   while (0)
  44
  45 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0.  */
  46 #ifdef __DECC
  47 static double
  48 NaN ()
  49 {
  50   static double zero = 0.0;
  51   return zero / zero;
  52 }
  53 #else
  54 # define NaN() (0.0 / 0.0)
  55 #endif
  56
  57 static int
  58 strmatch (const char *pattern, const char *string)
  59 {
  60   if (strlen (pattern) != strlen (string))
  61     return 0;
  62   for (; *pattern != '\0'; pattern++, string++)
  63     if (*pattern != '*' && *string != *pattern)
  64       return 0;
  65   return 1;
  66 }
  67
  68 static void
  69 test_function (int (*my_asprintf) (char **, const char *, ...))
  70 {
  71   int repeat;
  72
  73   /* Test return value convention.  */
  74
  75   for (repeat = 0; repeat <= 8; repeat++)
  76     {
  77       char *result;
  78       int retval = asprintf (&result, "%d", 12345);
  79       ASSERT (retval == 5);
  80       ASSERT (result != NULL);
  81       ASSERT (strcmp (result, "12345") == 0);
  82       free (result);
  83     }
  84
  85   /* Test support of size specifiers as in C99.  */
  86
  87   {
  88     char *result;
  89     int retval =
  90       my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  91     ASSERT (result != NULL);
  92     ASSERT (strcmp (result, "12345671 33") == 0);
  93     ASSERT (retval == strlen (result));
  94     free (result);
  95   }
  96
  97   {
  98     char *result;
  99     int retval =
 100       my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
 101     ASSERT (result != NULL);
 102     ASSERT (strcmp (result, "12345672 33") == 0);
 103     ASSERT (retval == strlen (result));
 104     free (result);
 105   }
 106
 107   {
 108     char *result;
 109     int retval =
 110       my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
 111     ASSERT (result != NULL);
 112     ASSERT (strcmp (result, "12345673 33") == 0);
 113     ASSERT (retval == strlen (result));
 114     free (result);
 115   }
 116
 117   {
 118     char *result;
 119     int retval =
 120       my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
 121     ASSERT (result != NULL);
 122     ASSERT (strcmp (result, "1.5 33") == 0);
 123     ASSERT (retval == strlen (result));
 124     free (result);
 125   }
 126
 127   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 128      output of floating-point numbers.  */
 129
 130   { /* A positive number.  */
 131     char *result;
 132     int retval =
 133       my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
 134     ASSERT (result != NULL);
 135     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 136             || strcmp (result, "0x3.244p+0 33") == 0
 137             || strcmp (result, "0x6.488p-1 33") == 0
 138             || strcmp (result, "0xc.91p-2 33") == 0);
 139     ASSERT (retval == strlen (result));
 140     free (result);
 141   }
 142
 143   { /* A negative number.  */
 144     char *result;
 145     int retval =
 146       my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
 147     ASSERT (result != NULL);
 148     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 149             || strcmp (result, "-0X3.244P+0 33") == 0
 150             || strcmp (result, "-0X6.488P-1 33") == 0
 151             || strcmp (result, "-0XC.91P-2 33") == 0);
 152     ASSERT (retval == strlen (result));
 153     free (result);
 154   }
 155
 156   { /* Positive zero.  */
 157     char *result;
 158     int retval =
 159       my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
 160     ASSERT (result != NULL);
 161     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 162     ASSERT (retval == strlen (result));
 163     free (result);
 164   }
 165
 166   { /* Negative zero.  */
 167     char *result;
 168     int retval =
 169       my_asprintf (&result, "%a %d", -0.0, 33, 44, 55);
 170     ASSERT (result != NULL);
 171     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 172     ASSERT (retval == strlen (result));
 173     free (result);
 174   }
 175
 176   { /* Positive infinity.  */
 177     char *result;
 178     int retval =
 179       my_asprintf (&result, "%a %d", 1.0 / 0.0, 33, 44, 55);
 180     ASSERT (result != NULL);
 181     ASSERT (strcmp (result, "inf 33") == 0);
 182     ASSERT (retval == strlen (result));
 183     free (result);
 184   }
 185
 186   { /* Negative infinity.  */
 187     char *result;
 188     int retval =
 189       my_asprintf (&result, "%a %d", -1.0 / 0.0, 33, 44, 55);
 190     ASSERT (result != NULL);
 191     ASSERT (strcmp (result, "-inf 33") == 0);
 192     ASSERT (retval == strlen (result));
 193     free (result);
 194   }
 195
 196   { /* NaN.  */
 197     char *result;
 198     int retval =
 199       my_asprintf (&result, "%a %d", NaN (), 33, 44, 55);
 200     ASSERT (result != NULL);
 201     ASSERT (strcmp (result, "nan 33") == 0);
 202     ASSERT (retval == strlen (result));
 203     free (result);
 204   }
 205
 206   { /* Rounding near the decimal point.  */
 207     char *result;
 208     int retval =
 209       my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
 210     ASSERT (result != NULL);
 211     ASSERT (strcmp (result, "0x2p+0 33") == 0
 212             || strcmp (result, "0x3p-1 33") == 0
 213             || strcmp (result, "0x6p-2 33") == 0
 214             || strcmp (result, "0xcp-3 33") == 0);
 215     ASSERT (retval == strlen (result));
 216     free (result);
 217   }
 218
 219   { /* Rounding with precision 0.  */
 220     char *result;
 221     int retval =
 222       my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
 223     ASSERT (result != NULL);
 224     ASSERT (strcmp (result, "0x2p+0 33") == 0
 225             || strcmp (result, "0x3p-1 33") == 0
 226             || strcmp (result, "0x6p-2 33") == 0
 227             || strcmp (result, "0xcp-3 33") == 0);
 228     ASSERT (retval == strlen (result));
 229     free (result);
 230   }
 231
 232   { /* Rounding with precision 1.  */
 233     char *result;
 234     int retval =
 235       my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
 236     ASSERT (result != NULL);
 237     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 238             || strcmp (result, "0x3.0p-1 33") == 0
 239             || strcmp (result, "0x6.1p-2 33") == 0
 240             || strcmp (result, "0xc.1p-3 33") == 0);
 241     ASSERT (retval == strlen (result));
 242     free (result);
 243   }
 244
 245   { /* Rounding with precision 2.  */
 246     char *result;
 247     int retval =
 248       my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
 249     ASSERT (result != NULL);
 250     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 251             || strcmp (result, "0x3.05p-1 33") == 0
 252             || strcmp (result, "0x6.0ap-2 33") == 0
 253             || strcmp (result, "0xc.14p-3 33") == 0);
 254     ASSERT (retval == strlen (result));
 255     free (result);
 256   }
 257
 258   { /* Rounding with precision 3.  */
 259     char *result;
 260     int retval =
 261       my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
 262     ASSERT (result != NULL);
 263     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 264             || strcmp (result, "0x3.052p-1 33") == 0
 265             || strcmp (result, "0x6.0a4p-2 33") == 0
 266             || strcmp (result, "0xc.148p-3 33") == 0);
 267     ASSERT (retval == strlen (result));
 268     free (result);
 269   }
 270
 271   { /* Rounding can turn a ...FFF into a ...000.  */
 272     char *result;
 273     int retval =
 274       my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
 275     ASSERT (result != NULL);
 276     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 277             || strcmp (result, "0x3.000p-1 33") == 0
 278             || strcmp (result, "0x6.000p-2 33") == 0
 279             || strcmp (result, "0xc.000p-3 33") == 0);
 280     ASSERT (retval == strlen (result));
 281     free (result);
 282   }
 283
 284   { /* Rounding can turn a ...FFF into a ...000.
 285        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 286     char *result;
 287     int retval =
 288       my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
 289     ASSERT (result != NULL);
 290     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 291             || strcmp (result, "0x2.0p+0 33") == 0
 292             || strcmp (result, "0x4.0p-1 33") == 0
 293             || strcmp (result, "0x8.0p-2 33") == 0);
 294     ASSERT (retval == strlen (result));
 295     free (result);
 296   }
 297
 298   { /* Width.  */
 299     char *result;
 300     int retval =
 301       my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
 302     ASSERT (result != NULL);
 303     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 304             || strcmp (result, "  0x3.8p-1 33") == 0
 305             || strcmp (result, "    0x7p-2 33") == 0
 306             || strcmp (result, "    0xep-3 33") == 0);
 307     ASSERT (retval == strlen (result));
 308     free (result);
 309   }
 310
 311   { /* Small precision.  */
 312     char *result;
 313     int retval =
 314       my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
 315     ASSERT (result != NULL);
 316     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 317             || strcmp (result, "0x3.8000000000p-1 33") == 0
 318             || strcmp (result, "0x7.0000000000p-2 33") == 0
 319             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 320     ASSERT (retval == strlen (result));
 321     free (result);
 322   }
 323
 324   { /* Large precision.  */
 325     char *result;
 326     int retval =
 327       my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
 328     ASSERT (result != NULL);
 329     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 330             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 331             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 332             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 333     ASSERT (retval == strlen (result));
 334     free (result);
 335   }
 336
 337   { /* FLAG_LEFT.  */
 338     char *result;
 339     int retval =
 340       my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
 341     ASSERT (result != NULL);
 342     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 343             || strcmp (result, "0x3.8p-1   33") == 0
 344             || strcmp (result, "0x7p-2     33") == 0
 345             || strcmp (result, "0xep-3     33") == 0);
 346     ASSERT (retval == strlen (result));
 347     free (result);
 348   }
 349
 350   { /* FLAG_SHOWSIGN.  */
 351     char *result;
 352     int retval =
 353       my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
 354     ASSERT (result != NULL);
 355     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 356             || strcmp (result, "+0x3.8p-1 33") == 0
 357             || strcmp (result, "+0x7p-2 33") == 0
 358             || strcmp (result, "+0xep-3 33") == 0);
 359     ASSERT (retval == strlen (result));
 360     free (result);
 361   }
 362
 363   { /* FLAG_SPACE.  */
 364     char *result;
 365     int retval =
 366       my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
 367     ASSERT (result != NULL);
 368     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 369             || strcmp (result, " 0x3.8p-1 33") == 0
 370             || strcmp (result, " 0x7p-2 33") == 0
 371             || strcmp (result, " 0xep-3 33") == 0);
 372     ASSERT (retval == strlen (result));
 373     free (result);
 374   }
 375
 376   { /* FLAG_ALT.  */
 377     char *result;
 378     int retval =
 379       my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
 380     ASSERT (result != NULL);
 381     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 382             || strcmp (result, "0x3.8p-1 33") == 0
 383             || strcmp (result, "0x7.p-2 33") == 0
 384             || strcmp (result, "0xe.p-3 33") == 0);
 385     ASSERT (retval == strlen (result));
 386     free (result);
 387   }
 388
 389   { /* FLAG_ALT.  */
 390     char *result;
 391     int retval =
 392       my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
 393     ASSERT (result != NULL);
 394     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 395             || strcmp (result, "0x2.p-1 33") == 0
 396             || strcmp (result, "0x4.p-2 33") == 0
 397             || strcmp (result, "0x8.p-3 33") == 0);
 398     ASSERT (retval == strlen (result));
 399     free (result);
 400   }
 401
 402   { /* FLAG_ZERO with finite number.  */
 403     char *result;
 404     int retval =
 405       my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
 406     ASSERT (result != NULL);
 407     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 408             || strcmp (result, "0x003.8p-1 33") == 0
 409             || strcmp (result, "0x00007p-2 33") == 0
 410             || strcmp (result, "0x0000ep-3 33") == 0);
 411     ASSERT (retval == strlen (result));
 412     free (result);
 413   }
 414
 415   { /* FLAG_ZERO with infinite number.  */
 416     char *result;
 417     int retval =
 418       my_asprintf (&result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 419     ASSERT (result != NULL);
 420     /* "0000000inf 33" is not a valid result; see
 421        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 422     ASSERT (strcmp (result, "       inf 33") == 0);
 423     ASSERT (retval == strlen (result));
 424     free (result);
 425   }
 426
 427   { /* FLAG_ZERO with NaN.  */
 428     char *result;
 429     int retval =
 430       my_asprintf (&result, "%010a %d", NaN (), 33, 44, 55);
 431     ASSERT (result != NULL);
 432     /* "0000000nan 33" is not a valid result; see
 433        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 434     ASSERT (strcmp (result, "       nan 33") == 0);
 435     ASSERT (retval == strlen (result));
 436     free (result);
 437   }
 438
 439   { /* A positive number.  */
 440     char *result;
 441     int retval =
 442       my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
 443     ASSERT (result != NULL);
 444     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 445             || strcmp (result, "0x3.244p+0 33") == 0
 446             || strcmp (result, "0x6.488p-1 33") == 0
 447             || strcmp (result, "0xc.91p-2 33") == 0);
 448     ASSERT (retval == strlen (result));
 449     free (result);
 450   }
 451
 452   { /* A negative number.  */
 453     char *result;
 454     int retval =
 455       my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
 456     ASSERT (result != NULL);
 457     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 458             || strcmp (result, "-0X3.244P+0 33") == 0
 459             || strcmp (result, "-0X6.488P-1 33") == 0
 460             || strcmp (result, "-0XC.91P-2 33") == 0);
 461     ASSERT (retval == strlen (result));
 462     free (result);
 463   }
 464
 465   { /* Positive zero.  */
 466     char *result;
 467     int retval =
 468       my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
 469     ASSERT (result != NULL);
 470     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 471     ASSERT (retval == strlen (result));
 472     free (result);
 473   }
 474
 475   { /* Negative zero.  */
 476     char *result;
 477     int retval =
 478       my_asprintf (&result, "%La %d", -0.0L, 33, 44, 55);
 479     ASSERT (result != NULL);
 480     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 481     ASSERT (retval == strlen (result));
 482     free (result);
 483   }
 484
 485   { /* Positive infinity.  */
 486     char *result;
 487     int retval =
 488       my_asprintf (&result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
 489     ASSERT (result != NULL);
 490     ASSERT (strcmp (result, "inf 33") == 0);
 491     ASSERT (retval == strlen (result));
 492     free (result);
 493   }
 494
 495   { /* Negative infinity.  */
 496     char *result;
 497     int retval =
 498       my_asprintf (&result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
 499     ASSERT (result != NULL);
 500     ASSERT (strcmp (result, "-inf 33") == 0);
 501     ASSERT (retval == strlen (result));
 502     free (result);
 503   }
 504
 505   { /* NaN.  */
 506     char *result;
 507     int retval =
 508       my_asprintf (&result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
 509     ASSERT (result != NULL);
 510     ASSERT (strcmp (result, "nan 33") == 0);
 511     ASSERT (retval == strlen (result));
 512     free (result);
 513   }
 514
 515   { /* Rounding near the decimal point.  */
 516     char *result;
 517     int retval =
 518       my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
 519     ASSERT (result != NULL);
 520     ASSERT (strcmp (result, "0x2p+0 33") == 0
 521             || strcmp (result, "0x3p-1 33") == 0
 522             || strcmp (result, "0x6p-2 33") == 0
 523             || strcmp (result, "0xcp-3 33") == 0);
 524     ASSERT (retval == strlen (result));
 525     free (result);
 526   }
 527
 528   { /* Rounding with precision 0.  */
 529     char *result;
 530     int retval =
 531       my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
 532     ASSERT (result != NULL);
 533     ASSERT (strcmp (result, "0x2p+0 33") == 0
 534             || strcmp (result, "0x3p-1 33") == 0
 535             || strcmp (result, "0x6p-2 33") == 0
 536             || strcmp (result, "0xcp-3 33") == 0);
 537     ASSERT (retval == strlen (result));
 538     free (result);
 539   }
 540
 541   { /* Rounding with precision 1.  */
 542     char *result;
 543     int retval =
 544       my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
 545     ASSERT (result != NULL);
 546     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 547             || strcmp (result, "0x3.0p-1 33") == 0
 548             || strcmp (result, "0x6.1p-2 33") == 0
 549             || strcmp (result, "0xc.1p-3 33") == 0);
 550     ASSERT (retval == strlen (result));
 551     free (result);
 552   }
 553
 554   { /* Rounding with precision 2.  */
 555     char *result;
 556     int retval =
 557       my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
 558     ASSERT (result != NULL);
 559     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 560             || strcmp (result, "0x3.05p-1 33") == 0
 561             || strcmp (result, "0x6.0ap-2 33") == 0
 562             || strcmp (result, "0xc.14p-3 33") == 0);
 563     ASSERT (retval == strlen (result));
 564     free (result);
 565   }
 566
 567   { /* Rounding with precision 3.  */
 568     char *result;
 569     int retval =
 570       my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
 571     ASSERT (result != NULL);
 572     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 573             || strcmp (result, "0x3.052p-1 33") == 0
 574             || strcmp (result, "0x6.0a4p-2 33") == 0
 575             || strcmp (result, "0xc.148p-3 33") == 0);
 576     ASSERT (retval == strlen (result));
 577     free (result);
 578   }
 579
 580   { /* Rounding can turn a ...FFF into a ...000.  */
 581     char *result;
 582     int retval =
 583       my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
 584     ASSERT (result != NULL);
 585     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 586             || strcmp (result, "0x3.000p-1 33") == 0
 587             || strcmp (result, "0x6.000p-2 33") == 0
 588             || strcmp (result, "0xc.000p-3 33") == 0);
 589     ASSERT (retval == strlen (result));
 590     free (result);
 591   }
 592
 593   { /* Rounding can turn a ...FFF into a ...000.
 594        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 595        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 596     char *result;
 597     int retval =
 598       my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
 599     ASSERT (result != NULL);
 600     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 601             || strcmp (result, "0x2.0p+0 33") == 0
 602             || strcmp (result, "0x4.0p-1 33") == 0
 603             || strcmp (result, "0x8.0p-2 33") == 0);
 604     ASSERT (retval == strlen (result));
 605     free (result);
 606   }
 607
 608   { /* Width.  */
 609     char *result;
 610     int retval =
 611       my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
 612     ASSERT (result != NULL);
 613     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 614             || strcmp (result, "  0x3.8p-1 33") == 0
 615             || strcmp (result, "    0x7p-2 33") == 0
 616             || strcmp (result, "    0xep-3 33") == 0);
 617     ASSERT (retval == strlen (result));
 618     free (result);
 619   }
 620
 621   { /* Small precision.  */
 622     char *result;
 623     int retval =
 624       my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
 625     ASSERT (result != NULL);
 626     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 627             || strcmp (result, "0x3.8000000000p-1 33") == 0
 628             || strcmp (result, "0x7.0000000000p-2 33") == 0
 629             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 630     ASSERT (retval == strlen (result));
 631     free (result);
 632   }
 633
 634   { /* Large precision.  */
 635     char *result;
 636     int retval =
 637       my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
 638     ASSERT (result != NULL);
 639     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 640             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 641             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 642             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 643     ASSERT (retval == strlen (result));
 644     free (result);
 645   }
 646
 647   { /* FLAG_LEFT.  */
 648     char *result;
 649     int retval =
 650       my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
 651     ASSERT (result != NULL);
 652     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 653             || strcmp (result, "0x3.8p-1   33") == 0
 654             || strcmp (result, "0x7p-2     33") == 0
 655             || strcmp (result, "0xep-3     33") == 0);
 656     ASSERT (retval == strlen (result));
 657     free (result);
 658   }
 659
 660   { /* FLAG_SHOWSIGN.  */
 661     char *result;
 662     int retval =
 663       my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
 664     ASSERT (result != NULL);
 665     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 666             || strcmp (result, "+0x3.8p-1 33") == 0
 667             || strcmp (result, "+0x7p-2 33") == 0
 668             || strcmp (result, "+0xep-3 33") == 0);
 669     ASSERT (retval == strlen (result));
 670     free (result);
 671   }
 672
 673   { /* FLAG_SPACE.  */
 674     char *result;
 675     int retval =
 676       my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
 677     ASSERT (result != NULL);
 678     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 679             || strcmp (result, " 0x3.8p-1 33") == 0
 680             || strcmp (result, " 0x7p-2 33") == 0
 681             || strcmp (result, " 0xep-3 33") == 0);
 682     ASSERT (retval == strlen (result));
 683     free (result);
 684   }
 685
 686   { /* FLAG_ALT.  */
 687     char *result;
 688     int retval =
 689       my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
 690     ASSERT (result != NULL);
 691     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 692             || strcmp (result, "0x3.8p-1 33") == 0
 693             || strcmp (result, "0x7.p-2 33") == 0
 694             || strcmp (result, "0xe.p-3 33") == 0);
 695     ASSERT (retval == strlen (result));
 696     free (result);
 697   }
 698
 699   { /* FLAG_ALT.  */
 700     char *result;
 701     int retval =
 702       my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
 703     ASSERT (result != NULL);
 704     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 705             || strcmp (result, "0x2.p-1 33") == 0
 706             || strcmp (result, "0x4.p-2 33") == 0
 707             || strcmp (result, "0x8.p-3 33") == 0);
 708     ASSERT (retval == strlen (result));
 709     free (result);
 710   }
 711
 712   { /* FLAG_ZERO with finite number.  */
 713     char *result;
 714     int retval =
 715       my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
 716     ASSERT (result != NULL);
 717     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 718             || strcmp (result, "0x003.8p-1 33") == 0
 719             || strcmp (result, "0x00007p-2 33") == 0
 720             || strcmp (result, "0x0000ep-3 33") == 0);
 721     ASSERT (retval == strlen (result));
 722     free (result);
 723   }
 724
 725   { /* FLAG_ZERO with infinite number.  */
 726     char *result;
 727     int retval =
 728       my_asprintf (&result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 729     ASSERT (result != NULL);
 730     /* "0000000inf 33" is not a valid result; see
 731        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 732     ASSERT (strcmp (result, "       inf 33") == 0);
 733     ASSERT (retval == strlen (result));
 734     free (result);
 735   }
 736
 737   { /* FLAG_ZERO with NaN.  */
 738     char *result;
 739     int retval =
 740       my_asprintf (&result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 741     ASSERT (result != NULL);
 742     /* "0000000nan 33" is not a valid result; see
 743        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 744     ASSERT (strcmp (result, "       nan 33") == 0);
 745     ASSERT (retval == strlen (result));
 746     free (result);
 747   }
 748
 749   /* Test the support of the %f format directive.  */
 750
 751   { /* A positive number.  */
 752     char *result;
 753     int retval =
 754       my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
 755     ASSERT (result != NULL);
 756     ASSERT (strcmp (result, "12.750000 33") == 0);
 757     ASSERT (retval == strlen (result));
 758     free (result);
 759   }
 760
 761   { /* A larger positive number.  */
 762     char *result;
 763     int retval =
 764       my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
 765     ASSERT (result != NULL);
 766     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 767     ASSERT (retval == strlen (result));
 768     free (result);
 769   }
 770
 771   { /* Small and large positive numbers.  */
 772     static struct { double value; const char *string; } data[] =
 773       {
 774         { 1.234321234321234e-37, "0.000000" },
 775         { 1.234321234321234e-36, "0.000000" },
 776         { 1.234321234321234e-35, "0.000000" },
 777         { 1.234321234321234e-34, "0.000000" },
 778         { 1.234321234321234e-33, "0.000000" },
 779         { 1.234321234321234e-32, "0.000000" },
 780         { 1.234321234321234e-31, "0.000000" },
 781         { 1.234321234321234e-30, "0.000000" },
 782         { 1.234321234321234e-29, "0.000000" },
 783         { 1.234321234321234e-28, "0.000000" },
 784         { 1.234321234321234e-27, "0.000000" },
 785         { 1.234321234321234e-26, "0.000000" },
 786         { 1.234321234321234e-25, "0.000000" },
 787         { 1.234321234321234e-24, "0.000000" },
 788         { 1.234321234321234e-23, "0.000000" },
 789         { 1.234321234321234e-22, "0.000000" },
 790         { 1.234321234321234e-21, "0.000000" },
 791         { 1.234321234321234e-20, "0.000000" },
 792         { 1.234321234321234e-19, "0.000000" },
 793         { 1.234321234321234e-18, "0.000000" },
 794         { 1.234321234321234e-17, "0.000000" },
 795         { 1.234321234321234e-16, "0.000000" },
 796         { 1.234321234321234e-15, "0.000000" },
 797         { 1.234321234321234e-14, "0.000000" },
 798         { 1.234321234321234e-13, "0.000000" },
 799         { 1.234321234321234e-12, "0.000000" },
 800         { 1.234321234321234e-11, "0.000000" },
 801         { 1.234321234321234e-10, "0.000000" },
 802         { 1.234321234321234e-9, "0.000000" },
 803         { 1.234321234321234e-8, "0.000000" },
 804         { 1.234321234321234e-7, "0.000000" },
 805         { 1.234321234321234e-6, "0.000001" },
 806         { 1.234321234321234e-5, "0.000012" },
 807         { 1.234321234321234e-4, "0.000123" },
 808         { 1.234321234321234e-3, "0.001234" },
 809         { 1.234321234321234e-2, "0.012343" },
 810         { 1.234321234321234e-1, "0.123432" },
 811         { 1.234321234321234, "1.234321" },
 812         { 1.234321234321234e1, "12.343212" },
 813         { 1.234321234321234e2, "123.432123" },
 814         { 1.234321234321234e3, "1234.321234" },
 815         { 1.234321234321234e4, "12343.212343" },
 816         { 1.234321234321234e5, "123432.123432" },
 817         { 1.234321234321234e6, "1234321.234321" },
 818         { 1.234321234321234e7, "12343212.343212" },
 819         { 1.234321234321234e8, "123432123.432123" },
 820         { 1.234321234321234e9, "1234321234.321234" },
 821         { 1.234321234321234e10, "12343212343.2123**" },
 822         { 1.234321234321234e11, "123432123432.123***" },
 823         { 1.234321234321234e12, "1234321234321.23****" },
 824         { 1.234321234321234e13, "12343212343212.3*****" },
 825         { 1.234321234321234e14, "123432123432123.******" },
 826         { 1.234321234321234e15, "1234321234321234.000000" },
 827         { 1.234321234321234e16, "123432123432123**.000000" },
 828         { 1.234321234321234e17, "123432123432123***.000000" },
 829         { 1.234321234321234e18, "123432123432123****.000000" },
 830         { 1.234321234321234e19, "123432123432123*****.000000" },
 831         { 1.234321234321234e20, "123432123432123******.000000" },
 832         { 1.234321234321234e21, "123432123432123*******.000000" },
 833         { 1.234321234321234e22, "123432123432123********.000000" },
 834         { 1.234321234321234e23, "123432123432123*********.000000" },
 835         { 1.234321234321234e24, "123432123432123**********.000000" },
 836         { 1.234321234321234e25, "123432123432123***********.000000" },
 837         { 1.234321234321234e26, "123432123432123************.000000" },
 838         { 1.234321234321234e27, "123432123432123*************.000000" },
 839         { 1.234321234321234e28, "123432123432123**************.000000" },
 840         { 1.234321234321234e29, "123432123432123***************.000000" },
 841         { 1.234321234321234e30, "123432123432123****************.000000" },
 842         { 1.234321234321234e31, "123432123432123*****************.000000" },
 843         { 1.234321234321234e32, "123432123432123******************.000000" },
 844         { 1.234321234321234e33, "123432123432123*******************.000000" },
 845         { 1.234321234321234e34, "123432123432123********************.000000" },
 846         { 1.234321234321234e35, "123432123432123*********************.000000" },
 847         { 1.234321234321234e36, "123432123432123**********************.000000" }
 848       };
 849     size_t k;
 850     for (k = 0; k < SIZEOF (data); k++)
 851       {
 852         char *result;
 853         int retval =
 854           my_asprintf (&result, "%f", data[k].value);
 855         ASSERT (result != NULL);
 856         ASSERT (strmatch (data[k].string, result));
 857         ASSERT (retval == strlen (result));
 858         free (result);
 859       }
 860   }
 861
 862   { /* A negative number.  */
 863     char *result;
 864     int retval =
 865       my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
 866     ASSERT (result != NULL);
 867     ASSERT (strcmp (result, "-0.031250 33") == 0);
 868     ASSERT (retval == strlen (result));
 869     free (result);
 870   }
 871
 872   { /* Positive zero.  */
 873     char *result;
 874     int retval =
 875       my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
 876     ASSERT (result != NULL);
 877     ASSERT (strcmp (result, "0.000000 33") == 0);
 878     ASSERT (retval == strlen (result));
 879     free (result);
 880   }
 881
 882   { /* Negative zero.  */
 883     char *result;
 884     int retval =
 885       my_asprintf (&result, "%f %d", -0.0, 33, 44, 55);
 886     ASSERT (result != NULL);
 887     ASSERT (strcmp (result, "-0.000000 33") == 0);
 888     ASSERT (retval == strlen (result));
 889     free (result);
 890   }
 891
 892   { /* Positive infinity.  */
 893     char *result;
 894     int retval =
 895       my_asprintf (&result, "%f %d", 1.0 / 0.0, 33, 44, 55);
 896     ASSERT (result != NULL);
 897     ASSERT (strcmp (result, "inf 33") == 0
 898             || strcmp (result, "infinity 33") == 0);
 899     ASSERT (retval == strlen (result));
 900     free (result);
 901   }
 902
 903   { /* Negative infinity.  */
 904     char *result;
 905     int retval =
 906       my_asprintf (&result, "%f %d", -1.0 / 0.0, 33, 44, 55);
 907     ASSERT (result != NULL);
 908     ASSERT (strcmp (result, "-inf 33") == 0
 909             || strcmp (result, "-infinity 33") == 0);
 910     ASSERT (retval == strlen (result));
 911     free (result);
 912   }
 913
 914   { /* NaN.  */
 915     char *result;
 916     int retval =
 917       my_asprintf (&result, "%f %d", NaN (), 33, 44, 55);
 918     ASSERT (result != NULL);
 919     ASSERT (strcmp (result, "nan 33") == 0);
 920     ASSERT (retval == strlen (result));
 921     free (result);
 922   }
 923
 924   { /* Width.  */
 925     char *result;
 926     int retval =
 927       my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
 928     ASSERT (result != NULL);
 929     ASSERT (strcmp (result, "  1.750000 33") == 0);
 930     ASSERT (retval == strlen (result));
 931     free (result);
 932   }
 933
 934   { /* FLAG_LEFT.  */
 935     char *result;
 936     int retval =
 937       my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
 938     ASSERT (result != NULL);
 939     ASSERT (strcmp (result, "1.750000   33") == 0);
 940     ASSERT (retval == strlen (result));
 941     free (result);
 942   }
 943
 944   { /* FLAG_SHOWSIGN.  */
 945     char *result;
 946     int retval =
 947       my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
 948     ASSERT (result != NULL);
 949     ASSERT (strcmp (result, "+1.750000 33") == 0);
 950     ASSERT (retval == strlen (result));
 951     free (result);
 952   }
 953
 954   { /* FLAG_SPACE.  */
 955     char *result;
 956     int retval =
 957       my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
 958     ASSERT (result != NULL);
 959     ASSERT (strcmp (result, " 1.750000 33") == 0);
 960     ASSERT (retval == strlen (result));
 961     free (result);
 962   }
 963
 964   { /* FLAG_ALT.  */
 965     char *result;
 966     int retval =
 967       my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
 968     ASSERT (result != NULL);
 969     ASSERT (strcmp (result, "1.750000 33") == 0);
 970     ASSERT (retval == strlen (result));
 971     free (result);
 972   }
 973
 974   { /* FLAG_ALT.  */
 975     char *result;
 976     int retval =
 977       my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
 978     ASSERT (result != NULL);
 979     ASSERT (strcmp (result, "2. 33") == 0);
 980     ASSERT (retval == strlen (result));
 981     free (result);
 982   }
 983
 984   { /* FLAG_ZERO with finite number.  */
 985     char *result;
 986     int retval =
 987       my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
 988     ASSERT (result != NULL);
 989     ASSERT (strcmp (result, "00001234.000000 33") == 0);
 990     ASSERT (retval == strlen (result));
 991     free (result);
 992   }
 993
 994   { /* FLAG_ZERO with infinite number.  */
 995     char *result;
 996     int retval =
 997       my_asprintf (&result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
 998     ASSERT (result != NULL);
 999     ASSERT (strcmp (result, "           -inf 33") == 0
1000             || strcmp (result, "      -infinity 33") == 0);
1001     ASSERT (retval == strlen (result));
1002     free (result);
1003   }
1004
1005   { /* FLAG_ZERO with NaN.  */
1006     char *result;
1007     int retval =
1008       my_asprintf (&result, "%015f %d", NaN (), 33, 44, 55);
1009     ASSERT (result != NULL);
1010     ASSERT (strcmp (result, "            nan 33") == 0);
1011     ASSERT (retval == strlen (result));
1012     free (result);
1013   }
1014
1015   { /* Precision.  */
1016     char *result;
1017     int retval =
1018       my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
1019     ASSERT (result != NULL);
1020     ASSERT (strcmp (result, "1234 33") == 0);
1021     ASSERT (retval == strlen (result));
1022     free (result);
1023   }
1024
1025   { /* A positive number.  */
1026     char *result;
1027     int retval =
1028       my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
1029     ASSERT (result != NULL);
1030     ASSERT (strcmp (result, "12.750000 33") == 0);
1031     ASSERT (retval == strlen (result));
1032     free (result);
1033   }
1034
1035   { /* A larger positive number.  */
1036     char *result;
1037     int retval =
1038       my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
1039     ASSERT (result != NULL);
1040     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1041     ASSERT (retval == strlen (result));
1042     free (result);
1043   }
1044
1045   { /* Small and large positive numbers.  */
1046     static struct { long double value; const char *string; } data[] =
1047       {
1048         { 1.234321234321234e-37L, "0.000000" },
1049         { 1.234321234321234e-36L, "0.000000" },
1050         { 1.234321234321234e-35L, "0.000000" },
1051         { 1.234321234321234e-34L, "0.000000" },
1052         { 1.234321234321234e-33L, "0.000000" },
1053         { 1.234321234321234e-32L, "0.000000" },
1054         { 1.234321234321234e-31L, "0.000000" },
1055         { 1.234321234321234e-30L, "0.000000" },
1056         { 1.234321234321234e-29L, "0.000000" },
1057         { 1.234321234321234e-28L, "0.000000" },
1058         { 1.234321234321234e-27L, "0.000000" },
1059         { 1.234321234321234e-26L, "0.000000" },
1060         { 1.234321234321234e-25L, "0.000000" },
1061         { 1.234321234321234e-24L, "0.000000" },
1062         { 1.234321234321234e-23L, "0.000000" },
1063         { 1.234321234321234e-22L, "0.000000" },
1064         { 1.234321234321234e-21L, "0.000000" },
1065         { 1.234321234321234e-20L, "0.000000" },
1066         { 1.234321234321234e-19L, "0.000000" },
1067         { 1.234321234321234e-18L, "0.000000" },
1068         { 1.234321234321234e-17L, "0.000000" },
1069         { 1.234321234321234e-16L, "0.000000" },
1070         { 1.234321234321234e-15L, "0.000000" },
1071         { 1.234321234321234e-14L, "0.000000" },
1072         { 1.234321234321234e-13L, "0.000000" },
1073         { 1.234321234321234e-12L, "0.000000" },
1074         { 1.234321234321234e-11L, "0.000000" },
1075         { 1.234321234321234e-10L, "0.000000" },
1076         { 1.234321234321234e-9L, "0.000000" },
1077         { 1.234321234321234e-8L, "0.000000" },
1078         { 1.234321234321234e-7L, "0.000000" },
1079         { 1.234321234321234e-6L, "0.000001" },
1080         { 1.234321234321234e-5L, "0.000012" },
1081         { 1.234321234321234e-4L, "0.000123" },
1082         { 1.234321234321234e-3L, "0.001234" },
1083         { 1.234321234321234e-2L, "0.012343" },
1084         { 1.234321234321234e-1L, "0.123432" },
1085         { 1.234321234321234L, "1.234321" },
1086         { 1.234321234321234e1L, "12.343212" },
1087         { 1.234321234321234e2L, "123.432123" },
1088         { 1.234321234321234e3L, "1234.321234" },
1089         { 1.234321234321234e4L, "12343.212343" },
1090         { 1.234321234321234e5L, "123432.123432" },
1091         { 1.234321234321234e6L, "1234321.234321" },
1092         { 1.234321234321234e7L, "12343212.343212" },
1093         { 1.234321234321234e8L, "123432123.432123" },
1094         { 1.234321234321234e9L, "1234321234.321234" },
1095         { 1.234321234321234e10L, "12343212343.2123**" },
1096         { 1.234321234321234e11L, "123432123432.123***" },
1097         { 1.234321234321234e12L, "1234321234321.23****" },
1098         { 1.234321234321234e13L, "12343212343212.3*****" },
1099         { 1.234321234321234e14L, "123432123432123.******" },
1100         { 1.234321234321234e15L, "1234321234321234.000000" },
1101         { 1.234321234321234e16L, "123432123432123**.000000" },
1102         { 1.234321234321234e17L, "123432123432123***.000000" },
1103         { 1.234321234321234e18L, "123432123432123****.000000" },
1104         { 1.234321234321234e19L, "123432123432123*****.000000" },
1105         { 1.234321234321234e20L, "123432123432123******.000000" },
1106         { 1.234321234321234e21L, "123432123432123*******.000000" },
1107         { 1.234321234321234e22L, "123432123432123********.000000" },
1108         { 1.234321234321234e23L, "123432123432123*********.000000" },
1109         { 1.234321234321234e24L, "123432123432123**********.000000" },
1110         { 1.234321234321234e25L, "123432123432123***********.000000" },
1111         { 1.234321234321234e26L, "123432123432123************.000000" },
1112         { 1.234321234321234e27L, "123432123432123*************.000000" },
1113         { 1.234321234321234e28L, "123432123432123**************.000000" },
1114         { 1.234321234321234e29L, "123432123432123***************.000000" },
1115         { 1.234321234321234e30L, "123432123432123****************.000000" },
1116         { 1.234321234321234e31L, "123432123432123*****************.000000" },
1117         { 1.234321234321234e32L, "123432123432123******************.000000" },
1118         { 1.234321234321234e33L, "123432123432123*******************.000000" },
1119         { 1.234321234321234e34L, "123432123432123********************.000000" },
1120         { 1.234321234321234e35L, "123432123432123*********************.000000" },
1121         { 1.234321234321234e36L, "123432123432123**********************.000000" }
1122       };
1123     size_t k;
1124     for (k = 0; k < SIZEOF (data); k++)
1125       {
1126         char *result;
1127         int retval =
1128           my_asprintf (&result, "%Lf", data[k].value);
1129         ASSERT (result != NULL);
1130         ASSERT (strmatch (data[k].string, result));
1131         ASSERT (retval == strlen (result));
1132         free (result);
1133       }
1134   }
1135
1136   { /* A negative number.  */
1137     char *result;
1138     int retval =
1139       my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
1140     ASSERT (result != NULL);
1141     ASSERT (strcmp (result, "-0.031250 33") == 0);
1142     ASSERT (retval == strlen (result));
1143     free (result);
1144   }
1145
1146   { /* Positive zero.  */
1147     char *result;
1148     int retval =
1149       my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
1150     ASSERT (result != NULL);
1151     ASSERT (strcmp (result, "0.000000 33") == 0);
1152     ASSERT (retval == strlen (result));
1153     free (result);
1154   }
1155
1156   { /* Negative zero.  */
1157     char *result;
1158     int retval =
1159       my_asprintf (&result, "%Lf %d", -0.0L, 33, 44, 55);
1160     ASSERT (result != NULL);
1161     ASSERT (strcmp (result, "-0.000000 33") == 0);
1162     ASSERT (retval == strlen (result));
1163     free (result);
1164   }
1165
1166   { /* Positive infinity.  */
1167     char *result;
1168     int retval =
1169       my_asprintf (&result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1170     ASSERT (result != NULL);
1171     ASSERT (strcmp (result, "inf 33") == 0
1172             || strcmp (result, "infinity 33") == 0);
1173     ASSERT (retval == strlen (result));
1174     free (result);
1175   }
1176
1177   { /* Negative infinity.  */
1178     char *result;
1179     int retval =
1180       my_asprintf (&result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1181     ASSERT (result != NULL);
1182     ASSERT (strcmp (result, "-inf 33") == 0
1183             || strcmp (result, "-infinity 33") == 0);
1184     ASSERT (retval == strlen (result));
1185     free (result);
1186   }
1187
1188   { /* NaN.  */
1189     static long double zero = 0.0L;
1190     char *result;
1191     int retval =
1192       my_asprintf (&result, "%Lf %d", zero / zero, 33, 44, 55);
1193     ASSERT (result != NULL);
1194     ASSERT (strcmp (result, "nan 33") == 0);
1195     ASSERT (retval == strlen (result));
1196     free (result);
1197   }
1198
1199   { /* Width.  */
1200     char *result;
1201     int retval =
1202       my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
1203     ASSERT (result != NULL);
1204     ASSERT (strcmp (result, "  1.750000 33") == 0);
1205     ASSERT (retval == strlen (result));
1206     free (result);
1207   }
1208
1209   { /* FLAG_LEFT.  */
1210     char *result;
1211     int retval =
1212       my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
1213     ASSERT (result != NULL);
1214     ASSERT (strcmp (result, "1.750000   33") == 0);
1215     ASSERT (retval == strlen (result));
1216     free (result);
1217   }
1218
1219   { /* FLAG_SHOWSIGN.  */
1220     char *result;
1221     int retval =
1222       my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
1223     ASSERT (result != NULL);
1224     ASSERT (strcmp (result, "+1.750000 33") == 0);
1225     ASSERT (retval == strlen (result));
1226     free (result);
1227   }
1228
1229   { /* FLAG_SPACE.  */
1230     char *result;
1231     int retval =
1232       my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
1233     ASSERT (result != NULL);
1234     ASSERT (strcmp (result, " 1.750000 33") == 0);
1235     ASSERT (retval == strlen (result));
1236     free (result);
1237   }
1238
1239   { /* FLAG_ALT.  */
1240     char *result;
1241     int retval =
1242       my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
1243     ASSERT (result != NULL);
1244     ASSERT (strcmp (result, "1.750000 33") == 0);
1245     ASSERT (retval == strlen (result));
1246     free (result);
1247   }
1248
1249   { /* FLAG_ALT.  */
1250     char *result;
1251     int retval =
1252       my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
1253     ASSERT (result != NULL);
1254     ASSERT (strcmp (result, "2. 33") == 0);
1255     ASSERT (retval == strlen (result));
1256     free (result);
1257   }
1258
1259   { /* FLAG_ZERO with finite number.  */
1260     char *result;
1261     int retval =
1262       my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
1263     ASSERT (result != NULL);
1264     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1265     ASSERT (retval == strlen (result));
1266     free (result);
1267   }
1268
1269   { /* FLAG_ZERO with infinite number.  */
1270     char *result;
1271     int retval =
1272       my_asprintf (&result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1273     ASSERT (result != NULL);
1274     ASSERT (strcmp (result, "           -inf 33") == 0
1275             || strcmp (result, "      -infinity 33") == 0);
1276     ASSERT (retval == strlen (result));
1277     free (result);
1278   }
1279
1280   { /* FLAG_ZERO with NaN.  */
1281     static long double zero = 0.0L;
1282     char *result;
1283     int retval =
1284       my_asprintf (&result, "%015Lf %d", zero / zero, 33, 44, 55);
1285     ASSERT (result != NULL);
1286     ASSERT (strcmp (result, "            nan 33") == 0);
1287     ASSERT (retval == strlen (result));
1288     free (result);
1289   }
1290
1291   { /* Precision.  */
1292     char *result;
1293     int retval =
1294       my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
1295     ASSERT (result != NULL);
1296     ASSERT (strcmp (result, "1234 33") == 0);
1297     ASSERT (retval == strlen (result));
1298     free (result);
1299   }
1300
1301   /* Test the support of the %F format directive.  */
1302
1303   { /* A positive number.  */
1304     char *result;
1305     int retval =
1306       my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
1307     ASSERT (result != NULL);
1308     ASSERT (strcmp (result, "12.750000 33") == 0);
1309     ASSERT (retval == strlen (result));
1310     free (result);
1311   }
1312
1313   { /* A larger positive number.  */
1314     char *result;
1315     int retval =
1316       my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
1317     ASSERT (result != NULL);
1318     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1319     ASSERT (retval == strlen (result));
1320     free (result);
1321   }
1322
1323   { /* A negative number.  */
1324     char *result;
1325     int retval =
1326       my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
1327     ASSERT (result != NULL);
1328     ASSERT (strcmp (result, "-0.031250 33") == 0);
1329     ASSERT (retval == strlen (result));
1330     free (result);
1331   }
1332
1333   { /* Positive zero.  */
1334     char *result;
1335     int retval =
1336       my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
1337     ASSERT (result != NULL);
1338     ASSERT (strcmp (result, "0.000000 33") == 0);
1339     ASSERT (retval == strlen (result));
1340     free (result);
1341   }
1342
1343   { /* Negative zero.  */
1344     char *result;
1345     int retval =
1346       my_asprintf (&result, "%F %d", -0.0, 33, 44, 55);
1347     ASSERT (result != NULL);
1348     ASSERT (strcmp (result, "-0.000000 33") == 0);
1349     ASSERT (retval == strlen (result));
1350     free (result);
1351   }
1352
1353   { /* Positive infinity.  */
1354     char *result;
1355     int retval =
1356       my_asprintf (&result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1357     ASSERT (result != NULL);
1358     ASSERT (strcmp (result, "INF 33") == 0
1359             || strcmp (result, "INFINITY 33") == 0);
1360     ASSERT (retval == strlen (result));
1361     free (result);
1362   }
1363
1364   { /* Negative infinity.  */
1365     char *result;
1366     int retval =
1367       my_asprintf (&result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1368     ASSERT (result != NULL);
1369     ASSERT (strcmp (result, "-INF 33") == 0
1370             || strcmp (result, "-INFINITY 33") == 0);
1371     ASSERT (retval == strlen (result));
1372     free (result);
1373   }
1374
1375   { /* NaN.  */
1376     char *result;
1377     int retval =
1378       my_asprintf (&result, "%F %d", NaN (), 33, 44, 55);
1379     ASSERT (result != NULL);
1380     ASSERT (strcmp (result, "NAN 33") == 0);
1381     ASSERT (retval == strlen (result));
1382     free (result);
1383   }
1384
1385   { /* FLAG_ZERO.  */
1386     char *result;
1387     int retval =
1388       my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
1389     ASSERT (result != NULL);
1390     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1391     ASSERT (retval == strlen (result));
1392     free (result);
1393   }
1394
1395   { /* FLAG_ZERO with infinite number.  */
1396     char *result;
1397     int retval =
1398       my_asprintf (&result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1399     ASSERT (result != NULL);
1400     ASSERT (strcmp (result, "           -INF 33") == 0
1401             || strcmp (result, "      -INFINITY 33") == 0);
1402     ASSERT (retval == strlen (result));
1403     free (result);
1404   }
1405
1406   { /* Precision.  */
1407     char *result;
1408     int retval =
1409       my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
1410     ASSERT (result != NULL);
1411     ASSERT (strcmp (result, "1234 33") == 0);
1412     ASSERT (retval == strlen (result));
1413     free (result);
1414   }
1415
1416   { /* A positive number.  */
1417     char *result;
1418     int retval =
1419       my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
1420     ASSERT (result != NULL);
1421     ASSERT (strcmp (result, "12.750000 33") == 0);
1422     ASSERT (retval == strlen (result));
1423     free (result);
1424   }
1425
1426   { /* A larger positive number.  */
1427     char *result;
1428     int retval =
1429       my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
1430     ASSERT (result != NULL);
1431     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1432     ASSERT (retval == strlen (result));
1433     free (result);
1434   }
1435
1436   { /* A negative number.  */
1437     char *result;
1438     int retval =
1439       my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
1440     ASSERT (result != NULL);
1441     ASSERT (strcmp (result, "-0.031250 33") == 0);
1442     ASSERT (retval == strlen (result));
1443     free (result);
1444   }
1445
1446   { /* Positive zero.  */
1447     char *result;
1448     int retval =
1449       my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
1450     ASSERT (result != NULL);
1451     ASSERT (strcmp (result, "0.000000 33") == 0);
1452     ASSERT (retval == strlen (result));
1453     free (result);
1454   }
1455
1456   { /* Negative zero.  */
1457     char *result;
1458     int retval =
1459       my_asprintf (&result, "%LF %d", -0.0L, 33, 44, 55);
1460     ASSERT (result != NULL);
1461     ASSERT (strcmp (result, "-0.000000 33") == 0);
1462     ASSERT (retval == strlen (result));
1463     free (result);
1464   }
1465
1466   { /* Positive infinity.  */
1467     char *result;
1468     int retval =
1469       my_asprintf (&result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1470     ASSERT (result != NULL);
1471     ASSERT (strcmp (result, "INF 33") == 0
1472             || strcmp (result, "INFINITY 33") == 0);
1473     ASSERT (retval == strlen (result));
1474     free (result);
1475   }
1476
1477   { /* Negative infinity.  */
1478     char *result;
1479     int retval =
1480       my_asprintf (&result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1481     ASSERT (result != NULL);
1482     ASSERT (strcmp (result, "-INF 33") == 0
1483             || strcmp (result, "-INFINITY 33") == 0);
1484     ASSERT (retval == strlen (result));
1485     free (result);
1486   }
1487
1488   { /* NaN.  */
1489     static long double zero = 0.0L;
1490     char *result;
1491     int retval =
1492       my_asprintf (&result, "%LF %d", zero / zero, 33, 44, 55);
1493     ASSERT (result != NULL);
1494     ASSERT (strcmp (result, "NAN 33") == 0);
1495     ASSERT (retval == strlen (result));
1496     free (result);
1497   }
1498
1499   { /* FLAG_ZERO.  */
1500     char *result;
1501     int retval =
1502       my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
1503     ASSERT (result != NULL);
1504     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1505     ASSERT (retval == strlen (result));
1506     free (result);
1507   }
1508
1509   { /* FLAG_ZERO with infinite number.  */
1510     char *result;
1511     int retval =
1512       my_asprintf (&result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1513     ASSERT (result != NULL);
1514     ASSERT (strcmp (result, "           -INF 33") == 0
1515             || strcmp (result, "      -INFINITY 33") == 0);
1516     ASSERT (retval == strlen (result));
1517     free (result);
1518   }
1519
1520   { /* Precision.  */
1521     char *result;
1522     int retval =
1523       my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
1524     ASSERT (result != NULL);
1525     ASSERT (strcmp (result, "1234 33") == 0);
1526     ASSERT (retval == strlen (result));
1527     free (result);
1528   }
1529
1530   /* Test the support of the %n format directive.  */
1531
1532   {
1533     int count = -1;
1534     char *result;
1535     int retval =
1536       my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
1537     ASSERT (result != NULL);
1538     ASSERT (strcmp (result, "123 ") == 0);
1539     ASSERT (retval == strlen (result));
1540     ASSERT (count == 4);
1541     free (result);
1542   }
1543
1544   /* Test the support of the POSIX/XSI format strings with positions.  */
1545
1546   {
1547     char *result;
1548     int retval =
1549       my_asprintf (&result, "%2$d %1$d", 33, 55);
1550     ASSERT (result != NULL);
1551     ASSERT (strcmp (result, "55 33") == 0);
1552     ASSERT (retval == strlen (result));
1553     free (result);
1554   }
1555
1556   /* Test the support of the grouping flag.  */
1557
1558   {
1559     char *result;
1560     int retval =
1561       my_asprintf (&result, "%'d %d", 1234567, 99);
1562     ASSERT (result != NULL);
1563     ASSERT (result[strlen (result) - 1] == '9');
1564     ASSERT (retval == strlen (result));
1565     free (result);
1566   }
1567 }
1568
1569 static int
1570 my_asprintf (char **result, const char *format, ...)
1571 {
1572   va_list args;
1573   int ret;
1574
1575   va_start (args, format);
1576   ret = vasprintf (result, format, args);
1577   va_end (args);
1578   return ret;
1579 }
1580
1581 static void
1582 test_vasprintf ()
1583 {
1584   test_function (my_asprintf);
1585 }
1586
1587 static void
1588 test_asprintf ()
1589 {
1590   test_function (asprintf);
1591 }
1592
1593 int
1594 main (int argc, char *argv[])
1595 {
1596   test_vasprintf ();
1597   test_asprintf ();
1598   return 0;
1599 }