root/maint/gnulib/tests/test-vasprintf-posix.c

/* */

DEFINITIONS

1. have_minus_zero
2. strmatch
3. strisnan
4. test_function
5. my_asprintf
6. test_vasprintf
7. test_asprintf
8. main

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