Inside Bitcoin

501    BOOST_CHECK(!ParseMoney(" +1 .2  "));
502
503    // Attempted 63 bit overflow should fail
504    BOOST_CHECK(!ParseMoney("92233720368.54775808"));
505
506    // Parsing negative amounts must fail
507    BOOST_CHECK(!ParseMoney("-1"));
508
509    // Parsing strings with embedded NUL characters should fail
510    BOOST_CHECK(!ParseMoney("\0-1"s));
511    BOOST_CHECK(!ParseMoney(STRING_WITH_EMBEDDED_NULL_CHAR));
512    BOOST_CHECK(!ParseMoney("1\0"s));
513}
514
515BOOST_AUTO_TEST_CASE(util_IsHex)
516{
517    BOOST_CHECK(IsHex("00"));
518    BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
519    BOOST_CHECK(IsHex("ff"));
520    BOOST_CHECK(IsHex("FF"));
521
522    BOOST_CHECK(!IsHex(""));
523    BOOST_CHECK(!IsHex("0"));
524    BOOST_CHECK(!IsHex("a"));
525    BOOST_CHECK(!IsHex("eleven"));
526    BOOST_CHECK(!IsHex("00xx00"));
527    BOOST_CHECK(!IsHex("0x0000"));
528}
529
530BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
531{
532    SeedRandomForTest(SeedRand::ZEROS);
533    for (int mod=2;mod<11;mod++)
534    {
535        int mask = 1;
536        // Really rough binomial confidence approximation.
537        int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
538        //mask is 2^ceil(log2(mod))-1
539        while(mask<mod-1)mask=(mask<<1)+1;
540
541        int count = 0;
542        //How often does it get a zero from the uniform range [0,mod)?
543        for (int i = 0; i < 10000; i++) {
544            uint32_t rval;
545            do{
546                rval=m_rng.rand32()&mask;
547            }while(rval>=(uint32_t)mod);
548            count += rval==0;
549        }
550        BOOST_CHECK(count<=10000/mod+err);
551        BOOST_CHECK(count>=10000/mod-err);
552    }
553}
554
555BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
556{
557    BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
558    BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
559    BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
560    BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
561    BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
562    BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
563    BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
564}
565
566/* Test strprintf formatting directives.
567 * Put a string before and after to ensure sanity of element sizes on stack. */
568#define B "check_prefix"
569#define E "check_postfix"
570BOOST_AUTO_TEST_CASE(strprintf_numbers)
571{
572    int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
573    uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
574    BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
575    BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
576    BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);
577
578    size_t st = 12345678; /* unsigned size_t test value */
579    ssize_t sst = -12345678; /* signed size_t test value */
580    BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
581    BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
582    BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);
583
584    ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
585    ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
586    BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
587    BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
588    BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
589}
590#undef B
591#undef E
592
593BOOST_AUTO_TEST_CASE(util_mocktime)
594{
595    FakeNodeClock clock{111s};
596    // Check that mock time does not change after a sleep
597    for (const auto& num_sleep : {0ms, 1ms}) {
598        UninterruptibleSleep(num_sleep);
599        BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
600        BOOST_CHECK_EQUAL(111, Now<NodeSeconds>().time_since_epoch().count());
601        BOOST_CHECK_EQUAL(111, TicksSinceEpoch<std::chrono::seconds>(NodeClock::now()));
602        BOOST_CHECK_EQUAL(111, TicksSinceEpoch<SecondsDouble>(Now<NodeSeconds>()));
603        BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
604        BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
605        BOOST_CHECK_EQUAL(111000, TicksSinceEpoch<std::chrono::milliseconds>(NodeClock::now()));
606        BOOST_CHECK_EQUAL(111000000, GetTime<std::chrono::microseconds>().count());
607    }
608}
609
610BOOST_AUTO_TEST_CASE(util_ticksseconds)
611{
612    BOOST_CHECK_EQUAL(TicksSeconds(0s), 0);
613    BOOST_CHECK_EQUAL(TicksSeconds(1s), 1);
614    BOOST_CHECK_EQUAL(TicksSeconds(999ms), 0);
615    BOOST_CHECK_EQUAL(TicksSeconds(1000ms), 1);
616    BOOST_CHECK_EQUAL(TicksSeconds(1500ms), 1);
617}
618
619BOOST_AUTO_TEST_CASE(test_IsDigit)
620{
621    BOOST_CHECK_EQUAL(IsDigit('0'), true);
622    BOOST_CHECK_EQUAL(IsDigit('1'), true);
623    BOOST_CHECK_EQUAL(IsDigit('8'), true);
624    BOOST_CHECK_EQUAL(IsDigit('9'), true);
625
626    BOOST_CHECK_EQUAL(IsDigit('0' - 1), false);
627    BOOST_CHECK_EQUAL(IsDigit('9' + 1), false);
628    BOOST_CHECK_EQUAL(IsDigit(0), false);
629    BOOST_CHECK_EQUAL(IsDigit(1), false);
630    BOOST_CHECK_EQUAL(IsDigit(8), false);
631    BOOST_CHECK_EQUAL(IsDigit(9), false);
632}
633
634/* Check for overflow */
635template <typename T>
636static void TestAddMatrixOverflow()
637{
638    constexpr T MAXI{std::numeric_limits<T>::max()};
639    BOOST_CHECK(!CheckedAdd(T{1}, MAXI));
640    BOOST_CHECK(!CheckedAdd(MAXI, MAXI));
641    BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(T{1}, MAXI));
642    BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(MAXI, MAXI));
643
644    BOOST_CHECK_EQUAL(0, CheckedAdd(T{0}, T{0}).value());
645    BOOST_CHECK_EQUAL(MAXI, CheckedAdd(T{0}, MAXI).value());
646    BOOST_CHECK_EQUAL(MAXI, CheckedAdd(T{1}, MAXI - 1).value());
647    BOOST_CHECK_EQUAL(MAXI - 1, CheckedAdd(T{1}, MAXI - 2).value());
648    BOOST_CHECK_EQUAL(0, SaturatingAdd(T{0}, T{0}));
649    BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(T{0}, MAXI));
650    BOOST_CHECK_EQUAL(MAXI, SaturatingAdd(T{1}, MAXI - 1));
651    BOOST_CHECK_EQUAL(MAXI - 1, SaturatingAdd(T{1}, MAXI - 2));
652}
653
654/* Check for overflow or underflow */
655template <typename T>
656static void TestAddMatrix()
657{
658    TestAddMatrixOverflow<T>();
659    constexpr T MINI{std::numeric_limits<T>::min()};
660    constexpr T MAXI{std::numeric_limits<T>::max()};
661    BOOST_CHECK(!CheckedAdd(T{-1}, MINI));
662    BOOST_CHECK(!CheckedAdd(MINI, MINI));
663    BOOST_CHECK_EQUAL(MINI, SaturatingAdd(T{-1}, MINI));
664    BOOST_CHECK_EQUAL(MINI, SaturatingAdd(MINI, MINI));
665
666    BOOST_CHECK_EQUAL(MINI, CheckedAdd(T{0}, MINI).value());
667    BOOST_CHECK_EQUAL(MINI, CheckedAdd(T{-1}, MINI + 1).value());
668    BOOST_CHECK_EQUAL(-1, CheckedAdd(MINI, MAXI).value());
669    BOOST_CHECK_EQUAL(MINI + 1, CheckedAdd(T{-1}, MINI + 2).value());
670    BOOST_CHECK_EQUAL(MINI, SaturatingAdd(T{0}, MINI));
671    BOOST_CHECK_EQUAL(MINI, SaturatingAdd(T{-1}, MINI + 1));
672    BOOST_CHECK_EQUAL(MINI + 1, SaturatingAdd(T{-1}, MINI + 2));
673    BOOST_CHECK_EQUAL(-1, SaturatingAdd(MINI, MAXI));
674}
675
676BOOST_AUTO_TEST_CASE(util_overflow)
677{
678    TestAddMatrixOverflow<unsigned>();
679    TestAddMatrix<signed>();
680}
681
682template <typename T>
683static void RunToIntegralTests()
684{
685    BOOST_CHECK(!ToIntegral<T>(STRING_WITH_EMBEDDED_NULL_CHAR));
686    BOOST_CHECK(!ToIntegral<T>(" 1"));
687    BOOST_CHECK(!ToIntegral<T>("1 "));
688    BOOST_CHECK(!ToIntegral<T>("1a"));
689    BOOST_CHECK(!ToIntegral<T>("1.1"));
690    BOOST_CHECK(!ToIntegral<T>("1.9"));
691    BOOST_CHECK(!ToIntegral<T>("+01.9"));
692    BOOST_CHECK(!ToIntegral<T>("-"));
693    BOOST_CHECK(!ToIntegral<T>("+"));
694    BOOST_CHECK(!ToIntegral<T>(" -1"));
695    BOOST_CHECK(!ToIntegral<T>("-1 "));
696    BOOST_CHECK(!ToIntegral<T>(" -1 "));
697    BOOST_CHECK(!ToIntegral<T>("+1"));
698    BOOST_CHECK(!ToIntegral<T>(" +1"));
699    BOOST_CHECK(!ToIntegral<T>(" +1 "));
700    BOOST_CHECK(!ToIntegral<T>("+-1"));
701    BOOST_CHECK(!ToIntegral<T>("-+1"));
702    BOOST_CHECK(!ToIntegral<T>("++1"));
703    BOOST_CHECK(!ToIntegral<T>("--1"));
704    BOOST_CHECK(!ToIntegral<T>(""));
705    BOOST_CHECK(!ToIntegral<T>("aap"));
706    BOOST_CHECK(!ToIntegral<T>("0x1"));
707    BOOST_CHECK(!ToIntegral<T>("-32482348723847471234"));
708    BOOST_CHECK(!ToIntegral<T>("32482348723847471234"));
709}
710
711BOOST_AUTO_TEST_CASE(test_ToIntegral)
712{
713    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("1234").value(), 1'234);
714    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("0").value(), 0);
715    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("01234").value(), 1'234);
716    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("00000000000000001234").value(), 1'234);
717    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-00000000000000001234").value(), -1'234);
718    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("00000000000000000000").value(), 0);
719    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-00000000000000000000").value(), 0);
720    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-1234").value(), -1'234);
721    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-1").value(), -1);
722
723    RunToIntegralTests<uint64_t>();
724    RunToIntegralTests<int64_t>();
725    RunToIntegralTests<uint32_t>();
726    RunToIntegralTests<int32_t>();
727    RunToIntegralTests<uint16_t>();
728    RunToIntegralTests<int16_t>();
729    RunToIntegralTests<uint8_t>();
730    RunToIntegralTests<int8_t>();
731
732    BOOST_CHECK(!ToIntegral<int64_t>("-9223372036854775809"));
733    BOOST_CHECK_EQUAL(ToIntegral<int64_t>("-9223372036854775808").value(), -9'223'372'036'854'775'807LL - 1LL);
734    BOOST_CHECK_EQUAL(ToIntegral<int64_t>("9223372036854775807").value(), 9'223'372'036'854'775'807);
735    BOOST_CHECK(!ToIntegral<int64_t>("9223372036854775808"));
736
737    BOOST_CHECK(!ToIntegral<uint64_t>("-1"));
738    BOOST_CHECK_EQUAL(ToIntegral<uint64_t>("0").value(), 0U);
739    BOOST_CHECK_EQUAL(ToIntegral<uint64_t>("18446744073709551615").value(), 18'446'744'073'709'551'615ULL);
740    BOOST_CHECK(!ToIntegral<uint64_t>("18446744073709551616"));
741
742    BOOST_CHECK(!ToIntegral<int32_t>("-2147483649"));
743    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("-2147483648").value(), -2'147'483'648LL);
744    BOOST_CHECK_EQUAL(ToIntegral<int32_t>("2147483647").value(), 2'147'483'647);
745    BOOST_CHECK(!ToIntegral<int32_t>("2147483648"));
746
747    BOOST_CHECK(!ToIntegral<uint32_t>("-1"));
748    BOOST_CHECK_EQUAL(ToIntegral<uint32_t>("0").value(), 0U);
749    BOOST_CHECK_EQUAL(ToIntegral<uint32_t>("4294967295").value(), 4'294'967'295U);
750    BOOST_CHECK(!ToIntegral<uint32_t>("4294967296"));