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