glib/tests/printf.c

   1 /* Unit tests for gprintf
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This work is provided "as is"; redistribution and modification
   5  * in whole or in part, in any medium, physical or electronic is
   6  * permitted without restriction.
   7  *
   8  * This work is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * In no event shall the authors or contributors be liable for any
  13  * direct, indirect, incidental, special, exemplary, or consequential
  14  * damages (including, but not limited to, procurement of substitute
  15  * goods or services; loss of use, data, or profits; or business
  16  * interruption) however caused and on any theory of liability, whether
  17  * in contract, strict liability, or tort (including negligence or
  18  * otherwise) arising in any way out of the use of this software, even
  19  * if advised of the possibility of such damage.
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include "glib.h"
  25
  26 static void
  27 test_retval_and_trunc (void)
  28 {
  29   gchar buf[128];
  30   gint res;
  31
  32   res = g_snprintf (buf, 0, "abc");
  33   g_assert_cmpint (res, ==, 3);
  34
  35   res = g_snprintf (NULL, 0, "abc");
  36   g_assert_cmpint (res, ==, 3);
  37
  38   res = g_snprintf (buf, 5, "abc");
  39   g_assert_cmpint (res, ==, 3);
  40
  41   res = g_snprintf (buf, 1, "abc");
  42   g_assert_cmpint (res, ==, 3);
  43   g_assert (buf[0] == '\0');
  44   g_assert_cmpstr (buf, ==, "");
  45
  46   res = g_snprintf (buf, 2, "abc");
  47   g_assert_cmpint (res, ==, 3);
  48   g_assert (buf[1] == '\0');
  49   g_assert_cmpstr (buf, ==, "a");
  50
  51   res = g_snprintf (buf, 3, "abc");
  52   g_assert_cmpint (res, ==, 3);
  53   g_assert (buf[2] == '\0');
  54   g_assert_cmpstr (buf, ==, "ab");
  55
  56   res = g_snprintf (buf, 4, "abc");
  57   g_assert_cmpint (res, ==, 3);
  58   g_assert (buf[3] == '\0');
  59   g_assert_cmpstr (buf, ==, "abc");
  60
  61   res = g_snprintf (buf, 5, "abc");
  62   g_assert_cmpint (res, ==, 3);
  63   g_assert (buf[3] == '\0');
  64   g_assert_cmpstr (buf, ==, "abc");
  65 }
  66
  67 static void
  68 test_d (void)
  69 {
  70   gchar buf[128];
  71   gint res;
  72   const gchar *fmt;
  73
  74   /* %d basic formatting */
  75
  76   res = g_snprintf (buf, 128, "%d", 5);
  77   g_assert_cmpint (res, ==, 1);
  78   g_assert_cmpstr (buf, ==, "5");
  79
  80   res = g_snprintf (buf, 128, "%d", 0);
  81   g_assert_cmpint (res, ==, 1);
  82   g_assert_cmpstr (buf, ==, "0");
  83
  84   res = g_snprintf (buf, 128, "%.0d", 0);
  85   g_assert_cmpint (res, ==, 0);
  86   g_assert_cmpstr (buf, ==, "");
  87
  88   res = g_snprintf (buf, 128, "%.0d", 1);
  89   g_assert_cmpint (res, ==, 1);
  90   g_assert_cmpstr (buf, ==, "1");
  91
  92   res = g_snprintf (buf, 128, "%.d", 2);
  93   g_assert_cmpint (res, ==, 1);
  94   g_assert_cmpstr (buf, ==, "2");
  95
  96   res = g_snprintf (buf, 128, "%d", -1);
  97   g_assert_cmpint (res, ==, 2);
  98   g_assert_cmpstr (buf, ==, "-1");
  99
 100   res = g_snprintf (buf, 128, "%.3d", 5);
 101   g_assert_cmpint (res, ==, 3);
 102   g_assert_cmpstr (buf, ==, "005");
 103
 104   res = g_snprintf (buf, 128, "%.3d", -5);
 105   g_assert_cmpint (res, ==, 4);
 106   g_assert_cmpstr (buf, ==, "-005");
 107
 108   res = g_snprintf (buf, 128, "%5.3d", 5);
 109   g_assert_cmpint (res, ==, 5);
 110   g_assert_cmpstr (buf, ==, "  005");
 111
 112   res = g_snprintf (buf, 128, "%-5.3d", -5);
 113   g_assert_cmpint (res, ==, 5);
 114   g_assert_cmpstr (buf, ==, "-005 ");
 115
 116   /* %d, length modifiers */
 117
 118   res = g_snprintf (buf, 128, "%" G_GINT16_FORMAT, (gint16)-5);
 119   g_assert_cmpint (res, ==, 2);
 120   g_assert_cmpstr (buf, ==, "-5");
 121
 122   res = g_snprintf (buf, 128, "%" G_GUINT16_FORMAT, (guint16)5);
 123   g_assert_cmpint (res, ==, 1);
 124   g_assert_cmpstr (buf, ==, "5");
 125
 126   res = g_snprintf (buf, 128, "%" G_GINT32_FORMAT, (gint32)-5);
 127   g_assert_cmpint (res, ==, 2);
 128   g_assert_cmpstr (buf, ==, "-5");
 129
 130   res = g_snprintf (buf, 128, "%" G_GUINT32_FORMAT, (guint32)5);
 131   g_assert_cmpint (res, ==, 1);
 132   g_assert_cmpstr (buf, ==, "5");
 133
 134   res = g_snprintf (buf, 128, "%" G_GINT64_FORMAT, (gint64)-5);
 135   g_assert_cmpint (res, ==, 2);
 136   g_assert_cmpstr (buf, ==, "-5");
 137
 138   res = g_snprintf (buf, 128, "%" G_GUINT64_FORMAT, (guint64)5);
 139   g_assert_cmpint (res, ==, 1);
 140   g_assert_cmpstr (buf, ==, "5");
 141
 142   res = g_snprintf (buf, 128, "%" G_GSSIZE_FORMAT, (gssize)-5);
 143   g_assert_cmpint (res, ==, 2);
 144   g_assert_cmpstr (buf, ==, "-5");
 145
 146   res = g_snprintf (buf, 128, "%" G_GSIZE_FORMAT, (gsize)5);
 147   g_assert_cmpint (res, ==, 1);
 148   g_assert_cmpstr (buf, ==, "5");
 149
 150   /* %d, flags */
 151
 152   res = g_snprintf (buf, 128, "%-d", 5);
 153   g_assert_cmpint (res, ==, 1);
 154   g_assert_cmpstr (buf, ==, "5");
 155
 156   res = g_snprintf (buf, 128, "%-+d", 5);
 157   g_assert_cmpint (res, ==, 2);
 158   g_assert_cmpstr (buf, ==, "+5");
 159
 160   res = g_snprintf (buf, 128, "%+-d", 5);
 161   g_assert_cmpint (res, ==, 2);
 162   g_assert_cmpstr (buf, ==, "+5");
 163
 164   res = g_snprintf (buf, 128, "%+d", -5);
 165   g_assert_cmpint (res, ==, 2);
 166   g_assert_cmpstr (buf, ==, "-5");
 167
 168   res = g_snprintf (buf, 128, "% d", 5);
 169   g_assert_cmpint (res, ==, 2);
 170   g_assert_cmpstr (buf, ==, " 5");
 171
 172   res = g_snprintf (buf, 128, "% .0d", 0);
 173   g_assert_cmpint (res, ==, 1);
 174   g_assert_cmpstr (buf, ==, " ");
 175
 176   res = g_snprintf (buf, 128, "%03d", 5);
 177   g_assert_cmpint (res, ==, 3);
 178   g_assert_cmpstr (buf, ==, "005");
 179
 180   res = g_snprintf (buf, 128, "%03d", -5);
 181   g_assert_cmpint (res, ==, 3);
 182   g_assert_cmpstr (buf, ==, "-05");
 183
 184   /* gcc emits warnings for the following formats, since the C spec
 185    * says some of the flags must be ignored. (The " " in "% +d" and
 186    * the "0" in "%-03d".) But we need to test that our printf gets
 187    * those rules right. So we fool gcc into not warning.
 188    */
 189   fmt = "% +d";
 190   res = g_snprintf (buf, 128, fmt, 5);
 191   g_assert_cmpint (res, ==, 2);
 192   g_assert_cmpstr (buf, ==, "+5");
 193
 194   fmt = "%-03d";
 195   res = g_snprintf (buf, 128, fmt, -5);
 196   g_assert_cmpint (res, ==, 3);
 197   g_assert_cmpstr (buf, ==, "-5 ");
 198 }
 199
 200 static void
 201 test_o (void)
 202 {
 203   gchar buf[128];
 204   gint res;
 205
 206   /* %o basic formatting */
 207
 208   res = g_snprintf (buf, 128, "%o", 5);
 209   g_assert_cmpint (res, ==, 1);
 210   g_assert_cmpstr (buf, ==, "5");
 211
 212   res = g_snprintf (buf, 128, "%o", 8);
 213   g_assert_cmpint (res, ==, 2);
 214   g_assert_cmpstr (buf, ==, "10");
 215
 216   res = g_snprintf (buf, 128, "%o", 0);
 217   g_assert_cmpint (res, ==, 1);
 218   g_assert_cmpstr (buf, ==, "0");
 219
 220   res = g_snprintf (buf, 128, "%.0o", 0);
 221   g_assert_cmpint (res, ==, 0);
 222   g_assert_cmpstr (buf, ==, "");
 223
 224   res = g_snprintf (buf, 128, "%.0o", 1);
 225   g_assert_cmpint (res, ==, 1);
 226   g_assert_cmpstr (buf, ==, "1");
 227
 228   res = g_snprintf (buf, 128, "%.3o", 5);
 229   g_assert_cmpint (res, ==, 3);
 230   g_assert_cmpstr (buf, ==, "005");
 231
 232   res = g_snprintf (buf, 128, "%.3o", 8);
 233   g_assert_cmpint (res, ==, 3);
 234   g_assert_cmpstr (buf, ==, "010");
 235
 236   res = g_snprintf (buf, 128, "%5.3o", 5);
 237   g_assert_cmpint (res, ==, 5);
 238   g_assert_cmpstr (buf, ==, "  005");
 239 }
 240
 241 static void
 242 test_u (void)
 243 {
 244   gchar buf[128];
 245   gint res;
 246
 247   /* %u, basic formatting */
 248
 249   res = g_snprintf (buf, 128, "%u", 5);
 250   g_assert_cmpint (res, ==, 1);
 251   g_assert_cmpstr (buf, ==, "5");
 252
 253   res = g_snprintf (buf, 128, "%u", 0);
 254   g_assert_cmpint (res, ==, 1);
 255   g_assert_cmpstr (buf, ==, "0");
 256
 257   res = g_snprintf (buf, 128, "%.0u", 0);
 258   g_assert_cmpint (res, ==, 0);
 259   g_assert_cmpstr (buf, ==, "");
 260
 261   res = g_snprintf (buf, 128, "%.0u", 1);
 262   g_assert_cmpint (res, ==, 1);
 263   g_assert_cmpstr (buf, ==, "1");
 264
 265   res = g_snprintf (buf, 128, "%.3u", 5);
 266   g_assert_cmpint (res, ==, 3);
 267   g_assert_cmpstr (buf, ==, "005");
 268
 269   res = g_snprintf (buf, 128, "%5.3u", 5);
 270   g_assert_cmpint (res, ==, 5);
 271   g_assert_cmpstr (buf, ==, "  005");
 272 }
 273
 274 static void
 275 test_x (void)
 276 {
 277   gchar buf[128];
 278   gint res;
 279
 280   /* %x, basic formatting */
 281
 282   res = g_snprintf (buf, 128, "%x", 5);
 283   g_assert_cmpint (res, ==, 1);
 284   g_assert_cmpstr (buf, ==, "5");
 285
 286   res = g_snprintf (buf, 128, "%x", 31);
 287   g_assert_cmpint (res, ==, 2);
 288   g_assert_cmpstr (buf, ==, "1f");
 289
 290   res = g_snprintf (buf, 128, "%x", 0);
 291   g_assert_cmpint (res, ==, 1);
 292   g_assert_cmpstr (buf, ==, "0");
 293
 294   res = g_snprintf (buf, 128, "%.0x", 0);
 295   g_assert_cmpint (res, ==, 0);
 296   g_assert_cmpstr (buf, ==, "");
 297
 298   res = g_snprintf (buf, 128, "%.0x", 1);
 299   g_assert_cmpint (res, ==, 1);
 300   g_assert_cmpstr (buf, ==, "1");
 301
 302   res = g_snprintf (buf, 128, "%.3x", 5);
 303   g_assert_cmpint (res, ==, 3);
 304   g_assert_cmpstr (buf, ==, "005");
 305
 306   res = g_snprintf (buf, 128, "%.3x", 31);
 307   g_assert_cmpint (res, ==, 3);
 308   g_assert_cmpstr (buf, ==, "01f");
 309
 310   res = g_snprintf (buf, 128, "%5.3x", 5);
 311   g_assert_cmpint (res, ==, 5);
 312   g_assert_cmpstr (buf, ==, "  005");
 313
 314   /* %x, flags */
 315
 316   res = g_snprintf (buf, 128, "%-x", 5);
 317   g_assert_cmpint (res, ==, 1);
 318   g_assert_cmpstr (buf, ==, "5");
 319
 320   res = g_snprintf (buf, 128, "%03x", 5);
 321   g_assert_cmpint (res, ==, 3);
 322   g_assert_cmpstr (buf, ==, "005");
 323
 324   res = g_snprintf (buf, 128, "%#x", 31);
 325   g_assert_cmpint (res, ==, 4);
 326   g_assert_cmpstr (buf, ==, "0x1f");
 327
 328   res = g_snprintf (buf, 128, "%#x", 0);
 329   g_assert_cmpint (res, ==, 1);
 330   g_assert_cmpstr (buf, ==, "0");
 331 }
 332
 333 static void
 334 test_X (void)
 335 {
 336   gchar buf[128];
 337   gint res;
 338
 339   /* %X, basic formatting */
 340
 341   res = g_snprintf (buf, 128, "%X", 5);
 342   g_assert_cmpint (res, ==, 1);
 343   g_assert_cmpstr (buf, ==, "5");
 344
 345   res = g_snprintf (buf, 128, "%X", 31);
 346   g_assert_cmpint (res, ==, 2);
 347   g_assert_cmpstr (buf, ==, "1F");
 348
 349   res = g_snprintf (buf, 128, "%X", 0);
 350   g_assert_cmpint (res, ==, 1);
 351   g_assert_cmpstr (buf, ==, "0");
 352
 353   res = g_snprintf (buf, 128, "%.0X", 0);
 354   g_assert_cmpint (res, ==, 0);
 355   g_assert_cmpstr (buf, ==, "");
 356
 357   res = g_snprintf (buf, 128, "%.0X", 1);
 358   g_assert_cmpint (res, ==, 1);
 359   g_assert_cmpstr (buf, ==, "1");
 360
 361   res = g_snprintf (buf, 128, "%.3X", 5);
 362   g_assert_cmpint (res, ==, 3);
 363   g_assert_cmpstr (buf, ==, "005");
 364
 365   res = g_snprintf (buf, 128, "%.3X", 31);
 366   g_assert_cmpint (res, ==, 3);
 367   g_assert_cmpstr (buf, ==, "01F");
 368
 369   res = g_snprintf (buf, 128, "%5.3X", 5);
 370   g_assert_cmpint (res, ==, 5);
 371   g_assert_cmpstr (buf, ==, "  005");
 372
 373   /* %X, flags */
 374
 375   res = g_snprintf (buf, 128, "%-X", 5);
 376   g_assert_cmpint (res, ==, 1);
 377   g_assert_cmpstr (buf, ==, "5");
 378
 379   res = g_snprintf (buf, 128, "%03X", 5);
 380   g_assert_cmpint (res, ==, 3);
 381   g_assert_cmpstr (buf, ==, "005");
 382
 383   res = g_snprintf (buf, 128, "%#X", 31);
 384   g_assert_cmpint (res, ==, 4);
 385   g_assert_cmpstr (buf, ==, "0X1F");
 386
 387   res = g_snprintf (buf, 128, "%#X", 0);
 388   g_assert_cmpint (res, ==, 1);
 389   g_assert_cmpstr (buf, ==, "0");
 390 }
 391
 392 static void
 393 test_f (void)
 394 {
 395   gchar buf[128];
 396   gint res;
 397
 398   /* %f, basic formattting */
 399
 400   res = g_snprintf (buf, 128, "%f", G_PI);
 401   g_assert_cmpint (res, ==, 8);
 402   g_assert (0 == strncmp (buf, "3.14159", 7));
 403
 404   res = g_snprintf (buf, 128, "%.8f", G_PI);
 405   g_assert_cmpint (res, ==, 10);
 406   g_assert (0 == strncmp (buf, "3.1415926", 9));
 407
 408   res = g_snprintf (buf, 128, "%.0f", G_PI);
 409   g_assert_cmpint (res, ==, 1);
 410   g_assert_cmpstr (buf, ==, "3");
 411
 412   res = g_snprintf (buf, 128, "%1.f", G_PI);
 413   g_assert_cmpint (res, ==, 1);
 414   g_assert_cmpstr (buf, ==, "3");
 415
 416   res = g_snprintf (buf, 128, "%3.f", G_PI);
 417   g_assert_cmpint (res, ==, 3);
 418   g_assert_cmpstr (buf, ==, "  3");
 419
 420   /* %f, flags */
 421
 422   res = g_snprintf (buf, 128, "%+f", G_PI);
 423   g_assert_cmpint (res, ==, 9);
 424   g_assert (0 == strncmp (buf, "+3.14159", 8));
 425
 426   res = g_snprintf (buf, 128, "% f", G_PI);
 427   g_assert_cmpint (res, ==, 9);
 428   g_assert (0 == strncmp (buf, " 3.14159", 8));
 429
 430   res = g_snprintf (buf, 128, "%#.0f", G_PI);
 431   g_assert_cmpint (res, ==, 2);
 432   g_assert_cmpstr (buf, ==, "3.");
 433
 434   res = g_snprintf (buf, 128, "%05.2f", G_PI);
 435   g_assert_cmpint (res, ==, 5);
 436   g_assert_cmpstr (buf, ==, "03.14");
 437 }
 438
 439 static gboolean
 440 same_value (const gchar *actual,
 441             const gchar *expected)
 442 {
 443   gdouble actual_value, expected_value;
 444
 445   actual_value = g_ascii_strtod (actual, NULL);
 446   expected_value = g_ascii_strtod (expected, NULL);
 447
 448   return actual_value == expected_value;
 449 }
 450
 451 static void
 452 test_e (void)
 453 {
 454   gchar buf[128];
 455   gint res;
 456
 457   /* %e, basic formatting */
 458   /* for %e we can't expect to reproduce exact strings and lengths, since SUS
 459    * only guarantees that the exponent shall always contain at least two
 460    * digits. On Windows, it seems to be at least three digits long.
 461    * Therefore, we compare the results of parsing the expected result and the
 462    * actual result.
 463    */
 464
 465   res = g_snprintf (buf, 128, "%e", G_PI);
 466   g_assert_cmpint (res, >=, 12);
 467   g_assert (same_value (buf, "3.141593e+00"));
 468
 469   res = g_snprintf (buf, 128, "%.8e", G_PI);
 470   g_assert_cmpint (res, >=, 14);
 471   g_assert (same_value (buf, "3.14159265e+00"));
 472
 473   res = g_snprintf (buf, 128, "%.0e", G_PI);
 474   g_assert_cmpint (res, >=, 5);
 475   g_assert (same_value (buf, "3e+00"));
 476
 477   res = g_snprintf (buf, 128, "%.1e", 0.0);
 478   g_assert_cmpint (res, >=, 7);
 479   g_assert (same_value (buf, "0.0e+00"));
 480
 481   res = g_snprintf (buf, 128, "%.1e", 0.00001);
 482   g_assert_cmpint (res, >=, 7);
 483   g_assert (same_value (buf, "1.0e-05"));
 484
 485   res = g_snprintf (buf, 128, "%.1e", 10000.0);
 486   g_assert_cmpint (res, >=, 7);
 487   g_assert (same_value (buf, "1.0e+04"));
 488
 489   /* %e, flags */
 490
 491   res = g_snprintf (buf, 128, "%+e", G_PI);
 492   g_assert_cmpint (res, >=, 13);
 493   g_assert (same_value (buf, "+3.141593e+00"));
 494
 495   res = g_snprintf (buf, 128, "% e", G_PI);
 496   g_assert_cmpint (res, >=, 13);
 497   g_assert (same_value (buf, " 3.141593e+00"));
 498
 499   res = g_snprintf (buf, 128, "%#.0e", G_PI);
 500   g_assert_cmpint (res, >=, 6);
 501   g_assert (same_value (buf, "3.e+00"));
 502
 503   res = g_snprintf (buf, 128, "%09.2e", G_PI);
 504   g_assert_cmpint (res, >=, 9);
 505   g_assert (same_value (buf, "03.14e+00"));
 506 }
 507
 508 static void
 509 test_c (void)
 510 {
 511   gchar buf[128];
 512   gint res;
 513
 514   res = g_snprintf (buf, 128, "%c", 'a');
 515   g_assert_cmpint (res, ==, 1);
 516   g_assert_cmpstr (buf, ==, "a");
 517 }
 518
 519 static void
 520 test_s (void)
 521 {
 522   gchar buf[128];
 523   gint res;
 524
 525   res = g_snprintf (buf, 128, "%.2s", "abc");
 526   g_assert_cmpint (res, ==, 2);
 527   g_assert_cmpstr (buf, ==, "ab");
 528
 529   res = g_snprintf (buf, 128, "%.6s", "abc");
 530   g_assert_cmpint (res, ==, 3);
 531   g_assert_cmpstr (buf, ==, "abc");
 532
 533   res = g_snprintf (buf, 128, "%5s", "abc");
 534   g_assert_cmpint (res, ==, 5);
 535   g_assert_cmpstr (buf, ==, "  abc");
 536
 537   res = g_snprintf (buf, 128, "%-5s", "abc");
 538   g_assert_cmpint (res, ==, 5);
 539   g_assert_cmpstr (buf, ==, "abc  ");
 540
 541   res = g_snprintf (buf, 128, "%5.2s", "abc");
 542   g_assert_cmpint (res, ==, 5);
 543   g_assert_cmpstr (buf, ==, "   ab");
 544
 545   res = g_snprintf (buf, 128, "%*s", 5, "abc");
 546   g_assert_cmpint (res, ==, 5);
 547   g_assert_cmpstr (buf, ==, "  abc");
 548
 549 #if 0 /* HP-UX doesn't get this right */
 550   res = g_snprintf (buf, 128, "%*s", -5, "abc");
 551   g_assert_cmpint (res, ==, 5);
 552   g_assert_cmpstr (buf, ==, "abc  ");
 553 #endif
 554
 555   res = g_snprintf (buf, 128, "%*.*s", 5, 2, "abc");
 556   g_assert_cmpint (res, ==, 5);
 557   g_assert_cmpstr (buf, ==, "   ab");
 558 }
 559
 560 static void
 561 test_n (void)
 562 {
 563   gchar buf[128];
 564   gint res;
 565   gint i;
 566   glong l;
 567
 568   res = g_snprintf (buf, 128, "abc%n", &i);
 569   g_assert_cmpint (res, ==, 3);
 570   g_assert_cmpstr (buf, ==, "abc");
 571   g_assert_cmpint (i, ==, 3);
 572
 573   res = g_snprintf (buf, 128, "abc%ln", &l);
 574   g_assert_cmpint (res, ==, 3);
 575   g_assert_cmpstr (buf, ==, "abc");
 576   g_assert_cmpint (l, ==, 3);
 577 }
 578
 579 static void
 580 test_percent (void)
 581 {
 582   gchar buf[128];
 583   gint res;
 584
 585   res = g_snprintf (buf, 128, "%%");
 586   g_assert_cmpint (res, ==, 1);
 587   g_assert_cmpstr (buf, ==, "%");
 588 }
 589
 590 static void
 591 test_positional_params (void)
 592 {
 593   gchar buf[128];
 594   gint res;
 595
 596   res = g_snprintf (buf, 128, "%2$c %1$c", 'b', 'a');
 597   g_assert_cmpint (res, ==, 3);
 598   g_assert_cmpstr (buf, ==, "a b");
 599
 600   res = g_snprintf (buf, 128, "%1$*2$.*3$s", "abc", 5, 2);
 601   g_assert_cmpint (res, ==, 5);
 602   g_assert_cmpstr (buf, ==, "   ab");
 603
 604   res = g_snprintf (buf, 128, "%1$s%1$s", "abc");
 605   g_assert_cmpint (res, ==, 6);
 606   g_assert_cmpstr (buf, ==, "abcabc");
 607 }
 608
 609 static void
 610 test_64bit (void)
 611 {
 612   gchar buf[128];
 613   gint res;
 614
 615   res = g_snprintf (buf, 128, "%" G_GINT64_FORMAT, (gint64)123456);
 616   g_assert_cmpint (res, ==, 6);
 617   g_assert_cmpstr (buf, ==, "123456");
 618
 619   res = g_snprintf (buf, 128, "%" G_GINT64_FORMAT, (gint64)-123456);
 620   g_assert_cmpint (res, ==, 7);
 621   g_assert_cmpstr (buf, ==, "-123456");
 622
 623   res = g_snprintf (buf, 128, "%" G_GUINT64_FORMAT, (guint64)123456);
 624   g_assert_cmpint (res, ==, 6);
 625   g_assert_cmpstr (buf, ==, "123456");
 626
 627   res = g_snprintf (buf, 128, "%" G_GINT64_MODIFIER "o", (gint64)123456);
 628   g_assert_cmpint (res, ==, 6);
 629   g_assert_cmpstr (buf, ==, "361100");
 630
 631   res = g_snprintf (buf, 128, "%#" G_GINT64_MODIFIER "o", (gint64)123456);
 632   g_assert_cmpint (res, ==, 7);
 633   g_assert_cmpstr (buf, ==, "0361100");
 634
 635   res = g_snprintf (buf, 128, "%" G_GINT64_MODIFIER "x", (gint64)123456);
 636   g_assert_cmpint (res, ==, 5);
 637   g_assert_cmpstr (buf, ==, "1e240");
 638
 639   res = g_snprintf (buf, 128, "%#" G_GINT64_MODIFIER "x", (gint64)123456);
 640   g_assert_cmpint (res, ==, 7);
 641   g_assert_cmpstr (buf, ==, "0x1e240");
 642
 643   res = g_snprintf (buf, 128, "%" G_GINT64_MODIFIER "X", (gint64)123456);
 644   g_assert_cmpint (res, ==, 5);
 645   g_assert_cmpstr (buf, ==, "1E240");
 646
 647 #ifdef G_OS_WIN32
 648   /* On Win32, test that the "ll" modifier also works, for backward
 649    * compatibility. One really should use the G_GINT64_MODIFIER (which
 650    * on Win32 is the "I64" that the (msvcrt) C library's printf uses),
 651    * but "ll" used to work with the "trio" g_printf implementation in
 652    * GLib 2.2, so it's best if it continues to work.
 653    */
 654
 655   res = g_snprintf (buf, 128, "%" "lli", (gint64)123456);
 656   g_assert_cmpint (res, ==, 6);
 657   g_assert_cmpstr (buf, ==, "123456");
 658
 659   res = g_snprintf (buf, 128, "%" "lli", (gint64)-123456);
 660   g_assert_cmpint (res, ==, 7);
 661   g_assert_cmpstr (buf, ==, "-123456");
 662
 663   res = g_snprintf (buf, 128, "%" "llu", (guint64)123456);
 664   g_assert_cmpint (res, ==, 6);
 665   g_assert_cmpstr (buf, ==, "123456");
 666
 667   res = g_snprintf (buf, 128, "%" "ll" "o", (gint64)123456);
 668   g_assert_cmpint (res, ==, 6);
 669   g_assert_cmpstr (buf, ==, "361100");
 670
 671   res = g_snprintf (buf, 128, "%#" "ll" "o", (gint64)123456);
 672   g_assert_cmpint (res, ==, 7);
 673   g_assert_cmpstr (buf, ==, "0361100");
 674
 675   res = g_snprintf (buf, 128, "%" "ll" "x", (gint64)123456);
 676   g_assert_cmpint (res, ==, 5);
 677   g_assert_cmpstr (buf, ==, "1e240");
 678
 679   res = g_snprintf (buf, 128, "%#" "ll" "x", (gint64)123456);
 680   g_assert_cmpint (res, ==, 7);
 681   g_assert_cmpstr (buf, ==, "0x1e240");
 682
 683   res = g_snprintf (buf, 128, "%" "ll" "X", (gint64)123456);
 684   g_assert_cmpint (res, ==, 5);
 685   g_assert_cmpstr (buf, ==, "1E240");
 686 #endif
 687 }
 688
 689 int
 690 main (int   argc,
 691       char *argv[])
 692 {
 693   g_test_init (&argc, &argv, NULL);
 694
 695   g_test_add_func ("/printf/test-retval-and-trunc", test_retval_and_trunc);
 696   g_test_add_func ("/printf/test-d", test_d);
 697   g_test_add_func ("/printf/test-o", test_o);
 698   g_test_add_func ("/printf/test-u", test_u);
 699   g_test_add_func ("/printf/test-x", test_x);
 700   g_test_add_func ("/printf/test-X", test_X);
 701   g_test_add_func ("/printf/test-f", test_f);
 702   g_test_add_func ("/printf/test-e", test_e);
 703   g_test_add_func ("/printf/test-c", test_c);
 704   g_test_add_func ("/printf/test-s", test_s);
 705   g_test_add_func ("/printf/test-n", test_n);
 706   g_test_add_func ("/printf/test-percent", test_percent);
 707   g_test_add_func ("/printf/test-positional-params", test_positional_params);
 708   g_test_add_func ("/printf/test-64bit", test_64bit);
 709
 710   return g_test_run();
 711 }