tests/unistdio/test-ulc-printf1.h

   1 /* Test of ulc_v[a]s[n]printf() 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 static void
  21 test_xfunction (char * (*my_xasprintf) (const char *, ...))
  22 {
  23   /* Test support of size specifiers as in C99.  */
  24
  25   {
  26     char *result =
  27       my_xasprintf ("%ju %d", (uintmax_t) 12345671, 33, 44, 55);
  28     ASSERT (result != NULL);
  29     ASSERT (strcmp (result, "12345671 33") == 0);
  30     free (result);
  31   }
  32
  33   {
  34     char *result =
  35       my_xasprintf ("%zu %d", (size_t) 12345672, 33, 44, 55);
  36     ASSERT (result != NULL);
  37     ASSERT (strcmp (result, "12345672 33") == 0);
  38     free (result);
  39   }
  40
  41   {
  42     char *result =
  43       my_xasprintf ("%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
  44     ASSERT (result != NULL);
  45     ASSERT (strcmp (result, "12345673 33") == 0);
  46     free (result);
  47   }
  48
  49   {
  50     char *result =
  51       my_xasprintf ("%Lg %d", (long double) 1.5, 33, 44, 55);
  52     ASSERT (result != NULL);
  53     ASSERT (strcmp (result, "1.5 33") == 0);
  54     free (result);
  55   }
  56
  57   /* Test the support of the 'U' conversion specifier for Unicode strings.  */
  58
  59   {
  60     static const uint8_t unicode_string[] = "Hello";
  61     {
  62       char *result =
  63         my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
  64       ASSERT (result != NULL);
  65       ASSERT (strcmp (result, "Hello 33") == 0);
  66       free (result);
  67     }
  68     { /* Width.  */
  69       char *result =
  70         my_xasprintf ("%10U %d", unicode_string, 33, 44, 55);
  71       ASSERT (result != NULL);
  72       ASSERT (strcmp (result, "     Hello 33") == 0);
  73       free (result);
  74     }
  75     { /* FLAG_LEFT.  */
  76       char *result =
  77         my_xasprintf ("%-10U %d", unicode_string, 33, 44, 55);
  78       ASSERT (result != NULL);
  79       ASSERT (strcmp (result, "Hello      33") == 0);
  80       free (result);
  81     }
  82     { /* FLAG_ZERO: no effect.  */
  83       char *result =
  84         my_xasprintf ("%010U %d", unicode_string, 33, 44, 55);
  85       ASSERT (result != NULL);
  86       ASSERT (strcmp (result, "     Hello 33") == 0);
  87       free (result);
  88     }
  89   }
  90
  91   {
  92     static const uint16_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
  93     {
  94       char *result =
  95         my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
  96       ASSERT (result != NULL);
  97       ASSERT (strcmp (result, "Hello 33") == 0);
  98       free (result);
  99     }
 100     { /* Width.  */
 101       char *result =
 102         my_xasprintf ("%10lU %d", unicode_string, 33, 44, 55);
 103       ASSERT (result != NULL);
 104       ASSERT (strcmp (result, "     Hello 33") == 0);
 105       free (result);
 106     }
 107     { /* FLAG_LEFT.  */
 108       char *result =
 109         my_xasprintf ("%-10lU %d", unicode_string, 33, 44, 55);
 110       ASSERT (result != NULL);
 111       ASSERT (strcmp (result, "Hello      33") == 0);
 112       free (result);
 113     }
 114     { /* FLAG_ZERO: no effect.  */
 115       char *result =
 116         my_xasprintf ("%010lU %d", unicode_string, 33, 44, 55);
 117       ASSERT (result != NULL);
 118       ASSERT (strcmp (result, "     Hello 33") == 0);
 119       free (result);
 120     }
 121   }
 122
 123   {
 124     static const uint32_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
 125     {
 126       char *result =
 127         my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
 128       ASSERT (result != NULL);
 129       ASSERT (strcmp (result, "Hello 33") == 0);
 130       free (result);
 131     }
 132     { /* Width.  */
 133       char *result =
 134         my_xasprintf ("%10llU %d", unicode_string, 33, 44, 55);
 135       ASSERT (result != NULL);
 136       ASSERT (strcmp (result, "     Hello 33") == 0);
 137       free (result);
 138     }
 139     { /* FLAG_LEFT.  */
 140       char *result =
 141         my_xasprintf ("%-10llU %d", unicode_string, 33, 44, 55);
 142       ASSERT (result != NULL);
 143       ASSERT (strcmp (result, "Hello      33") == 0);
 144       free (result);
 145     }
 146     { /* FLAG_ZERO: no effect.  */
 147       char *result =
 148         my_xasprintf ("%010llU %d", unicode_string, 33, 44, 55);
 149       ASSERT (result != NULL);
 150       ASSERT (strcmp (result, "     Hello 33") == 0);
 151       free (result);
 152     }
 153   }
 154
 155   /* Test the support of the 's' conversion specifier for strings.  */
 156
 157   {
 158     char *result =
 159       my_xasprintf ("Mr. %s %d", "Ronald Reagan", 33, 44, 55);
 160     ASSERT (result != NULL);
 161     ASSERT (strcmp (result, "Mr. Ronald Reagan 33") == 0);
 162     free (result);
 163   }
 164
 165   { /* Width.  */
 166     char *result =
 167       my_xasprintf ("Mr. %20s %d", "Ronald Reagan", 33, 44, 55);
 168     ASSERT (result != NULL);
 169     ASSERT (strcmp (result, "Mr.        Ronald Reagan 33") == 0);
 170     free (result);
 171   }
 172
 173   { /* FLAG_LEFT.  */
 174     char *result =
 175       my_xasprintf ("Mr. %-20s %d", "Ronald Reagan", 33, 44, 55);
 176     ASSERT (result != NULL);
 177     ASSERT (strcmp (result, "Mr. Ronald Reagan        33") == 0);
 178     free (result);
 179   }
 180
 181   { /* FLAG_ZERO: no effect.  */
 182     char *result =
 183       my_xasprintf ("Mr. %020s %d", "Ronald Reagan", 33, 44, 55);
 184     ASSERT (result != NULL);
 185     ASSERT (strcmp (result, "Mr.        Ronald Reagan 33") == 0);
 186     free (result);
 187   }
 188
 189   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
 190      output of floating-point numbers.  */
 191
 192   { /* A positive number.  */
 193     char *result =
 194       my_xasprintf ("%a %d", 3.1416015625, 33, 44, 55);
 195     ASSERT (result != NULL);
 196     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 197             || strcmp (result, "0x3.244p+0 33") == 0
 198             || strcmp (result, "0x6.488p-1 33") == 0
 199             || strcmp (result, "0xc.91p-2 33") == 0);
 200     free (result);
 201   }
 202
 203   { /* Width.  */
 204     char *result =
 205       my_xasprintf ("%10a %d", 1.75, 33, 44, 55);
 206     ASSERT (result != NULL);
 207     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 208             || strcmp (result, "  0x3.8p-1 33") == 0
 209             || strcmp (result, "    0x7p-2 33") == 0
 210             || strcmp (result, "    0xep-3 33") == 0);
 211     free (result);
 212   }
 213
 214   { /* Small precision.  */
 215     char *result =
 216       my_xasprintf ("%.10a %d", 1.75, 33, 44, 55);
 217     ASSERT (result != NULL);
 218     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 219             || strcmp (result, "0x3.8000000000p-1 33") == 0
 220             || strcmp (result, "0x7.0000000000p-2 33") == 0
 221             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 222     free (result);
 223   }
 224
 225   { /* Large precision.  */
 226     char *result =
 227       my_xasprintf ("%.50a %d", 1.75, 33, 44, 55);
 228     ASSERT (result != NULL);
 229     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 230             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 231             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 232             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 233     free (result);
 234   }
 235
 236   { /* A positive number.  */
 237     char *result =
 238       my_xasprintf ("%La %d", 3.1416015625L, 33, 44, 55);
 239     ASSERT (result != NULL);
 240     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
 241             || strcmp (result, "0x3.244p+0 33") == 0
 242             || strcmp (result, "0x6.488p-1 33") == 0
 243             || strcmp (result, "0xc.91p-2 33") == 0);
 244     free (result);
 245   }
 246
 247   { /* Width.  */
 248     char *result =
 249       my_xasprintf ("%10La %d", 1.75L, 33, 44, 55);
 250     ASSERT (result != NULL);
 251     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
 252             || strcmp (result, "  0x3.8p-1 33") == 0
 253             || strcmp (result, "    0x7p-2 33") == 0
 254             || strcmp (result, "    0xep-3 33") == 0);
 255     free (result);
 256   }
 257
 258   { /* Small precision.  */
 259     char *result =
 260       my_xasprintf ("%.10La %d", 1.75L, 33, 44, 55);
 261     ASSERT (result != NULL);
 262     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
 263             || strcmp (result, "0x3.8000000000p-1 33") == 0
 264             || strcmp (result, "0x7.0000000000p-2 33") == 0
 265             || strcmp (result, "0xe.0000000000p-3 33") == 0);
 266     free (result);
 267   }
 268
 269   { /* Large precision.  */
 270     char *result =
 271       my_xasprintf ("%.50La %d", 1.75L, 33, 44, 55);
 272     ASSERT (result != NULL);
 273     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
 274             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
 275             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
 276             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
 277     free (result);
 278   }
 279
 280   /* Test the support of the %f format directive.  */
 281
 282   { /* A positive number.  */
 283     char *result =
 284       my_xasprintf ("%f %d", 12.75, 33, 44, 55);
 285     ASSERT (result != NULL);
 286     ASSERT (strcmp (result, "12.750000 33") == 0);
 287     free (result);
 288   }
 289
 290   { /* Width.  */
 291     char *result =
 292       my_xasprintf ("%10f %d", 1.75, 33, 44, 55);
 293     ASSERT (result != NULL);
 294     ASSERT (strcmp (result, "  1.750000 33") == 0);
 295     free (result);
 296   }
 297
 298   { /* Precision.  */
 299     char *result =
 300       my_xasprintf ("%.f %d", 1234.0, 33, 44, 55);
 301     ASSERT (result != NULL);
 302     ASSERT (strcmp (result, "1234 33") == 0);
 303     free (result);
 304   }
 305
 306   { /* A positive number.  */
 307     char *result =
 308       my_xasprintf ("%Lf %d", 12.75L, 33, 44, 55);
 309     ASSERT (result != NULL);
 310     ASSERT (strcmp (result, "12.750000 33") == 0);
 311     free (result);
 312   }
 313
 314   { /* Width.  */
 315     char *result =
 316       my_xasprintf ("%10Lf %d", 1.75L, 33, 44, 55);
 317     ASSERT (result != NULL);
 318     ASSERT (strcmp (result, "  1.750000 33") == 0);
 319     free (result);
 320   }
 321
 322   { /* Precision.  */
 323     char *result =
 324       my_xasprintf ("%.Lf %d", 1234.0L, 33, 44, 55);
 325     ASSERT (result != NULL);
 326     ASSERT (strcmp (result, "1234 33") == 0);
 327     free (result);
 328   }
 329
 330   /* Test the support of the %F format directive.  */
 331
 332   { /* A positive number.  */
 333     char *result =
 334       my_xasprintf ("%F %d", 12.75, 33, 44, 55);
 335     ASSERT (result != NULL);
 336     ASSERT (strcmp (result, "12.750000 33") == 0);
 337     free (result);
 338   }
 339
 340   { /* Precision.  */
 341     char *result =
 342       my_xasprintf ("%.F %d", 1234.0, 33, 44, 55);
 343     ASSERT (result != NULL);
 344     ASSERT (strcmp (result, "1234 33") == 0);
 345     free (result);
 346   }
 347
 348   { /* A positive number.  */
 349     char *result =
 350       my_xasprintf ("%LF %d", 12.75L, 33, 44, 55);
 351     ASSERT (result != NULL);
 352     ASSERT (strcmp (result, "12.750000 33") == 0);
 353     free (result);
 354   }
 355
 356   { /* Precision.  */
 357     char *result =
 358       my_xasprintf ("%.LF %d", 1234.0L, 33, 44, 55);
 359     ASSERT (result != NULL);
 360     ASSERT (strcmp (result, "1234 33") == 0);
 361     free (result);
 362   }
 363
 364   /* Test the support of the %e format directive.  */
 365
 366   { /* A positive number.  */
 367     char *result =
 368       my_xasprintf ("%e %d", 12.75, 33, 44, 55);
 369     ASSERT (result != NULL);
 370     ASSERT (strcmp (result, "1.275000e+01 33") == 0
 371             || strcmp (result, "1.275000e+001 33") == 0);
 372     free (result);
 373   }
 374
 375   { /* Width.  */
 376     char *result =
 377       my_xasprintf ("%15e %d", 1.75, 33, 44, 55);
 378     ASSERT (result != NULL);
 379     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
 380             || strcmp (result, "  1.750000e+000 33") == 0);
 381     free (result);
 382   }
 383
 384   { /* Precision.  */
 385     char *result =
 386       my_xasprintf ("%.e %d", 1234.0, 33, 44, 55);
 387     ASSERT (result != NULL);
 388     ASSERT (strcmp (result, "1e+03 33") == 0
 389             || strcmp (result, "1e+003 33") == 0);
 390     free (result);
 391   }
 392
 393   { /* A positive number.  */
 394     char *result =
 395       my_xasprintf ("%Le %d", 12.75L, 33, 44, 55);
 396     ASSERT (result != NULL);
 397     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
 398     free (result);
 399   }
 400
 401   { /* Width.  */
 402     char *result =
 403       my_xasprintf ("%15Le %d", 1.75L, 33, 44, 55);
 404     ASSERT (result != NULL);
 405     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
 406     free (result);
 407   }
 408
 409   { /* Precision.  */
 410     char *result =
 411       my_xasprintf ("%.Le %d", 1234.0L, 33, 44, 55);
 412     ASSERT (result != NULL);
 413     ASSERT (strcmp (result, "1e+03 33") == 0);
 414     free (result);
 415   }
 416
 417   /* Test the support of the %g format directive.  */
 418
 419   { /* A positive number.  */
 420     char *result =
 421       my_xasprintf ("%g %d", 12.75, 33, 44, 55);
 422     ASSERT (result != NULL);
 423     ASSERT (strcmp (result, "12.75 33") == 0);
 424     free (result);
 425   }
 426
 427   { /* Width.  */
 428     char *result =
 429       my_xasprintf ("%10g %d", 1.75, 33, 44, 55);
 430     ASSERT (result != NULL);
 431     ASSERT (strcmp (result, "      1.75 33") == 0);
 432     free (result);
 433   }
 434
 435   { /* Precision.  */
 436     char *result =
 437       my_xasprintf ("%.g %d", 1234.0, 33, 44, 55);
 438     ASSERT (result != NULL);
 439     ASSERT (strcmp (result, "1e+03 33") == 0
 440             || strcmp (result, "1e+003 33") == 0);
 441     free (result);
 442   }
 443
 444   { /* A positive number.  */
 445     char *result =
 446       my_xasprintf ("%Lg %d", 12.75L, 33, 44, 55);
 447     ASSERT (result != NULL);
 448     ASSERT (strcmp (result, "12.75 33") == 0);
 449     free (result);
 450   }
 451
 452   { /* Width.  */
 453     char *result =
 454       my_xasprintf ("%10Lg %d", 1.75L, 33, 44, 55);
 455     ASSERT (result != NULL);
 456     ASSERT (strcmp (result, "      1.75 33") == 0);
 457     free (result);
 458   }
 459
 460   { /* Precision.  */
 461     char *result =
 462       my_xasprintf ("%.Lg %d", 1234.0L, 33, 44, 55);
 463     ASSERT (result != NULL);
 464     ASSERT (strcmp (result, "1e+03 33") == 0);
 465     free (result);
 466   }
 467
 468   /* Test the support of the %n format directive.  */
 469
 470   {
 471     int count = -1;
 472     char *result =
 473       my_xasprintf ("%d %n", 123, &count, 33, 44, 55);
 474     ASSERT (result != NULL);
 475     ASSERT (strcmp (result, "123 ") == 0);
 476     ASSERT (count == 4);
 477     free (result);
 478   }
 479
 480   /* Test the support of the POSIX/XSI format strings with positions.  */
 481
 482   {
 483     char *result =
 484       my_xasprintf ("%2$d %1$d", 33, 55);
 485     ASSERT (result != NULL);
 486     ASSERT (strcmp (result, "55 33") == 0);
 487     free (result);
 488   }
 489
 490   /* Test the support of the grouping flag.  */
 491
 492   {
 493     char *result =
 494       my_xasprintf ("%'d %d", 1234567, 99);
 495     ASSERT (result != NULL);
 496     ASSERT (result[strlen (result) - 1] == '9');
 497     free (result);
 498   }
 499 }