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