test:uint256 cxx-20 constexpr patches

Author: RandyMcMillan

src/test/blockencodings_tests.cpp

@@ -63,7 +63,7 @@ BOOST_AUTO_TEST_CASE(SimpleRoundTripTest)
 {
     CTxMemPool& pool = *Assert(m_node.mempool);
     TestMemPoolEntryHelper entry;
-    auto rand_ctx(FastRandomContext(uint256{42}));
+    auto rand_ctx(FastRandomContext(uint256{42ULL}));
     CBlock block(BuildBlockTestCase(rand_ctx));
 
     LOCK2(cs_main, pool.cs);
@@ -147,7 +147,7 @@ BOOST_AUTO_TEST_CASE(NonCoinbasePreforwardRTTest)
 {
     CTxMemPool& pool = *Assert(m_node.mempool);
     TestMemPoolEntryHelper entry;
-    auto rand_ctx(FastRandomContext(uint256{42}));
+    auto rand_ctx(FastRandomContext(uint256{42ULL}));
     CBlock block(BuildBlockTestCase(rand_ctx));
 
     LOCK2(cs_main, pool.cs);
@@ -218,7 +218,7 @@ BOOST_AUTO_TEST_CASE(SufficientPreforwardRTTest)
 {
     CTxMemPool& pool = *Assert(m_node.mempool);
     TestMemPoolEntryHelper entry;
-    auto rand_ctx(FastRandomContext(uint256{42}));
+    auto rand_ctx(FastRandomContext(uint256{42ULL}));
     CBlock block(BuildBlockTestCase(rand_ctx));
 
     LOCK2(cs_main, pool.cs);
@@ -272,7 +272,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
     CMutableTransaction coinbase = BuildTransactionTestCase();
 
     CBlock block;
-    auto rand_ctx(FastRandomContext(uint256{42}));
+    auto rand_ctx(FastRandomContext(uint256{42ULL}));
     block.vtx.resize(1);
     block.vtx[0] = MakeTransactionRef(std::move(coinbase));
     block.nVersion = 42;
@@ -310,7 +310,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
 BOOST_AUTO_TEST_CASE(ReceiveWithExtraTransactions) {
     CTxMemPool& pool = *Assert(m_node.mempool);
     TestMemPoolEntryHelper entry;
-    auto rand_ctx(FastRandomContext(uint256{42}));
+    auto rand_ctx(FastRandomContext(uint256{42ULL}));
 
     CMutableTransaction mtx = BuildTransactionTestCase();
     mtx.vin[0].prevout.hash = Txid::FromUint256(rand_ctx.rand256());

src/test/orphanage_tests.cpp

@@ -102,7 +102,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
     // ecdsa_signature_parse_der_lax are executed during this test.
     // Specifically branches that run only when an ECDSA
     // signature's R and S values have leading zeros.
-    m_rng.Reseed(uint256{33});
+    m_rng.Reseed(uint256{33ULL});
 
     TxOrphanageTest orphanage{m_rng};
     CKey key;

src/test/pmt_tests.cpp

@@ -111,12 +111,12 @@ BOOST_AUTO_TEST_CASE(pmt_test1)
 BOOST_AUTO_TEST_CASE(pmt_malleability)
 {
     std::vector<uint256> vTxid{
-        uint256{1}, uint256{2},
-        uint256{3}, uint256{4},
-        uint256{5}, uint256{6},
-        uint256{7}, uint256{8},
-        uint256{9}, uint256{10},
-        uint256{9}, uint256{10},
+        uint256{1ULL}, uint256{2ULL},
+        uint256{3ULL}, uint256{4ULL},
+        uint256{5ULL}, uint256{6ULL},
+        uint256{7ULL}, uint256{8ULL},
+        uint256{9ULL}, uint256{10ULL},
+        uint256{9ULL}, uint256{10ULL},
     };
     std::vector<bool> vMatch = {false, false, false, false, false, false, false, false, false, true, true, false};
 

src/test/pow_tests.cpp

@@ -86,7 +86,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_negative_target)
     uint256 hash;
     unsigned int nBits;
     nBits = UintToArith256(consensus.powLimit).GetCompact(true);
-    hash = uint256{1};
+    hash = uint256{1ULL};
     BOOST_CHECK(!CheckProofOfWork(hash, nBits, consensus));
 }
 
@@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_overflow_target)
     const auto consensus = CreateChainParams(*m_node.args, ChainType::MAIN)->GetConsensus();
     uint256 hash;
     unsigned int nBits{~0x00800000U};
-    hash = uint256{1};
+    hash = uint256{1ULL};
     BOOST_CHECK(!CheckProofOfWork(hash, nBits, consensus));
 }
 
@@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE(CheckProofOfWork_test_too_easy_target)
     arith_uint256 nBits_arith = UintToArith256(consensus.powLimit);
     nBits_arith *= 2;
     nBits = nBits_arith.GetCompact();
-    hash = uint256{1};
+    hash = uint256{1ULL};
     BOOST_CHECK(!CheckProofOfWork(hash, nBits, consensus));
 }
 

src/test/uint256_tests.cpp

@@ -301,10 +301,10 @@ BOOST_AUTO_TEST_CASE(from_user_hex)
     BOOST_CHECK_EQUAL(uint256::FromUserHex("0"), uint256::ZERO);
     BOOST_CHECK_EQUAL(uint256::FromUserHex("00"), uint256::ZERO);
     BOOST_CHECK_EQUAL(uint256::FromUserHex("1"), uint256::ONE);
-    BOOST_CHECK_EQUAL(uint256::FromUserHex("0x10"), uint256{0x10});
-    BOOST_CHECK_EQUAL(uint256::FromUserHex("10"), uint256{0x10});
-    BOOST_CHECK_EQUAL(uint256::FromUserHex("0xFf"), uint256{0xff});
-    BOOST_CHECK_EQUAL(uint256::FromUserHex("Ff"), uint256{0xff});
+    BOOST_CHECK_EQUAL(uint256::FromUserHex("0x10"), uint256{0x10ULL});
+    BOOST_CHECK_EQUAL(uint256::FromUserHex("10"), uint256{0x10ULL});
+    BOOST_CHECK_EQUAL(uint256::FromUserHex("0xFf"), uint256{0xffULL});
+    BOOST_CHECK_EQUAL(uint256::FromUserHex("Ff"), uint256{0xffULL});
     const std::string valid_hex_64{"0x0123456789abcdef0123456789abcdef0123456789ABDCEF0123456789ABCDEF"};
     BOOST_REQUIRE_EQUAL(valid_hex_64.size(), 2 + 64); // 0x prefix and 64 hex digits
     BOOST_CHECK_EQUAL(uint256::FromUserHex(valid_hex_64.substr(2)).value().ToString(), ToLower(valid_hex_64.substr(2)));

src/test/validation_chainstatemanager_tests.cpp

@@ -815,7 +815,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_args, BasicTestingSetup)
     BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid="}).assumed_valid_block, uint256::ZERO);
     BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid=0"}).assumed_valid_block, uint256::ZERO);
     BOOST_CHECK_EQUAL(get_valid_opts({"-noassumevalid"}).assumed_valid_block, uint256::ZERO);
-    BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid=0x12"}).assumed_valid_block, uint256{0x12});
+    BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid=0x12"}).assumed_valid_block, uint256{0x12ULL});
 
     std::string assume_valid{"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"};
     BOOST_CHECK_EQUAL(get_valid_opts({("-assumevalid=" + assume_valid).c_str()}).assumed_valid_block, uint256::FromHex(assume_valid));

src/test/validation_tests.cpp

@@ -206,7 +206,7 @@ BOOST_AUTO_TEST_CASE(block_malleation)
 
         // Empty block is expected to have merkle root of 0x0.
         BOOST_CHECK(block.vtx.empty());
-        block.hashMerkleRoot = uint256{1};
+        block.hashMerkleRoot = uint256{1ULL};
         BOOST_CHECK(is_mutated(block, /*check_witness_root=*/false));
         block.hashMerkleRoot = uint256{};
         BOOST_CHECK(is_not_mutated(block, /*check_witness_root=*/false));

src/uint256.h

@@ -203,7 +203,6 @@ class uint256 : public base_blob<256> {
             m_data[i] = (val >> (i * 8)) & 0xFF;
         }
     }
-    constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
     consteval explicit uint256(std::string_view hex_str) : base_blob<256>() {
         if (hex_str.size() > 64) {
             throw "Invalid hex string size in consteval uint256";