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