tests/test-vasprintf-posix.c

   1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
   2    Copyright (C) 2007-2008 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 3 of the License, or
   7    (at your option) 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, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22
  23 #include <float.h>
  24 #include <stdarg.h>
  25 #include <stddef.h>
  26 #include <stdio.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "nan.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           fflush (stderr);                                                   \
  41           abort ();                                                          \
  42         }                                                                    \
  43     }                                                                        \
  44   while (0)
  45
  46 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0.  */
  47 static int
  48 have_minus_zero ()
  49 {
  50   static double plus_zero = 0.0;
  51   double minus_zero = - plus_zero;
  52   return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  53 }
  54
  55 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
  56    So we use -zero instead.  */
  57 double zerod = 0.0;
  58
  59 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
  60    So we use -zero instead.  */
  61 long double zerol = 0.0L;
  62
  63 /* Representation of an 80-bit 'long double' as an initializer for a sequence
  64    of 'unsigned int' words.  */
  65 #ifdef WORDS_BIGENDIAN
  66 # define LDBL80_WORDS(exponent,manthi,mantlo) \
  67     { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
  68       ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16),    \
  69       (unsigned int) (mantlo) << 16                                        \
  70     }
  71 #else
  72 # define LDBL80_WORDS(exponent,manthi,mantlo) \
  73     { mantlo, manthi, exponent }
  74 #endif
  75
  76 static int
  77 strmatch (const char *pattern, const char *string)
  78 {
  79   if (strlen (pattern) != strlen (string))
  80     return 0;
  81   for (; *pattern != '\0'; pattern++, string++)
  82     if (*pattern != '*' && *string != *pattern)
  83       return 0;
  84   return 1;
  85 }
  86
  87 /* Test whether string[start_index..end_index-1] is a valid textual
  88    representation of NaN.  */
  89 static int
  90 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
  91 {
  92   if (start_index < end_index)
  93     {
  94       if (string[start_index] == '-')
  95         start_index++;
  96       if (start_index + 3 <= end_index
  97           && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
  98         {
  99           start_index += 3;
 100           if (start_index == end_index
 101               || (string[start_index] == '(' && string[end_index - 1] == ')'))
 102             return 1;
 103         }
 104     }
 105   return 0;
 106 }
 107
 108 static void
 109 test_function (int (*my_asprintf) (char **, const char *, ...))
 110 {
 111   int repeat;
 112
 113   /* Test return value convention.  */
 114
 115   for (repeat = 0; repeat <= 8; repeat++)
 116     {
 117       char *result;
 118       int retval = asprintf (&result, "%d", 12345);
 119       ASSERT (retval == 5);
 120       ASSERT (result != NULL);
 121       ASSERT (strcmp (result, "12345") == 0);
 122       free (result);
 123     }
 124
 125   /* Test support of size specifiers as in C99.  */
 126
 127   {
 128     char *result;
 129     int retval =
 130       my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
 131     ASSERT (result != NULL);
 132     ASSERT (strcmp (result, "12345671 33") == 0);
 133     ASSERT (retval == strlen (result));
 134     free (result);
 135   }
 136
 137   {
 138     char *result;
 139     int retval =
 140       my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
 141     ASSERT (result != NULL);
 142     ASSERT (strcmp (result, "12345672 33") == 0);
 143     ASSERT (retval == strlen (result));
 144     free (result);
 145   }
 146
 147   {
 148     char *result;
 149     int retval =
 150       my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
 151     ASSERT (result != NULL);
 152     ASSERT (strcmp (result, "12345673 33") == 0);
 153     ASSERT (retval == strlen (result));
 154     free (result);
 155   }
 156
 157   {
 158     char *result;
 159     int retval =
 160       my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
 161     ASSERT (result != NULL);
 162     ASSERT (strcmp (result, "1.5 33") == 0);
 163     ASSERT (retval == strlen (result));
 164     free (result);
 165   }
 166
 167   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 168      output of floating-point numbers.  */
 169
 170   { /* A positive number.  */
 171     char *result;
 172     int retval =
 173       my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
 174     ASSERT (result != NULL);
 175     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 176             || strcmp (result, "0x3.244p+0 33") == 0
 177             || strcmp (result, "0x6.488p-1 33") == 0
 178             || strcmp (result, "0xc.91p-2 33") == 0);
 179     ASSERT (retval == strlen (result));
 180     free (result);
 181   }
 182
 183   { /* A negative number.  */
 184     char *result;
 185     int retval =
 186       my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
 187     ASSERT (result != NULL);
 188     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 189             || strcmp (result, "-0X3.244P+0 33") == 0
 190             || strcmp (result, "-0X6.488P-1 33") == 0
 191             || strcmp (result, "-0XC.91P-2 33") == 0);
 192     ASSERT (retval == strlen (result));
 193     free (result);
 194   }
 195
 196   { /* Positive zero.  */
 197     char *result;
 198     int retval =
 199       my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
 200     ASSERT (result != NULL);
 201     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 202     ASSERT (retval == strlen (result));
 203     free (result);
 204   }
 205
 206   { /* Negative zero.  */
 207     char *result;
 208     int retval =
 209       my_asprintf (&result, "%a %d", -zerod, 33, 44, 55);
 210     ASSERT (result != NULL);
 211     if (have_minus_zero ())
 212       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 213     ASSERT (retval == strlen (result));
 214     free (result);
 215   }
 216
 217   { /* Positive infinity.  */
 218     char *result;
 219     int retval =
 220       my_asprintf (&result, "%a %d", 1.0 / 0.0, 33, 44, 55);
 221     ASSERT (result != NULL);
 222     ASSERT (strcmp (result, "inf 33") == 0);
 223     ASSERT (retval == strlen (result));
 224     free (result);
 225   }
 226
 227   { /* Negative infinity.  */
 228     char *result;
 229     int retval =
 230       my_asprintf (&result, "%a %d", -1.0 / 0.0, 33, 44, 55);
 231     ASSERT (result != NULL);
 232     ASSERT (strcmp (result, "-inf 33") == 0);
 233     ASSERT (retval == strlen (result));
 234     free (result);
 235   }
 236
 237   { /* NaN.  */
 238     char *result;
 239     int retval =
 240       my_asprintf (&result, "%a %d", NaNd (), 33, 44, 55);
 241     ASSERT (result != NULL);
 242     ASSERT (strlen (result) >= 3 + 3
 243             && strisnan (result, 0, strlen (result) - 3, 0)
 244             && strcmp (result + strlen (result) - 3, " 33") == 0);
 245     ASSERT (retval == strlen (result));
 246     free (result);
 247   }
 248
 249   { /* Rounding near the decimal point.  */
 250     char *result;
 251     int retval =
 252       my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
 253     ASSERT (result != NULL);
 254     ASSERT (strcmp (result, "0x2p+0 33") == 0
 255             || strcmp (result, "0x3p-1 33") == 0
 256             || strcmp (result, "0x6p-2 33") == 0
 257             || strcmp (result, "0xcp-3 33") == 0);
 258     ASSERT (retval == strlen (result));
 259     free (result);
 260   }
 261
 262   { /* Rounding with precision 0.  */
 263     char *result;
 264     int retval =
 265       my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
 266     ASSERT (result != NULL);
 267     ASSERT (strcmp (result, "0x2p+0 33") == 0
 268             || strcmp (result, "0x3p-1 33") == 0
 269             || strcmp (result, "0x6p-2 33") == 0
 270             || strcmp (result, "0xcp-3 33") == 0);
 271     ASSERT (retval == strlen (result));
 272     free (result);
 273   }
 274
 275   { /* Rounding with precision 1.  */
 276     char *result;
 277     int retval =
 278       my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
 279     ASSERT (result != NULL);
 280     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 281             || strcmp (result, "0x3.0p-1 33") == 0
 282             || strcmp (result, "0x6.1p-2 33") == 0
 283             || strcmp (result, "0xc.1p-3 33") == 0);
 284     ASSERT (retval == strlen (result));
 285     free (result);
 286   }
 287
 288   { /* Rounding with precision 2.  */
 289     char *result;
 290     int retval =
 291       my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
 292     ASSERT (result != NULL);
 293     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 294             || strcmp (result, "0x3.05p-1 33") == 0
 295             || strcmp (result, "0x6.0ap-2 33") == 0
 296             || strcmp (result, "0xc.14p-3 33") == 0);
 297     ASSERT (retval == strlen (result));
 298     free (result);
 299   }
 300
 301   { /* Rounding with precision 3.  */
 302     char *result;
 303     int retval =
 304       my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
 305     ASSERT (result != NULL);
 306     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 307             || strcmp (result, "0x3.052p-1 33") == 0
 308             || strcmp (result, "0x6.0a4p-2 33") == 0
 309             || strcmp (result, "0xc.148p-3 33") == 0);
 310     ASSERT (retval == strlen (result));
 311     free (result);
 312   }
 313
 314   { /* Rounding can turn a ...FFF into a ...000.  */
 315     char *result;
 316     int retval =
 317       my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
 318     ASSERT (result != NULL);
 319     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 320             || strcmp (result, "0x3.000p-1 33") == 0
 321             || strcmp (result, "0x6.000p-2 33") == 0
 322             || strcmp (result, "0xc.000p-3 33") == 0);
 323     ASSERT (retval == strlen (result));
 324     free (result);
 325   }
 326
 327   { /* Rounding can turn a ...FFF into a ...000.
 328        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 329     char *result;
 330     int retval =
 331       my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
 332     ASSERT (result != NULL);
 333     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 334             || strcmp (result, "0x2.0p+0 33") == 0
 335             || strcmp (result, "0x4.0p-1 33") == 0
 336             || strcmp (result, "0x8.0p-2 33") == 0);
 337     ASSERT (retval == strlen (result));
 338     free (result);
 339   }
 340
 341   { /* Width.  */
 342     char *result;
 343     int retval =
 344       my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
 345     ASSERT (result != NULL);
 346     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 347             || strcmp (result, "  0x3.8p-1 33") == 0
 348             || strcmp (result, "    0x7p-2 33") == 0
 349             || strcmp (result, "    0xep-3 33") == 0);
 350     ASSERT (retval == strlen (result));
 351     free (result);
 352   }
 353
 354   { /* Small precision.  */
 355     char *result;
 356     int retval =
 357       my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
 358     ASSERT (result != NULL);
 359     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 360             || strcmp (result, "0x3.8000000000p-1 33") == 0
 361             || strcmp (result, "0x7.0000000000p-2 33") == 0
 362             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 363     ASSERT (retval == strlen (result));
 364     free (result);
 365   }
 366
 367   { /* Large precision.  */
 368     char *result;
 369     int retval =
 370       my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
 371     ASSERT (result != NULL);
 372     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 373             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 374             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 375             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 376     ASSERT (retval == strlen (result));
 377     free (result);
 378   }
 379
 380   { /* FLAG_LEFT.  */
 381     char *result;
 382     int retval =
 383       my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
 384     ASSERT (result != NULL);
 385     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 386             || strcmp (result, "0x3.8p-1   33") == 0
 387             || strcmp (result, "0x7p-2     33") == 0
 388             || strcmp (result, "0xep-3     33") == 0);
 389     ASSERT (retval == strlen (result));
 390     free (result);
 391   }
 392
 393   { /* FLAG_SHOWSIGN.  */
 394     char *result;
 395     int retval =
 396       my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
 397     ASSERT (result != NULL);
 398     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 399             || strcmp (result, "+0x3.8p-1 33") == 0
 400             || strcmp (result, "+0x7p-2 33") == 0
 401             || strcmp (result, "+0xep-3 33") == 0);
 402     ASSERT (retval == strlen (result));
 403     free (result);
 404   }
 405
 406   { /* FLAG_SPACE.  */
 407     char *result;
 408     int retval =
 409       my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
 410     ASSERT (result != NULL);
 411     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 412             || strcmp (result, " 0x3.8p-1 33") == 0
 413             || strcmp (result, " 0x7p-2 33") == 0
 414             || strcmp (result, " 0xep-3 33") == 0);
 415     ASSERT (retval == strlen (result));
 416     free (result);
 417   }
 418
 419   { /* FLAG_ALT.  */
 420     char *result;
 421     int retval =
 422       my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
 423     ASSERT (result != NULL);
 424     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 425             || strcmp (result, "0x3.8p-1 33") == 0
 426             || strcmp (result, "0x7.p-2 33") == 0
 427             || strcmp (result, "0xe.p-3 33") == 0);
 428     ASSERT (retval == strlen (result));
 429     free (result);
 430   }
 431
 432   { /* FLAG_ALT.  */
 433     char *result;
 434     int retval =
 435       my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
 436     ASSERT (result != NULL);
 437     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 438             || strcmp (result, "0x2.p-1 33") == 0
 439             || strcmp (result, "0x4.p-2 33") == 0
 440             || strcmp (result, "0x8.p-3 33") == 0);
 441     ASSERT (retval == strlen (result));
 442     free (result);
 443   }
 444
 445   { /* FLAG_ZERO with finite number.  */
 446     char *result;
 447     int retval =
 448       my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
 449     ASSERT (result != NULL);
 450     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 451             || strcmp (result, "0x003.8p-1 33") == 0
 452             || strcmp (result, "0x00007p-2 33") == 0
 453             || strcmp (result, "0x0000ep-3 33") == 0);
 454     ASSERT (retval == strlen (result));
 455     free (result);
 456   }
 457
 458   { /* FLAG_ZERO with infinite number.  */
 459     char *result;
 460     int retval =
 461       my_asprintf (&result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 462     ASSERT (result != NULL);
 463     /* "0000000inf 33" is not a valid result; see
 464        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 465     ASSERT (strcmp (result, "       inf 33") == 0);
 466     ASSERT (retval == strlen (result));
 467     free (result);
 468   }
 469
 470   { /* FLAG_ZERO with NaN.  */
 471     char *result;
 472     int retval =
 473       my_asprintf (&result, "%050a %d", NaNd (), 33, 44, 55);
 474     ASSERT (result != NULL);
 475     /* "0000000nan 33" is not a valid result; see
 476        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 477     ASSERT (strlen (result) == 50 + 3
 478             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 479             && strcmp (result + strlen (result) - 3, " 33") == 0);
 480     ASSERT (retval == strlen (result));
 481     free (result);
 482   }
 483
 484   { /* A positive number.  */
 485     char *result;
 486     int retval =
 487       my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
 488     ASSERT (result != NULL);
 489     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 490             || strcmp (result, "0x3.244p+0 33") == 0
 491             || strcmp (result, "0x6.488p-1 33") == 0
 492             || strcmp (result, "0xc.91p-2 33") == 0);
 493     ASSERT (retval == strlen (result));
 494     free (result);
 495   }
 496
 497   { /* A negative number.  */
 498     char *result;
 499     int retval =
 500       my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
 501     ASSERT (result != NULL);
 502     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 503             || strcmp (result, "-0X3.244P+0 33") == 0
 504             || strcmp (result, "-0X6.488P-1 33") == 0
 505             || strcmp (result, "-0XC.91P-2 33") == 0);
 506     ASSERT (retval == strlen (result));
 507     free (result);
 508   }
 509
 510   { /* Positive zero.  */
 511     char *result;
 512     int retval =
 513       my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
 514     ASSERT (result != NULL);
 515     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 516     ASSERT (retval == strlen (result));
 517     free (result);
 518   }
 519
 520   { /* Negative zero.  */
 521     char *result;
 522     int retval =
 523       my_asprintf (&result, "%La %d", -zerol, 33, 44, 55);
 524     ASSERT (result != NULL);
 525     if (have_minus_zero ())
 526       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 527     ASSERT (retval == strlen (result));
 528     free (result);
 529   }
 530
 531   { /* Positive infinity.  */
 532     char *result;
 533     int retval =
 534       my_asprintf (&result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
 535     ASSERT (result != NULL);
 536     ASSERT (strcmp (result, "inf 33") == 0);
 537     ASSERT (retval == strlen (result));
 538     free (result);
 539   }
 540
 541   { /* Negative infinity.  */
 542     char *result;
 543     int retval =
 544       my_asprintf (&result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
 545     ASSERT (result != NULL);
 546     ASSERT (strcmp (result, "-inf 33") == 0);
 547     ASSERT (retval == strlen (result));
 548     free (result);
 549   }
 550
 551   { /* NaN.  */
 552     char *result;
 553     int retval =
 554       my_asprintf (&result, "%La %d", NaNl (), 33, 44, 55);
 555     ASSERT (result != NULL);
 556     ASSERT (strlen (result) >= 3 + 3
 557             && strisnan (result, 0, strlen (result) - 3, 0)
 558             && strcmp (result + strlen (result) - 3, " 33") == 0);
 559     ASSERT (retval == strlen (result));
 560     free (result);
 561   }
 562 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
 563   { /* Quiet NaN.  */
 564     static union { unsigned int word[4]; long double value; } x =
 565       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
 566     char *result;
 567     int retval =
 568       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 569     ASSERT (result != NULL);
 570     ASSERT (strlen (result) >= 3 + 3
 571             && strisnan (result, 0, strlen (result) - 3, 0)
 572             && strcmp (result + strlen (result) - 3, " 33") == 0);
 573     ASSERT (retval == strlen (result));
 574     free (result);
 575   }
 576   {
 577     /* Signalling NaN.  */
 578     static union { unsigned int word[4]; long double value; } x =
 579       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
 580     char *result;
 581     int retval =
 582       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 583     ASSERT (result != NULL);
 584     ASSERT (strlen (result) >= 3 + 3
 585             && strisnan (result, 0, strlen (result) - 3, 0)
 586             && strcmp (result + strlen (result) - 3, " 33") == 0);
 587     ASSERT (retval == strlen (result));
 588     free (result);
 589   }
 590   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
 591      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
 592        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
 593        Application Architecture.
 594        Table 5-2 "Floating-Point Register Encodings"
 595        Figure 5-6 "Memory to Floating-Point Register Data Translation"
 596    */
 597   { /* Pseudo-NaN.  */
 598     static union { unsigned int word[4]; long double value; } x =
 599       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
 600     char *result;
 601     int retval =
 602       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 603     ASSERT (result != NULL);
 604     ASSERT (strlen (result) >= 3 + 3
 605             && strisnan (result, 0, strlen (result) - 3, 0)
 606             && strcmp (result + strlen (result) - 3, " 33") == 0);
 607     ASSERT (retval == strlen (result));
 608     free (result);
 609   }
 610   { /* Pseudo-Infinity.  */
 611     static union { unsigned int word[4]; long double value; } x =
 612       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
 613     char *result;
 614     int retval =
 615       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 616     ASSERT (result != NULL);
 617     ASSERT (strlen (result) >= 3 + 3
 618             && strisnan (result, 0, strlen (result) - 3, 0)
 619             && strcmp (result + strlen (result) - 3, " 33") == 0);
 620     ASSERT (retval == strlen (result));
 621     free (result);
 622   }
 623   { /* Pseudo-Zero.  */
 624     static union { unsigned int word[4]; long double value; } x =
 625       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
 626     char *result;
 627     int retval =
 628       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 629     ASSERT (result != NULL);
 630     ASSERT (strlen (result) >= 3 + 3
 631             && strisnan (result, 0, strlen (result) - 3, 0)
 632             && strcmp (result + strlen (result) - 3, " 33") == 0);
 633     ASSERT (retval == strlen (result));
 634     free (result);
 635   }
 636   { /* Unnormalized number.  */
 637     static union { unsigned int word[4]; long double value; } x =
 638       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
 639     char *result;
 640     int retval =
 641       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 642     ASSERT (result != NULL);
 643     ASSERT (strlen (result) >= 3 + 3
 644             && strisnan (result, 0, strlen (result) - 3, 0)
 645             && strcmp (result + strlen (result) - 3, " 33") == 0);
 646     ASSERT (retval == strlen (result));
 647     free (result);
 648   }
 649   { /* Pseudo-Denormal.  */
 650     static union { unsigned int word[4]; long double value; } x =
 651       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
 652     char *result;
 653     int retval =
 654       my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
 655     ASSERT (result != NULL);
 656     ASSERT (strlen (result) >= 3 + 3
 657             && strisnan (result, 0, strlen (result) - 3, 0)
 658             && strcmp (result + strlen (result) - 3, " 33") == 0);
 659     ASSERT (retval == strlen (result));
 660     free (result);
 661   }
 662 #endif
 663
 664   { /* Rounding near the decimal point.  */
 665     char *result;
 666     int retval =
 667       my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
 668     ASSERT (result != NULL);
 669     ASSERT (strcmp (result, "0x2p+0 33") == 0
 670             || strcmp (result, "0x3p-1 33") == 0
 671             || strcmp (result, "0x6p-2 33") == 0
 672             || strcmp (result, "0xcp-3 33") == 0);
 673     ASSERT (retval == strlen (result));
 674     free (result);
 675   }
 676
 677   { /* Rounding with precision 0.  */
 678     char *result;
 679     int retval =
 680       my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
 681     ASSERT (result != NULL);
 682     ASSERT (strcmp (result, "0x2p+0 33") == 0
 683             || strcmp (result, "0x3p-1 33") == 0
 684             || strcmp (result, "0x6p-2 33") == 0
 685             || strcmp (result, "0xcp-3 33") == 0);
 686     ASSERT (retval == strlen (result));
 687     free (result);
 688   }
 689
 690   { /* Rounding with precision 1.  */
 691     char *result;
 692     int retval =
 693       my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
 694     ASSERT (result != NULL);
 695     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 696             || strcmp (result, "0x3.0p-1 33") == 0
 697             || strcmp (result, "0x6.1p-2 33") == 0
 698             || strcmp (result, "0xc.1p-3 33") == 0);
 699     ASSERT (retval == strlen (result));
 700     free (result);
 701   }
 702
 703   { /* Rounding with precision 2.  */
 704     char *result;
 705     int retval =
 706       my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
 707     ASSERT (result != NULL);
 708     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 709             || strcmp (result, "0x3.05p-1 33") == 0
 710             || strcmp (result, "0x6.0ap-2 33") == 0
 711             || strcmp (result, "0xc.14p-3 33") == 0);
 712     ASSERT (retval == strlen (result));
 713     free (result);
 714   }
 715
 716   { /* Rounding with precision 3.  */
 717     char *result;
 718     int retval =
 719       my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
 720     ASSERT (result != NULL);
 721     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 722             || strcmp (result, "0x3.052p-1 33") == 0
 723             || strcmp (result, "0x6.0a4p-2 33") == 0
 724             || strcmp (result, "0xc.148p-3 33") == 0);
 725     ASSERT (retval == strlen (result));
 726     free (result);
 727   }
 728
 729   { /* Rounding can turn a ...FFF into a ...000.  */
 730     char *result;
 731     int retval =
 732       my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
 733     ASSERT (result != NULL);
 734     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 735             || strcmp (result, "0x3.000p-1 33") == 0
 736             || strcmp (result, "0x6.000p-2 33") == 0
 737             || strcmp (result, "0xc.000p-3 33") == 0);
 738     ASSERT (retval == strlen (result));
 739     free (result);
 740   }
 741
 742   { /* Rounding can turn a ...FFF into a ...000.
 743        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 744        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 745     char *result;
 746     int retval =
 747       my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
 748     ASSERT (result != NULL);
 749     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 750             || strcmp (result, "0x2.0p+0 33") == 0
 751             || strcmp (result, "0x4.0p-1 33") == 0
 752             || strcmp (result, "0x8.0p-2 33") == 0);
 753     ASSERT (retval == strlen (result));
 754     free (result);
 755   }
 756
 757   { /* Width.  */
 758     char *result;
 759     int retval =
 760       my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
 761     ASSERT (result != NULL);
 762     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 763             || strcmp (result, "  0x3.8p-1 33") == 0
 764             || strcmp (result, "    0x7p-2 33") == 0
 765             || strcmp (result, "    0xep-3 33") == 0);
 766     ASSERT (retval == strlen (result));
 767     free (result);
 768   }
 769
 770   { /* Small precision.  */
 771     char *result;
 772     int retval =
 773       my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
 774     ASSERT (result != NULL);
 775     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 776             || strcmp (result, "0x3.8000000000p-1 33") == 0
 777             || strcmp (result, "0x7.0000000000p-2 33") == 0
 778             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 779     ASSERT (retval == strlen (result));
 780     free (result);
 781   }
 782
 783   { /* Large precision.  */
 784     char *result;
 785     int retval =
 786       my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
 787     ASSERT (result != NULL);
 788     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 789             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 790             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 791             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 792     ASSERT (retval == strlen (result));
 793     free (result);
 794   }
 795
 796   { /* FLAG_LEFT.  */
 797     char *result;
 798     int retval =
 799       my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
 800     ASSERT (result != NULL);
 801     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 802             || strcmp (result, "0x3.8p-1   33") == 0
 803             || strcmp (result, "0x7p-2     33") == 0
 804             || strcmp (result, "0xep-3     33") == 0);
 805     ASSERT (retval == strlen (result));
 806     free (result);
 807   }
 808
 809   { /* FLAG_SHOWSIGN.  */
 810     char *result;
 811     int retval =
 812       my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
 813     ASSERT (result != NULL);
 814     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 815             || strcmp (result, "+0x3.8p-1 33") == 0
 816             || strcmp (result, "+0x7p-2 33") == 0
 817             || strcmp (result, "+0xep-3 33") == 0);
 818     ASSERT (retval == strlen (result));
 819     free (result);
 820   }
 821
 822   { /* FLAG_SPACE.  */
 823     char *result;
 824     int retval =
 825       my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
 826     ASSERT (result != NULL);
 827     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 828             || strcmp (result, " 0x3.8p-1 33") == 0
 829             || strcmp (result, " 0x7p-2 33") == 0
 830             || strcmp (result, " 0xep-3 33") == 0);
 831     ASSERT (retval == strlen (result));
 832     free (result);
 833   }
 834
 835   { /* FLAG_ALT.  */
 836     char *result;
 837     int retval =
 838       my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
 839     ASSERT (result != NULL);
 840     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 841             || strcmp (result, "0x3.8p-1 33") == 0
 842             || strcmp (result, "0x7.p-2 33") == 0
 843             || strcmp (result, "0xe.p-3 33") == 0);
 844     ASSERT (retval == strlen (result));
 845     free (result);
 846   }
 847
 848   { /* FLAG_ALT.  */
 849     char *result;
 850     int retval =
 851       my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
 852     ASSERT (result != NULL);
 853     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 854             || strcmp (result, "0x2.p-1 33") == 0
 855             || strcmp (result, "0x4.p-2 33") == 0
 856             || strcmp (result, "0x8.p-3 33") == 0);
 857     ASSERT (retval == strlen (result));
 858     free (result);
 859   }
 860
 861   { /* FLAG_ZERO with finite number.  */
 862     char *result;
 863     int retval =
 864       my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
 865     ASSERT (result != NULL);
 866     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 867             || strcmp (result, "0x003.8p-1 33") == 0
 868             || strcmp (result, "0x00007p-2 33") == 0
 869             || strcmp (result, "0x0000ep-3 33") == 0);
 870     ASSERT (retval == strlen (result));
 871     free (result);
 872   }
 873
 874   { /* FLAG_ZERO with infinite number.  */
 875     char *result;
 876     int retval =
 877       my_asprintf (&result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 878     ASSERT (result != NULL);
 879     /* "0000000inf 33" is not a valid result; see
 880        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 881     ASSERT (strcmp (result, "       inf 33") == 0);
 882     ASSERT (retval == strlen (result));
 883     free (result);
 884   }
 885
 886   { /* FLAG_ZERO with NaN.  */
 887     char *result;
 888     int retval =
 889       my_asprintf (&result, "%050La %d", NaNl (), 33, 44, 55);
 890     ASSERT (result != NULL);
 891     /* "0000000nan 33" is not a valid result; see
 892        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
 893     ASSERT (strlen (result) == 50 + 3
 894             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
 895             && strcmp (result + strlen (result) - 3, " 33") == 0);
 896     ASSERT (retval == strlen (result));
 897     free (result);
 898   }
 899
 900   /* Test the support of the %f format directive.  */
 901
 902   { /* A positive number.  */
 903     char *result;
 904     int retval =
 905       my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
 906     ASSERT (result != NULL);
 907     ASSERT (strcmp (result, "12.750000 33") == 0);
 908     ASSERT (retval == strlen (result));
 909     free (result);
 910   }
 911
 912   { /* A larger positive number.  */
 913     char *result;
 914     int retval =
 915       my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
 916     ASSERT (result != NULL);
 917     ASSERT (strcmp (result, "1234567.000000 33") == 0);
 918     ASSERT (retval == strlen (result));
 919     free (result);
 920   }
 921
 922   { /* Small and large positive numbers.  */
 923     static struct { double value; const char *string; } data[] =
 924       {
 925         { 1.234321234321234e-37, "0.000000" },
 926         { 1.234321234321234e-36, "0.000000" },
 927         { 1.234321234321234e-35, "0.000000" },
 928         { 1.234321234321234e-34, "0.000000" },
 929         { 1.234321234321234e-33, "0.000000" },
 930         { 1.234321234321234e-32, "0.000000" },
 931         { 1.234321234321234e-31, "0.000000" },
 932         { 1.234321234321234e-30, "0.000000" },
 933         { 1.234321234321234e-29, "0.000000" },
 934         { 1.234321234321234e-28, "0.000000" },
 935         { 1.234321234321234e-27, "0.000000" },
 936         { 1.234321234321234e-26, "0.000000" },
 937         { 1.234321234321234e-25, "0.000000" },
 938         { 1.234321234321234e-24, "0.000000" },
 939         { 1.234321234321234e-23, "0.000000" },
 940         { 1.234321234321234e-22, "0.000000" },
 941         { 1.234321234321234e-21, "0.000000" },
 942         { 1.234321234321234e-20, "0.000000" },
 943         { 1.234321234321234e-19, "0.000000" },
 944         { 1.234321234321234e-18, "0.000000" },
 945         { 1.234321234321234e-17, "0.000000" },
 946         { 1.234321234321234e-16, "0.000000" },
 947         { 1.234321234321234e-15, "0.000000" },
 948         { 1.234321234321234e-14, "0.000000" },
 949         { 1.234321234321234e-13, "0.000000" },
 950         { 1.234321234321234e-12, "0.000000" },
 951         { 1.234321234321234e-11, "0.000000" },
 952         { 1.234321234321234e-10, "0.000000" },
 953         { 1.234321234321234e-9, "0.000000" },
 954         { 1.234321234321234e-8, "0.000000" },
 955         { 1.234321234321234e-7, "0.000000" },
 956         { 1.234321234321234e-6, "0.000001" },
 957         { 1.234321234321234e-5, "0.000012" },
 958         { 1.234321234321234e-4, "0.000123" },
 959         { 1.234321234321234e-3, "0.001234" },
 960         { 1.234321234321234e-2, "0.012343" },
 961         { 1.234321234321234e-1, "0.123432" },
 962         { 1.234321234321234, "1.234321" },
 963         { 1.234321234321234e1, "12.343212" },
 964         { 1.234321234321234e2, "123.432123" },
 965         { 1.234321234321234e3, "1234.321234" },
 966         { 1.234321234321234e4, "12343.212343" },
 967         { 1.234321234321234e5, "123432.123432" },
 968         { 1.234321234321234e6, "1234321.234321" },
 969         { 1.234321234321234e7, "12343212.343212" },
 970         { 1.234321234321234e8, "123432123.432123" },
 971         { 1.234321234321234e9, "1234321234.321234" },
 972         { 1.234321234321234e10, "12343212343.2123**" },
 973         { 1.234321234321234e11, "123432123432.123***" },
 974         { 1.234321234321234e12, "1234321234321.23****" },
 975         { 1.234321234321234e13, "12343212343212.3*****" },
 976         { 1.234321234321234e14, "123432123432123.******" },
 977         { 1.234321234321234e15, "1234321234321234.000000" },
 978         { 1.234321234321234e16, "123432123432123**.000000" },
 979         { 1.234321234321234e17, "123432123432123***.000000" },
 980         { 1.234321234321234e18, "123432123432123****.000000" },
 981         { 1.234321234321234e19, "123432123432123*****.000000" },
 982         { 1.234321234321234e20, "123432123432123******.000000" },
 983         { 1.234321234321234e21, "123432123432123*******.000000" },
 984         { 1.234321234321234e22, "123432123432123********.000000" },
 985         { 1.234321234321234e23, "123432123432123*********.000000" },
 986         { 1.234321234321234e24, "123432123432123**********.000000" },
 987         { 1.234321234321234e25, "123432123432123***********.000000" },
 988         { 1.234321234321234e26, "123432123432123************.000000" },
 989         { 1.234321234321234e27, "123432123432123*************.000000" },
 990         { 1.234321234321234e28, "123432123432123**************.000000" },
 991         { 1.234321234321234e29, "123432123432123***************.000000" },
 992         { 1.234321234321234e30, "123432123432123****************.000000" },
 993         { 1.234321234321234e31, "123432123432123*****************.000000" },
 994         { 1.234321234321234e32, "123432123432123******************.000000" },
 995         { 1.234321234321234e33, "123432123432123*******************.000000" },
 996         { 1.234321234321234e34, "123432123432123********************.000000" },
 997         { 1.234321234321234e35, "123432123432123*********************.000000" },
 998         { 1.234321234321234e36, "123432123432123**********************.000000" }
 999       };
1000     size_t k;
1001     for (k = 0; k < SIZEOF (data); k++)
1002       {
1003         char *result;
1004         int retval =
1005           my_asprintf (&result, "%f", data[k].value);
1006         ASSERT (result != NULL);
1007         ASSERT (strmatch (data[k].string, result));
1008         ASSERT (retval == strlen (result));
1009         free (result);
1010       }
1011   }
1012
1013   { /* A negative number.  */
1014     char *result;
1015     int retval =
1016       my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
1017     ASSERT (result != NULL);
1018     ASSERT (strcmp (result, "-0.031250 33") == 0);
1019     ASSERT (retval == strlen (result));
1020     free (result);
1021   }
1022
1023   { /* Positive zero.  */
1024     char *result;
1025     int retval =
1026       my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
1027     ASSERT (result != NULL);
1028     ASSERT (strcmp (result, "0.000000 33") == 0);
1029     ASSERT (retval == strlen (result));
1030     free (result);
1031   }
1032
1033   { /* Negative zero.  */
1034     char *result;
1035     int retval =
1036       my_asprintf (&result, "%f %d", -zerod, 33, 44, 55);
1037     ASSERT (result != NULL);
1038     if (have_minus_zero ())
1039       ASSERT (strcmp (result, "-0.000000 33") == 0);
1040     ASSERT (retval == strlen (result));
1041     free (result);
1042   }
1043
1044   { /* Positive infinity.  */
1045     char *result;
1046     int retval =
1047       my_asprintf (&result, "%f %d", 1.0 / 0.0, 33, 44, 55);
1048     ASSERT (result != NULL);
1049     ASSERT (strcmp (result, "inf 33") == 0
1050             || strcmp (result, "infinity 33") == 0);
1051     ASSERT (retval == strlen (result));
1052     free (result);
1053   }
1054
1055   { /* Negative infinity.  */
1056     char *result;
1057     int retval =
1058       my_asprintf (&result, "%f %d", -1.0 / 0.0, 33, 44, 55);
1059     ASSERT (result != NULL);
1060     ASSERT (strcmp (result, "-inf 33") == 0
1061             || strcmp (result, "-infinity 33") == 0);
1062     ASSERT (retval == strlen (result));
1063     free (result);
1064   }
1065
1066   { /* NaN.  */
1067     char *result;
1068     int retval =
1069       my_asprintf (&result, "%f %d", NaNd (), 33, 44, 55);
1070     ASSERT (result != NULL);
1071     ASSERT (strlen (result) >= 3 + 3
1072             && strisnan (result, 0, strlen (result) - 3, 0)
1073             && strcmp (result + strlen (result) - 3, " 33") == 0);
1074     ASSERT (retval == strlen (result));
1075     free (result);
1076   }
1077
1078   { /* Width.  */
1079     char *result;
1080     int retval =
1081       my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
1082     ASSERT (result != NULL);
1083     ASSERT (strcmp (result, "  1.750000 33") == 0);
1084     ASSERT (retval == strlen (result));
1085     free (result);
1086   }
1087
1088   { /* FLAG_LEFT.  */
1089     char *result;
1090     int retval =
1091       my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
1092     ASSERT (result != NULL);
1093     ASSERT (strcmp (result, "1.750000   33") == 0);
1094     ASSERT (retval == strlen (result));
1095     free (result);
1096   }
1097
1098   { /* FLAG_SHOWSIGN.  */
1099     char *result;
1100     int retval =
1101       my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
1102     ASSERT (result != NULL);
1103     ASSERT (strcmp (result, "+1.750000 33") == 0);
1104     ASSERT (retval == strlen (result));
1105     free (result);
1106   }
1107
1108   { /* FLAG_SPACE.  */
1109     char *result;
1110     int retval =
1111       my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
1112     ASSERT (result != NULL);
1113     ASSERT (strcmp (result, " 1.750000 33") == 0);
1114     ASSERT (retval == strlen (result));
1115     free (result);
1116   }
1117
1118   { /* FLAG_ALT.  */
1119     char *result;
1120     int retval =
1121       my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
1122     ASSERT (result != NULL);
1123     ASSERT (strcmp (result, "1.750000 33") == 0);
1124     ASSERT (retval == strlen (result));
1125     free (result);
1126   }
1127
1128   { /* FLAG_ALT.  */
1129     char *result;
1130     int retval =
1131       my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
1132     ASSERT (result != NULL);
1133     ASSERT (strcmp (result, "2. 33") == 0);
1134     ASSERT (retval == strlen (result));
1135     free (result);
1136   }
1137
1138   { /* FLAG_ZERO with finite number.  */
1139     char *result;
1140     int retval =
1141       my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
1142     ASSERT (result != NULL);
1143     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1144     ASSERT (retval == strlen (result));
1145     free (result);
1146   }
1147
1148   { /* FLAG_ZERO with infinite number.  */
1149     char *result;
1150     int retval =
1151       my_asprintf (&result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
1152     ASSERT (result != NULL);
1153     ASSERT (strcmp (result, "           -inf 33") == 0
1154             || strcmp (result, "      -infinity 33") == 0);
1155     ASSERT (retval == strlen (result));
1156     free (result);
1157   }
1158
1159   { /* FLAG_ZERO with NaN.  */
1160     char *result;
1161     int retval =
1162       my_asprintf (&result, "%050f %d", NaNd (), 33, 44, 55);
1163     ASSERT (result != NULL);
1164     ASSERT (strlen (result) == 50 + 3
1165             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1166             && strcmp (result + strlen (result) - 3, " 33") == 0);
1167     ASSERT (retval == strlen (result));
1168     free (result);
1169   }
1170
1171   { /* Precision.  */
1172     char *result;
1173     int retval =
1174       my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
1175     ASSERT (result != NULL);
1176     ASSERT (strcmp (result, "1234 33") == 0);
1177     ASSERT (retval == strlen (result));
1178     free (result);
1179   }
1180
1181   { /* Precision with no rounding.  */
1182     char *result;
1183     int retval =
1184       my_asprintf (&result, "%.2f %d", 999.951, 33, 44, 55);
1185     ASSERT (result != NULL);
1186     ASSERT (strcmp (result, "999.95 33") == 0);
1187     ASSERT (retval == strlen (result));
1188     free (result);
1189   }
1190
1191   { /* Precision with rounding.  */
1192     char *result;
1193     int retval =
1194       my_asprintf (&result, "%.2f %d", 999.996, 33, 44, 55);
1195     ASSERT (result != NULL);
1196     ASSERT (strcmp (result, "1000.00 33") == 0);
1197     ASSERT (retval == strlen (result));
1198     free (result);
1199   }
1200
1201   { /* A positive number.  */
1202     char *result;
1203     int retval =
1204       my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
1205     ASSERT (result != NULL);
1206     ASSERT (strcmp (result, "12.750000 33") == 0);
1207     ASSERT (retval == strlen (result));
1208     free (result);
1209   }
1210
1211   { /* A larger positive number.  */
1212     char *result;
1213     int retval =
1214       my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
1215     ASSERT (result != NULL);
1216     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1217     ASSERT (retval == strlen (result));
1218     free (result);
1219   }
1220
1221   { /* Small and large positive numbers.  */
1222     static struct { long double value; const char *string; } data[] =
1223       {
1224         { 1.234321234321234e-37L, "0.000000" },
1225         { 1.234321234321234e-36L, "0.000000" },
1226         { 1.234321234321234e-35L, "0.000000" },
1227         { 1.234321234321234e-34L, "0.000000" },
1228         { 1.234321234321234e-33L, "0.000000" },
1229         { 1.234321234321234e-32L, "0.000000" },
1230         { 1.234321234321234e-31L, "0.000000" },
1231         { 1.234321234321234e-30L, "0.000000" },
1232         { 1.234321234321234e-29L, "0.000000" },
1233         { 1.234321234321234e-28L, "0.000000" },
1234         { 1.234321234321234e-27L, "0.000000" },
1235         { 1.234321234321234e-26L, "0.000000" },
1236         { 1.234321234321234e-25L, "0.000000" },
1237         { 1.234321234321234e-24L, "0.000000" },
1238         { 1.234321234321234e-23L, "0.000000" },
1239         { 1.234321234321234e-22L, "0.000000" },
1240         { 1.234321234321234e-21L, "0.000000" },
1241         { 1.234321234321234e-20L, "0.000000" },
1242         { 1.234321234321234e-19L, "0.000000" },
1243         { 1.234321234321234e-18L, "0.000000" },
1244         { 1.234321234321234e-17L, "0.000000" },
1245         { 1.234321234321234e-16L, "0.000000" },
1246         { 1.234321234321234e-15L, "0.000000" },
1247         { 1.234321234321234e-14L, "0.000000" },
1248         { 1.234321234321234e-13L, "0.000000" },
1249         { 1.234321234321234e-12L, "0.000000" },
1250         { 1.234321234321234e-11L, "0.000000" },
1251         { 1.234321234321234e-10L, "0.000000" },
1252         { 1.234321234321234e-9L, "0.000000" },
1253         { 1.234321234321234e-8L, "0.000000" },
1254         { 1.234321234321234e-7L, "0.000000" },
1255         { 1.234321234321234e-6L, "0.000001" },
1256         { 1.234321234321234e-5L, "0.000012" },
1257         { 1.234321234321234e-4L, "0.000123" },
1258         { 1.234321234321234e-3L, "0.001234" },
1259         { 1.234321234321234e-2L, "0.012343" },
1260         { 1.234321234321234e-1L, "0.123432" },
1261         { 1.234321234321234L, "1.234321" },
1262         { 1.234321234321234e1L, "12.343212" },
1263         { 1.234321234321234e2L, "123.432123" },
1264         { 1.234321234321234e3L, "1234.321234" },
1265         { 1.234321234321234e4L, "12343.212343" },
1266         { 1.234321234321234e5L, "123432.123432" },
1267         { 1.234321234321234e6L, "1234321.234321" },
1268         { 1.234321234321234e7L, "12343212.343212" },
1269         { 1.234321234321234e8L, "123432123.432123" },
1270         { 1.234321234321234e9L, "1234321234.321234" },
1271         { 1.234321234321234e10L, "12343212343.2123**" },
1272         { 1.234321234321234e11L, "123432123432.123***" },
1273         { 1.234321234321234e12L, "1234321234321.23****" },
1274         { 1.234321234321234e13L, "12343212343212.3*****" },
1275         { 1.234321234321234e14L, "123432123432123.******" },
1276         { 1.234321234321234e15L, "1234321234321234.000000" },
1277         { 1.234321234321234e16L, "123432123432123**.000000" },
1278         { 1.234321234321234e17L, "123432123432123***.000000" },
1279         { 1.234321234321234e18L, "123432123432123****.000000" },
1280         { 1.234321234321234e19L, "123432123432123*****.000000" },
1281         { 1.234321234321234e20L, "123432123432123******.000000" },
1282         { 1.234321234321234e21L, "123432123432123*******.000000" },
1283         { 1.234321234321234e22L, "123432123432123********.000000" },
1284         { 1.234321234321234e23L, "123432123432123*********.000000" },
1285         { 1.234321234321234e24L, "123432123432123**********.000000" },
1286         { 1.234321234321234e25L, "123432123432123***********.000000" },
1287         { 1.234321234321234e26L, "123432123432123************.000000" },
1288         { 1.234321234321234e27L, "123432123432123*************.000000" },
1289         { 1.234321234321234e28L, "123432123432123**************.000000" },
1290         { 1.234321234321234e29L, "123432123432123***************.000000" },
1291         { 1.234321234321234e30L, "123432123432123****************.000000" },
1292         { 1.234321234321234e31L, "123432123432123*****************.000000" },
1293         { 1.234321234321234e32L, "123432123432123******************.000000" },
1294         { 1.234321234321234e33L, "123432123432123*******************.000000" },
1295         { 1.234321234321234e34L, "123432123432123********************.000000" },
1296         { 1.234321234321234e35L, "123432123432123*********************.000000" },
1297         { 1.234321234321234e36L, "123432123432123**********************.000000" }
1298       };
1299     size_t k;
1300     for (k = 0; k < SIZEOF (data); k++)
1301       {
1302         char *result;
1303         int retval =
1304           my_asprintf (&result, "%Lf", data[k].value);
1305         ASSERT (result != NULL);
1306         ASSERT (strmatch (data[k].string, result));
1307         ASSERT (retval == strlen (result));
1308         free (result);
1309       }
1310   }
1311
1312   { /* A negative number.  */
1313     char *result;
1314     int retval =
1315       my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
1316     ASSERT (result != NULL);
1317     ASSERT (strcmp (result, "-0.031250 33") == 0);
1318     ASSERT (retval == strlen (result));
1319     free (result);
1320   }
1321
1322   { /* Positive zero.  */
1323     char *result;
1324     int retval =
1325       my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
1326     ASSERT (result != NULL);
1327     ASSERT (strcmp (result, "0.000000 33") == 0);
1328     ASSERT (retval == strlen (result));
1329     free (result);
1330   }
1331
1332   { /* Negative zero.  */
1333     char *result;
1334     int retval =
1335       my_asprintf (&result, "%Lf %d", -zerol, 33, 44, 55);
1336     ASSERT (result != NULL);
1337     if (have_minus_zero ())
1338       ASSERT (strcmp (result, "-0.000000 33") == 0);
1339     ASSERT (retval == strlen (result));
1340     free (result);
1341   }
1342
1343   { /* Positive infinity.  */
1344     char *result;
1345     int retval =
1346       my_asprintf (&result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1347     ASSERT (result != NULL);
1348     ASSERT (strcmp (result, "inf 33") == 0
1349             || strcmp (result, "infinity 33") == 0);
1350     ASSERT (retval == strlen (result));
1351     free (result);
1352   }
1353
1354   { /* Negative infinity.  */
1355     char *result;
1356     int retval =
1357       my_asprintf (&result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1358     ASSERT (result != NULL);
1359     ASSERT (strcmp (result, "-inf 33") == 0
1360             || strcmp (result, "-infinity 33") == 0);
1361     ASSERT (retval == strlen (result));
1362     free (result);
1363   }
1364
1365   { /* NaN.  */
1366     char *result;
1367     int retval =
1368       my_asprintf (&result, "%Lf %d", NaNl (), 33, 44, 55);
1369     ASSERT (result != NULL);
1370     ASSERT (strlen (result) >= 3 + 3
1371             && strisnan (result, 0, strlen (result) - 3, 0)
1372             && strcmp (result + strlen (result) - 3, " 33") == 0);
1373     ASSERT (retval == strlen (result));
1374     free (result);
1375   }
1376 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
1377   { /* Quiet NaN.  */
1378     static union { unsigned int word[4]; long double value; } x =
1379       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1380     char *result;
1381     int retval =
1382       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1383     ASSERT (result != NULL);
1384     ASSERT (strlen (result) >= 3 + 3
1385             && strisnan (result, 0, strlen (result) - 3, 0)
1386             && strcmp (result + strlen (result) - 3, " 33") == 0);
1387     ASSERT (retval == strlen (result));
1388     free (result);
1389   }
1390   {
1391     /* Signalling NaN.  */
1392     static union { unsigned int word[4]; long double value; } x =
1393       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1394     char *result;
1395     int retval =
1396       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1397     ASSERT (result != NULL);
1398     ASSERT (strlen (result) >= 3 + 3
1399             && strisnan (result, 0, strlen (result) - 3, 0)
1400             && strcmp (result + strlen (result) - 3, " 33") == 0);
1401     ASSERT (retval == strlen (result));
1402     free (result);
1403   }
1404   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1405      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1406        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1407        Application Architecture.
1408        Table 5-2 "Floating-Point Register Encodings"
1409        Figure 5-6 "Memory to Floating-Point Register Data Translation"
1410    */
1411   { /* Pseudo-NaN.  */
1412     static union { unsigned int word[4]; long double value; } x =
1413       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1414     char *result;
1415     int retval =
1416       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1417     ASSERT (result != NULL);
1418     ASSERT (strlen (result) >= 3 + 3
1419             && strisnan (result, 0, strlen (result) - 3, 0)
1420             && strcmp (result + strlen (result) - 3, " 33") == 0);
1421     ASSERT (retval == strlen (result));
1422     free (result);
1423   }
1424   { /* Pseudo-Infinity.  */
1425     static union { unsigned int word[4]; long double value; } x =
1426       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1427     char *result;
1428     int retval =
1429       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1430     ASSERT (result != NULL);
1431     ASSERT (strlen (result) >= 3 + 3
1432             && strisnan (result, 0, strlen (result) - 3, 0)
1433             && strcmp (result + strlen (result) - 3, " 33") == 0);
1434     ASSERT (retval == strlen (result));
1435     free (result);
1436   }
1437   { /* Pseudo-Zero.  */
1438     static union { unsigned int word[4]; long double value; } x =
1439       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1440     char *result;
1441     int retval =
1442       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1443     ASSERT (result != NULL);
1444     ASSERT (strlen (result) >= 3 + 3
1445             && strisnan (result, 0, strlen (result) - 3, 0)
1446             && strcmp (result + strlen (result) - 3, " 33") == 0);
1447     ASSERT (retval == strlen (result));
1448     free (result);
1449   }
1450   { /* Unnormalized number.  */
1451     static union { unsigned int word[4]; long double value; } x =
1452       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1453     char *result;
1454     int retval =
1455       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1456     ASSERT (result != NULL);
1457     ASSERT (strlen (result) >= 3 + 3
1458             && strisnan (result, 0, strlen (result) - 3, 0)
1459             && strcmp (result + strlen (result) - 3, " 33") == 0);
1460     ASSERT (retval == strlen (result));
1461     free (result);
1462   }
1463   { /* Pseudo-Denormal.  */
1464     static union { unsigned int word[4]; long double value; } x =
1465       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1466     char *result;
1467     int retval =
1468       my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1469     ASSERT (result != NULL);
1470     ASSERT (strlen (result) >= 3 + 3
1471             && strisnan (result, 0, strlen (result) - 3, 0)
1472             && strcmp (result + strlen (result) - 3, " 33") == 0);
1473     ASSERT (retval == strlen (result));
1474     free (result);
1475   }
1476 #endif
1477
1478   { /* Width.  */
1479     char *result;
1480     int retval =
1481       my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
1482     ASSERT (result != NULL);
1483     ASSERT (strcmp (result, "  1.750000 33") == 0);
1484     ASSERT (retval == strlen (result));
1485     free (result);
1486   }
1487
1488   { /* FLAG_LEFT.  */
1489     char *result;
1490     int retval =
1491       my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
1492     ASSERT (result != NULL);
1493     ASSERT (strcmp (result, "1.750000   33") == 0);
1494     ASSERT (retval == strlen (result));
1495     free (result);
1496   }
1497
1498   { /* FLAG_SHOWSIGN.  */
1499     char *result;
1500     int retval =
1501       my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
1502     ASSERT (result != NULL);
1503     ASSERT (strcmp (result, "+1.750000 33") == 0);
1504     ASSERT (retval == strlen (result));
1505     free (result);
1506   }
1507
1508   { /* FLAG_SPACE.  */
1509     char *result;
1510     int retval =
1511       my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
1512     ASSERT (result != NULL);
1513     ASSERT (strcmp (result, " 1.750000 33") == 0);
1514     ASSERT (retval == strlen (result));
1515     free (result);
1516   }
1517
1518   { /* FLAG_ALT.  */
1519     char *result;
1520     int retval =
1521       my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
1522     ASSERT (result != NULL);
1523     ASSERT (strcmp (result, "1.750000 33") == 0);
1524     ASSERT (retval == strlen (result));
1525     free (result);
1526   }
1527
1528   { /* FLAG_ALT.  */
1529     char *result;
1530     int retval =
1531       my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
1532     ASSERT (result != NULL);
1533     ASSERT (strcmp (result, "2. 33") == 0);
1534     ASSERT (retval == strlen (result));
1535     free (result);
1536   }
1537
1538   { /* FLAG_ZERO with finite number.  */
1539     char *result;
1540     int retval =
1541       my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
1542     ASSERT (result != NULL);
1543     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1544     ASSERT (retval == strlen (result));
1545     free (result);
1546   }
1547
1548   { /* FLAG_ZERO with infinite number.  */
1549     char *result;
1550     int retval =
1551       my_asprintf (&result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1552     ASSERT (result != NULL);
1553     ASSERT (strcmp (result, "           -inf 33") == 0
1554             || strcmp (result, "      -infinity 33") == 0);
1555     ASSERT (retval == strlen (result));
1556     free (result);
1557   }
1558
1559   { /* FLAG_ZERO with NaN.  */
1560     char *result;
1561     int retval =
1562       my_asprintf (&result, "%050Lf %d", NaNl (), 33, 44, 55);
1563     ASSERT (result != NULL);
1564     ASSERT (strlen (result) == 50 + 3
1565             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1566             && strcmp (result + strlen (result) - 3, " 33") == 0);
1567     ASSERT (retval == strlen (result));
1568     free (result);
1569   }
1570
1571   { /* Precision.  */
1572     char *result;
1573     int retval =
1574       my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
1575     ASSERT (result != NULL);
1576     ASSERT (strcmp (result, "1234 33") == 0);
1577     ASSERT (retval == strlen (result));
1578     free (result);
1579   }
1580
1581   { /* Precision with no rounding.  */
1582     char *result;
1583     int retval =
1584       my_asprintf (&result, "%.2Lf %d", 999.951L, 33, 44, 55);
1585     ASSERT (result != NULL);
1586     ASSERT (strcmp (result, "999.95 33") == 0);
1587     ASSERT (retval == strlen (result));
1588     free (result);
1589   }
1590
1591   { /* Precision with rounding.  */
1592     char *result;
1593     int retval =
1594       my_asprintf (&result, "%.2Lf %d", 999.996L, 33, 44, 55);
1595     ASSERT (result != NULL);
1596     ASSERT (strcmp (result, "1000.00 33") == 0);
1597     ASSERT (retval == strlen (result));
1598     free (result);
1599   }
1600
1601   /* Test the support of the %F format directive.  */
1602
1603   { /* A positive number.  */
1604     char *result;
1605     int retval =
1606       my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
1607     ASSERT (result != NULL);
1608     ASSERT (strcmp (result, "12.750000 33") == 0);
1609     ASSERT (retval == strlen (result));
1610     free (result);
1611   }
1612
1613   { /* A larger positive number.  */
1614     char *result;
1615     int retval =
1616       my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
1617     ASSERT (result != NULL);
1618     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1619     ASSERT (retval == strlen (result));
1620     free (result);
1621   }
1622
1623   { /* A negative number.  */
1624     char *result;
1625     int retval =
1626       my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
1627     ASSERT (result != NULL);
1628     ASSERT (strcmp (result, "-0.031250 33") == 0);
1629     ASSERT (retval == strlen (result));
1630     free (result);
1631   }
1632
1633   { /* Positive zero.  */
1634     char *result;
1635     int retval =
1636       my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
1637     ASSERT (result != NULL);
1638     ASSERT (strcmp (result, "0.000000 33") == 0);
1639     ASSERT (retval == strlen (result));
1640     free (result);
1641   }
1642
1643   { /* Negative zero.  */
1644     char *result;
1645     int retval =
1646       my_asprintf (&result, "%F %d", -zerod, 33, 44, 55);
1647     ASSERT (result != NULL);
1648     if (have_minus_zero ())
1649       ASSERT (strcmp (result, "-0.000000 33") == 0);
1650     ASSERT (retval == strlen (result));
1651     free (result);
1652   }
1653
1654   { /* Positive infinity.  */
1655     char *result;
1656     int retval =
1657       my_asprintf (&result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1658     ASSERT (result != NULL);
1659     ASSERT (strcmp (result, "INF 33") == 0
1660             || strcmp (result, "INFINITY 33") == 0);
1661     ASSERT (retval == strlen (result));
1662     free (result);
1663   }
1664
1665   { /* Negative infinity.  */
1666     char *result;
1667     int retval =
1668       my_asprintf (&result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1669     ASSERT (result != NULL);
1670     ASSERT (strcmp (result, "-INF 33") == 0
1671             || strcmp (result, "-INFINITY 33") == 0);
1672     ASSERT (retval == strlen (result));
1673     free (result);
1674   }
1675
1676   { /* NaN.  */
1677     char *result;
1678     int retval =
1679       my_asprintf (&result, "%F %d", NaNd (), 33, 44, 55);
1680     ASSERT (result != NULL);
1681     ASSERT (strlen (result) >= 3 + 3
1682             && strisnan (result, 0, strlen (result) - 3, 1)
1683             && strcmp (result + strlen (result) - 3, " 33") == 0);
1684     ASSERT (retval == strlen (result));
1685     free (result);
1686   }
1687
1688   { /* FLAG_ZERO.  */
1689     char *result;
1690     int retval =
1691       my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
1692     ASSERT (result != NULL);
1693     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1694     ASSERT (retval == strlen (result));
1695     free (result);
1696   }
1697
1698   { /* FLAG_ZERO with infinite number.  */
1699     char *result;
1700     int retval =
1701       my_asprintf (&result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1702     ASSERT (result != NULL);
1703     ASSERT (strcmp (result, "           -INF 33") == 0
1704             || strcmp (result, "      -INFINITY 33") == 0);
1705     ASSERT (retval == strlen (result));
1706     free (result);
1707   }
1708
1709   { /* Precision.  */
1710     char *result;
1711     int retval =
1712       my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
1713     ASSERT (result != NULL);
1714     ASSERT (strcmp (result, "1234 33") == 0);
1715     ASSERT (retval == strlen (result));
1716     free (result);
1717   }
1718
1719   { /* Precision with no rounding.  */
1720     char *result;
1721     int retval =
1722       my_asprintf (&result, "%.2F %d", 999.951, 33, 44, 55);
1723     ASSERT (result != NULL);
1724     ASSERT (strcmp (result, "999.95 33") == 0);
1725     ASSERT (retval == strlen (result));
1726     free (result);
1727   }
1728
1729   { /* Precision with rounding.  */
1730     char *result;
1731     int retval =
1732       my_asprintf (&result, "%.2F %d", 999.996, 33, 44, 55);
1733     ASSERT (result != NULL);
1734     ASSERT (strcmp (result, "1000.00 33") == 0);
1735     ASSERT (retval == strlen (result));
1736     free (result);
1737   }
1738
1739   { /* A positive number.  */
1740     char *result;
1741     int retval =
1742       my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
1743     ASSERT (result != NULL);
1744     ASSERT (strcmp (result, "12.750000 33") == 0);
1745     ASSERT (retval == strlen (result));
1746     free (result);
1747   }
1748
1749   { /* A larger positive number.  */
1750     char *result;
1751     int retval =
1752       my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
1753     ASSERT (result != NULL);
1754     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1755     ASSERT (retval == strlen (result));
1756     free (result);
1757   }
1758
1759   { /* A negative number.  */
1760     char *result;
1761     int retval =
1762       my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
1763     ASSERT (result != NULL);
1764     ASSERT (strcmp (result, "-0.031250 33") == 0);
1765     ASSERT (retval == strlen (result));
1766     free (result);
1767   }
1768
1769   { /* Positive zero.  */
1770     char *result;
1771     int retval =
1772       my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
1773     ASSERT (result != NULL);
1774     ASSERT (strcmp (result, "0.000000 33") == 0);
1775     ASSERT (retval == strlen (result));
1776     free (result);
1777   }
1778
1779   { /* Negative zero.  */
1780     char *result;
1781     int retval =
1782       my_asprintf (&result, "%LF %d", -zerol, 33, 44, 55);
1783     ASSERT (result != NULL);
1784     if (have_minus_zero ())
1785       ASSERT (strcmp (result, "-0.000000 33") == 0);
1786     ASSERT (retval == strlen (result));
1787     free (result);
1788   }
1789
1790   { /* Positive infinity.  */
1791     char *result;
1792     int retval =
1793       my_asprintf (&result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1794     ASSERT (result != NULL);
1795     ASSERT (strcmp (result, "INF 33") == 0
1796             || strcmp (result, "INFINITY 33") == 0);
1797     ASSERT (retval == strlen (result));
1798     free (result);
1799   }
1800
1801   { /* Negative infinity.  */
1802     char *result;
1803     int retval =
1804       my_asprintf (&result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1805     ASSERT (result != NULL);
1806     ASSERT (strcmp (result, "-INF 33") == 0
1807             || strcmp (result, "-INFINITY 33") == 0);
1808     ASSERT (retval == strlen (result));
1809     free (result);
1810   }
1811
1812   { /* NaN.  */
1813     char *result;
1814     int retval =
1815       my_asprintf (&result, "%LF %d", NaNl (), 33, 44, 55);
1816     ASSERT (result != NULL);
1817     ASSERT (strlen (result) >= 3 + 3
1818             && strisnan (result, 0, strlen (result) - 3, 1)
1819             && strcmp (result + strlen (result) - 3, " 33") == 0);
1820     ASSERT (retval == strlen (result));
1821     free (result);
1822   }
1823
1824   { /* FLAG_ZERO.  */
1825     char *result;
1826     int retval =
1827       my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
1828     ASSERT (result != NULL);
1829     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1830     ASSERT (retval == strlen (result));
1831     free (result);
1832   }
1833
1834   { /* FLAG_ZERO with infinite number.  */
1835     char *result;
1836     int retval =
1837       my_asprintf (&result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1838     ASSERT (result != NULL);
1839     ASSERT (strcmp (result, "           -INF 33") == 0
1840             || strcmp (result, "      -INFINITY 33") == 0);
1841     ASSERT (retval == strlen (result));
1842     free (result);
1843   }
1844
1845   { /* Precision.  */
1846     char *result;
1847     int retval =
1848       my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
1849     ASSERT (result != NULL);
1850     ASSERT (strcmp (result, "1234 33") == 0);
1851     ASSERT (retval == strlen (result));
1852     free (result);
1853   }
1854
1855   { /* Precision with no rounding.  */
1856     char *result;
1857     int retval =
1858       my_asprintf (&result, "%.2LF %d", 999.951L, 33, 44, 55);
1859     ASSERT (result != NULL);
1860     ASSERT (strcmp (result, "999.95 33") == 0);
1861     ASSERT (retval == strlen (result));
1862     free (result);
1863   }
1864
1865   { /* Precision with rounding.  */
1866     char *result;
1867     int retval =
1868       my_asprintf (&result, "%.2LF %d", 999.996L, 33, 44, 55);
1869     ASSERT (result != NULL);
1870     ASSERT (strcmp (result, "1000.00 33") == 0);
1871     ASSERT (retval == strlen (result));
1872     free (result);
1873   }
1874
1875   /* Test the support of the %e format directive.  */
1876
1877   { /* A positive number.  */
1878     char *result;
1879     int retval =
1880       my_asprintf (&result, "%e %d", 12.75, 33, 44, 55);
1881     ASSERT (result != NULL);
1882     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1883             || strcmp (result, "1.275000e+001 33") == 0);
1884     ASSERT (retval == strlen (result));
1885     free (result);
1886   }
1887
1888   { /* A larger positive number.  */
1889     char *result;
1890     int retval =
1891       my_asprintf (&result, "%e %d", 1234567.0, 33, 44, 55);
1892     ASSERT (result != NULL);
1893     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1894             || strcmp (result, "1.234567e+006 33") == 0);
1895     ASSERT (retval == strlen (result));
1896     free (result);
1897   }
1898
1899   { /* Small and large positive numbers.  */
1900     static struct { double value; const char *string; } data[] =
1901       {
1902         { 1.234321234321234e-37, "1.234321e-37" },
1903         { 1.234321234321234e-36, "1.234321e-36" },
1904         { 1.234321234321234e-35, "1.234321e-35" },
1905         { 1.234321234321234e-34, "1.234321e-34" },
1906         { 1.234321234321234e-33, "1.234321e-33" },
1907         { 1.234321234321234e-32, "1.234321e-32" },
1908         { 1.234321234321234e-31, "1.234321e-31" },
1909         { 1.234321234321234e-30, "1.234321e-30" },
1910         { 1.234321234321234e-29, "1.234321e-29" },
1911         { 1.234321234321234e-28, "1.234321e-28" },
1912         { 1.234321234321234e-27, "1.234321e-27" },
1913         { 1.234321234321234e-26, "1.234321e-26" },
1914         { 1.234321234321234e-25, "1.234321e-25" },
1915         { 1.234321234321234e-24, "1.234321e-24" },
1916         { 1.234321234321234e-23, "1.234321e-23" },
1917         { 1.234321234321234e-22, "1.234321e-22" },
1918         { 1.234321234321234e-21, "1.234321e-21" },
1919         { 1.234321234321234e-20, "1.234321e-20" },
1920         { 1.234321234321234e-19, "1.234321e-19" },
1921         { 1.234321234321234e-18, "1.234321e-18" },
1922         { 1.234321234321234e-17, "1.234321e-17" },
1923         { 1.234321234321234e-16, "1.234321e-16" },
1924         { 1.234321234321234e-15, "1.234321e-15" },
1925         { 1.234321234321234e-14, "1.234321e-14" },
1926         { 1.234321234321234e-13, "1.234321e-13" },
1927         { 1.234321234321234e-12, "1.234321e-12" },
1928         { 1.234321234321234e-11, "1.234321e-11" },
1929         { 1.234321234321234e-10, "1.234321e-10" },
1930         { 1.234321234321234e-9, "1.234321e-09" },
1931         { 1.234321234321234e-8, "1.234321e-08" },
1932         { 1.234321234321234e-7, "1.234321e-07" },
1933         { 1.234321234321234e-6, "1.234321e-06" },
1934         { 1.234321234321234e-5, "1.234321e-05" },
1935         { 1.234321234321234e-4, "1.234321e-04" },
1936         { 1.234321234321234e-3, "1.234321e-03" },
1937         { 1.234321234321234e-2, "1.234321e-02" },
1938         { 1.234321234321234e-1, "1.234321e-01" },
1939         { 1.234321234321234, "1.234321e+00" },
1940         { 1.234321234321234e1, "1.234321e+01" },
1941         { 1.234321234321234e2, "1.234321e+02" },
1942         { 1.234321234321234e3, "1.234321e+03" },
1943         { 1.234321234321234e4, "1.234321e+04" },
1944         { 1.234321234321234e5, "1.234321e+05" },
1945         { 1.234321234321234e6, "1.234321e+06" },
1946         { 1.234321234321234e7, "1.234321e+07" },
1947         { 1.234321234321234e8, "1.234321e+08" },
1948         { 1.234321234321234e9, "1.234321e+09" },
1949         { 1.234321234321234e10, "1.234321e+10" },
1950         { 1.234321234321234e11, "1.234321e+11" },
1951         { 1.234321234321234e12, "1.234321e+12" },
1952         { 1.234321234321234e13, "1.234321e+13" },
1953         { 1.234321234321234e14, "1.234321e+14" },
1954         { 1.234321234321234e15, "1.234321e+15" },
1955         { 1.234321234321234e16, "1.234321e+16" },
1956         { 1.234321234321234e17, "1.234321e+17" },
1957         { 1.234321234321234e18, "1.234321e+18" },
1958         { 1.234321234321234e19, "1.234321e+19" },
1959         { 1.234321234321234e20, "1.234321e+20" },
1960         { 1.234321234321234e21, "1.234321e+21" },
1961         { 1.234321234321234e22, "1.234321e+22" },
1962         { 1.234321234321234e23, "1.234321e+23" },
1963         { 1.234321234321234e24, "1.234321e+24" },
1964         { 1.234321234321234e25, "1.234321e+25" },
1965         { 1.234321234321234e26, "1.234321e+26" },
1966         { 1.234321234321234e27, "1.234321e+27" },
1967         { 1.234321234321234e28, "1.234321e+28" },
1968         { 1.234321234321234e29, "1.234321e+29" },
1969         { 1.234321234321234e30, "1.234321e+30" },
1970         { 1.234321234321234e31, "1.234321e+31" },
1971         { 1.234321234321234e32, "1.234321e+32" },
1972         { 1.234321234321234e33, "1.234321e+33" },
1973         { 1.234321234321234e34, "1.234321e+34" },
1974         { 1.234321234321234e35, "1.234321e+35" },
1975         { 1.234321234321234e36, "1.234321e+36" }
1976       };
1977     size_t k;
1978     for (k = 0; k < SIZEOF (data); k++)
1979       {
1980         char *result;
1981         int retval =
1982           my_asprintf (&result, "%e", data[k].value);
1983         const char *expected = data[k].string;
1984         ASSERT (result != NULL);
1985         ASSERT (strcmp (result, expected) == 0
1986                 /* Some implementations produce exponents with 3 digits.  */
1987                 || (strlen (result) == strlen (expected) + 1
1988                     && memcmp (result, expected, strlen (expected) - 2) == 0
1989                     && result[strlen (expected) - 2] == '0'
1990                     && strcmp (result + strlen (expected) - 1,
1991                                expected + strlen (expected) - 2)
1992                        == 0));
1993         ASSERT (retval == strlen (result));
1994         free (result);
1995       }
1996   }
1997
1998   { /* A negative number.  */
1999     char *result;
2000     int retval =
2001       my_asprintf (&result, "%e %d", -0.03125, 33, 44, 55);
2002     ASSERT (result != NULL);
2003     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
2004             || strcmp (result, "-3.125000e-002 33") == 0);
2005     ASSERT (retval == strlen (result));
2006     free (result);
2007   }
2008
2009   { /* Positive zero.  */
2010     char *result;
2011     int retval =
2012       my_asprintf (&result, "%e %d", 0.0, 33, 44, 55);
2013     ASSERT (result != NULL);
2014     ASSERT (strcmp (result, "0.000000e+00 33") == 0
2015             || strcmp (result, "0.000000e+000 33") == 0);
2016     ASSERT (retval == strlen (result));
2017     free (result);
2018   }
2019
2020   { /* Negative zero.  */
2021     char *result;
2022     int retval =
2023       my_asprintf (&result, "%e %d", -zerod, 33, 44, 55);
2024     ASSERT (result != NULL);
2025     if (have_minus_zero ())
2026       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
2027               || strcmp (result, "-0.000000e+000 33") == 0);
2028     ASSERT (retval == strlen (result));
2029     free (result);
2030   }
2031
2032   { /* Positive infinity.  */
2033     char *result;
2034     int retval =
2035       my_asprintf (&result, "%e %d", 1.0 / 0.0, 33, 44, 55);
2036     ASSERT (result != NULL);
2037     ASSERT (strcmp (result, "inf 33") == 0
2038             || strcmp (result, "infinity 33") == 0);
2039     ASSERT (retval == strlen (result));
2040     free (result);
2041   }
2042
2043   { /* Negative infinity.  */
2044     char *result;
2045     int retval =
2046       my_asprintf (&result, "%e %d", -1.0 / 0.0, 33, 44, 55);
2047     ASSERT (result != NULL);
2048     ASSERT (strcmp (result, "-inf 33") == 0
2049             || strcmp (result, "-infinity 33") == 0);
2050     ASSERT (retval == strlen (result));
2051     free (result);
2052   }
2053
2054   { /* NaN.  */
2055     char *result;
2056     int retval =
2057       my_asprintf (&result, "%e %d", NaNd (), 33, 44, 55);
2058     ASSERT (result != NULL);
2059     ASSERT (strlen (result) >= 3 + 3
2060             && strisnan (result, 0, strlen (result) - 3, 0)
2061             && strcmp (result + strlen (result) - 3, " 33") == 0);
2062     ASSERT (retval == strlen (result));
2063     free (result);
2064   }
2065
2066   { /* Width.  */
2067     char *result;
2068     int retval =
2069       my_asprintf (&result, "%15e %d", 1.75, 33, 44, 55);
2070     ASSERT (result != NULL);
2071     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
2072             || strcmp (result, "  1.750000e+000 33") == 0);
2073     ASSERT (retval == strlen (result));
2074     free (result);
2075   }
2076
2077   { /* FLAG_LEFT.  */
2078     char *result;
2079     int retval =
2080       my_asprintf (&result, "%-15e %d", 1.75, 33, 44, 55);
2081     ASSERT (result != NULL);
2082     ASSERT (strcmp (result, "1.750000e+00    33") == 0
2083             || strcmp (result, "1.750000e+000   33") == 0);
2084     ASSERT (retval == strlen (result));
2085     free (result);
2086   }
2087
2088   { /* FLAG_SHOWSIGN.  */
2089     char *result;
2090     int retval =
2091       my_asprintf (&result, "%+e %d", 1.75, 33, 44, 55);
2092     ASSERT (result != NULL);
2093     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
2094             || strcmp (result, "+1.750000e+000 33") == 0);
2095     ASSERT (retval == strlen (result));
2096     free (result);
2097   }
2098
2099   { /* FLAG_SPACE.  */
2100     char *result;
2101     int retval =
2102       my_asprintf (&result, "% e %d", 1.75, 33, 44, 55);
2103     ASSERT (result != NULL);
2104     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2105             || strcmp (result, " 1.750000e+000 33") == 0);
2106     ASSERT (retval == strlen (result));
2107     free (result);
2108   }
2109
2110   { /* FLAG_ALT.  */
2111     char *result;
2112     int retval =
2113       my_asprintf (&result, "%#e %d", 1.75, 33, 44, 55);
2114     ASSERT (result != NULL);
2115     ASSERT (strcmp (result, "1.750000e+00 33") == 0
2116             || strcmp (result, "1.750000e+000 33") == 0);
2117     ASSERT (retval == strlen (result));
2118     free (result);
2119   }
2120
2121   { /* FLAG_ALT.  */
2122     char *result;
2123     int retval =
2124       my_asprintf (&result, "%#.e %d", 1.75, 33, 44, 55);
2125     ASSERT (result != NULL);
2126     ASSERT (strcmp (result, "2.e+00 33") == 0
2127             || strcmp (result, "2.e+000 33") == 0);
2128     ASSERT (retval == strlen (result));
2129     free (result);
2130   }
2131
2132   { /* FLAG_ALT.  */
2133     char *result;
2134     int retval =
2135       my_asprintf (&result, "%#.e %d", 9.75, 33, 44, 55);
2136     ASSERT (result != NULL);
2137     ASSERT (strcmp (result, "1.e+01 33") == 0
2138             || strcmp (result, "1.e+001 33") == 0);
2139     ASSERT (retval == strlen (result));
2140     free (result);
2141   }
2142
2143   { /* FLAG_ZERO with finite number.  */
2144     char *result;
2145     int retval =
2146       my_asprintf (&result, "%015e %d", 1234.0, 33, 44, 55);
2147     ASSERT (result != NULL);
2148     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
2149             || strcmp (result, "001.234000e+003 33") == 0);
2150     ASSERT (retval == strlen (result));
2151     free (result);
2152   }
2153
2154   { /* FLAG_ZERO with infinite number.  */
2155     char *result;
2156     int retval =
2157       my_asprintf (&result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
2158     ASSERT (result != NULL);
2159     ASSERT (strcmp (result, "           -inf 33") == 0
2160             || strcmp (result, "      -infinity 33") == 0);
2161     ASSERT (retval == strlen (result));
2162     free (result);
2163   }
2164
2165   { /* FLAG_ZERO with NaN.  */
2166     char *result;
2167     int retval =
2168       my_asprintf (&result, "%050e %d", NaNd (), 33, 44, 55);
2169     ASSERT (result != NULL);
2170     ASSERT (strlen (result) == 50 + 3
2171             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2172             && strcmp (result + strlen (result) - 3, " 33") == 0);
2173     ASSERT (retval == strlen (result));
2174     free (result);
2175   }
2176
2177   { /* Precision.  */
2178     char *result;
2179     int retval =
2180       my_asprintf (&result, "%.e %d", 1234.0, 33, 44, 55);
2181     ASSERT (result != NULL);
2182     ASSERT (strcmp (result, "1e+03 33") == 0
2183             || strcmp (result, "1e+003 33") == 0);
2184     ASSERT (retval == strlen (result));
2185     free (result);
2186   }
2187
2188   { /* Precision with no rounding.  */
2189     char *result;
2190     int retval =
2191       my_asprintf (&result, "%.4e %d", 999.951, 33, 44, 55);
2192     ASSERT (result != NULL);
2193     ASSERT (strcmp (result, "9.9995e+02 33") == 0
2194             || strcmp (result, "9.9995e+002 33") == 0);
2195     ASSERT (retval == strlen (result));
2196     free (result);
2197   }
2198
2199   { /* Precision with rounding.  */
2200     char *result;
2201     int retval =
2202       my_asprintf (&result, "%.4e %d", 999.996, 33, 44, 55);
2203     ASSERT (result != NULL);
2204     ASSERT (strcmp (result, "1.0000e+03 33") == 0
2205             || strcmp (result, "1.0000e+003 33") == 0);
2206     ASSERT (retval == strlen (result));
2207     free (result);
2208   }
2209
2210   { /* A positive number.  */
2211     char *result;
2212     int retval =
2213       my_asprintf (&result, "%Le %d", 12.75L, 33, 44, 55);
2214     ASSERT (result != NULL);
2215     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
2216     ASSERT (retval == strlen (result));
2217     free (result);
2218   }
2219
2220   { /* A larger positive number.  */
2221     char *result;
2222     int retval =
2223       my_asprintf (&result, "%Le %d", 1234567.0L, 33, 44, 55);
2224     ASSERT (result != NULL);
2225     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
2226     ASSERT (retval == strlen (result));
2227     free (result);
2228   }
2229
2230   { /* Small and large positive numbers.  */
2231     static struct { long double value; const char *string; } data[] =
2232       {
2233         { 1.234321234321234e-37L, "1.234321e-37" },
2234         { 1.234321234321234e-36L, "1.234321e-36" },
2235         { 1.234321234321234e-35L, "1.234321e-35" },
2236         { 1.234321234321234e-34L, "1.234321e-34" },
2237         { 1.234321234321234e-33L, "1.234321e-33" },
2238         { 1.234321234321234e-32L, "1.234321e-32" },
2239         { 1.234321234321234e-31L, "1.234321e-31" },
2240         { 1.234321234321234e-30L, "1.234321e-30" },
2241         { 1.234321234321234e-29L, "1.234321e-29" },
2242         { 1.234321234321234e-28L, "1.234321e-28" },
2243         { 1.234321234321234e-27L, "1.234321e-27" },
2244         { 1.234321234321234e-26L, "1.234321e-26" },
2245         { 1.234321234321234e-25L, "1.234321e-25" },
2246         { 1.234321234321234e-24L, "1.234321e-24" },
2247         { 1.234321234321234e-23L, "1.234321e-23" },
2248         { 1.234321234321234e-22L, "1.234321e-22" },
2249         { 1.234321234321234e-21L, "1.234321e-21" },
2250         { 1.234321234321234e-20L, "1.234321e-20" },
2251         { 1.234321234321234e-19L, "1.234321e-19" },
2252         { 1.234321234321234e-18L, "1.234321e-18" },
2253         { 1.234321234321234e-17L, "1.234321e-17" },
2254         { 1.234321234321234e-16L, "1.234321e-16" },
2255         { 1.234321234321234e-15L, "1.234321e-15" },
2256         { 1.234321234321234e-14L, "1.234321e-14" },
2257         { 1.234321234321234e-13L, "1.234321e-13" },
2258         { 1.234321234321234e-12L, "1.234321e-12" },
2259         { 1.234321234321234e-11L, "1.234321e-11" },
2260         { 1.234321234321234e-10L, "1.234321e-10" },
2261         { 1.234321234321234e-9L, "1.234321e-09" },
2262         { 1.234321234321234e-8L, "1.234321e-08" },
2263         { 1.234321234321234e-7L, "1.234321e-07" },
2264         { 1.234321234321234e-6L, "1.234321e-06" },
2265         { 1.234321234321234e-5L, "1.234321e-05" },
2266         { 1.234321234321234e-4L, "1.234321e-04" },
2267         { 1.234321234321234e-3L, "1.234321e-03" },
2268         { 1.234321234321234e-2L, "1.234321e-02" },
2269         { 1.234321234321234e-1L, "1.234321e-01" },
2270         { 1.234321234321234L, "1.234321e+00" },
2271         { 1.234321234321234e1L, "1.234321e+01" },
2272         { 1.234321234321234e2L, "1.234321e+02" },
2273         { 1.234321234321234e3L, "1.234321e+03" },
2274         { 1.234321234321234e4L, "1.234321e+04" },
2275         { 1.234321234321234e5L, "1.234321e+05" },
2276         { 1.234321234321234e6L, "1.234321e+06" },
2277         { 1.234321234321234e7L, "1.234321e+07" },
2278         { 1.234321234321234e8L, "1.234321e+08" },
2279         { 1.234321234321234e9L, "1.234321e+09" },
2280         { 1.234321234321234e10L, "1.234321e+10" },
2281         { 1.234321234321234e11L, "1.234321e+11" },
2282         { 1.234321234321234e12L, "1.234321e+12" },
2283         { 1.234321234321234e13L, "1.234321e+13" },
2284         { 1.234321234321234e14L, "1.234321e+14" },
2285         { 1.234321234321234e15L, "1.234321e+15" },
2286         { 1.234321234321234e16L, "1.234321e+16" },
2287         { 1.234321234321234e17L, "1.234321e+17" },
2288         { 1.234321234321234e18L, "1.234321e+18" },
2289         { 1.234321234321234e19L, "1.234321e+19" },
2290         { 1.234321234321234e20L, "1.234321e+20" },
2291         { 1.234321234321234e21L, "1.234321e+21" },
2292         { 1.234321234321234e22L, "1.234321e+22" },
2293         { 1.234321234321234e23L, "1.234321e+23" },
2294         { 1.234321234321234e24L, "1.234321e+24" },
2295         { 1.234321234321234e25L, "1.234321e+25" },
2296         { 1.234321234321234e26L, "1.234321e+26" },
2297         { 1.234321234321234e27L, "1.234321e+27" },
2298         { 1.234321234321234e28L, "1.234321e+28" },
2299         { 1.234321234321234e29L, "1.234321e+29" },
2300         { 1.234321234321234e30L, "1.234321e+30" },
2301         { 1.234321234321234e31L, "1.234321e+31" },
2302         { 1.234321234321234e32L, "1.234321e+32" },
2303         { 1.234321234321234e33L, "1.234321e+33" },
2304         { 1.234321234321234e34L, "1.234321e+34" },
2305         { 1.234321234321234e35L, "1.234321e+35" },
2306         { 1.234321234321234e36L, "1.234321e+36" }
2307       };
2308     size_t k;
2309     for (k = 0; k < SIZEOF (data); k++)
2310       {
2311         char *result;
2312         int retval =
2313           my_asprintf (&result, "%Le", data[k].value);
2314         ASSERT (result != NULL);
2315         ASSERT (strcmp (result, data[k].string) == 0);
2316         ASSERT (retval == strlen (result));
2317         free (result);
2318       }
2319   }
2320
2321   { /* A negative number.  */
2322     char *result;
2323     int retval =
2324       my_asprintf (&result, "%Le %d", -0.03125L, 33, 44, 55);
2325     ASSERT (result != NULL);
2326     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
2327     ASSERT (retval == strlen (result));
2328     free (result);
2329   }
2330
2331   { /* Positive zero.  */
2332     char *result;
2333     int retval =
2334       my_asprintf (&result, "%Le %d", 0.0L, 33, 44, 55);
2335     ASSERT (result != NULL);
2336     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
2337     ASSERT (retval == strlen (result));
2338     free (result);
2339   }
2340
2341   { /* Negative zero.  */
2342     char *result;
2343     int retval =
2344       my_asprintf (&result, "%Le %d", -zerol, 33, 44, 55);
2345     ASSERT (result != NULL);
2346     if (have_minus_zero ())
2347       ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
2348     ASSERT (retval == strlen (result));
2349     free (result);
2350   }
2351
2352   { /* Positive infinity.  */
2353     char *result;
2354     int retval =
2355       my_asprintf (&result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
2356     ASSERT (result != NULL);
2357     ASSERT (strcmp (result, "inf 33") == 0
2358             || strcmp (result, "infinity 33") == 0);
2359     ASSERT (retval == strlen (result));
2360     free (result);
2361   }
2362
2363   { /* Negative infinity.  */
2364     char *result;
2365     int retval =
2366       my_asprintf (&result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
2367     ASSERT (result != NULL);
2368     ASSERT (strcmp (result, "-inf 33") == 0
2369             || strcmp (result, "-infinity 33") == 0);
2370     ASSERT (retval == strlen (result));
2371     free (result);
2372   }
2373
2374   { /* NaN.  */
2375     char *result;
2376     int retval =
2377       my_asprintf (&result, "%Le %d", NaNl (), 33, 44, 55);
2378     ASSERT (result != NULL);
2379     ASSERT (strlen (result) >= 3 + 3
2380             && strisnan (result, 0, strlen (result) - 3, 0)
2381             && strcmp (result + strlen (result) - 3, " 33") == 0);
2382     ASSERT (retval == strlen (result));
2383     free (result);
2384   }
2385 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
2386   { /* Quiet NaN.  */
2387     static union { unsigned int word[4]; long double value; } x =
2388       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2389     char *result;
2390     int retval =
2391       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2392     ASSERT (result != NULL);
2393     ASSERT (strlen (result) >= 3 + 3
2394             && strisnan (result, 0, strlen (result) - 3, 0)
2395             && strcmp (result + strlen (result) - 3, " 33") == 0);
2396     ASSERT (retval == strlen (result));
2397     free (result);
2398   }
2399   {
2400     /* Signalling NaN.  */
2401     static union { unsigned int word[4]; long double value; } x =
2402       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2403     char *result;
2404     int retval =
2405       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2406     ASSERT (result != NULL);
2407     ASSERT (strlen (result) >= 3 + 3
2408             && strisnan (result, 0, strlen (result) - 3, 0)
2409             && strcmp (result + strlen (result) - 3, " 33") == 0);
2410     ASSERT (retval == strlen (result));
2411     free (result);
2412   }
2413   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2414      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2415        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2416        Application Architecture.
2417        Table 5-2 "Floating-Point Register Encodings"
2418        Figure 5-6 "Memory to Floating-Point Register Data Translation"
2419    */
2420   { /* Pseudo-NaN.  */
2421     static union { unsigned int word[4]; long double value; } x =
2422       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2423     char *result;
2424     int retval =
2425       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2426     ASSERT (result != NULL);
2427     ASSERT (strlen (result) >= 3 + 3
2428             && strisnan (result, 0, strlen (result) - 3, 0)
2429             && strcmp (result + strlen (result) - 3, " 33") == 0);
2430     ASSERT (retval == strlen (result));
2431     free (result);
2432   }
2433   { /* Pseudo-Infinity.  */
2434     static union { unsigned int word[4]; long double value; } x =
2435       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2436     char *result;
2437     int retval =
2438       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2439     ASSERT (result != NULL);
2440     ASSERT (strlen (result) >= 3 + 3
2441             && strisnan (result, 0, strlen (result) - 3, 0)
2442             && strcmp (result + strlen (result) - 3, " 33") == 0);
2443     ASSERT (retval == strlen (result));
2444     free (result);
2445   }
2446   { /* Pseudo-Zero.  */
2447     static union { unsigned int word[4]; long double value; } x =
2448       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2449     char *result;
2450     int retval =
2451       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2452     ASSERT (result != NULL);
2453     ASSERT (strlen (result) >= 3 + 3
2454             && strisnan (result, 0, strlen (result) - 3, 0)
2455             && strcmp (result + strlen (result) - 3, " 33") == 0);
2456     ASSERT (retval == strlen (result));
2457     free (result);
2458   }
2459   { /* Unnormalized number.  */
2460     static union { unsigned int word[4]; long double value; } x =
2461       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2462     char *result;
2463     int retval =
2464       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2465     ASSERT (result != NULL);
2466     ASSERT (strlen (result) >= 3 + 3
2467             && strisnan (result, 0, strlen (result) - 3, 0)
2468             && strcmp (result + strlen (result) - 3, " 33") == 0);
2469     ASSERT (retval == strlen (result));
2470     free (result);
2471   }
2472   { /* Pseudo-Denormal.  */
2473     static union { unsigned int word[4]; long double value; } x =
2474       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2475     char *result;
2476     int retval =
2477       my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2478     ASSERT (result != NULL);
2479     ASSERT (strlen (result) >= 3 + 3
2480             && strisnan (result, 0, strlen (result) - 3, 0)
2481             && strcmp (result + strlen (result) - 3, " 33") == 0);
2482     ASSERT (retval == strlen (result));
2483     free (result);
2484   }
2485 #endif
2486
2487   { /* Width.  */
2488     char *result;
2489     int retval =
2490       my_asprintf (&result, "%15Le %d", 1.75L, 33, 44, 55);
2491     ASSERT (result != NULL);
2492     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
2493     ASSERT (retval == strlen (result));
2494     free (result);
2495   }
2496
2497   { /* FLAG_LEFT.  */
2498     char *result;
2499     int retval =
2500       my_asprintf (&result, "%-15Le %d", 1.75L, 33, 44, 55);
2501     ASSERT (result != NULL);
2502     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
2503     ASSERT (retval == strlen (result));
2504     free (result);
2505   }
2506
2507   { /* FLAG_SHOWSIGN.  */
2508     char *result;
2509     int retval =
2510       my_asprintf (&result, "%+Le %d", 1.75L, 33, 44, 55);
2511     ASSERT (result != NULL);
2512     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2513     ASSERT (retval == strlen (result));
2514     free (result);
2515   }
2516
2517   { /* FLAG_SPACE.  */
2518     char *result;
2519     int retval =
2520       my_asprintf (&result, "% Le %d", 1.75L, 33, 44, 55);
2521     ASSERT (result != NULL);
2522     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2523     ASSERT (retval == strlen (result));
2524     free (result);
2525   }
2526
2527   { /* FLAG_ALT.  */
2528     char *result;
2529     int retval =
2530       my_asprintf (&result, "%#Le %d", 1.75L, 33, 44, 55);
2531     ASSERT (result != NULL);
2532     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2533     ASSERT (retval == strlen (result));
2534     free (result);
2535   }
2536
2537   { /* FLAG_ALT.  */
2538     char *result;
2539     int retval =
2540       my_asprintf (&result, "%#.Le %d", 1.75L, 33, 44, 55);
2541     ASSERT (result != NULL);
2542     ASSERT (strcmp (result, "2.e+00 33") == 0);
2543     ASSERT (retval == strlen (result));
2544     free (result);
2545   }
2546
2547   { /* FLAG_ALT.  */
2548     char *result;
2549     int retval =
2550       my_asprintf (&result, "%#.Le %d", 9.75L, 33, 44, 55);
2551     ASSERT (result != NULL);
2552     ASSERT (strcmp (result, "1.e+01 33") == 0);
2553     ASSERT (retval == strlen (result));
2554     free (result);
2555   }
2556
2557   { /* FLAG_ZERO with finite number.  */
2558     char *result;
2559     int retval =
2560       my_asprintf (&result, "%015Le %d", 1234.0L, 33, 44, 55);
2561     ASSERT (result != NULL);
2562     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2563     ASSERT (retval == strlen (result));
2564     free (result);
2565   }
2566
2567   { /* FLAG_ZERO with infinite number.  */
2568     char *result;
2569     int retval =
2570       my_asprintf (&result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2571     ASSERT (result != NULL);
2572     ASSERT (strcmp (result, "           -inf 33") == 0
2573             || strcmp (result, "      -infinity 33") == 0);
2574     ASSERT (retval == strlen (result));
2575     free (result);
2576   }
2577
2578   { /* FLAG_ZERO with NaN.  */
2579     char *result;
2580     int retval =
2581       my_asprintf (&result, "%050Le %d", NaNl (), 33, 44, 55);
2582     ASSERT (result != NULL);
2583     ASSERT (strlen (result) == 50 + 3
2584             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2585             && strcmp (result + strlen (result) - 3, " 33") == 0);
2586     ASSERT (retval == strlen (result));
2587     free (result);
2588   }
2589
2590   { /* Precision.  */
2591     char *result;
2592     int retval =
2593       my_asprintf (&result, "%.Le %d", 1234.0L, 33, 44, 55);
2594     ASSERT (result != NULL);
2595     ASSERT (strcmp (result, "1e+03 33") == 0);
2596     ASSERT (retval == strlen (result));
2597     free (result);
2598   }
2599
2600   { /* Precision with no rounding.  */
2601     char *result;
2602     int retval =
2603       my_asprintf (&result, "%.4Le %d", 999.951L, 33, 44, 55);
2604     ASSERT (result != NULL);
2605     ASSERT (strcmp (result, "9.9995e+02 33") == 0);
2606     ASSERT (retval == strlen (result));
2607     free (result);
2608   }
2609
2610   { /* Precision with rounding.  */
2611     char *result;
2612     int retval =
2613       my_asprintf (&result, "%.4Le %d", 999.996L, 33, 44, 55);
2614     ASSERT (result != NULL);
2615     ASSERT (strcmp (result, "1.0000e+03 33") == 0);
2616     ASSERT (retval == strlen (result));
2617     free (result);
2618   }
2619
2620   /* Test the support of the %g format directive.  */
2621
2622   { /* A positive number.  */
2623     char *result;
2624     int retval =
2625       my_asprintf (&result, "%g %d", 12.75, 33, 44, 55);
2626     ASSERT (result != NULL);
2627     ASSERT (strcmp (result, "12.75 33") == 0);
2628     ASSERT (retval == strlen (result));
2629     free (result);
2630   }
2631
2632   { /* A larger positive number.  */
2633     char *result;
2634     int retval =
2635       my_asprintf (&result, "%g %d", 1234567.0, 33, 44, 55);
2636     ASSERT (result != NULL);
2637     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2638             || strcmp (result, "1.23457e+006 33") == 0);
2639     ASSERT (retval == strlen (result));
2640     free (result);
2641   }
2642
2643   { /* Small and large positive numbers.  */
2644     static struct { double value; const char *string; } data[] =
2645       {
2646         { 1.234321234321234e-37, "1.23432e-37" },
2647         { 1.234321234321234e-36, "1.23432e-36" },
2648         { 1.234321234321234e-35, "1.23432e-35" },
2649         { 1.234321234321234e-34, "1.23432e-34" },
2650         { 1.234321234321234e-33, "1.23432e-33" },
2651         { 1.234321234321234e-32, "1.23432e-32" },
2652         { 1.234321234321234e-31, "1.23432e-31" },
2653         { 1.234321234321234e-30, "1.23432e-30" },
2654         { 1.234321234321234e-29, "1.23432e-29" },
2655         { 1.234321234321234e-28, "1.23432e-28" },
2656         { 1.234321234321234e-27, "1.23432e-27" },
2657         { 1.234321234321234e-26, "1.23432e-26" },
2658         { 1.234321234321234e-25, "1.23432e-25" },
2659         { 1.234321234321234e-24, "1.23432e-24" },
2660         { 1.234321234321234e-23, "1.23432e-23" },
2661         { 1.234321234321234e-22, "1.23432e-22" },
2662         { 1.234321234321234e-21, "1.23432e-21" },
2663         { 1.234321234321234e-20, "1.23432e-20" },
2664         { 1.234321234321234e-19, "1.23432e-19" },
2665         { 1.234321234321234e-18, "1.23432e-18" },
2666         { 1.234321234321234e-17, "1.23432e-17" },
2667         { 1.234321234321234e-16, "1.23432e-16" },
2668         { 1.234321234321234e-15, "1.23432e-15" },
2669         { 1.234321234321234e-14, "1.23432e-14" },
2670         { 1.234321234321234e-13, "1.23432e-13" },
2671         { 1.234321234321234e-12, "1.23432e-12" },
2672         { 1.234321234321234e-11, "1.23432e-11" },
2673         { 1.234321234321234e-10, "1.23432e-10" },
2674         { 1.234321234321234e-9, "1.23432e-09" },
2675         { 1.234321234321234e-8, "1.23432e-08" },
2676         { 1.234321234321234e-7, "1.23432e-07" },
2677         { 1.234321234321234e-6, "1.23432e-06" },
2678         { 1.234321234321234e-5, "1.23432e-05" },
2679         { 1.234321234321234e-4, "0.000123432" },
2680         { 1.234321234321234e-3, "0.00123432" },
2681         { 1.234321234321234e-2, "0.0123432" },
2682         { 1.234321234321234e-1, "0.123432" },
2683         { 1.234321234321234, "1.23432" },
2684         { 1.234321234321234e1, "12.3432" },
2685         { 1.234321234321234e2, "123.432" },
2686         { 1.234321234321234e3, "1234.32" },
2687         { 1.234321234321234e4, "12343.2" },
2688         { 1.234321234321234e5, "123432" },
2689         { 1.234321234321234e6, "1.23432e+06" },
2690         { 1.234321234321234e7, "1.23432e+07" },
2691         { 1.234321234321234e8, "1.23432e+08" },
2692         { 1.234321234321234e9, "1.23432e+09" },
2693         { 1.234321234321234e10, "1.23432e+10" },
2694         { 1.234321234321234e11, "1.23432e+11" },
2695         { 1.234321234321234e12, "1.23432e+12" },
2696         { 1.234321234321234e13, "1.23432e+13" },
2697         { 1.234321234321234e14, "1.23432e+14" },
2698         { 1.234321234321234e15, "1.23432e+15" },
2699         { 1.234321234321234e16, "1.23432e+16" },
2700         { 1.234321234321234e17, "1.23432e+17" },
2701         { 1.234321234321234e18, "1.23432e+18" },
2702         { 1.234321234321234e19, "1.23432e+19" },
2703         { 1.234321234321234e20, "1.23432e+20" },
2704         { 1.234321234321234e21, "1.23432e+21" },
2705         { 1.234321234321234e22, "1.23432e+22" },
2706         { 1.234321234321234e23, "1.23432e+23" },
2707         { 1.234321234321234e24, "1.23432e+24" },
2708         { 1.234321234321234e25, "1.23432e+25" },
2709         { 1.234321234321234e26, "1.23432e+26" },
2710         { 1.234321234321234e27, "1.23432e+27" },
2711         { 1.234321234321234e28, "1.23432e+28" },
2712         { 1.234321234321234e29, "1.23432e+29" },
2713         { 1.234321234321234e30, "1.23432e+30" },
2714         { 1.234321234321234e31, "1.23432e+31" },
2715         { 1.234321234321234e32, "1.23432e+32" },
2716         { 1.234321234321234e33, "1.23432e+33" },
2717         { 1.234321234321234e34, "1.23432e+34" },
2718         { 1.234321234321234e35, "1.23432e+35" },
2719         { 1.234321234321234e36, "1.23432e+36" }
2720       };
2721     size_t k;
2722     for (k = 0; k < SIZEOF (data); k++)
2723       {
2724         char *result;
2725         int retval =
2726           my_asprintf (&result, "%g", data[k].value);
2727         const char *expected = data[k].string;
2728         ASSERT (result != NULL);
2729         ASSERT (strcmp (result, expected) == 0
2730                 /* Some implementations produce exponents with 3 digits.  */
2731                 || (expected[strlen (expected) - 4] == 'e'
2732                     && strlen (result) == strlen (expected) + 1
2733                     && memcmp (result, expected, strlen (expected) - 2) == 0
2734                     && result[strlen (expected) - 2] == '0'
2735                     && strcmp (result + strlen (expected) - 1,
2736                                expected + strlen (expected) - 2)
2737                        == 0));
2738         ASSERT (retval == strlen (result));
2739         free (result);
2740       }
2741   }
2742
2743   { /* A negative number.  */
2744     char *result;
2745     int retval =
2746       my_asprintf (&result, "%g %d", -0.03125, 33, 44, 55);
2747     ASSERT (result != NULL);
2748     ASSERT (strcmp (result, "-0.03125 33") == 0);
2749     ASSERT (retval == strlen (result));
2750     free (result);
2751   }
2752
2753   { /* Positive zero.  */
2754     char *result;
2755     int retval =
2756       my_asprintf (&result, "%g %d", 0.0, 33, 44, 55);
2757     ASSERT (result != NULL);
2758     ASSERT (strcmp (result, "0 33") == 0);
2759     ASSERT (retval == strlen (result));
2760     free (result);
2761   }
2762
2763   { /* Negative zero.  */
2764     char *result;
2765     int retval =
2766       my_asprintf (&result, "%g %d", -zerod, 33, 44, 55);
2767     ASSERT (result != NULL);
2768     if (have_minus_zero ())
2769       ASSERT (strcmp (result, "-0 33") == 0);
2770     ASSERT (retval == strlen (result));
2771     free (result);
2772   }
2773
2774   { /* Positive infinity.  */
2775     char *result;
2776     int retval =
2777       my_asprintf (&result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2778     ASSERT (result != NULL);
2779     ASSERT (strcmp (result, "inf 33") == 0
2780             || strcmp (result, "infinity 33") == 0);
2781     ASSERT (retval == strlen (result));
2782     free (result);
2783   }
2784
2785   { /* Negative infinity.  */
2786     char *result;
2787     int retval =
2788       my_asprintf (&result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2789     ASSERT (result != NULL);
2790     ASSERT (strcmp (result, "-inf 33") == 0
2791             || strcmp (result, "-infinity 33") == 0);
2792     ASSERT (retval == strlen (result));
2793     free (result);
2794   }
2795
2796   { /* NaN.  */
2797     char *result;
2798     int retval =
2799       my_asprintf (&result, "%g %d", NaNd (), 33, 44, 55);
2800     ASSERT (result != NULL);
2801     ASSERT (strlen (result) >= 3 + 3
2802             && strisnan (result, 0, strlen (result) - 3, 0)
2803             && strcmp (result + strlen (result) - 3, " 33") == 0);
2804     ASSERT (retval == strlen (result));
2805     free (result);
2806   }
2807
2808   { /* Width.  */
2809     char *result;
2810     int retval =
2811       my_asprintf (&result, "%10g %d", 1.75, 33, 44, 55);
2812     ASSERT (result != NULL);
2813     ASSERT (strcmp (result, "      1.75 33") == 0);
2814     ASSERT (retval == strlen (result));
2815     free (result);
2816   }
2817
2818   { /* FLAG_LEFT.  */
2819     char *result;
2820     int retval =
2821       my_asprintf (&result, "%-10g %d", 1.75, 33, 44, 55);
2822     ASSERT (result != NULL);
2823     ASSERT (strcmp (result, "1.75       33") == 0);
2824     ASSERT (retval == strlen (result));
2825     free (result);
2826   }
2827
2828   { /* FLAG_SHOWSIGN.  */
2829     char *result;
2830     int retval =
2831       my_asprintf (&result, "%+g %d", 1.75, 33, 44, 55);
2832     ASSERT (result != NULL);
2833     ASSERT (strcmp (result, "+1.75 33") == 0);
2834     ASSERT (retval == strlen (result));
2835     free (result);
2836   }
2837
2838   { /* FLAG_SPACE.  */
2839     char *result;
2840     int retval =
2841       my_asprintf (&result, "% g %d", 1.75, 33, 44, 55);
2842     ASSERT (result != NULL);
2843     ASSERT (strcmp (result, " 1.75 33") == 0);
2844     ASSERT (retval == strlen (result));
2845     free (result);
2846   }
2847
2848   { /* FLAG_ALT.  */
2849     char *result;
2850     int retval =
2851       my_asprintf (&result, "%#g %d", 1.75, 33, 44, 55);
2852     ASSERT (result != NULL);
2853     ASSERT (strcmp (result, "1.75000 33") == 0);
2854     ASSERT (retval == strlen (result));
2855     free (result);
2856   }
2857
2858   { /* FLAG_ALT.  */
2859     char *result;
2860     int retval =
2861       my_asprintf (&result, "%#.g %d", 1.75, 33, 44, 55);
2862     ASSERT (result != NULL);
2863     ASSERT (strcmp (result, "2. 33") == 0);
2864     ASSERT (retval == strlen (result));
2865     free (result);
2866   }
2867
2868   { /* FLAG_ALT.  */
2869     char *result;
2870     int retval =
2871       my_asprintf (&result, "%#.g %d", 9.75, 33, 44, 55);
2872     ASSERT (result != NULL);
2873     ASSERT (strcmp (result, "1.e+01 33") == 0
2874             || strcmp (result, "1.e+001 33") == 0);
2875     ASSERT (retval == strlen (result));
2876     free (result);
2877   }
2878
2879   { /* FLAG_ZERO with finite number.  */
2880     char *result;
2881     int retval =
2882       my_asprintf (&result, "%010g %d", 1234.0, 33, 44, 55);
2883     ASSERT (result != NULL);
2884     ASSERT (strcmp (result, "0000001234 33") == 0);
2885     ASSERT (retval == strlen (result));
2886     free (result);
2887   }
2888
2889   { /* FLAG_ZERO with infinite number.  */
2890     char *result;
2891     int retval =
2892       my_asprintf (&result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2893     ASSERT (result != NULL);
2894     ASSERT (strcmp (result, "           -inf 33") == 0
2895             || strcmp (result, "      -infinity 33") == 0);
2896     ASSERT (retval == strlen (result));
2897     free (result);
2898   }
2899
2900   { /* FLAG_ZERO with NaN.  */
2901     char *result;
2902     int retval =
2903       my_asprintf (&result, "%050g %d", NaNd (), 33, 44, 55);
2904     ASSERT (result != NULL);
2905     ASSERT (strlen (result) == 50 + 3
2906             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2907             && strcmp (result + strlen (result) - 3, " 33") == 0);
2908     ASSERT (retval == strlen (result));
2909     free (result);
2910   }
2911
2912   { /* Precision.  */
2913     char *result;
2914     int retval =
2915       my_asprintf (&result, "%.g %d", 1234.0, 33, 44, 55);
2916     ASSERT (result != NULL);
2917     ASSERT (strcmp (result, "1e+03 33") == 0
2918             || strcmp (result, "1e+003 33") == 0);
2919     ASSERT (retval == strlen (result));
2920     free (result);
2921   }
2922
2923   { /* Precision with no rounding.  */
2924     char *result;
2925     int retval =
2926       my_asprintf (&result, "%.5g %d", 999.951, 33, 44, 55);
2927     ASSERT (result != NULL);
2928     ASSERT (strcmp (result, "999.95 33") == 0);
2929     ASSERT (retval == strlen (result));
2930     free (result);
2931   }
2932
2933   { /* Precision with rounding.  */
2934     char *result;
2935     int retval =
2936       my_asprintf (&result, "%.5g %d", 999.996, 33, 44, 55);
2937     ASSERT (result != NULL);
2938     ASSERT (strcmp (result, "1000 33") == 0);
2939     ASSERT (retval == strlen (result));
2940     free (result);
2941   }
2942
2943   { /* A positive number.  */
2944     char *result;
2945     int retval =
2946       my_asprintf (&result, "%Lg %d", 12.75L, 33, 44, 55);
2947     ASSERT (result != NULL);
2948     ASSERT (strcmp (result, "12.75 33") == 0);
2949     ASSERT (retval == strlen (result));
2950     free (result);
2951   }
2952
2953   { /* A larger positive number.  */
2954     char *result;
2955     int retval =
2956       my_asprintf (&result, "%Lg %d", 1234567.0L, 33, 44, 55);
2957     ASSERT (result != NULL);
2958     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2959     ASSERT (retval == strlen (result));
2960     free (result);
2961   }
2962
2963   { /* Small and large positive numbers.  */
2964     static struct { long double value; const char *string; } data[] =
2965       {
2966         { 1.234321234321234e-37L, "1.23432e-37" },
2967         { 1.234321234321234e-36L, "1.23432e-36" },
2968         { 1.234321234321234e-35L, "1.23432e-35" },
2969         { 1.234321234321234e-34L, "1.23432e-34" },
2970         { 1.234321234321234e-33L, "1.23432e-33" },
2971         { 1.234321234321234e-32L, "1.23432e-32" },
2972         { 1.234321234321234e-31L, "1.23432e-31" },
2973         { 1.234321234321234e-30L, "1.23432e-30" },
2974         { 1.234321234321234e-29L, "1.23432e-29" },
2975         { 1.234321234321234e-28L, "1.23432e-28" },
2976         { 1.234321234321234e-27L, "1.23432e-27" },
2977         { 1.234321234321234e-26L, "1.23432e-26" },
2978         { 1.234321234321234e-25L, "1.23432e-25" },
2979         { 1.234321234321234e-24L, "1.23432e-24" },
2980         { 1.234321234321234e-23L, "1.23432e-23" },
2981         { 1.234321234321234e-22L, "1.23432e-22" },
2982         { 1.234321234321234e-21L, "1.23432e-21" },
2983         { 1.234321234321234e-20L, "1.23432e-20" },
2984         { 1.234321234321234e-19L, "1.23432e-19" },
2985         { 1.234321234321234e-18L, "1.23432e-18" },
2986         { 1.234321234321234e-17L, "1.23432e-17" },
2987         { 1.234321234321234e-16L, "1.23432e-16" },
2988         { 1.234321234321234e-15L, "1.23432e-15" },
2989         { 1.234321234321234e-14L, "1.23432e-14" },
2990         { 1.234321234321234e-13L, "1.23432e-13" },
2991         { 1.234321234321234e-12L, "1.23432e-12" },
2992         { 1.234321234321234e-11L, "1.23432e-11" },
2993         { 1.234321234321234e-10L, "1.23432e-10" },
2994         { 1.234321234321234e-9L, "1.23432e-09" },
2995         { 1.234321234321234e-8L, "1.23432e-08" },
2996         { 1.234321234321234e-7L, "1.23432e-07" },
2997         { 1.234321234321234e-6L, "1.23432e-06" },
2998         { 1.234321234321234e-5L, "1.23432e-05" },
2999         { 1.234321234321234e-4L, "0.000123432" },
3000         { 1.234321234321234e-3L, "0.00123432" },
3001         { 1.234321234321234e-2L, "0.0123432" },
3002         { 1.234321234321234e-1L, "0.123432" },
3003         { 1.234321234321234L, "1.23432" },
3004         { 1.234321234321234e1L, "12.3432" },
3005         { 1.234321234321234e2L, "123.432" },
3006         { 1.234321234321234e3L, "1234.32" },
3007         { 1.234321234321234e4L, "12343.2" },
3008         { 1.234321234321234e5L, "123432" },
3009         { 1.234321234321234e6L, "1.23432e+06" },
3010         { 1.234321234321234e7L, "1.23432e+07" },
3011         { 1.234321234321234e8L, "1.23432e+08" },
3012         { 1.234321234321234e9L, "1.23432e+09" },
3013         { 1.234321234321234e10L, "1.23432e+10" },
3014         { 1.234321234321234e11L, "1.23432e+11" },
3015         { 1.234321234321234e12L, "1.23432e+12" },
3016         { 1.234321234321234e13L, "1.23432e+13" },
3017         { 1.234321234321234e14L, "1.23432e+14" },
3018         { 1.234321234321234e15L, "1.23432e+15" },
3019         { 1.234321234321234e16L, "1.23432e+16" },
3020         { 1.234321234321234e17L, "1.23432e+17" },
3021         { 1.234321234321234e18L, "1.23432e+18" },
3022         { 1.234321234321234e19L, "1.23432e+19" },
3023         { 1.234321234321234e20L, "1.23432e+20" },
3024         { 1.234321234321234e21L, "1.23432e+21" },
3025         { 1.234321234321234e22L, "1.23432e+22" },
3026         { 1.234321234321234e23L, "1.23432e+23" },
3027         { 1.234321234321234e24L, "1.23432e+24" },
3028         { 1.234321234321234e25L, "1.23432e+25" },
3029         { 1.234321234321234e26L, "1.23432e+26" },
3030         { 1.234321234321234e27L, "1.23432e+27" },
3031         { 1.234321234321234e28L, "1.23432e+28" },
3032         { 1.234321234321234e29L, "1.23432e+29" },
3033         { 1.234321234321234e30L, "1.23432e+30" },
3034         { 1.234321234321234e31L, "1.23432e+31" },
3035         { 1.234321234321234e32L, "1.23432e+32" },
3036         { 1.234321234321234e33L, "1.23432e+33" },
3037         { 1.234321234321234e34L, "1.23432e+34" },
3038         { 1.234321234321234e35L, "1.23432e+35" },
3039         { 1.234321234321234e36L, "1.23432e+36" }
3040       };
3041     size_t k;
3042     for (k = 0; k < SIZEOF (data); k++)
3043       {
3044         char *result;
3045         int retval =
3046           my_asprintf (&result, "%Lg", data[k].value);
3047         ASSERT (result != NULL);
3048         ASSERT (strcmp (result, data[k].string) == 0);
3049         ASSERT (retval == strlen (result));
3050         free (result);
3051       }
3052   }
3053
3054   { /* A negative number.  */
3055     char *result;
3056     int retval =
3057       my_asprintf (&result, "%Lg %d", -0.03125L, 33, 44, 55);
3058     ASSERT (result != NULL);
3059     ASSERT (strcmp (result, "-0.03125 33") == 0);
3060     ASSERT (retval == strlen (result));
3061     free (result);
3062   }
3063
3064   { /* Positive zero.  */
3065     char *result;
3066     int retval =
3067       my_asprintf (&result, "%Lg %d", 0.0L, 33, 44, 55);
3068     ASSERT (result != NULL);
3069     ASSERT (strcmp (result, "0 33") == 0);
3070     ASSERT (retval == strlen (result));
3071     free (result);
3072   }
3073
3074   { /* Negative zero.  */
3075     char *result;
3076     int retval =
3077       my_asprintf (&result, "%Lg %d", -zerol, 33, 44, 55);
3078     ASSERT (result != NULL);
3079     if (have_minus_zero ())
3080       ASSERT (strcmp (result, "-0 33") == 0);
3081     ASSERT (retval == strlen (result));
3082     free (result);
3083   }
3084
3085   { /* Positive infinity.  */
3086     char *result;
3087     int retval =
3088       my_asprintf (&result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
3089     ASSERT (result != NULL);
3090     ASSERT (strcmp (result, "inf 33") == 0
3091             || strcmp (result, "infinity 33") == 0);
3092     ASSERT (retval == strlen (result));
3093     free (result);
3094   }
3095
3096   { /* Negative infinity.  */
3097     char *result;
3098     int retval =
3099       my_asprintf (&result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
3100     ASSERT (result != NULL);
3101     ASSERT (strcmp (result, "-inf 33") == 0
3102             || strcmp (result, "-infinity 33") == 0);
3103     ASSERT (retval == strlen (result));
3104     free (result);
3105   }
3106
3107   { /* NaN.  */
3108     char *result;
3109     int retval =
3110       my_asprintf (&result, "%Lg %d", NaNl (), 33, 44, 55);
3111     ASSERT (result != NULL);
3112     ASSERT (strlen (result) >= 3 + 3
3113             && strisnan (result, 0, strlen (result) - 3, 0)
3114             && strcmp (result + strlen (result) - 3, " 33") == 0);
3115     ASSERT (retval == strlen (result));
3116     free (result);
3117   }
3118 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
3119   { /* Quiet NaN.  */
3120     static union { unsigned int word[4]; long double value; } x =
3121       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
3122     char *result;
3123     int retval =
3124       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3125     ASSERT (result != NULL);
3126     ASSERT (strlen (result) >= 3 + 3
3127             && strisnan (result, 0, strlen (result) - 3, 0)
3128             && strcmp (result + strlen (result) - 3, " 33") == 0);
3129     ASSERT (retval == strlen (result));
3130     free (result);
3131   }
3132   {
3133     /* Signalling NaN.  */
3134     static union { unsigned int word[4]; long double value; } x =
3135       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
3136     char *result;
3137     int retval =
3138       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3139     ASSERT (result != NULL);
3140     ASSERT (strlen (result) >= 3 + 3
3141             && strisnan (result, 0, strlen (result) - 3, 0)
3142             && strcmp (result + strlen (result) - 3, " 33") == 0);
3143     ASSERT (retval == strlen (result));
3144     free (result);
3145   }
3146   /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
3147      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
3148        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
3149        Application Architecture.
3150        Table 5-2 "Floating-Point Register Encodings"
3151        Figure 5-6 "Memory to Floating-Point Register Data Translation"
3152    */
3153   { /* Pseudo-NaN.  */
3154     static union { unsigned int word[4]; long double value; } x =
3155       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
3156     char *result;
3157     int retval =
3158       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3159     ASSERT (result != NULL);
3160     ASSERT (strlen (result) >= 3 + 3
3161             && strisnan (result, 0, strlen (result) - 3, 0)
3162             && strcmp (result + strlen (result) - 3, " 33") == 0);
3163     ASSERT (retval == strlen (result));
3164     free (result);
3165   }
3166   { /* Pseudo-Infinity.  */
3167     static union { unsigned int word[4]; long double value; } x =
3168       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
3169     char *result;
3170     int retval =
3171       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3172     ASSERT (result != NULL);
3173     ASSERT (strlen (result) >= 3 + 3
3174             && strisnan (result, 0, strlen (result) - 3, 0)
3175             && strcmp (result + strlen (result) - 3, " 33") == 0);
3176     ASSERT (retval == strlen (result));
3177     free (result);
3178   }
3179   { /* Pseudo-Zero.  */
3180     static union { unsigned int word[4]; long double value; } x =
3181       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
3182     char *result;
3183     int retval =
3184       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3185     ASSERT (result != NULL);
3186     ASSERT (strlen (result) >= 3 + 3
3187             && strisnan (result, 0, strlen (result) - 3, 0)
3188             && strcmp (result + strlen (result) - 3, " 33") == 0);
3189     ASSERT (retval == strlen (result));
3190     free (result);
3191   }
3192   { /* Unnormalized number.  */
3193     static union { unsigned int word[4]; long double value; } x =
3194       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
3195     char *result;
3196     int retval =
3197       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3198     ASSERT (result != NULL);
3199     ASSERT (strlen (result) >= 3 + 3
3200             && strisnan (result, 0, strlen (result) - 3, 0)
3201             && strcmp (result + strlen (result) - 3, " 33") == 0);
3202     ASSERT (retval == strlen (result));
3203     free (result);
3204   }
3205   { /* Pseudo-Denormal.  */
3206     static union { unsigned int word[4]; long double value; } x =
3207       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
3208     char *result;
3209     int retval =
3210       my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3211     ASSERT (result != NULL);
3212     ASSERT (strlen (result) >= 3 + 3
3213             && strisnan (result, 0, strlen (result) - 3, 0)
3214             && strcmp (result + strlen (result) - 3, " 33") == 0);
3215     ASSERT (retval == strlen (result));
3216     free (result);
3217   }
3218 #endif
3219
3220   { /* Width.  */
3221     char *result;
3222     int retval =
3223       my_asprintf (&result, "%10Lg %d", 1.75L, 33, 44, 55);
3224     ASSERT (result != NULL);
3225     ASSERT (strcmp (result, "      1.75 33") == 0);
3226     ASSERT (retval == strlen (result));
3227     free (result);
3228   }
3229
3230   { /* FLAG_LEFT.  */
3231     char *result;
3232     int retval =
3233       my_asprintf (&result, "%-10Lg %d", 1.75L, 33, 44, 55);
3234     ASSERT (result != NULL);
3235     ASSERT (strcmp (result, "1.75       33") == 0);
3236     ASSERT (retval == strlen (result));
3237     free (result);
3238   }
3239
3240   { /* FLAG_SHOWSIGN.  */
3241     char *result;
3242     int retval =
3243       my_asprintf (&result, "%+Lg %d", 1.75L, 33, 44, 55);
3244     ASSERT (result != NULL);
3245     ASSERT (strcmp (result, "+1.75 33") == 0);
3246     ASSERT (retval == strlen (result));
3247     free (result);
3248   }
3249
3250   { /* FLAG_SPACE.  */
3251     char *result;
3252     int retval =
3253       my_asprintf (&result, "% Lg %d", 1.75L, 33, 44, 55);
3254     ASSERT (result != NULL);
3255     ASSERT (strcmp (result, " 1.75 33") == 0);
3256     ASSERT (retval == strlen (result));
3257     free (result);
3258   }
3259
3260   { /* FLAG_ALT.  */
3261     char *result;
3262     int retval =
3263       my_asprintf (&result, "%#Lg %d", 1.75L, 33, 44, 55);
3264     ASSERT (result != NULL);
3265     ASSERT (strcmp (result, "1.75000 33") == 0);
3266     ASSERT (retval == strlen (result));
3267     free (result);
3268   }
3269
3270   { /* FLAG_ALT.  */
3271     char *result;
3272     int retval =
3273       my_asprintf (&result, "%#.Lg %d", 1.75L, 33, 44, 55);
3274     ASSERT (result != NULL);
3275     ASSERT (strcmp (result, "2. 33") == 0);
3276     ASSERT (retval == strlen (result));
3277     free (result);
3278   }
3279
3280   { /* FLAG_ALT.  */
3281     char *result;
3282     int retval =
3283       my_asprintf (&result, "%#.Lg %d", 9.75L, 33, 44, 55);
3284     ASSERT (result != NULL);
3285     ASSERT (strcmp (result, "1.e+01 33") == 0);
3286     ASSERT (retval == strlen (result));
3287     free (result);
3288   }
3289
3290   { /* FLAG_ZERO with finite number.  */
3291     char *result;
3292     int retval =
3293       my_asprintf (&result, "%010Lg %d", 1234.0L, 33, 44, 55);
3294     ASSERT (result != NULL);
3295     ASSERT (strcmp (result, "0000001234 33") == 0);
3296     ASSERT (retval == strlen (result));
3297     free (result);
3298   }
3299
3300   { /* FLAG_ZERO with infinite number.  */
3301     char *result;
3302     int retval =
3303       my_asprintf (&result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
3304     ASSERT (result != NULL);
3305     ASSERT (strcmp (result, "           -inf 33") == 0
3306             || strcmp (result, "      -infinity 33") == 0);
3307     ASSERT (retval == strlen (result));
3308     free (result);
3309   }
3310
3311   { /* FLAG_ZERO with NaN.  */
3312     char *result;
3313     int retval =
3314       my_asprintf (&result, "%050Lg %d", NaNl (), 33, 44, 55);
3315     ASSERT (result != NULL);
3316     ASSERT (strlen (result) == 50 + 3
3317             && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
3318             && strcmp (result + strlen (result) - 3, " 33") == 0);
3319     ASSERT (retval == strlen (result));
3320     free (result);
3321   }
3322
3323   { /* Precision.  */
3324     char *result;
3325     int retval =
3326       my_asprintf (&result, "%.Lg %d", 1234.0L, 33, 44, 55);
3327     ASSERT (result != NULL);
3328     ASSERT (strcmp (result, "1e+03 33") == 0);
3329     ASSERT (retval == strlen (result));
3330     free (result);
3331   }
3332
3333   { /* Precision with no rounding.  */
3334     char *result;
3335     int retval =
3336       my_asprintf (&result, "%.5Lg %d", 999.951L, 33, 44, 55);
3337     ASSERT (result != NULL);
3338     ASSERT (strcmp (result, "999.95 33") == 0);
3339     ASSERT (retval == strlen (result));
3340     free (result);
3341   }
3342
3343   { /* Precision with rounding.  */
3344     char *result;
3345     int retval =
3346       my_asprintf (&result, "%.5Lg %d", 999.996L, 33, 44, 55);
3347     ASSERT (result != NULL);
3348     ASSERT (strcmp (result, "1000 33") == 0);
3349     ASSERT (retval == strlen (result));
3350     free (result);
3351   }
3352
3353   /* Test the support of the %n format directive.  */
3354
3355   {
3356     int count = -1;
3357     char *result;
3358     int retval =
3359       my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
3360     ASSERT (result != NULL);
3361     ASSERT (strcmp (result, "123 ") == 0);
3362     ASSERT (retval == strlen (result));
3363     ASSERT (count == 4);
3364     free (result);
3365   }
3366
3367   /* Test the support of the POSIX/XSI format strings with positions.  */
3368
3369   {
3370     char *result;
3371     int retval =
3372       my_asprintf (&result, "%2$d %1$d", 33, 55);
3373     ASSERT (result != NULL);
3374     ASSERT (strcmp (result, "55 33") == 0);
3375     ASSERT (retval == strlen (result));
3376     free (result);
3377   }
3378
3379   /* Test the support of the grouping flag.  */
3380
3381   {
3382     char *result;
3383     int retval =
3384       my_asprintf (&result, "%'d %d", 1234567, 99);
3385     ASSERT (result != NULL);
3386     ASSERT (result[strlen (result) - 1] == '9');
3387     ASSERT (retval == strlen (result));
3388     free (result);
3389   }
3390
3391   /* Test the support of the left-adjust flag.  */
3392
3393   {
3394     char *result;
3395     int retval =
3396       my_asprintf (&result, "a%*sc", -3, "b");
3397     ASSERT (result != NULL);
3398     ASSERT (strcmp (result, "ab  c") == 0);
3399     ASSERT (retval == strlen (result));
3400     free (result);
3401   }
3402
3403   {
3404     char *result;
3405     int retval =
3406       my_asprintf (&result, "a%-*sc", 3, "b");
3407     ASSERT (result != NULL);
3408     ASSERT (strcmp (result, "ab  c") == 0);
3409     ASSERT (retval == strlen (result));
3410     free (result);
3411   }
3412
3413   {
3414     char *result;
3415     int retval =
3416       my_asprintf (&result, "a%-*sc", -3, "b");
3417     ASSERT (result != NULL);
3418     ASSERT (strcmp (result, "ab  c") == 0);
3419     ASSERT (retval == strlen (result));
3420     free (result);
3421   }
3422
3423   /* Test the support of large precision.  */
3424
3425   {
3426     char *result;
3427     int retval =
3428       my_asprintf (&result, "%.4000d %d", 1234567, 99);
3429     size_t i;
3430     ASSERT (result != NULL);
3431     for (i = 0; i < 4000 - 7; i++)
3432       ASSERT (result[i] == '0');
3433     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
3434     ASSERT (retval == strlen (result));
3435     free (result);
3436   }
3437
3438   {
3439     char *result;
3440     int retval =
3441       my_asprintf (&result, "%.*d %d", 4000, 1234567, 99);
3442     size_t i;
3443     ASSERT (result != NULL);
3444     for (i = 0; i < 4000 - 7; i++)
3445       ASSERT (result[i] == '0');
3446     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
3447     ASSERT (retval == strlen (result));
3448     free (result);
3449   }
3450
3451   {
3452     char *result;
3453     int retval =
3454       my_asprintf (&result, "%.4000d %d", -1234567, 99);
3455     size_t i;
3456     ASSERT (result != NULL);
3457     ASSERT (result[0] == '-');
3458     for (i = 0; i < 4000 - 7; i++)
3459       ASSERT (result[1 + i] == '0');
3460     ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
3461     ASSERT (retval == strlen (result));
3462     free (result);
3463   }
3464
3465   {
3466     char *result;
3467     int retval =
3468       my_asprintf (&result, "%.4000u %d", 1234567, 99);
3469     size_t i;
3470     ASSERT (result != NULL);
3471     for (i = 0; i < 4000 - 7; i++)
3472       ASSERT (result[i] == '0');
3473     ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
3474     ASSERT (retval == strlen (result));
3475     free (result);
3476   }
3477
3478   {
3479     char *result;
3480     int retval =
3481       my_asprintf (&result, "%.4000o %d", 1234567, 99);
3482     size_t i;
3483     ASSERT (result != NULL);
3484     for (i = 0; i < 4000 - 7; i++)
3485       ASSERT (result[i] == '0');
3486     ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
3487     ASSERT (retval == strlen (result));
3488     free (result);
3489   }
3490
3491   {
3492     char *result;
3493     int retval =
3494       my_asprintf (&result, "%.4000x %d", 1234567, 99);
3495     size_t i;
3496     ASSERT (result != NULL);
3497     for (i = 0; i < 4000 - 6; i++)
3498       ASSERT (result[i] == '0');
3499     ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
3500     ASSERT (retval == strlen (result));
3501     free (result);
3502   }
3503
3504   {
3505     char *result;
3506     int retval =
3507       my_asprintf (&result, "%#.4000x %d", 1234567, 99);
3508     size_t i;
3509     ASSERT (result != NULL);
3510     ASSERT (result[0] == '0');
3511     ASSERT (result[1] == 'x');
3512     for (i = 0; i < 4000 - 6; i++)
3513       ASSERT (result[2 + i] == '0');
3514     ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
3515     ASSERT (retval == strlen (result));
3516     free (result);
3517   }
3518
3519   {
3520     char input[5000];
3521     char *result;
3522     int retval;
3523     size_t i;
3524
3525     for (i = 0; i < sizeof (input) - 1; i++)
3526       input[i] = 'a' + ((1000000 / (i + 1)) % 26);
3527     input[i] = '\0';
3528     retval = my_asprintf (&result, "%.4000s %d", input, 99);
3529     ASSERT (result != NULL);
3530     ASSERT (memcmp (result, input, 4000) == 0);
3531     ASSERT (strcmp (result + 4000, " 99") == 0);
3532     ASSERT (retval == strlen (result));
3533     free (result);
3534   }
3535 }
3536
3537 static int
3538 my_asprintf (char **result, const char *format, ...)
3539 {
3540   va_list args;
3541   int ret;
3542
3543   va_start (args, format);
3544   ret = vasprintf (result, format, args);
3545   va_end (args);
3546   return ret;
3547 }
3548
3549 static void
3550 test_vasprintf ()
3551 {
3552   test_function (my_asprintf);
3553 }
3554
3555 static void
3556 test_asprintf ()
3557 {
3558   test_function (asprintf);
3559 }
3560
3561 int
3562 main (int argc, char *argv[])
3563 {
3564   test_vasprintf ();
3565   test_asprintf ();
3566   return 0;
3567 }