glib/tests/printf.c

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