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