tests/test-vasnprintf-posix.c

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