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 #if HAVE_LONG_DOUBLE
 115   {
 116     size_t length;
 117     char *result =
 118       my_asnprintf (NULL, &length, "%Lg %d", (long double) 1.5, 33, 44, 55);
 119     ASSERT (result != NULL);
 120     ASSERT (strcmp (result, "1.5 33") == 0);
 121     ASSERT (length == strlen (result));
 122     free (result);
 123   }
 124 #endif
 125
 126   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 127      output of floating-point numbers.  */
 128
 129   { /* A positive number.  */
 130     size_t length;
 131     char *result =
 132       my_asnprintf (NULL, &length, "%a %d", 3.1416015625, 33, 44, 55);
 133     ASSERT (result != NULL);
 134     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 135             || strcmp (result, "0x3.244p+0 33") == 0
 136             || strcmp (result, "0x6.488p-1 33") == 0
 137             || strcmp (result, "0xc.91p-2 33") == 0);
 138     ASSERT (length == strlen (result));
 139     free (result);
 140   }
 141
 142   { /* A negative number.  */
 143     size_t length;
 144     char *result =
 145       my_asnprintf (NULL, &length, "%A %d", -3.1416015625, 33, 44, 55);
 146     ASSERT (result != NULL);
 147     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
 148             || strcmp (result, "-0X3.244P+0 33") == 0
 149             || strcmp (result, "-0X6.488P-1 33") == 0
 150             || strcmp (result, "-0XC.91P-2 33") == 0);
 151     ASSERT (length == strlen (result));
 152     free (result);
 153   }
 154
 155   { /* Positive zero.  */
 156     size_t length;
 157     char *result =
 158       my_asnprintf (NULL, &length, "%a %d", 0.0, 33, 44, 55);
 159     ASSERT (result != NULL);
 160     ASSERT (strcmp (result, "0x0p+0 33") == 0);
 161     ASSERT (length == strlen (result));
 162     free (result);
 163   }
 164
 165   { /* Negative zero.  */
 166     size_t length;
 167     char *result =
 168       my_asnprintf (NULL, &length, "%a %d", -0.0, 33, 44, 55);
 169     ASSERT (result != NULL);
 170     ASSERT (strcmp (result, "-0x0p+0 33") == 0);
 171     ASSERT (length == strlen (result));
 172     free (result);
 173   }
 174
 175   { /* Positive infinity.  */
 176     size_t length;
 177     char *result =
 178       my_asnprintf (NULL, &length, "%a %d", 1.0 / 0.0, 33, 44, 55);
 179     ASSERT (result != NULL);
 180     ASSERT (strcmp (result, "inf 33") == 0);
 181     ASSERT (length == strlen (result));
 182     free (result);
 183   }
 184
 185   { /* Negative infinity.  */
 186     size_t length;
 187     char *result =
 188       my_asnprintf (NULL, &length, "%a %d", -1.0 / 0.0, 33, 44, 55);
 189     ASSERT (result != NULL);
 190     ASSERT (strcmp (result, "-inf 33") == 0);
 191     ASSERT (length == strlen (result));
 192     free (result);
 193   }
 194
 195   { /* NaN.  */
 196     size_t length;
 197     char *result =
 198       my_asnprintf (NULL, &length, "%a %d", NaN (), 33, 44, 55);
 199     ASSERT (result != NULL);
 200     ASSERT (strcmp (result, "nan 33") == 0);
 201     ASSERT (length == strlen (result));
 202     free (result);
 203   }
 204
 205   { /* Rounding near the decimal point.  */
 206     size_t length;
 207     char *result =
 208       my_asnprintf (NULL, &length, "%.0a %d", 1.5, 33, 44, 55);
 209     ASSERT (result != NULL);
 210     ASSERT (strcmp (result, "0x2p+0 33") == 0
 211             || strcmp (result, "0x3p-1 33") == 0
 212             || strcmp (result, "0x6p-2 33") == 0
 213             || strcmp (result, "0xcp-3 33") == 0);
 214     ASSERT (length == strlen (result));
 215     free (result);
 216   }
 217
 218   { /* Rounding with precision 0.  */
 219     size_t length;
 220     char *result =
 221       my_asnprintf (NULL, &length, "%.0a %d", 1.51, 33, 44, 55);
 222     ASSERT (result != NULL);
 223     ASSERT (strcmp (result, "0x2p+0 33") == 0
 224             || strcmp (result, "0x3p-1 33") == 0
 225             || strcmp (result, "0x6p-2 33") == 0
 226             || strcmp (result, "0xcp-3 33") == 0);
 227     ASSERT (length == strlen (result));
 228     free (result);
 229   }
 230
 231   { /* Rounding with precision 1.  */
 232     size_t length;
 233     char *result =
 234       my_asnprintf (NULL, &length, "%.1a %d", 1.51, 33, 44, 55);
 235     ASSERT (result != NULL);
 236     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
 237             || strcmp (result, "0x3.0p-1 33") == 0
 238             || strcmp (result, "0x6.1p-2 33") == 0
 239             || strcmp (result, "0xc.1p-3 33") == 0);
 240     ASSERT (length == strlen (result));
 241     free (result);
 242   }
 243
 244   { /* Rounding with precision 2.  */
 245     size_t length;
 246     char *result =
 247       my_asnprintf (NULL, &length, "%.2a %d", 1.51, 33, 44, 55);
 248     ASSERT (result != NULL);
 249     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
 250             || strcmp (result, "0x3.05p-1 33") == 0
 251             || strcmp (result, "0x6.0ap-2 33") == 0
 252             || strcmp (result, "0xc.14p-3 33") == 0);
 253     ASSERT (length == strlen (result));
 254     free (result);
 255   }
 256
 257   { /* Rounding with precision 3.  */
 258     size_t length;
 259     char *result =
 260       my_asnprintf (NULL, &length, "%.3a %d", 1.51, 33, 44, 55);
 261     ASSERT (result != NULL);
 262     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
 263             || strcmp (result, "0x3.052p-1 33") == 0
 264             || strcmp (result, "0x6.0a4p-2 33") == 0
 265             || strcmp (result, "0xc.148p-3 33") == 0);
 266     ASSERT (length == strlen (result));
 267     free (result);
 268   }
 269
 270   { /* Rounding can turn a ...FFF into a ...000.  */
 271     size_t length;
 272     char *result =
 273       my_asnprintf (NULL, &length, "%.3a %d", 1.49999, 33, 44, 55);
 274     ASSERT (result != NULL);
 275     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
 276             || strcmp (result, "0x3.000p-1 33") == 0
 277             || strcmp (result, "0x6.000p-2 33") == 0
 278             || strcmp (result, "0xc.000p-3 33") == 0);
 279     ASSERT (length == strlen (result));
 280     free (result);
 281   }
 282
 283   { /* Rounding can turn a ...FFF into a ...000.
 284        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
 285     size_t length;
 286     char *result =
 287       my_asnprintf (NULL, &length, "%.1a %d", 1.999, 33, 44, 55);
 288     ASSERT (result != NULL);
 289     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
 290             || strcmp (result, "0x2.0p+0 33") == 0
 291             || strcmp (result, "0x4.0p-1 33") == 0
 292             || strcmp (result, "0x8.0p-2 33") == 0);
 293     ASSERT (length == strlen (result));
 294     free (result);
 295   }
 296
 297   { /* Width.  */
 298     size_t length;
 299     char *result =
 300       my_asnprintf (NULL, &length, "%10a %d", 1.75, 33, 44, 55);
 301     ASSERT (result != NULL);
 302     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 303             || strcmp (result, "  0x3.8p-1 33") == 0
 304             || strcmp (result, "    0x7p-2 33") == 0
 305             || strcmp (result, "    0xep-3 33") == 0);
 306     ASSERT (length == strlen (result));
 307     free (result);
 308   }
 309
 310   { /* Small precision.  */
 311     size_t length;
 312     char *result =
 313       my_asnprintf (NULL, &length, "%.10a %d", 1.75, 33, 44, 55);
 314     ASSERT (result != NULL);
 315     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 316             || strcmp (result, "0x3.8000000000p-1 33") == 0
 317             || strcmp (result, "0x7.0000000000p-2 33") == 0
 318             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 319     ASSERT (length == strlen (result));
 320     free (result);
 321   }
 322
 323   { /* Large precision.  */
 324     size_t length;
 325     char *result =
 326       my_asnprintf (NULL, &length, "%.50a %d", 1.75, 33, 44, 55);
 327     ASSERT (result != NULL);
 328     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 329             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 330             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 331             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 332     ASSERT (length == strlen (result));
 333     free (result);
 334   }
 335
 336   { /* FLAG_LEFT.  */
 337     size_t length;
 338     char *result =
 339       my_asnprintf (NULL, &length, "%-10a %d", 1.75, 33, 44, 55);
 340     ASSERT (result != NULL);
 341     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
 342             || strcmp (result, "0x3.8p-1   33") == 0
 343             || strcmp (result, "0x7p-2     33") == 0
 344             || strcmp (result, "0xep-3     33") == 0);
 345     ASSERT (length == strlen (result));
 346     free (result);
 347   }
 348
 349   { /* FLAG_SHOWSIGN.  */
 350     size_t length;
 351     char *result =
 352       my_asnprintf (NULL, &length, "%+a %d", 1.75, 33, 44, 55);
 353     ASSERT (result != NULL);
 354     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
 355             || strcmp (result, "+0x3.8p-1 33") == 0
 356             || strcmp (result, "+0x7p-2 33") == 0
 357             || strcmp (result, "+0xep-3 33") == 0);
 358     ASSERT (length == strlen (result));
 359     free (result);
 360   }
 361
 362   { /* FLAG_SPACE.  */
 363     size_t length;
 364     char *result =
 365       my_asnprintf (NULL, &length, "% a %d", 1.75, 33, 44, 55);
 366     ASSERT (result != NULL);
 367     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
 368             || strcmp (result, " 0x3.8p-1 33") == 0
 369             || strcmp (result, " 0x7p-2 33") == 0
 370             || strcmp (result, " 0xep-3 33") == 0);
 371     ASSERT (length == strlen (result));
 372     free (result);
 373   }
 374
 375   { /* FLAG_ALT.  */
 376     size_t length;
 377     char *result =
 378       my_asnprintf (NULL, &length, "%#a %d", 1.75, 33, 44, 55);
 379     ASSERT (result != NULL);
 380     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
 381             || strcmp (result, "0x3.8p-1 33") == 0
 382             || strcmp (result, "0x7.p-2 33") == 0
 383             || strcmp (result, "0xe.p-3 33") == 0);
 384     ASSERT (length == strlen (result));
 385     free (result);
 386   }
 387
 388   { /* FLAG_ALT.  */
 389     size_t length;
 390     char *result =
 391       my_asnprintf (NULL, &length, "%#a %d", 1.0, 33, 44, 55);
 392     ASSERT (result != NULL);
 393     ASSERT (strcmp (result, "0x1.p+0 33") == 0
 394             || strcmp (result, "0x2.p-1 33") == 0
 395             || strcmp (result, "0x4.p-2 33") == 0
 396             || strcmp (result, "0x8.p-3 33") == 0);
 397     ASSERT (length == strlen (result));
 398     free (result);
 399   }
 400
 401   { /* FLAG_ZERO with finite number.  */
 402     size_t length;
 403     char *result =
 404       my_asnprintf (NULL, &length, "%010a %d", 1.75, 33, 44, 55);
 405     ASSERT (result != NULL);
 406     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
 407             || strcmp (result, "0x003.8p-1 33") == 0
 408             || strcmp (result, "0x00007p-2 33") == 0
 409             || strcmp (result, "0x0000ep-3 33") == 0);
 410     ASSERT (length == strlen (result));
 411     free (result);
 412   }
 413
 414   { /* FLAG_ZERO with infinite number.  */
 415     size_t length;
 416     char *result =
 417       my_asnprintf (NULL, &length, "%010a %d", 1.0 / 0.0, 33, 44, 55);
 418     ASSERT (result != NULL);
 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     ASSERT (strcmp (result, "       nan 33") == 0);
 430     ASSERT (length == strlen (result));
 431     free (result);
 432   }
 433
 434 #if HAVE_LONG_DOUBLE
 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     ASSERT (strcmp (result, "       inf 33") == 0);
 728     ASSERT (length == strlen (result));
 729     free (result);
 730   }
 731
 732   { /* FLAG_ZERO with NaN.  */
 733     size_t length;
 734     char *result =
 735       my_asnprintf (NULL, &length, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
 736     ASSERT (result != NULL);
 737     ASSERT (strcmp (result, "       nan 33") == 0);
 738     ASSERT (length == strlen (result));
 739     free (result);
 740   }
 741
 742 #endif
 743
 744   /* Test the support of the %n format directive.  */
 745
 746   {
 747     int count = -1;
 748     size_t length;
 749     char *result =
 750       my_asnprintf (NULL, &length, "%d %n", 123, &count, 33, 44, 55);
 751     ASSERT (result != NULL);
 752     ASSERT (strcmp (result, "123 ") == 0);
 753     ASSERT (length == strlen (result));
 754     ASSERT (count == 4);
 755     free (result);
 756   }
 757
 758   /* Test the support of the POSIX/XSI format strings with positions.  */
 759
 760   {
 761     size_t length;
 762     char *result =
 763       my_asnprintf (NULL, &length, "%2$d %1$d", 33, 55);
 764     ASSERT (result != NULL);
 765     ASSERT (strcmp (result, "55 33") == 0);
 766     ASSERT (length == strlen (result));
 767     free (result);
 768   }
 769 }
 770
 771 static char *
 772 my_asnprintf (char *resultbuf, size_t *lengthp, const char *format, ...)
 773 {
 774   va_list args;
 775   char *ret;
 776
 777   va_start (args, format);
 778   ret = vasnprintf (resultbuf, lengthp, format, args);
 779   va_end (args);
 780   return ret;
 781 }
 782
 783 static void
 784 test_vasnprintf ()
 785 {
 786   test_function (my_asnprintf);
 787 }
 788
 789 static void
 790 test_asnprintf ()
 791 {
 792   test_function (asnprintf);
 793 }
 794
 795 int
 796 main (int argc, char *argv[])
 797 {
 798   test_vasnprintf ();
 799   test_asnprintf ();
 800   return 0;
 801 }