tests/test-vasnprintf-posix.c

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