mozglue/tests/TestIntegerPrintfMacros.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/Assertions.h"
   8 #include "mozilla/Sprintf.h"
   9
  10 #include <string.h>
  11 #include <inttypes.h>
  12
  13 /* Output array and poisoning method shared by all tests. */
  14 static char gOutput[32];
  15
  16 static void PoisonOutput() { memset(gOutput, 0xDA, sizeof(gOutput)); }
  17
  18 /*
  19  * The fprintf macros for signed integers are:
  20  *
  21  *   PRIdN   PRIdLEASTN   PRIdFASTN   PRIdMAX   PRIdPTR
  22  *   PRIiN   PRIiLEASTN   PRIiFASTN   PRIiMAX   PRIiPTR
  23  *
  24  * In these names N is the width of the type as described in C99 7.18.1.
  25  */
  26
  27 static void TestPrintSigned8() {
  28   PoisonOutput();
  29   SprintfLiteral(gOutput, "%" PRId8, int8_t(-17));
  30   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-17"));
  31
  32   PoisonOutput();
  33   SprintfLiteral(gOutput, "%" PRIi8, int8_t(42));
  34   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
  35 }
  36
  37 static void TestPrintSigned16() {
  38   PoisonOutput();
  39   SprintfLiteral(gOutput, "%" PRId16, int16_t(-289));
  40   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-289"));
  41
  42   PoisonOutput();
  43   SprintfLiteral(gOutput, "%" PRIi16, int16_t(728));
  44   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "728"));
  45 }
  46
  47 static void TestPrintSigned32() {
  48   PoisonOutput();
  49   SprintfLiteral(gOutput, "%" PRId32, int32_t(-342178));
  50   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-342178"));
  51
  52   PoisonOutput();
  53   SprintfLiteral(gOutput, "%" PRIi32, int32_t(5719283));
  54   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "5719283"));
  55 }
  56
  57 static void TestPrintSigned64() {
  58   PoisonOutput();
  59   SprintfLiteral(gOutput, "%" PRId64, int64_t(-INT64_C(432157943248732)));
  60   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
  61
  62   PoisonOutput();
  63   SprintfLiteral(gOutput, "%" PRIi64, int64_t(INT64_C(325719232983)));
  64   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
  65 }
  66
  67 static void TestPrintSignedN() {
  68   TestPrintSigned8();
  69   TestPrintSigned16();
  70   TestPrintSigned32();
  71   TestPrintSigned64();
  72 }
  73
  74 static void TestPrintSignedLeast8() {
  75   PoisonOutput();
  76   SprintfLiteral(gOutput, "%" PRIdLEAST8, int_least8_t(-17));
  77   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-17"));
  78
  79   PoisonOutput();
  80   SprintfLiteral(gOutput, "%" PRIiLEAST8, int_least8_t(42));
  81   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
  82 }
  83
  84 static void TestPrintSignedLeast16() {
  85   PoisonOutput();
  86   SprintfLiteral(gOutput, "%" PRIdLEAST16, int_least16_t(-289));
  87   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-289"));
  88
  89   PoisonOutput();
  90   SprintfLiteral(gOutput, "%" PRIiLEAST16, int_least16_t(728));
  91   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "728"));
  92 }
  93
  94 static void TestPrintSignedLeast32() {
  95   PoisonOutput();
  96   SprintfLiteral(gOutput, "%" PRIdLEAST32, int_least32_t(-342178));
  97   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-342178"));
  98
  99   PoisonOutput();
 100   SprintfLiteral(gOutput, "%" PRIiLEAST32, int_least32_t(5719283));
 101   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "5719283"));
 102 }
 103
 104 static void TestPrintSignedLeast64() {
 105   PoisonOutput();
 106   SprintfLiteral(gOutput, "%" PRIdLEAST64,
 107                  int_least64_t(-INT64_C(432157943248732)));
 108   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
 109
 110   PoisonOutput();
 111   SprintfLiteral(gOutput, "%" PRIiLEAST64,
 112                  int_least64_t(INT64_C(325719232983)));
 113   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
 114 }
 115
 116 static void TestPrintSignedLeastN() {
 117   TestPrintSignedLeast8();
 118   TestPrintSignedLeast16();
 119   TestPrintSignedLeast32();
 120   TestPrintSignedLeast64();
 121 }
 122
 123 static void TestPrintSignedFast8() {
 124   PoisonOutput();
 125   SprintfLiteral(gOutput, "%" PRIdFAST8, int_fast8_t(-17));
 126   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-17"));
 127
 128   PoisonOutput();
 129   SprintfLiteral(gOutput, "%" PRIiFAST8, int_fast8_t(42));
 130   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
 131 }
 132
 133 static void TestPrintSignedFast16() {
 134   PoisonOutput();
 135   SprintfLiteral(gOutput, "%" PRIdFAST16, int_fast16_t(-289));
 136   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-289"));
 137
 138   PoisonOutput();
 139   SprintfLiteral(gOutput, "%" PRIiFAST16, int_fast16_t(728));
 140   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "728"));
 141 }
 142
 143 static void TestPrintSignedFast32() {
 144   PoisonOutput();
 145   SprintfLiteral(gOutput, "%" PRIdFAST32, int_fast32_t(-342178));
 146   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-342178"));
 147
 148   PoisonOutput();
 149   SprintfLiteral(gOutput, "%" PRIiFAST32, int_fast32_t(5719283));
 150   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "5719283"));
 151 }
 152
 153 static void TestPrintSignedFast64() {
 154   PoisonOutput();
 155   SprintfLiteral(gOutput, "%" PRIdFAST64,
 156                  int_fast64_t(-INT64_C(432157943248732)));
 157   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
 158
 159   PoisonOutput();
 160   SprintfLiteral(gOutput, "%" PRIiFAST64, int_fast64_t(INT64_C(325719232983)));
 161   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
 162 }
 163
 164 static void TestPrintSignedFastN() {
 165   TestPrintSignedFast8();
 166   TestPrintSignedFast16();
 167   TestPrintSignedFast32();
 168   TestPrintSignedFast64();
 169 }
 170
 171 static void TestPrintSignedMax() {
 172   PoisonOutput();
 173   SprintfLiteral(gOutput, "%" PRIdMAX, intmax_t(-INTMAX_C(432157943248732)));
 174   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "-432157943248732"));
 175
 176   PoisonOutput();
 177   SprintfLiteral(gOutput, "%" PRIiMAX, intmax_t(INTMAX_C(325719232983)));
 178   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
 179 }
 180
 181 static void TestPrintSignedPtr() {
 182   PoisonOutput();
 183   SprintfLiteral(gOutput, "%" PRIdPTR,
 184                  intptr_t(reinterpret_cast<void*>(12345678)));
 185   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "12345678"));
 186
 187   PoisonOutput();
 188   SprintfLiteral(gOutput, "%" PRIiPTR,
 189                  intptr_t(reinterpret_cast<void*>(87654321)));
 190   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "87654321"));
 191 }
 192
 193 static void TestPrintSigned() {
 194   TestPrintSignedN();
 195   TestPrintSignedLeastN();
 196   TestPrintSignedFastN();
 197   TestPrintSignedMax();
 198   TestPrintSignedPtr();
 199 }
 200
 201 /*
 202  * The fprintf macros for unsigned integers are:
 203  *
 204  *   PRIoN   PRIoLEASTN   PRIoFASTN   PRIoMAX   PRIoPTR
 205  *   PRIuN   PRIuLEASTN   PRIuFASTN   PRIuMAX   PRIuPTR
 206  *   PRIxN   PRIxLEASTN   PRIxFASTN   PRIxMAX   PRIxPTR
 207  *   PRIXN   PRIXLEASTN   PRIXFASTN   PRIXMAX   PRIXPTR
 208  *
 209  * In these names N is the width of the type as described in C99 7.18.1.
 210  */
 211
 212 static void TestPrintUnsigned8() {
 213   PoisonOutput();
 214   SprintfLiteral(gOutput, "%" PRIo8, uint8_t(042));
 215   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
 216
 217   PoisonOutput();
 218   SprintfLiteral(gOutput, "%" PRIu8, uint8_t(17));
 219   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17"));
 220
 221   PoisonOutput();
 222   SprintfLiteral(gOutput, "%" PRIx8, uint8_t(0x2a));
 223   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a"));
 224
 225   PoisonOutput();
 226   SprintfLiteral(gOutput, "%" PRIX8, uint8_t(0xCD));
 227   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CD"));
 228 }
 229
 230 static void TestPrintUnsigned16() {
 231   PoisonOutput();
 232   SprintfLiteral(gOutput, "%" PRIo16, uint16_t(04242));
 233   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4242"));
 234
 235   PoisonOutput();
 236   SprintfLiteral(gOutput, "%" PRIu16, uint16_t(1717));
 237   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "1717"));
 238
 239   PoisonOutput();
 240   SprintfLiteral(gOutput, "%" PRIx16, uint16_t(0x2a2a));
 241   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a"));
 242
 243   PoisonOutput();
 244   SprintfLiteral(gOutput, "%" PRIX16, uint16_t(0xCDCD));
 245   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCD"));
 246 }
 247
 248 static void TestPrintUnsigned32() {
 249   PoisonOutput();
 250   SprintfLiteral(gOutput, "%" PRIo32, uint32_t(0424242));
 251   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242"));
 252
 253   PoisonOutput();
 254   SprintfLiteral(gOutput, "%" PRIu32, uint32_t(171717));
 255   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "171717"));
 256
 257   PoisonOutput();
 258   SprintfLiteral(gOutput, "%" PRIx32, uint32_t(0x2a2a2a));
 259   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a"));
 260
 261   PoisonOutput();
 262   SprintfLiteral(gOutput, "%" PRIX32, uint32_t(0xCDCDCD));
 263   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCD"));
 264 }
 265
 266 static void TestPrintUnsigned64() {
 267   PoisonOutput();
 268   SprintfLiteral(gOutput, "%" PRIo64, uint64_t(UINT64_C(0424242424242)));
 269   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242424242"));
 270
 271   PoisonOutput();
 272   SprintfLiteral(gOutput, "%" PRIu64, uint64_t(UINT64_C(17171717171717171717)));
 273   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17171717171717171717"));
 274
 275   PoisonOutput();
 276   SprintfLiteral(gOutput, "%" PRIx64, uint64_t(UINT64_C(0x2a2a2a2a2a2a2a)));
 277   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a2a2a2a2a"));
 278
 279   PoisonOutput();
 280   SprintfLiteral(gOutput, "%" PRIX64, uint64_t(UINT64_C(0xCDCDCDCDCDCD)));
 281   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCDCDCDCD"));
 282 }
 283
 284 static void TestPrintUnsignedN() {
 285   TestPrintUnsigned8();
 286   TestPrintUnsigned16();
 287   TestPrintUnsigned32();
 288   TestPrintUnsigned64();
 289 }
 290
 291 static void TestPrintUnsignedLeast8() {
 292   PoisonOutput();
 293   SprintfLiteral(gOutput, "%" PRIoLEAST8, uint_least8_t(042));
 294   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
 295
 296   PoisonOutput();
 297   SprintfLiteral(gOutput, "%" PRIuLEAST8, uint_least8_t(17));
 298   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17"));
 299
 300   PoisonOutput();
 301   SprintfLiteral(gOutput, "%" PRIxLEAST8, uint_least8_t(0x2a));
 302   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a"));
 303
 304   PoisonOutput();
 305   SprintfLiteral(gOutput, "%" PRIXLEAST8, uint_least8_t(0xCD));
 306   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CD"));
 307 }
 308
 309 static void TestPrintUnsignedLeast16() {
 310   PoisonOutput();
 311   SprintfLiteral(gOutput, "%" PRIoLEAST16, uint_least16_t(04242));
 312   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4242"));
 313
 314   PoisonOutput();
 315   SprintfLiteral(gOutput, "%" PRIuLEAST16, uint_least16_t(1717));
 316   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "1717"));
 317
 318   PoisonOutput();
 319   SprintfLiteral(gOutput, "%" PRIxLEAST16, uint_least16_t(0x2a2a));
 320   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a"));
 321
 322   PoisonOutput();
 323   SprintfLiteral(gOutput, "%" PRIXLEAST16, uint_least16_t(0xCDCD));
 324   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCD"));
 325 }
 326
 327 static void TestPrintUnsignedLeast32() {
 328   PoisonOutput();
 329   SprintfLiteral(gOutput, "%" PRIoLEAST32, uint_least32_t(0424242));
 330   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242"));
 331
 332   PoisonOutput();
 333   SprintfLiteral(gOutput, "%" PRIuLEAST32, uint_least32_t(171717));
 334   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "171717"));
 335
 336   PoisonOutput();
 337   SprintfLiteral(gOutput, "%" PRIxLEAST32, uint_least32_t(0x2a2a2a));
 338   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a"));
 339
 340   PoisonOutput();
 341   SprintfLiteral(gOutput, "%" PRIXLEAST32, uint_least32_t(0xCDCDCD));
 342   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCD"));
 343 }
 344
 345 static void TestPrintUnsignedLeast64() {
 346   PoisonOutput();
 347   SprintfLiteral(gOutput, "%" PRIoLEAST64,
 348                  uint_least64_t(UINT64_C(0424242424242)));
 349   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242424242"));
 350
 351   PoisonOutput();
 352   SprintfLiteral(gOutput, "%" PRIuLEAST64,
 353                  uint_least64_t(UINT64_C(17171717171717171717)));
 354   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17171717171717171717"));
 355
 356   PoisonOutput();
 357   SprintfLiteral(gOutput, "%" PRIxLEAST64,
 358                  uint_least64_t(UINT64_C(0x2a2a2a2a2a2a2a)));
 359   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a2a2a2a2a"));
 360
 361   PoisonOutput();
 362   SprintfLiteral(gOutput, "%" PRIXLEAST64,
 363                  uint_least64_t(UINT64_C(0xCDCDCDCDCDCD)));
 364   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCDCDCDCD"));
 365 }
 366
 367 static void TestPrintUnsignedLeastN() {
 368   TestPrintUnsignedLeast8();
 369   TestPrintUnsignedLeast16();
 370   TestPrintUnsignedLeast32();
 371   TestPrintUnsignedLeast64();
 372 }
 373
 374 static void TestPrintUnsignedFast8() {
 375   PoisonOutput();
 376   SprintfLiteral(gOutput, "%" PRIoFAST8, uint_fast8_t(042));
 377   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "42"));
 378
 379   PoisonOutput();
 380   SprintfLiteral(gOutput, "%" PRIuFAST8, uint_fast8_t(17));
 381   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17"));
 382
 383   PoisonOutput();
 384   SprintfLiteral(gOutput, "%" PRIxFAST8, uint_fast8_t(0x2a));
 385   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a"));
 386
 387   PoisonOutput();
 388   SprintfLiteral(gOutput, "%" PRIXFAST8, uint_fast8_t(0xCD));
 389   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CD"));
 390 }
 391
 392 static void TestPrintUnsignedFast16() {
 393   PoisonOutput();
 394   SprintfLiteral(gOutput, "%" PRIoFAST16, uint_fast16_t(04242));
 395   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4242"));
 396
 397   PoisonOutput();
 398   SprintfLiteral(gOutput, "%" PRIuFAST16, uint_fast16_t(1717));
 399   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "1717"));
 400
 401   PoisonOutput();
 402   SprintfLiteral(gOutput, "%" PRIxFAST16, uint_fast16_t(0x2a2a));
 403   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a"));
 404
 405   PoisonOutput();
 406   SprintfLiteral(gOutput, "%" PRIXFAST16, uint_fast16_t(0xCDCD));
 407   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCD"));
 408 }
 409
 410 static void TestPrintUnsignedFast32() {
 411   PoisonOutput();
 412   SprintfLiteral(gOutput, "%" PRIoFAST32, uint_fast32_t(0424242));
 413   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242"));
 414
 415   PoisonOutput();
 416   SprintfLiteral(gOutput, "%" PRIuFAST32, uint_fast32_t(171717));
 417   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "171717"));
 418
 419   PoisonOutput();
 420   SprintfLiteral(gOutput, "%" PRIxFAST32, uint_fast32_t(0x2a2a2a));
 421   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a"));
 422
 423   PoisonOutput();
 424   SprintfLiteral(gOutput, "%" PRIXFAST32, uint_fast32_t(0xCDCDCD));
 425   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCD"));
 426 }
 427
 428 static void TestPrintUnsignedFast64() {
 429   PoisonOutput();
 430   SprintfLiteral(gOutput, "%" PRIoFAST64,
 431                  uint_fast64_t(UINT64_C(0424242424242)));
 432   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "424242424242"));
 433
 434   PoisonOutput();
 435   SprintfLiteral(gOutput, "%" PRIuFAST64,
 436                  uint_fast64_t(UINT64_C(17171717171717171717)));
 437   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "17171717171717171717"));
 438
 439   PoisonOutput();
 440   SprintfLiteral(gOutput, "%" PRIxFAST64,
 441                  uint_fast64_t(UINT64_C(0x2a2a2a2a2a2a2a)));
 442   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "2a2a2a2a2a2a2a"));
 443
 444   PoisonOutput();
 445   SprintfLiteral(gOutput, "%" PRIXFAST64,
 446                  uint_fast64_t(UINT64_C(0xCDCDCDCDCDCD)));
 447   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "CDCDCDCDCDCD"));
 448 }
 449
 450 static void TestPrintUnsignedFastN() {
 451   TestPrintUnsignedFast8();
 452   TestPrintUnsignedFast16();
 453   TestPrintUnsignedFast32();
 454   TestPrintUnsignedFast64();
 455 }
 456
 457 static void TestPrintUnsignedMax() {
 458   PoisonOutput();
 459   SprintfLiteral(gOutput, "%" PRIoMAX, uintmax_t(UINTMAX_C(432157943248732)));
 460   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "14220563454333534"));
 461
 462   PoisonOutput();
 463   SprintfLiteral(gOutput, "%" PRIuMAX, uintmax_t(UINTMAX_C(325719232983)));
 464   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "325719232983"));
 465
 466   PoisonOutput();
 467   SprintfLiteral(gOutput, "%" PRIxMAX, uintmax_t(UINTMAX_C(327281321873)));
 468   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4c337ca791"));
 469
 470   PoisonOutput();
 471   SprintfLiteral(gOutput, "%" PRIXMAX, uintmax_t(UINTMAX_C(912389523743523)));
 472   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "33DD03D75A323"));
 473 }
 474
 475 static void TestPrintUnsignedPtr() {
 476   PoisonOutput();
 477   SprintfLiteral(gOutput, "%" PRIoPTR,
 478                  uintptr_t(reinterpret_cast<void*>(12345678)));
 479   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "57060516"));
 480
 481   PoisonOutput();
 482   SprintfLiteral(gOutput, "%" PRIuPTR,
 483                  uintptr_t(reinterpret_cast<void*>(87654321)));
 484   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "87654321"));
 485
 486   PoisonOutput();
 487   SprintfLiteral(gOutput, "%" PRIxPTR,
 488                  uintptr_t(reinterpret_cast<void*>(0x4c3a791)));
 489   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "4c3a791"));
 490
 491   PoisonOutput();
 492   SprintfLiteral(gOutput, "%" PRIXPTR,
 493                  uintptr_t(reinterpret_cast<void*>(0xF328DB)));
 494   MOZ_RELEASE_ASSERT(!strcmp(gOutput, "F328DB"));
 495 }
 496
 497 static void TestPrintUnsigned() {
 498   TestPrintUnsignedN();
 499   TestPrintUnsignedLeastN();
 500   TestPrintUnsignedFastN();
 501   TestPrintUnsignedMax();
 502   TestPrintUnsignedPtr();
 503 }
 504
 505 static void TestPrint() {
 506   TestPrintSigned();
 507   TestPrintUnsigned();
 508 }
 509
 510 /*
 511  * The fscanf macros for signed integers are:
 512  *
 513  *   SCNdN   SCNdLEASTN   SCNdFASTN   SCNdMAX   SCNdPTR
 514  *   SCNiN   SCNiLEASTN   SCNiFASTN   SCNiMAX   SCNiPTR
 515  *
 516  * In these names N is the width of the type as described in C99 7.18.1.
 517  */
 518
 519 /*
 520  * MSVC's scanf is insufficiently powerful to implement all the SCN* macros.
 521  * Rather than support some subset of them, we instead support none of them.
 522  * See the comment at the top of IntegerPrintfMacros.h.  But in case we ever do
 523  * support them, the following tests should adequately test implementation
 524  * correctness.  (Indeed, these tests *revealed* MSVC's limitations.)
 525  *
 526  * That said, even if MSVC ever picks up complete support, we still probably
 527  * don't want to support these, because of the undefined-behavior issue noted
 528  * further down in the comment atop IntegerPrintfMacros.h.
 529  */
 530 #define SHOULD_TEST_SCANF_MACROS 0
 531
 532 #if SHOULD_TEST_SCANF_MACROS
 533
 534 /*
 535  * glibc header definitions for SCN{d,i,o,u,x}{,LEAST,FAST}8 use the "hh" length
 536  * modifier, which is new in C99 (and C++11, by reference).  We compile this
 537  * file as C++11, so if "hh" is used in these macros, it's standard.  But some
 538  * versions of gcc wrongly think it isn't and warn about a "non-standard"
 539  * modifier.  And since these tests mostly exist to verify format-macro/type
 540  * consistency (particularly through compiler warnings about incorrect formats),
 541  * these warnings are unacceptable.  So for now, compile tests for those macros
 542  * only if we aren't compiling with gcc.
 543  */
 544 #  define SHOULD_TEST_8BIT_FORMAT_MACROS (!(MOZ_IS_GCC))
 545
 546 template <typename T>
 547 union Input {
 548   T mI;
 549   unsigned char mPun[16];
 550 };
 551
 552 template <typename T>
 553 static void PoisonInput(Input<T>& aInput) {
 554   memset(aInput.mPun, 0xDA, sizeof(aInput.mPun));
 555 }
 556
 557 template <typename T>
 558 static bool ExtraBitsUntouched(const Input<T>& aInput) {
 559   for (size_t i = sizeof(aInput.mI); i < sizeof(aInput); i++) {
 560     if (aInput.mPun[i] != 0xDA) {
 561       return false;
 562     }
 563   }
 564
 565   return true;
 566 }
 567
 568 static void TestScanSigned8() {
 569 #  if SHOULD_TEST_8BIT_FORMAT_MACROS
 570   Input<int8_t> u;
 571
 572   PoisonInput(u);
 573   sscanf("-17", "%" SCNd8, &u.mI);
 574   MOZ_RELEASE_ASSERT(u.mI == -17);
 575   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 576
 577   PoisonInput(u);
 578   sscanf("042", "%" SCNi8, &u.mI);
 579   MOZ_RELEASE_ASSERT(u.mI == 042);
 580   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 581 #  endif
 582 }
 583
 584 static void TestScanSigned16() {
 585   Input<int16_t> u;
 586
 587   PoisonInput(u);
 588   sscanf("-1742", "%" SCNd16, &u.mI);
 589   MOZ_RELEASE_ASSERT(u.mI == -1742);
 590   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 591
 592   PoisonInput(u);
 593   sscanf("04217", "%" SCNi16, &u.mI);
 594   MOZ_RELEASE_ASSERT(u.mI == 04217);
 595   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 596 }
 597
 598 static void TestScanSigned32() {
 599   Input<int32_t> u;
 600
 601   PoisonInput(u);
 602   sscanf("-174257", "%" SCNd32, &u.mI);
 603   MOZ_RELEASE_ASSERT(u.mI == -174257);
 604   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 605
 606   PoisonInput(u);
 607   sscanf("0423571", "%" SCNi32, &u.mI);
 608   MOZ_RELEASE_ASSERT(u.mI == 0423571);
 609   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 610 }
 611
 612 static void TestScanSigned64() {
 613   Input<int64_t> u;
 614
 615   PoisonInput(u);
 616   sscanf("-17425238927232", "%" SCNd64, &u.mI);
 617   MOZ_RELEASE_ASSERT(u.mI == -INT64_C(17425238927232));
 618   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 619
 620   PoisonInput(u);
 621   sscanf("042333576571", "%" SCNi64, &u.mI);
 622   MOZ_RELEASE_ASSERT(u.mI == INT64_C(042333576571));
 623   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 624 }
 625
 626 static void TestScanSignedN() {
 627   TestScanSigned8();
 628   TestScanSigned16();
 629   TestScanSigned32();
 630   TestScanSigned64();
 631 }
 632
 633 static void TestScanSignedLeast8() {
 634 #  if SHOULD_TEST_8BIT_FORMAT_MACROS
 635   Input<int_least8_t> u;
 636
 637   PoisonInput(u);
 638   sscanf("-17", "%" SCNdLEAST8, &u.mI);
 639   MOZ_RELEASE_ASSERT(u.mI == -17);
 640   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 641
 642   PoisonInput(u);
 643   sscanf("042", "%" SCNiLEAST8, &u.mI);
 644   MOZ_RELEASE_ASSERT(u.mI == 042);
 645   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 646 #  endif
 647 }
 648
 649 static void TestScanSignedLeast16() {
 650   Input<int_least16_t> u;
 651
 652   PoisonInput(u);
 653   sscanf("-1742", "%" SCNdLEAST16, &u.mI);
 654   MOZ_RELEASE_ASSERT(u.mI == -1742);
 655   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 656
 657   PoisonInput(u);
 658   sscanf("04217", "%" SCNiLEAST16, &u.mI);
 659   MOZ_RELEASE_ASSERT(u.mI == 04217);
 660   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 661 }
 662
 663 static void TestScanSignedLeast32() {
 664   Input<int_least32_t> u;
 665
 666   PoisonInput(u);
 667   sscanf("-174257", "%" SCNdLEAST32, &u.mI);
 668   MOZ_RELEASE_ASSERT(u.mI == -174257);
 669   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 670
 671   PoisonInput(u);
 672   sscanf("0423571", "%" SCNiLEAST32, &u.mI);
 673   MOZ_RELEASE_ASSERT(u.mI == 0423571);
 674   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 675 }
 676
 677 static void TestScanSignedLeast64() {
 678   Input<int_least64_t> u;
 679
 680   PoisonInput(u);
 681   sscanf("-17425238927232", "%" SCNdLEAST64, &u.mI);
 682   MOZ_RELEASE_ASSERT(u.mI == -INT64_C(17425238927232));
 683   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 684
 685   PoisonInput(u);
 686   sscanf("042333576571", "%" SCNiLEAST64, &u.mI);
 687   MOZ_RELEASE_ASSERT(u.mI == INT64_C(042333576571));
 688   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 689 }
 690
 691 static void TestScanSignedLeastN() {
 692   TestScanSignedLeast8();
 693   TestScanSignedLeast16();
 694   TestScanSignedLeast32();
 695   TestScanSignedLeast64();
 696 }
 697
 698 static void TestScanSignedFast8() {
 699 #  if SHOULD_TEST_8BIT_FORMAT_MACROS
 700   Input<int_fast8_t> u;
 701
 702   PoisonInput(u);
 703   sscanf("-17", "%" SCNdFAST8, &u.mI);
 704   MOZ_RELEASE_ASSERT(u.mI == -17);
 705   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 706
 707   PoisonInput(u);
 708   sscanf("042", "%" SCNiFAST8, &u.mI);
 709   MOZ_RELEASE_ASSERT(u.mI == 042);
 710   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 711 #  endif
 712 }
 713
 714 static void TestScanSignedFast16() {
 715   Input<int_fast16_t> u;
 716
 717   PoisonInput(u);
 718   sscanf("-1742", "%" SCNdFAST16, &u.mI);
 719   MOZ_RELEASE_ASSERT(u.mI == -1742);
 720   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 721
 722   PoisonInput(u);
 723   sscanf("04217", "%" SCNiFAST16, &u.mI);
 724   MOZ_RELEASE_ASSERT(u.mI == 04217);
 725   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 726 }
 727
 728 static void TestScanSignedFast32() {
 729   Input<int_fast32_t> u;
 730
 731   PoisonInput(u);
 732   sscanf("-174257", "%" SCNdFAST32, &u.mI);
 733   MOZ_RELEASE_ASSERT(u.mI == -174257);
 734   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 735
 736   PoisonInput(u);
 737   sscanf("0423571", "%" SCNiFAST32, &u.mI);
 738   MOZ_RELEASE_ASSERT(u.mI == 0423571);
 739   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 740 }
 741
 742 static void TestScanSignedFast64() {
 743   Input<int_fast64_t> u;
 744
 745   PoisonInput(u);
 746   sscanf("-17425238927232", "%" SCNdFAST64, &u.mI);
 747   MOZ_RELEASE_ASSERT(u.mI == -INT64_C(17425238927232));
 748   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 749
 750   PoisonInput(u);
 751   sscanf("042333576571", "%" SCNiFAST64, &u.mI);
 752   MOZ_RELEASE_ASSERT(u.mI == INT64_C(042333576571));
 753   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 754 }
 755
 756 static void TestScanSignedFastN() {
 757   TestScanSignedFast8();
 758   TestScanSignedFast16();
 759   TestScanSignedFast32();
 760   TestScanSignedFast64();
 761 }
 762
 763 static void TestScanSignedMax() {
 764   Input<intmax_t> u;
 765
 766   PoisonInput(u);
 767   sscanf("-432157943248732", "%" SCNdMAX, &u.mI);
 768   MOZ_RELEASE_ASSERT(u.mI == -INTMAX_C(432157943248732));
 769   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 770
 771   PoisonInput(u);
 772   sscanf("04233357236571", "%" SCNiMAX, &u.mI);
 773   MOZ_RELEASE_ASSERT(u.mI == INTMAX_C(04233357236571));
 774   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 775 }
 776
 777 static void TestScanSignedPtr() {
 778   Input<intptr_t> u;
 779
 780   PoisonInput(u);
 781   sscanf("12345678", "%" SCNdPTR, &u.mI);
 782   MOZ_RELEASE_ASSERT(u.mI == intptr_t(reinterpret_cast<void*>(12345678)));
 783   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 784
 785   PoisonInput(u);
 786   sscanf("04233357236", "%" SCNiPTR, &u.mI);
 787   MOZ_RELEASE_ASSERT(u.mI == intptr_t(reinterpret_cast<void*>(04233357236)));
 788   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 789 }
 790
 791 static void TestScanSigned() {
 792   TestScanSignedN();
 793   TestScanSignedLeastN();
 794   TestScanSignedFastN();
 795   TestScanSignedMax();
 796   TestScanSignedPtr();
 797 }
 798
 799 /*
 800  * The fscanf macros for unsigned integers are:
 801  *
 802  *   SCNoN   SCNoLEASTN   SCNoFASTN   SCNoMAX   SCNoPTR
 803  *   SCNuN   SCNuLEASTN   SCNuFASTN   SCNuMAX   SCNuPTR
 804  *   SCNxN   SCNxLEASTN   SCNxFASTN   SCNxMAX   SCNxPTR
 805  *
 806  * In these names N is the width of the type as described in C99 7.18.1.
 807  */
 808
 809 static void TestScanUnsigned8() {
 810 #  if SHOULD_TEST_8BIT_FORMAT_MACROS
 811   Input<uint8_t> u;
 812
 813   PoisonInput(u);
 814   sscanf("17", "%" SCNo8, &u.mI);
 815   MOZ_RELEASE_ASSERT(u.mI == 017);
 816   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 817
 818   PoisonInput(u);
 819   sscanf("42", "%" SCNu8, &u.mI);
 820   MOZ_RELEASE_ASSERT(u.mI == 42);
 821   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 822
 823   PoisonInput(u);
 824   sscanf("2A", "%" SCNx8, &u.mI);
 825   MOZ_RELEASE_ASSERT(u.mI == 0x2A);
 826   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 827 #  endif
 828 }
 829
 830 static void TestScanUnsigned16() {
 831   Input<uint16_t> u;
 832
 833   PoisonInput(u);
 834   sscanf("1742", "%" SCNo16, &u.mI);
 835   MOZ_RELEASE_ASSERT(u.mI == 01742);
 836   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 837
 838   PoisonInput(u);
 839   sscanf("4217", "%" SCNu16, &u.mI);
 840   MOZ_RELEASE_ASSERT(u.mI == 4217);
 841   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 842
 843   PoisonInput(u);
 844   sscanf("2ABC", "%" SCNx16, &u.mI);
 845   MOZ_RELEASE_ASSERT(u.mI == 0x2ABC);
 846   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 847 }
 848
 849 static void TestScanUnsigned32() {
 850   Input<uint32_t> u;
 851
 852   PoisonInput(u);
 853   sscanf("17421742", "%" SCNo32, &u.mI);
 854   MOZ_RELEASE_ASSERT(u.mI == 017421742);
 855   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 856
 857   PoisonInput(u);
 858   sscanf("4217867", "%" SCNu32, &u.mI);
 859   MOZ_RELEASE_ASSERT(u.mI == 4217867);
 860   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 861
 862   PoisonInput(u);
 863   sscanf("2ABCBEEF", "%" SCNx32, &u.mI);
 864   MOZ_RELEASE_ASSERT(u.mI == 0x2ABCBEEF);
 865   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 866 }
 867
 868 static void TestScanUnsigned64() {
 869   Input<uint64_t> u;
 870
 871   PoisonInput(u);
 872   sscanf("17421742173", "%" SCNo64, &u.mI);
 873   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(017421742173));
 874   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 875
 876   PoisonInput(u);
 877   sscanf("421786713579", "%" SCNu64, &u.mI);
 878   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(421786713579));
 879   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 880
 881   PoisonInput(u);
 882   sscanf("DEADBEEF7457E", "%" SCNx64, &u.mI);
 883   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(0xDEADBEEF7457E));
 884   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 885 }
 886
 887 static void TestScanUnsignedN() {
 888   TestScanUnsigned8();
 889   TestScanUnsigned16();
 890   TestScanUnsigned32();
 891   TestScanUnsigned64();
 892 }
 893
 894 static void TestScanUnsignedLeast8() {
 895 #  if SHOULD_TEST_8BIT_FORMAT_MACROS
 896   Input<uint_least8_t> u;
 897
 898   PoisonInput(u);
 899   sscanf("17", "%" SCNoLEAST8, &u.mI);
 900   MOZ_RELEASE_ASSERT(u.mI == 017);
 901   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 902
 903   PoisonInput(u);
 904   sscanf("42", "%" SCNuLEAST8, &u.mI);
 905   MOZ_RELEASE_ASSERT(u.mI == 42);
 906   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 907
 908   PoisonInput(u);
 909   sscanf("2A", "%" SCNxLEAST8, &u.mI);
 910   MOZ_RELEASE_ASSERT(u.mI == 0x2A);
 911   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 912 #  endif
 913 }
 914
 915 static void TestScanUnsignedLeast16() {
 916   Input<uint_least16_t> u;
 917
 918   PoisonInput(u);
 919   sscanf("1742", "%" SCNoLEAST16, &u.mI);
 920   MOZ_RELEASE_ASSERT(u.mI == 01742);
 921   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 922
 923   PoisonInput(u);
 924   sscanf("4217", "%" SCNuLEAST16, &u.mI);
 925   MOZ_RELEASE_ASSERT(u.mI == 4217);
 926   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 927
 928   PoisonInput(u);
 929   sscanf("2ABC", "%" SCNxLEAST16, &u.mI);
 930   MOZ_RELEASE_ASSERT(u.mI == 0x2ABC);
 931   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 932 }
 933
 934 static void TestScanUnsignedLeast32() {
 935   Input<uint_least32_t> u;
 936
 937   PoisonInput(u);
 938   sscanf("17421742", "%" SCNoLEAST32, &u.mI);
 939   MOZ_RELEASE_ASSERT(u.mI == 017421742);
 940   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 941
 942   PoisonInput(u);
 943   sscanf("4217867", "%" SCNuLEAST32, &u.mI);
 944   MOZ_RELEASE_ASSERT(u.mI == 4217867);
 945   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 946
 947   PoisonInput(u);
 948   sscanf("2ABCBEEF", "%" SCNxLEAST32, &u.mI);
 949   MOZ_RELEASE_ASSERT(u.mI == 0x2ABCBEEF);
 950   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 951 }
 952
 953 static void TestScanUnsignedLeast64() {
 954   Input<uint_least64_t> u;
 955
 956   PoisonInput(u);
 957   sscanf("17421742173", "%" SCNoLEAST64, &u.mI);
 958   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(017421742173));
 959   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 960
 961   PoisonInput(u);
 962   sscanf("421786713579", "%" SCNuLEAST64, &u.mI);
 963   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(421786713579));
 964   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 965
 966   PoisonInput(u);
 967   sscanf("DEADBEEF7457E", "%" SCNxLEAST64, &u.mI);
 968   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(0xDEADBEEF7457E));
 969   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 970 }
 971
 972 static void TestScanUnsignedLeastN() {
 973   TestScanUnsignedLeast8();
 974   TestScanUnsignedLeast16();
 975   TestScanUnsignedLeast32();
 976   TestScanUnsignedLeast64();
 977 }
 978
 979 static void TestScanUnsignedFast8() {
 980 #  if SHOULD_TEST_8BIT_FORMAT_MACROS
 981   Input<uint_fast8_t> u;
 982
 983   PoisonInput(u);
 984   sscanf("17", "%" SCNoFAST8, &u.mI);
 985   MOZ_RELEASE_ASSERT(u.mI == 017);
 986   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 987
 988   PoisonInput(u);
 989   sscanf("42", "%" SCNuFAST8, &u.mI);
 990   MOZ_RELEASE_ASSERT(u.mI == 42);
 991   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 992
 993   PoisonInput(u);
 994   sscanf("2A", "%" SCNxFAST8, &u.mI);
 995   MOZ_RELEASE_ASSERT(u.mI == 0x2A);
 996   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
 997 #  endif
 998 }
 999
1000 static void TestScanUnsignedFast16() {
1001   Input<uint_fast16_t> u;
1002
1003   PoisonInput(u);
1004   sscanf("1742", "%" SCNoFAST16, &u.mI);
1005   MOZ_RELEASE_ASSERT(u.mI == 01742);
1006   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1007
1008   PoisonInput(u);
1009   sscanf("4217", "%" SCNuFAST16, &u.mI);
1010   MOZ_RELEASE_ASSERT(u.mI == 4217);
1011   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1012
1013   PoisonInput(u);
1014   sscanf("2ABC", "%" SCNxFAST16, &u.mI);
1015   MOZ_RELEASE_ASSERT(u.mI == 0x2ABC);
1016   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1017 }
1018
1019 static void TestScanUnsignedFast32() {
1020   Input<uint_fast32_t> u;
1021
1022   PoisonInput(u);
1023   sscanf("17421742", "%" SCNoFAST32, &u.mI);
1024   MOZ_RELEASE_ASSERT(u.mI == 017421742);
1025   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1026
1027   PoisonInput(u);
1028   sscanf("4217867", "%" SCNuFAST32, &u.mI);
1029   MOZ_RELEASE_ASSERT(u.mI == 4217867);
1030   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1031
1032   PoisonInput(u);
1033   sscanf("2ABCBEEF", "%" SCNxFAST32, &u.mI);
1034   MOZ_RELEASE_ASSERT(u.mI == 0x2ABCBEEF);
1035   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1036 }
1037
1038 static void TestScanUnsignedFast64() {
1039   Input<uint_fast64_t> u;
1040
1041   PoisonInput(u);
1042   sscanf("17421742173", "%" SCNoFAST64, &u.mI);
1043   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(017421742173));
1044   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1045
1046   PoisonInput(u);
1047   sscanf("421786713579", "%" SCNuFAST64, &u.mI);
1048   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(421786713579));
1049   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1050
1051   PoisonInput(u);
1052   sscanf("DEADBEEF7457E", "%" SCNxFAST64, &u.mI);
1053   MOZ_RELEASE_ASSERT(u.mI == UINT64_C(0xDEADBEEF7457E));
1054   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1055 }
1056
1057 static void TestScanUnsignedFastN() {
1058   TestScanUnsignedFast8();
1059   TestScanUnsignedFast16();
1060   TestScanUnsignedFast32();
1061   TestScanUnsignedFast64();
1062 }
1063
1064 static void TestScanUnsignedMax() {
1065   Input<uintmax_t> u;
1066
1067   PoisonInput(u);
1068   sscanf("14220563454333534", "%" SCNoMAX, &u.mI);
1069   MOZ_RELEASE_ASSERT(u.mI == UINTMAX_C(432157943248732));
1070   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1071
1072   PoisonInput(u);
1073   sscanf("432157943248732", "%" SCNuMAX, &u.mI);
1074   MOZ_RELEASE_ASSERT(u.mI == UINTMAX_C(432157943248732));
1075   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1076
1077   PoisonInput(u);
1078   sscanf("4c337ca791", "%" SCNxMAX, &u.mI);
1079   MOZ_RELEASE_ASSERT(u.mI == UINTMAX_C(327281321873));
1080   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1081 }
1082
1083 static void TestScanUnsignedPtr() {
1084   Input<uintptr_t> u;
1085
1086   PoisonInput(u);
1087   sscanf("57060516", "%" SCNoPTR, &u.mI);
1088   MOZ_RELEASE_ASSERT(u.mI == uintptr_t(reinterpret_cast<void*>(12345678)));
1089   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1090
1091   PoisonInput(u);
1092   sscanf("87654321", "%" SCNuPTR, &u.mI);
1093   MOZ_RELEASE_ASSERT(u.mI == uintptr_t(reinterpret_cast<void*>(87654321)));
1094   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1095
1096   PoisonInput(u);
1097   sscanf("4c3a791", "%" SCNxPTR, &u.mI);
1098   MOZ_RELEASE_ASSERT(u.mI == uintptr_t(reinterpret_cast<void*>(0x4c3a791)));
1099   MOZ_RELEASE_ASSERT(ExtraBitsUntouched(u));
1100 }
1101
1102 static void TestScanUnsigned() {
1103   TestScanUnsignedN();
1104   TestScanUnsignedLeastN();
1105   TestScanUnsignedFastN();
1106   TestScanUnsignedMax();
1107   TestScanUnsignedPtr();
1108 }
1109
1110 static void TestScan() {
1111   TestScanSigned();
1112   TestScanUnsigned();
1113 }
1114
1115 #endif /* SHOULD_TEST_SCANF_MACROS */
1116
1117 #if defined(XP_WIN)
1118 int wmain()
1119 #else
1120 int main()
1121 #endif  // defined(XP_WIN)
1122 {
1123   TestPrint();
1124 #if SHOULD_TEST_SCANF_MACROS
1125   TestScan();
1126 #endif
1127   return 0;
1128 }