tests/test-vasprintf-posix.c

   1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25
  26 #include <stdarg.h>
  27 #include <stddef.h>
  28 #include <stdint.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #define ASSERT(expr) if (!(expr)) abort ();
  33
  34 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0.  */
  35 #ifdef __DECC
  36 static double
  37 NaN ()
  38 {
  39   static double zero = 0.0;
  40   return zero / zero;
  41 }
  42 #else
  43 # define NaN() (0.0 / 0.0)
  44 #endif
  45
  46 static void
  47 test_function (int (*my_asprintf) (char **, const char *, ...))
  48 {
  49   int repeat;
  50
  51   /* Test return value convention.  */
  52
  53   for (repeat = 0; repeat <= 8; repeat++)
  54     {
  55       char *result;
  56       int retval = asprintf (&result, "%d", 12345);
  57       ASSERT (retval == 5);
  58       ASSERT (result != NULL);
  59       ASSERT (strcmp (result, "12345") == 0);
  60       free (result);
  61     }
  62
  63   /* Test support of size specifiers as in C99.  */
  64
  65   {
  66     char *result;
  67     int retval =
  68       my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  69     ASSERT (result != NULL);
  70     ASSERT (strcmp (result, "12345671 33") == 0);
  71     ASSERT (retval == strlen (result));
  72     free (result);
  73   }
  74
  75   {
  76     char *result;
  77     int retval =
  78       my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
  79     ASSERT (result != NULL);
  80     ASSERT (strcmp (result, "12345672 33") == 0);
  81     ASSERT (retval == strlen (result));
  82     free (result);
  83   }
  84
  85   {
  86     char *result;
  87     int retval =
  88       my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
  89     ASSERT (result != NULL);
  90     ASSERT (strcmp (result, "12345673 33") == 0);
  91     ASSERT (retval == strlen (result));
  92     free (result);
  93   }
  94
  95 #if HAVE_LONG_DOUBLE
  96   {
  97     char *result;
  98     int retval =
  99       my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
 100     ASSERT (result != NULL);
 101     ASSERT (strcmp (result, "1.5 33") == 0);
 102     ASSERT (retval == strlen (result));
 103     free (result);
 104   }
 105 #endif
 106
 107   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 108      output of floating-point numbers.  */
 109
 110   { /* A positive number.  */
 111     char *result;
 112     int retval =
 113       my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
 114     ASSERT (result != NULL);
 115     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 116             || strcmp (result, "0x3.244p+0 33") == 0
 117             || strcmp (result, "0x6.488p-1 33") == 0
 118             || strcmp (result, "0xc.91p-2 33") == 0);
 119     ASSERT (retval == strlen (result));
 120     free (result);
 121   }
 122
 123   { /* A negative number.  */
 124     char *result;
 125     int retval =
 126       my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
 127     ASSERT (result != NULL);
 128     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 129             || strcmp (result, "-0X3.244P+0 33") == 0
 130             || strcmp (result, "-0X6.488P-1 33") == 0
 131             || strcmp (result, "-0XC.91P-2 33") == 0);
 132     ASSERT (retval == strlen (result));
 133     free (result);
 134   }
 135
 136   { /* Positive zero.  */
 137     char *result;
 138     int retval =
 139       my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
 140     ASSERT (result != NULL);
 141     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 142     ASSERT (retval == strlen (result));
 143     free (result);
 144   }
 145
 146   { /* Negative zero.  */
 147     char *result;
 148     int retval =
 149       my_asprintf (&result, "%a %d", -0.0, 33, 44, 55);
 150     ASSERT (result != NULL);
 151     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 152     ASSERT (retval == strlen (result));
 153     free (result);
 154   }
 155
 156   { /* Positive infinity.  */
 157     char *result;
 158     int retval =
 159       my_asprintf (&result, "%a %d", 1.0 / 0.0, 33, 44, 55);
 160     ASSERT (result != NULL);
 161     ASSERT (strcmp (result, "inf 33") == 0);
 162     ASSERT (retval == strlen (result));
 163     free (result);
 164   }
 165
 166   { /* Negative infinity.  */
 167     char *result;
 168     int retval =
 169       my_asprintf (&result, "%a %d", -1.0 / 0.0, 33, 44, 55);
 170     ASSERT (result != NULL);
 171     ASSERT (strcmp (result, "-inf 33") == 0);
 172     ASSERT (retval == strlen (result));
 173     free (result);
 174   }
 175
 176   { /* NaN.  */
 177     char *result;
 178     int retval =
 179       my_asprintf (&result, "%a %d", NaN (), 33, 44, 55);
 180     ASSERT (result != NULL);
 181     ASSERT (strcmp (result, "nan 33") == 0);
 182     ASSERT (retval == strlen (result));
 183     free (result);
 184   }
 185
 186   { /* Rounding near the decimal point.  */
 187     char *result;
 188     int retval =
 189       my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
 190     ASSERT (result != NULL);
 191     ASSERT (strcmp (result, "0x2p+0 33") == 0
 192             || strcmp (result, "0x3p-1 33") == 0
 193             || strcmp (result, "0x6p-2 33") == 0
 194             || strcmp (result, "0xcp-3 33") == 0);
 195     ASSERT (retval == strlen (result));
 196     free (result);
 197   }
 198
 199   { /* Rounding with precision 0.  */
 200     char *result;
 201     int retval =
 202       my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
 203     ASSERT (result != NULL);
 204     ASSERT (strcmp (result, "0x2p+0 33") == 0
 205             || strcmp (result, "0x3p-1 33") == 0
 206             || strcmp (result, "0x6p-2 33") == 0
 207             || strcmp (result, "0xcp-3 33") == 0);
 208     ASSERT (retval == strlen (result));
 209     free (result);
 210   }
 211
 212   { /* Rounding with precision 1.  */
 213     char *result;
 214     int retval =
 215       my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
 216     ASSERT (result != NULL);
 217     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 218             || strcmp (result, "0x3.0p-1 33") == 0
 219             || strcmp (result, "0x6.1p-2 33") == 0
 220             || strcmp (result, "0xc.1p-3 33") == 0);
 221     ASSERT (retval == strlen (result));
 222     free (result);
 223   }
 224
 225   { /* Rounding with precision 2.  */
 226     char *result;
 227     int retval =
 228       my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
 229     ASSERT (result != NULL);
 230     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 231             || strcmp (result, "0x3.05p-1 33") == 0
 232             || strcmp (result, "0x6.0ap-2 33") == 0
 233             || strcmp (result, "0xc.14p-3 33") == 0);
 234     ASSERT (retval == strlen (result));
 235     free (result);
 236   }
 237
 238   { /* Rounding with precision 3.  */
 239     char *result;
 240     int retval =
 241       my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
 242     ASSERT (result != NULL);
 243     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 244             || strcmp (result, "0x3.052p-1 33") == 0
 245             || strcmp (result, "0x6.0a4p-2 33") == 0
 246             || strcmp (result, "0xc.148p-3 33") == 0);
 247     ASSERT (retval == strlen (result));
 248     free (result);
 249   }
 250
 251   { /* Rounding can turn a ...FFF into a ...000.  */
 252     char *result;
 253     int retval =
 254       my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
 255     ASSERT (result != NULL);
 256     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 257             || strcmp (result, "0x3.000p-1 33") == 0
 258             || strcmp (result, "0x6.000p-2 33") == 0
 259             || strcmp (result, "0xc.000p-3 33") == 0);
 260     ASSERT (retval == strlen (result));
 261     free (result);
 262   }
 263
 264   { /* Rounding can turn a ...FFF into a ...000.
 265        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 266     char *result;
 267     int retval =
 268       my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
 269     ASSERT (result != NULL);
 270     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 271             || strcmp (result, "0x2.0p+0 33") == 0
 272             || strcmp (result, "0x4.0p-1 33") == 0
 273             || strcmp (result, "0x8.0p-2 33") == 0);
 274     ASSERT (retval == strlen (result));
 275     free (result);
 276   }
 277
 278   { /* Width.  */
 279     char *result;
 280     int retval =
 281       my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
 282     ASSERT (result != NULL);
 283     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 284             || strcmp (result, "  0x3.8p-1 33") == 0
 285             || strcmp (result, "    0x7p-2 33") == 0
 286             || strcmp (result, "    0xep-3 33") == 0);
 287     ASSERT (retval == strlen (result));
 288     free (result);
 289   }
 290
 291   { /* Small precision.  */
 292     char *result;
 293     int retval =
 294       my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
 295     ASSERT (result != NULL);
 296     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 297             || strcmp (result, "0x3.8000000000p-1 33") == 0
 298             || strcmp (result, "0x7.0000000000p-2 33") == 0
 299             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 300     ASSERT (retval == strlen (result));
 301     free (result);
 302   }
 303
 304   { /* Large precision.  */
 305     char *result;
 306     int retval =
 307       my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
 308     ASSERT (result != NULL);
 309     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 310             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 311             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 312             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 313     ASSERT (retval == strlen (result));
 314     free (result);
 315   }
 316
 317   { /* FLAG_LEFT.  */
 318     char *result;
 319     int retval =
 320       my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
 321     ASSERT (result != NULL);
 322     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 323             || strcmp (result, "0x3.8p-1   33") == 0
 324             || strcmp (result, "0x7p-2     33") == 0
 325             || strcmp (result, "0xep-3     33") == 0);
 326     ASSERT (retval == strlen (result));
 327     free (result);
 328   }
 329
 330   { /* FLAG_SHOWSIGN.  */
 331     char *result;
 332     int retval =
 333       my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
 334     ASSERT (result != NULL);
 335     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 336             || strcmp (result, "+0x3.8p-1 33") == 0
 337             || strcmp (result, "+0x7p-2 33") == 0
 338             || strcmp (result, "+0xep-3 33") == 0);
 339     ASSERT (retval == strlen (result));
 340     free (result);
 341   }
 342
 343   { /* FLAG_SPACE.  */
 344     char *result;
 345     int retval =
 346       my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
 347     ASSERT (result != NULL);
 348     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 349             || strcmp (result, " 0x3.8p-1 33") == 0
 350             || strcmp (result, " 0x7p-2 33") == 0
 351             || strcmp (result, " 0xep-3 33") == 0);
 352     ASSERT (retval == strlen (result));
 353     free (result);
 354   }
 355
 356   { /* FLAG_ALT.  */
 357     char *result;
 358     int retval =
 359       my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
 360     ASSERT (result != NULL);
 361     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 362             || strcmp (result, "0x3.8p-1 33") == 0
 363             || strcmp (result, "0x7.p-2 33") == 0
 364             || strcmp (result, "0xe.p-3 33") == 0);
 365     ASSERT (retval == strlen (result));
 366     free (result);
 367   }
 368
 369   { /* FLAG_ALT.  */
 370     char *result;
 371     int retval =
 372       my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
 373     ASSERT (result != NULL);
 374     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 375             || strcmp (result, "0x2.p-1 33") == 0
 376             || strcmp (result, "0x4.p-2 33") == 0
 377             || strcmp (result, "0x8.p-3 33") == 0);
 378     ASSERT (retval == strlen (result));
 379     free (result);
 380   }
 381
 382   { /* FLAG_ZERO with finite number.  */
 383     char *result;
 384     int retval =
 385       my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
 386     ASSERT (result != NULL);
 387     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 388             || strcmp (result, "0x003.8p-1 33") == 0
 389             || strcmp (result, "0x00007p-2 33") == 0
 390             || strcmp (result, "0x0000ep-3 33") == 0);
 391     ASSERT (retval == strlen (result));
 392     free (result);
 393   }
 394
 395   { /* FLAG_ZERO with infinite number.  */
 396     char *result;
 397     int retval =
 398       my_asprintf (&result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 399     ASSERT (result != NULL);
 400     ASSERT (strcmp (result, "       inf 33") == 0
 401             || strcmp (result, "0000000inf 33") == 0);
 402     ASSERT (retval == strlen (result));
 403     free (result);
 404   }
 405
 406   { /* FLAG_ZERO with NaN.  */
 407     char *result;
 408     int retval =
 409       my_asprintf (&result, "%010a %d", NaN (), 33, 44, 55);
 410     ASSERT (result != NULL);
 411     ASSERT (strcmp (result, "       nan 33") == 0
 412             || strcmp (result, "0000000nan 33") == 0);
 413     ASSERT (retval == strlen (result));
 414     free (result);
 415   }
 416
 417 #if HAVE_LONG_DOUBLE
 418
 419   { /* A positive number.  */
 420     char *result;
 421     int retval =
 422       my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
 423     ASSERT (result != NULL);
 424     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 425             || strcmp (result, "0x3.244p+0 33") == 0
 426             || strcmp (result, "0x6.488p-1 33") == 0
 427             || strcmp (result, "0xc.91p-2 33") == 0);
 428     ASSERT (retval == strlen (result));
 429     free (result);
 430   }
 431
 432   { /* A negative number.  */
 433     char *result;
 434     int retval =
 435       my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
 436     ASSERT (result != NULL);
 437     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 438             || strcmp (result, "-0X3.244P+0 33") == 0
 439             || strcmp (result, "-0X6.488P-1 33") == 0
 440             || strcmp (result, "-0XC.91P-2 33") == 0);
 441     ASSERT (retval == strlen (result));
 442     free (result);
 443   }
 444
 445   { /* Positive zero.  */
 446     char *result;
 447     int retval =
 448       my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
 449     ASSERT (result != NULL);
 450     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 451     ASSERT (retval == strlen (result));
 452     free (result);
 453   }
 454
 455   { /* Negative zero.  */
 456     char *result;
 457     int retval =
 458       my_asprintf (&result, "%La %d", -0.0L, 33, 44, 55);
 459     ASSERT (result != NULL);
 460     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 461     ASSERT (retval == strlen (result));
 462     free (result);
 463   }
 464
 465   { /* Positive infinity.  */
 466     char *result;
 467     int retval =
 468       my_asprintf (&result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
 469     ASSERT (result != NULL);
 470     ASSERT (strcmp (result, "inf 33") == 0);
 471     ASSERT (retval == strlen (result));
 472     free (result);
 473   }
 474
 475   { /* Negative infinity.  */
 476     char *result;
 477     int retval =
 478       my_asprintf (&result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
 479     ASSERT (result != NULL);
 480     ASSERT (strcmp (result, "-inf 33") == 0);
 481     ASSERT (retval == strlen (result));
 482     free (result);
 483   }
 484
 485   { /* NaN.  */
 486     char *result;
 487     int retval =
 488       my_asprintf (&result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
 489     ASSERT (result != NULL);
 490     ASSERT (strcmp (result, "nan 33") == 0);
 491     ASSERT (retval == strlen (result));
 492     free (result);
 493   }
 494
 495   { /* Rounding near the decimal point.  */
 496     char *result;
 497     int retval =
 498       my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
 499     ASSERT (result != NULL);
 500     ASSERT (strcmp (result, "0x2p+0 33") == 0
 501             || strcmp (result, "0x3p-1 33") == 0
 502             || strcmp (result, "0x6p-2 33") == 0
 503             || strcmp (result, "0xcp-3 33") == 0);
 504     ASSERT (retval == strlen (result));
 505     free (result);
 506   }
 507
 508   { /* Rounding with precision 0.  */
 509     char *result;
 510     int retval =
 511       my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
 512     ASSERT (result != NULL);
 513     ASSERT (strcmp (result, "0x2p+0 33") == 0
 514             || strcmp (result, "0x3p-1 33") == 0
 515             || strcmp (result, "0x6p-2 33") == 0
 516             || strcmp (result, "0xcp-3 33") == 0);
 517     ASSERT (retval == strlen (result));
 518     free (result);
 519   }
 520
 521   { /* Rounding with precision 1.  */
 522     char *result;
 523     int retval =
 524       my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
 525     ASSERT (result != NULL);
 526     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 527             || strcmp (result, "0x3.0p-1 33") == 0
 528             || strcmp (result, "0x6.1p-2 33") == 0
 529             || strcmp (result, "0xc.1p-3 33") == 0);
 530     ASSERT (retval == strlen (result));
 531     free (result);
 532   }
 533
 534   { /* Rounding with precision 2.  */
 535     char *result;
 536     int retval =
 537       my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
 538     ASSERT (result != NULL);
 539     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 540             || strcmp (result, "0x3.05p-1 33") == 0
 541             || strcmp (result, "0x6.0ap-2 33") == 0
 542             || strcmp (result, "0xc.14p-3 33") == 0);
 543     ASSERT (retval == strlen (result));
 544     free (result);
 545   }
 546
 547   { /* Rounding with precision 3.  */
 548     char *result;
 549     int retval =
 550       my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
 551     ASSERT (result != NULL);
 552     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 553             || strcmp (result, "0x3.052p-1 33") == 0
 554             || strcmp (result, "0x6.0a4p-2 33") == 0
 555             || strcmp (result, "0xc.148p-3 33") == 0);
 556     ASSERT (retval == strlen (result));
 557     free (result);
 558   }
 559
 560   { /* Rounding can turn a ...FFF into a ...000.  */
 561     char *result;
 562     int retval =
 563       my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
 564     ASSERT (result != NULL);
 565     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 566             || strcmp (result, "0x3.000p-1 33") == 0
 567             || strcmp (result, "0x6.000p-2 33") == 0
 568             || strcmp (result, "0xc.000p-3 33") == 0);
 569     ASSERT (retval == strlen (result));
 570     free (result);
 571   }
 572
 573   { /* Rounding can turn a ...FFF into a ...000.
 574        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
 575        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
 576     char *result;
 577     int retval =
 578       my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
 579     ASSERT (result != NULL);
 580     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 581             || strcmp (result, "0x2.0p+0 33") == 0
 582             || strcmp (result, "0x4.0p-1 33") == 0
 583             || strcmp (result, "0x8.0p-2 33") == 0);
 584     ASSERT (retval == strlen (result));
 585     free (result);
 586   }
 587
 588   { /* Width.  */
 589     char *result;
 590     int retval =
 591       my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
 592     ASSERT (result != NULL);
 593     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 594             || strcmp (result, "  0x3.8p-1 33") == 0
 595             || strcmp (result, "    0x7p-2 33") == 0
 596             || strcmp (result, "    0xep-3 33") == 0);
 597     ASSERT (retval == strlen (result));
 598     free (result);
 599   }
 600
 601   { /* Small precision.  */
 602     char *result;
 603     int retval =
 604       my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
 605     ASSERT (result != NULL);
 606     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 607             || strcmp (result, "0x3.8000000000p-1 33") == 0
 608             || strcmp (result, "0x7.0000000000p-2 33") == 0
 609             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 610     ASSERT (retval == strlen (result));
 611     free (result);
 612   }
 613
 614   { /* Large precision.  */
 615     char *result;
 616     int retval =
 617       my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
 618     ASSERT (result != NULL);
 619     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 620             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 621             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 622             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 623     ASSERT (retval == strlen (result));
 624     free (result);
 625   }
 626
 627   { /* FLAG_LEFT.  */
 628     char *result;
 629     int retval =
 630       my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
 631     ASSERT (result != NULL);
 632     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 633             || strcmp (result, "0x3.8p-1   33") == 0
 634             || strcmp (result, "0x7p-2     33") == 0
 635             || strcmp (result, "0xep-3     33") == 0);
 636     ASSERT (retval == strlen (result));
 637     free (result);
 638   }
 639
 640   { /* FLAG_SHOWSIGN.  */
 641     char *result;
 642     int retval =
 643       my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
 644     ASSERT (result != NULL);
 645     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 646             || strcmp (result, "+0x3.8p-1 33") == 0
 647             || strcmp (result, "+0x7p-2 33") == 0
 648             || strcmp (result, "+0xep-3 33") == 0);
 649     ASSERT (retval == strlen (result));
 650     free (result);
 651   }
 652
 653   { /* FLAG_SPACE.  */
 654     char *result;
 655     int retval =
 656       my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
 657     ASSERT (result != NULL);
 658     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 659             || strcmp (result, " 0x3.8p-1 33") == 0
 660             || strcmp (result, " 0x7p-2 33") == 0
 661             || strcmp (result, " 0xep-3 33") == 0);
 662     ASSERT (retval == strlen (result));
 663     free (result);
 664   }
 665
 666   { /* FLAG_ALT.  */
 667     char *result;
 668     int retval =
 669       my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
 670     ASSERT (result != NULL);
 671     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 672             || strcmp (result, "0x3.8p-1 33") == 0
 673             || strcmp (result, "0x7.p-2 33") == 0
 674             || strcmp (result, "0xe.p-3 33") == 0);
 675     ASSERT (retval == strlen (result));
 676     free (result);
 677   }
 678
 679   { /* FLAG_ALT.  */
 680     char *result;
 681     int retval =
 682       my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
 683     ASSERT (result != NULL);
 684     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 685             || strcmp (result, "0x2.p-1 33") == 0
 686             || strcmp (result, "0x4.p-2 33") == 0
 687             || strcmp (result, "0x8.p-3 33") == 0);
 688     ASSERT (retval == strlen (result));
 689     free (result);
 690   }
 691
 692   { /* FLAG_ZERO with finite number.  */
 693     char *result;
 694     int retval =
 695       my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
 696     ASSERT (result != NULL);
 697     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 698             || strcmp (result, "0x003.8p-1 33") == 0
 699             || strcmp (result, "0x00007p-2 33") == 0
 700             || strcmp (result, "0x0000ep-3 33") == 0);
 701     ASSERT (retval == strlen (result));
 702     free (result);
 703   }
 704
 705   { /* FLAG_ZERO with infinite number.  */
 706     char *result;
 707     int retval =
 708       my_asprintf (&result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
 709     ASSERT (result != NULL);
 710     ASSERT (strcmp (result, "       inf 33") == 0
 711             || strcmp (result, "0000000inf 33") == 0);
 712     ASSERT (retval == strlen (result));
 713     free (result);
 714   }
 715
 716   { /* FLAG_ZERO with NaN.  */
 717     char *result;
 718     int retval =
 719       my_asprintf (&result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 720     ASSERT (result != NULL);
 721     ASSERT (strcmp (result, "       nan 33") == 0
 722             || strcmp (result, "0000000nan 33") == 0);
 723     ASSERT (retval == strlen (result));
 724     free (result);
 725   }
 726
 727 #endif
 728
 729   /* Test the support of the %n format directive.  */
 730
 731   {
 732     int count = -1;
 733     char *result;
 734     int retval =
 735       my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
 736     ASSERT (result != NULL);
 737     ASSERT (strcmp (result, "123 ") == 0);
 738     ASSERT (retval == strlen (result));
 739     ASSERT (count == 4);
 740     free (result);
 741   }
 742
 743   /* Test the support of the POSIX/XSI format strings with positions.  */
 744
 745   {
 746     char *result;
 747     int retval =
 748       my_asprintf (&result, "%2$d %1$d", 33, 55);
 749     ASSERT (result != NULL);
 750     ASSERT (strcmp (result, "55 33") == 0);
 751     ASSERT (retval == strlen (result));
 752     free (result);
 753   }
 754 }
 755
 756 static int
 757 my_asprintf (char **result, const char *format, ...)
 758 {
 759   va_list args;
 760   int ret;
 761
 762   va_start (args, format);
 763   ret = vasprintf (result, format, args);
 764   va_end (args);
 765   return ret;
 766 }
 767
 768 static void
 769 test_vasprintf ()
 770 {
 771   test_function (my_asprintf);
 772 }
 773
 774 static void
 775 test_asprintf ()
 776 {
 777   test_function (asprintf);
 778 }
 779
 780 int
 781 main (int argc, char *argv[])
 782 {
 783   test_vasprintf ();
 784   test_asprintf ();
 785   return 0;
 786 }