diff --git a/src/test/DoS_tests.cpp b/src/test/DoS_tests.cpp
index a91d6a443..bdb1a51a3 100644
--- a/src/test/DoS_tests.cpp
+++ b/src/test/DoS_tests.cpp
@@ -1,396 +1,396 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 // Unit tests for denial-of-service detection/prevention code
 
-#include "chainparams.h"
-#include "config.h"
-#include "keystore.h"
-#include "net.h"
-#include "net_processing.h"
-#include "pow.h"
-#include "script/sign.h"
-#include "serialize.h"
-#include "util.h"
-#include "validation.h"
-
-#include "test/test_bitcoin.h"
-
-#include <cstdint>
+#include <chainparams.h>
+#include <config.h>
+#include <keystore.h>
+#include <net.h>
+#include <net_processing.h>
+#include <pow.h>
+#include <script/sign.h>
+#include <serialize.h>
+#include <util.h>
+#include <validation.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <cstdint>
+
 // Tests these internal-to-net_processing.cpp methods:
 extern bool AddOrphanTx(const CTransactionRef &tx, NodeId peer);
 extern void EraseOrphansFor(NodeId peer);
 extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
 struct COrphanTx {
     CTransactionRef tx;
     NodeId fromPeer;
     int64_t nTimeExpire;
 };
 extern std::map<uint256, COrphanTx> mapOrphanTransactions;
 
 CService ip(uint32_t i) {
     struct in_addr s;
     s.s_addr = i;
     return CService(CNetAddr(s), Params().GetDefaultPort());
 }
 
 static NodeId id = 0;
 
 void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds);
 
 BOOST_FIXTURE_TEST_SUITE(DoS_tests, TestingSetup)
 
 // Test eviction of an outbound peer whose chain never advances
 // Mock a node connection, and use mocktime to simulate a peer which never sends
 // any headers messages. PeerLogic should decide to evict that outbound peer,
 // after the appropriate timeouts.
 // Note that we protect 4 outbound nodes from being subject to this logic; this
 // test takes advantage of that protection only being applied to nodes which
 // send headers with sufficient work.
 BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     // Mock an outbound peer
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, ServiceFlags(NODE_NETWORK), 0, INVALID_SOCKET, addr1,
                      0, 0, CAddress(), "",
                      /*fInboundIn=*/false);
     dummyNode1.SetSendVersion(PROTOCOL_VERSION);
 
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.nVersion = 1;
     dummyNode1.fSuccessfullyConnected = true;
 
     // This test requires that we have a chain with non-zero work.
     LOCK(cs_main);
     BOOST_CHECK(chainActive.Tip() != nullptr);
     BOOST_CHECK(chainActive.Tip()->nChainWork > 0);
 
     // Test starts here
     LOCK(dummyNode1.cs_sendProcessing);
     // should result in getheaders
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     LOCK(dummyNode1.cs_vSend);
     BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
     dummyNode1.vSendMsg.clear();
 
     int64_t nStartTime = GetTime();
     // Wait 21 minutes
     SetMockTime(nStartTime + 21 * 60);
     // should result in getheaders
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
     // Wait 3 more minutes
     SetMockTime(nStartTime + 24 * 60);
     // should result in disconnect
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     BOOST_CHECK(dummyNode1.fDisconnect == true);
     SetMockTime(0);
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1.GetId(), dummy);
 }
 
 void AddRandomOutboundPeer(const Config &config, std::vector<CNode *> &vNodes,
                            PeerLogicValidation &peerLogic) {
     CAddress addr(ip(GetRandInt(0xffffffff)), NODE_NONE);
     vNodes.emplace_back(new CNode(id++, ServiceFlags(NODE_NETWORK), 0,
                                   INVALID_SOCKET, addr, 0, 0, CAddress(), "",
                                   /*fInboundIn=*/false));
     CNode &node = *vNodes.back();
     node.SetSendVersion(PROTOCOL_VERSION);
 
     peerLogic.InitializeNode(config, &node);
     node.nVersion = 1;
     node.fSuccessfullyConnected = true;
 
     CConnmanTest::AddNode(node);
 }
 
 BOOST_AUTO_TEST_CASE(stale_tip_peer_management) {
     const Config &config = GetConfig();
     const Consensus::Params &consensusParams =
         config.GetChainParams().GetConsensus();
     constexpr int nMaxOutbound = 8;
     CConnman::Options options;
     options.nMaxConnections = 125;
     options.nMaxOutbound = nMaxOutbound;
     options.nMaxFeeler = 1;
 
     connman->Init(options);
     std::vector<CNode *> vNodes;
 
     // Mock some outbound peers
     for (int i = 0; i < nMaxOutbound; ++i) {
         AddRandomOutboundPeer(config, vNodes, *peerLogic);
     }
 
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
 
     // No nodes should be marked for disconnection while we have no extra peers
     for (const CNode *node : vNodes) {
         BOOST_CHECK(node->fDisconnect == false);
     }
 
     SetMockTime(GetTime() + 3 * consensusParams.nPowTargetSpacing + 1);
 
     // Now tip should definitely be stale, and we should look for an extra
     // outbound peer
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
     BOOST_CHECK(connman->GetTryNewOutboundPeer());
 
     // Still no peers should be marked for disconnection
     for (const CNode *node : vNodes) {
         BOOST_CHECK(node->fDisconnect == false);
     }
 
     // If we add one more peer, something should get marked for eviction
     // on the next check (since we're mocking the time to be in the future, the
     // required time connected check should be satisfied).
     AddRandomOutboundPeer(config, vNodes, *peerLogic);
 
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
     for (int i = 0; i < nMaxOutbound; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     }
     // Last added node should get marked for eviction
     BOOST_CHECK(vNodes.back()->fDisconnect == true);
 
     vNodes.back()->fDisconnect = false;
 
     // Update the last announced block time for the last
     // peer, and check that the next newest node gets evicted.
     UpdateLastBlockAnnounceTime(vNodes.back()->GetId(), GetTime());
 
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
     for (int i = 0; i < nMaxOutbound - 1; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     }
     BOOST_CHECK(vNodes[nMaxOutbound - 1]->fDisconnect == true);
     BOOST_CHECK(vNodes.back()->fDisconnect == false);
 
     bool dummy;
     for (const CNode *node : vNodes) {
         peerLogic->FinalizeNode(config, node->GetId(), dummy);
     }
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(DoS_banning) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     connman->ClearBanned();
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 0, 0,
                      CAddress(), "", true);
     dummyNode1.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.nVersion = 1;
     dummyNode1.fSuccessfullyConnected = true;
     {
         LOCK(cs_main);
         // Should get banned.
         Misbehaving(dummyNode1.GetId(), 100, "");
     }
     LOCK(dummyNode1.cs_sendProcessing);
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     BOOST_CHECK(connman->IsBanned(addr1));
     // Different IP, not banned.
     BOOST_CHECK(!connman->IsBanned(ip(0xa0b0c001 | 0x0000ff00)));
 
     CAddress addr2(ip(0xa0b0c002), NODE_NONE);
     CNode dummyNode2(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr2, 1, 1,
                      CAddress(), "", true);
     dummyNode2.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode2);
     dummyNode2.nVersion = 1;
     dummyNode2.fSuccessfullyConnected = true;
     {
         LOCK(cs_main);
         Misbehaving(dummyNode2.GetId(), 50, "");
     }
     LOCK(dummyNode2.cs_sendProcessing);
     peerLogic->SendMessages(config, &dummyNode2, interruptDummy);
     // 2 not banned yet...
     BOOST_CHECK(!connman->IsBanned(addr2));
     // ... but 1 still should be.
     BOOST_CHECK(connman->IsBanned(addr1));
     {
         LOCK(cs_main);
         Misbehaving(dummyNode2.GetId(), 50, "");
     }
     peerLogic->SendMessages(config, &dummyNode2, interruptDummy);
     BOOST_CHECK(connman->IsBanned(addr2));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1.GetId(), dummy);
     peerLogic->FinalizeNode(config, dummyNode2.GetId(), dummy);
 }
 
 BOOST_AUTO_TEST_CASE(DoS_banscore) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     connman->ClearBanned();
     // because 11 is my favorite number.
     gArgs.ForceSetArg("-banscore", "111");
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 3, 1,
                      CAddress(), "", true);
     dummyNode1.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.nVersion = 1;
     dummyNode1.fSuccessfullyConnected = true;
     {
         LOCK(cs_main);
         Misbehaving(dummyNode1.GetId(), 100, "");
     }
     LOCK(dummyNode1.cs_sendProcessing);
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     BOOST_CHECK(!connman->IsBanned(addr1));
     {
         LOCK(cs_main);
         Misbehaving(dummyNode1.GetId(), 10, "");
     }
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     BOOST_CHECK(!connman->IsBanned(addr1));
     {
         LOCK(cs_main);
         Misbehaving(dummyNode1.GetId(), 1, "");
     }
     peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     BOOST_CHECK(connman->IsBanned(addr1));
     gArgs.ForceSetArg("-banscore", std::to_string(DEFAULT_BANSCORE_THRESHOLD));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1.GetId(), dummy);
 }
 
 BOOST_AUTO_TEST_CASE(DoS_bantime) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     connman->ClearBanned();
     int64_t nStartTime = GetTime();
     // Overrides future calls to GetTime()
     SetMockTime(nStartTime);
 
     CAddress addr(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr, 4, 4,
                     CAddress(), "", true);
     dummyNode.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode);
     dummyNode.nVersion = 1;
     dummyNode.fSuccessfullyConnected = true;
 
     {
         LOCK(cs_main);
         Misbehaving(dummyNode.GetId(), 100, "");
     }
     LOCK(dummyNode.cs_sendProcessing);
     peerLogic->SendMessages(config, &dummyNode, interruptDummy);
     BOOST_CHECK(connman->IsBanned(addr));
 
     SetMockTime(nStartTime + 60 * 60);
     BOOST_CHECK(connman->IsBanned(addr));
 
     SetMockTime(nStartTime + 60 * 60 * 24 + 1);
     BOOST_CHECK(!connman->IsBanned(addr));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode.GetId(), dummy);
 }
 
 CTransactionRef RandomOrphan() {
     std::map<uint256, COrphanTx>::iterator it;
     LOCK(cs_main);
     it = mapOrphanTransactions.lower_bound(InsecureRand256());
     if (it == mapOrphanTransactions.end()) {
         it = mapOrphanTransactions.begin();
     }
     return it->second.tx;
 }
 
 BOOST_AUTO_TEST_CASE(DoS_mapOrphans) {
     CKey key;
     key.MakeNewKey(true);
     CBasicKeyStore keystore;
     keystore.AddKey(key);
 
     // 50 orphan transactions:
     for (int i = 0; i < 50; i++) {
         CMutableTransaction tx;
         tx.vin.resize(1);
         tx.vin[0].prevout = COutPoint(InsecureRand256(), 0);
         tx.vin[0].scriptSig << OP_1;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
             GetScriptForDestination(key.GetPubKey().GetID());
 
         AddOrphanTx(MakeTransactionRef(tx), i);
     }
 
     // ... and 50 that depend on other orphans:
     for (int i = 0; i < 50; i++) {
         CTransactionRef txPrev = RandomOrphan();
 
         CMutableTransaction tx;
         tx.vin.resize(1);
         tx.vin[0].prevout = COutPoint(txPrev->GetId(), 0);
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
             GetScriptForDestination(key.GetPubKey().GetID());
         SignSignature(keystore, *txPrev, tx, 0, SigHashType());
 
         AddOrphanTx(MakeTransactionRef(tx), i);
     }
 
     // This really-big orphan should be ignored:
     for (int i = 0; i < 10; i++) {
         CTransactionRef txPrev = RandomOrphan();
 
         CMutableTransaction tx;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
             GetScriptForDestination(key.GetPubKey().GetID());
         tx.vin.resize(2777);
         for (size_t j = 0; j < tx.vin.size(); j++) {
             tx.vin[j].prevout = COutPoint(txPrev->GetId(), j);
         }
         SignSignature(keystore, *txPrev, tx, 0, SigHashType());
         // Re-use same signature for other inputs
         // (they don't have to be valid for this test)
         for (unsigned int j = 1; j < tx.vin.size(); j++)
             tx.vin[j].scriptSig = tx.vin[0].scriptSig;
 
         BOOST_CHECK(!AddOrphanTx(MakeTransactionRef(tx), i));
     }
 
     LOCK(cs_main);
     // Test EraseOrphansFor:
     for (NodeId i = 0; i < 3; i++) {
         size_t sizeBefore = mapOrphanTransactions.size();
         EraseOrphansFor(i);
         BOOST_CHECK(mapOrphanTransactions.size() < sizeBefore);
     }
 
     // Test LimitOrphanTxSize() function:
     LimitOrphanTxSize(40);
     BOOST_CHECK(mapOrphanTransactions.size() <= 40);
     LimitOrphanTxSize(10);
     BOOST_CHECK(mapOrphanTransactions.size() <= 10);
     LimitOrphanTxSize(0);
     BOOST_CHECK(mapOrphanTransactions.empty());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/activation_tests.cpp b/src/test/activation_tests.cpp
index ec23cded5..964e026e9 100644
--- a/src/test/activation_tests.cpp
+++ b/src/test/activation_tests.cpp
@@ -1,49 +1,50 @@
 // Copyright (c) 2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "chain.h"
-#include "chainparams.h"
-#include "config.h"
-#include "consensus/activation.h"
-#include "test/test_bitcoin.h"
+#include <chain.h>
+#include <chainparams.h>
+#include <config.h>
+#include <consensus/activation.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(activation_tests, BasicTestingSetup)
 
 static void SetMTP(std::array<CBlockIndex, 12> &blocks, int64_t mtp) {
     size_t len = blocks.size();
 
     for (size_t i = 0; i < len; ++i) {
         blocks[i].nTime = mtp + (i - (len / 2));
     }
 
     assert(blocks.back().GetMedianTimePast() == mtp);
 }
 
 BOOST_AUTO_TEST_CASE(isgreatwallenabled) {
     DummyConfig config;
     CBlockIndex prev;
 
     const auto activation =
         config.GetChainParams().GetConsensus().greatWallActivationTime;
 
     BOOST_CHECK(!IsGreatWallEnabled(config, nullptr));
 
     std::array<CBlockIndex, 12> blocks;
     for (size_t i = 1; i < blocks.size(); ++i) {
         blocks[i].pprev = &blocks[i - 1];
     }
 
     SetMTP(blocks, activation - 1);
     BOOST_CHECK(!IsGreatWallEnabled(config, &blocks.back()));
 
     SetMTP(blocks, activation);
     BOOST_CHECK(IsGreatWallEnabled(config, &blocks.back()));
 
     SetMTP(blocks, activation + 1);
     BOOST_CHECK(IsGreatWallEnabled(config, &blocks.back()));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/addrman_tests.cpp b/src/test/addrman_tests.cpp
index fabb0ae94..563ee705b 100644
--- a/src/test/addrman_tests.cpp
+++ b/src/test/addrman_tests.cpp
@@ -1,684 +1,687 @@
 // Copyright (c) 2012-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#include "addrman.h"
-#include "test/test_bitcoin.h"
+#include <addrman.h>
+
+#include <hash.h>
+#include <netbase.h>
+#include <random.h>
+
+#include <test/test_bitcoin.h>
+
 #include <boost/test/unit_test.hpp>
-#include <string>
 
-#include "hash.h"
-#include "netbase.h"
-#include "random.h"
+#include <string>
 
 class CAddrManTest : public CAddrMan {
     uint64_t state;
 
 public:
     CAddrManTest() { state = 1; }
 
     //! Ensure that bucket placement is always the same for testing purposes.
     void MakeDeterministic() {
         nKey.SetNull();
         insecure_rand = FastRandomContext(true);
     }
 
     int RandomInt(int nMax) override {
         state = (CHashWriter(SER_GETHASH, 0) << state).GetHash().GetCheapHash();
         return (unsigned int)(state % nMax);
     }
 
     CAddrInfo *Find(const CNetAddr &addr, int *pnId = nullptr) {
         return CAddrMan::Find(addr, pnId);
     }
 
     CAddrInfo *Create(const CAddress &addr, const CNetAddr &addrSource,
                       int *pnId = nullptr) {
         return CAddrMan::Create(addr, addrSource, pnId);
     }
 
     void Delete(int nId) { CAddrMan::Delete(nId); }
 
     // Simulates connection failure so that we can test eviction of offline
     // nodes
     void SimConnFail(CService &addr) {
         int64_t nLastSuccess = 1;
         // Set last good connection in the deep past.
         Good_(addr, true, nLastSuccess);
 
         bool count_failure = false;
         int64_t nLastTry = GetAdjustedTime() - 61;
         Attempt(addr, count_failure, nLastTry);
     }
 };
 
 static CNetAddr ResolveIP(const char *ip) {
     CNetAddr addr;
     BOOST_CHECK_MESSAGE(LookupHost(ip, addr, false),
                         strprintf("failed to resolve: %s", ip));
     return addr;
 }
 
 static CNetAddr ResolveIP(std::string ip) {
     return ResolveIP(ip.c_str());
 }
 
 static CService ResolveService(const char *ip, int port = 0) {
     CService serv;
     BOOST_CHECK_MESSAGE(Lookup(ip, serv, port, false),
                         strprintf("failed to resolve: %s:%i", ip, port));
     return serv;
 }
 
 static CService ResolveService(std::string ip, int port = 0) {
     return ResolveService(ip.c_str(), port);
 }
 
 BOOST_FIXTURE_TEST_SUITE(addrman_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(addrman_simple) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     // Test: Does Addrman respond correctly when empty.
     BOOST_CHECK_EQUAL(addrman.size(), 0);
     CAddrInfo addr_null = addrman.Select();
     BOOST_CHECK_EQUAL(addr_null.ToString(), "[::]:0");
 
     // Test: Does Addrman::Add work as expected.
     CService addr1 = ResolveService("250.1.1.1", 8333);
     BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1);
     CAddrInfo addr_ret1 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8333");
 
     // Test: Does IP address deduplication work correctly.
     //  Expected dup IP should not be added.
     CService addr1_dup = ResolveService("250.1.1.1", 8333);
     BOOST_CHECK(!addrman.Add(CAddress(addr1_dup, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1);
 
     // Test: New table has one addr and we add a diff addr we should
     //  have at least one addr.
     // Note that addrman's size cannot be tested reliably after insertion, as
     // hash collisions may occur. But we can always be sure of at least one
     // success.
     CService addr2 = ResolveService("250.1.1.2", 8333);
     BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE), source));
     BOOST_CHECK(addrman.size() >= 1);
 
     // Test: AddrMan::Clear() should empty the new table.
     addrman.Clear();
     BOOST_CHECK_EQUAL(addrman.size(), 0);
     CAddrInfo addr_null2 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_null2.ToString(), "[::]:0");
 
     // Test: AddrMan::Add multiple addresses works as expected
     std::vector<CAddress> vAddr;
     vAddr.push_back(CAddress(ResolveService("250.1.1.3", 8333), NODE_NONE));
     vAddr.push_back(CAddress(ResolveService("250.1.1.4", 8333), NODE_NONE));
     BOOST_CHECK(addrman.Add(vAddr, source));
     BOOST_CHECK(addrman.size() >= 1);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_ports) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     BOOST_CHECK_EQUAL(addrman.size(), 0);
 
     // Test: Addr with same IP but diff port does not replace existing addr.
     CService addr1 = ResolveService("250.1.1.1", 8333);
     addrman.Add(CAddress(addr1, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 1);
 
     CService addr1_port = ResolveService("250.1.1.1", 8334);
     addrman.Add(CAddress(addr1_port, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 1);
     CAddrInfo addr_ret2 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_ret2.ToString(), "250.1.1.1:8333");
 
     // Test: Add same IP but diff port to tried table, it doesn't get added.
     //  Perhaps this is not ideal behavior but it is the current behavior.
     addrman.Good(CAddress(addr1_port, NODE_NONE));
     BOOST_CHECK_EQUAL(addrman.size(), 1);
     bool newOnly = true;
     CAddrInfo addr_ret3 = addrman.Select(newOnly);
     BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8333");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_select) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     // Test: Select from new with 1 addr in new.
     CService addr1 = ResolveService("250.1.1.1", 8333);
     addrman.Add(CAddress(addr1, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 1);
 
     bool newOnly = true;
     CAddrInfo addr_ret1 = addrman.Select(newOnly);
     BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8333");
 
     // Test: move addr to tried, select from new expected nothing returned.
     addrman.Good(CAddress(addr1, NODE_NONE));
     BOOST_CHECK_EQUAL(addrman.size(), 1);
     CAddrInfo addr_ret2 = addrman.Select(newOnly);
     BOOST_CHECK_EQUAL(addr_ret2.ToString(), "[::]:0");
 
     CAddrInfo addr_ret3 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8333");
 
     BOOST_CHECK_EQUAL(addrman.size(), 1);
 
     // Add three addresses to new table.
     CService addr2 = ResolveService("250.3.1.1", 8333);
     CService addr3 = ResolveService("250.3.2.2", 9999);
     CService addr4 = ResolveService("250.3.3.3", 9999);
 
     addrman.Add(CAddress(addr2, NODE_NONE), ResolveService("250.3.1.1", 8333));
     addrman.Add(CAddress(addr3, NODE_NONE), ResolveService("250.3.1.1", 8333));
     addrman.Add(CAddress(addr4, NODE_NONE), ResolveService("250.4.1.1", 8333));
 
     // Add three addresses to tried table.
     CService addr5 = ResolveService("250.4.4.4", 8333);
     CService addr6 = ResolveService("250.4.5.5", 7777);
     CService addr7 = ResolveService("250.4.6.6", 8333);
 
     addrman.Add(CAddress(addr5, NODE_NONE), ResolveService("250.3.1.1", 8333));
     addrman.Good(CAddress(addr5, NODE_NONE));
     addrman.Add(CAddress(addr6, NODE_NONE), ResolveService("250.3.1.1", 8333));
     addrman.Good(CAddress(addr6, NODE_NONE));
     addrman.Add(CAddress(addr7, NODE_NONE), ResolveService("250.1.1.3", 8333));
     addrman.Good(CAddress(addr7, NODE_NONE));
 
     // Test: 6 addrs + 1 addr from last test = 7.
     BOOST_CHECK_EQUAL(addrman.size(), 7);
 
     // Test: Select pulls from new and tried regardless of port number.
     std::set<uint16_t> ports;
     for (int i = 0; i < 20; ++i) {
         ports.insert(addrman.Select().GetPort());
     }
     BOOST_CHECK_EQUAL(ports.size(), 3);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_new_collisions) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     BOOST_CHECK_EQUAL(addrman.size(), 0);
 
     for (unsigned int i = 1; i < 18; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Add(CAddress(addr, NODE_NONE), source);
 
         // Test: No collision in new table yet.
         BOOST_CHECK_EQUAL(addrman.size(), i);
     }
 
     // Test: new table collision!
     CService addr1 = ResolveService("250.1.1.18");
     addrman.Add(CAddress(addr1, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 17);
 
     CService addr2 = ResolveService("250.1.1.19");
     addrman.Add(CAddress(addr2, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 18);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_tried_collisions) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     BOOST_CHECK_EQUAL(addrman.size(), 0);
 
     for (unsigned int i = 1; i < 80; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Add(CAddress(addr, NODE_NONE), source);
         addrman.Good(CAddress(addr, NODE_NONE));
 
         // Test: No collision in tried table yet.
         BOOST_CHECK_EQUAL(addrman.size(), i);
     }
 
     // Test: tried table collision!
     CService addr1 = ResolveService("250.1.1.80");
     addrman.Add(CAddress(addr1, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 79);
 
     CService addr2 = ResolveService("250.1.1.81");
     addrman.Add(CAddress(addr2, NODE_NONE), source);
     BOOST_CHECK_EQUAL(addrman.size(), 80);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_find) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     BOOST_CHECK_EQUAL(addrman.size(), 0);
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
     CAddress addr3 = CAddress(ResolveService("251.255.2.1", 8333), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.2.1");
     CNetAddr source2 = ResolveIP("250.1.2.2");
 
     addrman.Add(addr1, source1);
     addrman.Add(addr2, source2);
     addrman.Add(addr3, source1);
 
     // Test: ensure Find returns an IP matching what we searched on.
     CAddrInfo *info1 = addrman.Find(addr1);
     BOOST_REQUIRE(info1);
     BOOST_CHECK_EQUAL(info1->ToString(), "250.1.2.1:8333");
 
     // Test: Find does not discriminate by port number.
     CAddrInfo *info2 = addrman.Find(addr2);
     BOOST_REQUIRE(info2);
     BOOST_CHECK_EQUAL(info2->ToString(), info1->ToString());
 
     // Test: Find returns another IP matching what we searched on.
     CAddrInfo *info3 = addrman.Find(addr3);
     BOOST_REQUIRE(info3);
     BOOST_CHECK_EQUAL(info3->ToString(), "251.255.2.1:8333");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_create) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     BOOST_CHECK_EQUAL(addrman.size(), 0);
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     int nId;
     CAddrInfo *pinfo = addrman.Create(addr1, source1, &nId);
 
     // Test: The result should be the same as the input addr.
     BOOST_CHECK_EQUAL(pinfo->ToString(), "250.1.2.1:8333");
 
     CAddrInfo *info2 = addrman.Find(addr1);
     BOOST_CHECK_EQUAL(info2->ToString(), "250.1.2.1:8333");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_delete) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     BOOST_CHECK_EQUAL(addrman.size(), 0);
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     int nId;
     addrman.Create(addr1, source1, &nId);
 
     // Test: Delete should actually delete the addr.
     BOOST_CHECK_EQUAL(addrman.size(), 1);
     addrman.Delete(nId);
     BOOST_CHECK_EQUAL(addrman.size(), 0);
     CAddrInfo *info2 = addrman.Find(addr1);
     BOOST_CHECK(info2 == nullptr);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_getaddr) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     // Test: Sanity check, GetAddr should never return anything if addrman
     //  is empty.
     BOOST_CHECK_EQUAL(addrman.size(), 0);
     std::vector<CAddress> vAddr1 = addrman.GetAddr();
     BOOST_CHECK_EQUAL(vAddr1.size(), 0);
 
     CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
     addr1.nTime = GetAdjustedTime(); // Set time so isTerrible = false
     CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
     addr2.nTime = GetAdjustedTime();
     CAddress addr3 = CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE);
     addr3.nTime = GetAdjustedTime();
     CAddress addr4 = CAddress(ResolveService("252.253.3.4", 8333), NODE_NONE);
     addr4.nTime = GetAdjustedTime();
     CAddress addr5 = CAddress(ResolveService("252.254.4.5", 8333), NODE_NONE);
     addr5.nTime = GetAdjustedTime();
     CNetAddr source1 = ResolveIP("250.1.2.1");
     CNetAddr source2 = ResolveIP("250.2.3.3");
 
     // Test: Ensure GetAddr works with new addresses.
     addrman.Add(addr1, source1);
     addrman.Add(addr2, source2);
     addrman.Add(addr3, source1);
     addrman.Add(addr4, source2);
     addrman.Add(addr5, source1);
 
     // GetAddr returns 23% of addresses, 23% of 5 is 1 rounded down.
     BOOST_CHECK_EQUAL(addrman.GetAddr().size(), 1);
 
     // Test: Ensure GetAddr works with new and tried addresses.
     addrman.Good(CAddress(addr1, NODE_NONE));
     addrman.Good(CAddress(addr2, NODE_NONE));
     BOOST_CHECK_EQUAL(addrman.GetAddr().size(), 1);
 
     // Test: Ensure GetAddr still returns 23% when addrman has many addrs.
     for (unsigned int i = 1; i < (8 * 256); i++) {
         int octet1 = i % 256;
         int octet2 = i >> 8 % 256;
         std::string strAddr =
             std::to_string(octet1) + "." + std::to_string(octet2) + ".1.23";
         CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);
 
         // Ensure that for all addrs in addrman, isTerrible == false.
         addr.nTime = GetAdjustedTime();
         addrman.Add(addr, ResolveIP(strAddr));
         if (i % 8 == 0) addrman.Good(addr);
     }
     std::vector<CAddress> vAddr = addrman.GetAddr();
 
     size_t percent23 = (addrman.size() * 23) / 100;
     BOOST_CHECK_EQUAL(vAddr.size(), percent23);
     BOOST_CHECK_EQUAL(vAddr.size(), 461);
     // (Addrman.size() < number of addresses added) due to address collisions.
     BOOST_CHECK_EQUAL(addrman.size(), 2006);
 }
 
 BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.1.1");
 
     CAddrInfo info1 = CAddrInfo(addr1, source1);
 
     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 
     BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1), 40);
 
     // Test: Make sure key actually randomizes bucket placement. A fail on
     //  this test could be a security issue.
     BOOST_CHECK(info1.GetTriedBucket(nKey1) != info1.GetTriedBucket(nKey2));
 
     // Test: Two addresses with same IP but different ports can map to
     //  different buckets because they have different keys.
     CAddrInfo info2 = CAddrInfo(addr2, source1);
 
     BOOST_CHECK(info1.GetKey() != info2.GetKey());
     BOOST_CHECK(info1.GetTriedBucket(nKey1) != info2.GetTriedBucket(nKey1));
 
     std::set<int> buckets;
     for (int i = 0; i < 255; i++) {
         CAddrInfo infoi = CAddrInfo(
             CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
             ResolveIP("250.1.1." + std::to_string(i)));
         int bucket = infoi.GetTriedBucket(nKey1);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same group (\16 prefix for IPv4) should
     //  never get more than 8 buckets
     BOOST_CHECK_EQUAL(buckets.size(), 8);
 
     buckets.clear();
     for (int j = 0; j < 255; j++) {
         CAddrInfo infoj = CAddrInfo(
             CAddress(ResolveService("250." + std::to_string(j) + ".1.1"),
                      NODE_NONE),
             ResolveIP("250." + std::to_string(j) + ".1.1"));
         int bucket = infoj.GetTriedBucket(nKey1);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different groups should map to more than
     //  8 buckets.
     BOOST_CHECK_EQUAL(buckets.size(), 160);
 }
 
 BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     CAddrInfo info1 = CAddrInfo(addr1, source1);
 
     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 
     // Test: Make sure the buckets are what we expect
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1), 786);
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1), 786);
 
     // Test: Make sure key actually randomizes bucket placement. A fail on
     //  this test could be a security issue.
     BOOST_CHECK(info1.GetNewBucket(nKey1) != info1.GetNewBucket(nKey2));
 
     // Test: Ports should not effect bucket placement in the addr
     CAddrInfo info2 = CAddrInfo(addr2, source1);
     BOOST_CHECK(info1.GetKey() != info2.GetKey());
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1), info2.GetNewBucket(nKey1));
 
     std::set<int> buckets;
     for (int i = 0; i < 255; i++) {
         CAddrInfo infoi = CAddrInfo(
             CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
             ResolveIP("250.1.1." + std::to_string(i)));
         int bucket = infoi.GetNewBucket(nKey1);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same group (\16 prefix for IPv4) should
     //  always map to the same bucket.
     BOOST_CHECK_EQUAL(buckets.size(), 1);
 
     buckets.clear();
     for (int j = 0; j < 4 * 255; j++) {
         CAddrInfo infoj = CAddrInfo(
             CAddress(ResolveService(std::to_string(250 + (j / 255)) + "." +
                                     std::to_string(j % 256) + ".1.1"),
                      NODE_NONE),
             ResolveIP("251.4.1.1"));
         int bucket = infoj.GetNewBucket(nKey1);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same source groups should map to no more
     //  than 64 buckets.
     BOOST_CHECK(buckets.size() <= 64);
 
     buckets.clear();
     for (int p = 0; p < 255; p++) {
         CAddrInfo infoj =
             CAddrInfo(CAddress(ResolveService("250.1.1.1"), NODE_NONE),
                       ResolveIP("250." + std::to_string(p) + ".1.1"));
         int bucket = infoj.GetNewBucket(nKey1);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different source groups should map to more
     //  than 64 buckets.
     BOOST_CHECK(buckets.size() > 64);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_selecttriedcollision) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     BOOST_CHECK(addrman.size() == 0);
 
     // Empty addrman should return blank addrman info.
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // Add twenty two addresses.
     CNetAddr source = ResolveIP("252.2.2.2");
     for (unsigned int i = 1; i < 23; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Add(CAddress(addr, NODE_NONE), source);
         addrman.Good(addr);
 
         // No collisions yet.
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Ensure Good handles duplicates well.
     for (unsigned int i = 1; i < 23; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Good(addr);
 
         BOOST_CHECK(addrman.size() == 22);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 }
 
 BOOST_AUTO_TEST_CASE(addrman_noevict) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     // Add twenty two addresses.
     CNetAddr source = ResolveIP("252.2.2.2");
     for (unsigned int i = 1; i < 23; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Add(CAddress(addr, NODE_NONE), source);
         addrman.Good(addr);
 
         // No collision yet.
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Collision between 23 and 19.
     CService addr23 = ResolveService("250.1.1.23");
     addrman.Add(CAddress(addr23, NODE_NONE), source);
     addrman.Good(addr23);
 
     BOOST_CHECK(addrman.size() == 23);
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.19:0");
 
     // 23 should be discarded and 19 not evicted.
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // Lets create two collisions.
     for (unsigned int i = 24; i < 33; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Add(CAddress(addr, NODE_NONE), source);
         addrman.Good(addr);
 
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Cause a collision.
     CService addr33 = ResolveService("250.1.1.33");
     addrman.Add(CAddress(addr33, NODE_NONE), source);
     addrman.Good(addr33);
     BOOST_CHECK(addrman.size() == 33);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.27:0");
 
     // Cause a second collision.
     addrman.Add(CAddress(addr23, NODE_NONE), source);
     addrman.Good(addr23);
     BOOST_CHECK(addrman.size() == 33);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() != "[::]:0");
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_evictionworks) {
     CAddrManTest addrman;
 
     // Set addrman addr placement to be deterministic.
     addrman.MakeDeterministic();
 
     BOOST_CHECK(addrman.size() == 0);
 
     // Empty addrman should return blank addrman info.
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // Add twenty two addresses.
     CNetAddr source = ResolveIP("252.2.2.2");
     for (unsigned int i = 1; i < 23; i++) {
         CService addr = ResolveService("250.1.1." + std::to_string(i));
         addrman.Add(CAddress(addr, NODE_NONE), source);
         addrman.Good(addr);
 
         // No collision yet.
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Collision between 23 and 19.
     CService addr = ResolveService("250.1.1.23");
     addrman.Add(CAddress(addr, NODE_NONE), source);
     addrman.Good(addr);
 
     BOOST_CHECK(addrman.size() == 23);
     CAddrInfo info = addrman.SelectTriedCollision();
     BOOST_CHECK(info.ToString() == "250.1.1.19:0");
 
     // Ensure test of address fails, so that it is evicted.
     addrman.SimConnFail(info);
 
     // Should swap 23 for 19.
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // If 23 was swapped for 19, then this should cause no collisions.
     addrman.Add(CAddress(addr, NODE_NONE), source);
     addrman.Good(addr);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // If we insert 19 is should collide with 23.
     CService addr19 = ResolveService("250.1.1.19");
     addrman.Add(CAddress(addr19, NODE_NONE), source);
     addrman.Good(addr19);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.23:0");
 
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/allocator_tests.cpp b/src/test/allocator_tests.cpp
index 139214fd5..6ade05b8d 100644
--- a/src/test/allocator_tests.cpp
+++ b/src/test/allocator_tests.cpp
@@ -1,232 +1,232 @@
 // Copyright (c) 2012-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "util.h"
+#include <support/allocators/secure.h>
+#include <util.h>
 
-#include "support/allocators/secure.h"
-#include "test/test_bitcoin.h"
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(allocator_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(arena_tests) {
     // Fake memory base address for testing
     // without actually using memory.
     void *synth_base = reinterpret_cast<void *>(0x08000000);
     const size_t synth_size = 1024 * 1024;
     Arena b(synth_base, synth_size, 16);
     void *chunk = b.alloc(1000);
 #ifdef ARENA_DEBUG
     b.walk();
 #endif
     BOOST_CHECK(chunk != nullptr);
     // Aligned to 16
     BOOST_CHECK(b.stats().used == 1008);
     // Nothing has disappeared?
     BOOST_CHECK(b.stats().total == synth_size);
     b.free(chunk);
 #ifdef ARENA_DEBUG
     b.walk();
 #endif
     BOOST_CHECK(b.stats().used == 0);
     BOOST_CHECK(b.stats().free == synth_size);
     try {
         // Test exception on double-free
         b.free(chunk);
         BOOST_CHECK(0);
     } catch (std::runtime_error &) {
     }
 
     void *a0 = b.alloc(128);
     void *a1 = b.alloc(256);
     void *a2 = b.alloc(512);
     BOOST_CHECK(b.stats().used == 896);
     BOOST_CHECK(b.stats().total == synth_size);
 #ifdef ARENA_DEBUG
     b.walk();
 #endif
     b.free(a0);
 #ifdef ARENA_DEBUG
     b.walk();
 #endif
     BOOST_CHECK(b.stats().used == 768);
     b.free(a1);
     BOOST_CHECK(b.stats().used == 512);
     void *a3 = b.alloc(128);
 #ifdef ARENA_DEBUG
     b.walk();
 #endif
     BOOST_CHECK(b.stats().used == 640);
     b.free(a2);
     BOOST_CHECK(b.stats().used == 128);
     b.free(a3);
     BOOST_CHECK(b.stats().used == 0);
     BOOST_CHECK_EQUAL(b.stats().chunks_used, 0);
     BOOST_CHECK(b.stats().total == synth_size);
     BOOST_CHECK(b.stats().free == synth_size);
     BOOST_CHECK_EQUAL(b.stats().chunks_free, 1);
 
     std::vector<void *> addr;
     // allocating 0 always returns nullptr
     BOOST_CHECK(b.alloc(0) == nullptr);
 #ifdef ARENA_DEBUG
     b.walk();
 #endif
     // Sweeping allocate all memory
     for (int x = 0; x < 1024; ++x)
         addr.push_back(b.alloc(1024));
     BOOST_CHECK(b.stats().free == 0);
     // memory is full, this must return nullptr
     BOOST_CHECK(b.alloc(1024) == nullptr);
     BOOST_CHECK(b.alloc(0) == nullptr);
     for (int x = 0; x < 1024; ++x)
         b.free(addr[x]);
     addr.clear();
     BOOST_CHECK(b.stats().total == synth_size);
     BOOST_CHECK(b.stats().free == synth_size);
 
     // Now in the other direction...
     for (int x = 0; x < 1024; ++x)
         addr.push_back(b.alloc(1024));
     for (int x = 0; x < 1024; ++x)
         b.free(addr[1023 - x]);
     addr.clear();
 
     // Now allocate in smaller unequal chunks, then deallocate haphazardly
     // Not all the chunks will succeed allocating, but freeing nullptr is
     // allowed so that is no problem.
     for (int x = 0; x < 2048; ++x)
         addr.push_back(b.alloc(x + 1));
     for (int x = 0; x < 2048; ++x)
         b.free(addr[((x * 23) % 2048) ^ 242]);
     addr.clear();
 
     // Go entirely wild: free and alloc interleaved, generate targets and sizes
     // using pseudo-randomness.
     for (int x = 0; x < 2048; ++x)
         addr.push_back(0);
     uint32_t s = 0x12345678;
     for (int x = 0; x < 5000; ++x) {
         int idx = s & (addr.size() - 1);
         if (s & 0x80000000) {
             b.free(addr[idx]);
             addr[idx] = 0;
         } else if (!addr[idx]) {
             addr[idx] = b.alloc((s >> 16) & 2047);
         }
         bool lsb = s & 1;
         s >>= 1;
         // LFSR period 0xf7ffffe0
         if (lsb) s ^= 0xf00f00f0;
     }
     for (void *ptr : addr)
         b.free(ptr);
     addr.clear();
 
     BOOST_CHECK(b.stats().total == synth_size);
     BOOST_CHECK(b.stats().free == synth_size);
 }
 
 /** Mock LockedPageAllocator for testing */
 class TestLockedPageAllocator : public LockedPageAllocator {
 public:
     TestLockedPageAllocator(int count_in, int lockedcount_in)
         : count(count_in), lockedcount(lockedcount_in) {}
     void *AllocateLocked(size_t len, bool *lockingSuccess) override {
         *lockingSuccess = false;
         if (count > 0) {
             --count;
 
             if (lockedcount > 0) {
                 --lockedcount;
                 *lockingSuccess = true;
             }
 
             // Fake address, do not actually use this memory
             return reinterpret_cast<void *>(0x08000000 + (count << 24));
         }
         return 0;
     }
     void FreeLocked(void *addr, size_t len) override {}
     size_t GetLimit() override { return std::numeric_limits<size_t>::max(); }
 
 private:
     int count;
     int lockedcount;
 };
 
 BOOST_AUTO_TEST_CASE(lockedpool_tests_mock) {
     // Test over three virtual arenas, of which one will succeed being locked
     std::unique_ptr<LockedPageAllocator> x(new TestLockedPageAllocator(3, 1));
     LockedPool pool(std::move(x));
     BOOST_CHECK(pool.stats().total == 0);
     BOOST_CHECK(pool.stats().locked == 0);
 
     // Ensure unreasonable requests are refused without allocating anything
     void *invalid_toosmall = pool.alloc(0);
     BOOST_CHECK(invalid_toosmall == nullptr);
     BOOST_CHECK(pool.stats().used == 0);
     BOOST_CHECK(pool.stats().free == 0);
     void *invalid_toobig = pool.alloc(LockedPool::ARENA_SIZE + 1);
     BOOST_CHECK(invalid_toobig == nullptr);
     BOOST_CHECK(pool.stats().used == 0);
     BOOST_CHECK(pool.stats().free == 0);
 
     void *a0 = pool.alloc(LockedPool::ARENA_SIZE / 2);
     BOOST_CHECK(a0);
     BOOST_CHECK(pool.stats().locked == LockedPool::ARENA_SIZE);
     void *a1 = pool.alloc(LockedPool::ARENA_SIZE / 2);
     BOOST_CHECK(a1);
     void *a2 = pool.alloc(LockedPool::ARENA_SIZE / 2);
     BOOST_CHECK(a2);
     void *a3 = pool.alloc(LockedPool::ARENA_SIZE / 2);
     BOOST_CHECK(a3);
     void *a4 = pool.alloc(LockedPool::ARENA_SIZE / 2);
     BOOST_CHECK(a4);
     void *a5 = pool.alloc(LockedPool::ARENA_SIZE / 2);
     BOOST_CHECK(a5);
     // We've passed a count of three arenas, so this allocation should fail
     void *a6 = pool.alloc(16);
     BOOST_CHECK(!a6);
 
     pool.free(a0);
     pool.free(a2);
     pool.free(a4);
     pool.free(a1);
     pool.free(a3);
     pool.free(a5);
     BOOST_CHECK(pool.stats().total == 3 * LockedPool::ARENA_SIZE);
     BOOST_CHECK(pool.stats().locked == LockedPool::ARENA_SIZE);
     BOOST_CHECK(pool.stats().used == 0);
 }
 
 // These tests used the live LockedPoolManager object, this is also used by
 // other tests so the conditions are somewhat less controllable and thus the
 // tests are somewhat more error-prone.
 BOOST_AUTO_TEST_CASE(lockedpool_tests_live) {
     LockedPoolManager &pool = LockedPoolManager::Instance();
     LockedPool::Stats initial = pool.stats();
 
     void *a0 = pool.alloc(16);
     BOOST_CHECK(a0);
     // Test reading and writing the allocated memory
     *((uint32_t *)a0) = 0x1234;
     BOOST_CHECK(*((uint32_t *)a0) == 0x1234);
 
     pool.free(a0);
     try {
         // Test exception on double-free
         pool.free(a0);
         BOOST_CHECK(0);
     } catch (std::runtime_error &) {
     }
     // If more than one new arena was allocated for the above tests, something
     // is wrong
     BOOST_CHECK(pool.stats().total <= (initial.total + LockedPool::ARENA_SIZE));
     // Usage must be back to where it started
     BOOST_CHECK(pool.stats().used == initial.used);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/amount_tests.cpp b/src/test/amount_tests.cpp
index 34dcbb6c4..d4428c6a8 100644
--- a/src/test/amount_tests.cpp
+++ b/src/test/amount_tests.cpp
@@ -1,104 +1,105 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "amount.h"
-#include "test/test_bitcoin.h"
+#include <amount.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <array>
 
 BOOST_FIXTURE_TEST_SUITE(amount_tests, BasicTestingSetup)
 
 static void CheckAmounts(int64_t aval, int64_t bval) {
     Amount a(aval * SATOSHI), b(bval * SATOSHI);
 
     // Equality
     BOOST_CHECK_EQUAL(a == b, aval == bval);
     BOOST_CHECK_EQUAL(b == a, aval == bval);
 
     BOOST_CHECK_EQUAL(a != b, aval != bval);
     BOOST_CHECK_EQUAL(b != a, aval != bval);
 
     // Comparison
     BOOST_CHECK_EQUAL(a < b, aval < bval);
     BOOST_CHECK_EQUAL(b < a, bval < aval);
 
     BOOST_CHECK_EQUAL(a > b, aval > bval);
     BOOST_CHECK_EQUAL(b > a, bval > aval);
 
     BOOST_CHECK_EQUAL(a <= b, aval <= bval);
     BOOST_CHECK_EQUAL(b <= a, bval <= aval);
 
     BOOST_CHECK_EQUAL(a >= b, aval >= bval);
     BOOST_CHECK_EQUAL(b >= a, bval >= aval);
 
     // Unary minus
     BOOST_CHECK_EQUAL(-a, -aval * SATOSHI);
     BOOST_CHECK_EQUAL(-b, -bval * SATOSHI);
 
     // Addition and subtraction.
     BOOST_CHECK_EQUAL(a + b, b + a);
     BOOST_CHECK_EQUAL(a + b, (aval + bval) * SATOSHI);
 
     BOOST_CHECK_EQUAL(a - b, -(b - a));
     BOOST_CHECK_EQUAL(a - b, (aval - bval) * SATOSHI);
 
     // Multiplication
     BOOST_CHECK_EQUAL(aval * b, bval * a);
     BOOST_CHECK_EQUAL(aval * b, (aval * bval) * SATOSHI);
 
     // Division
     if (b != Amount::zero()) {
         BOOST_CHECK_EQUAL(a / b, aval / bval);
         BOOST_CHECK_EQUAL(a / bval, (a / b) * SATOSHI);
     }
 
     if (a != Amount::zero()) {
         BOOST_CHECK_EQUAL(b / a, bval / aval);
         BOOST_CHECK_EQUAL(b / aval, (b / a) * SATOSHI);
     }
 
     // Modulus
     if (b != Amount::zero()) {
         BOOST_CHECK_EQUAL(a % b, a % bval);
         BOOST_CHECK_EQUAL(a % b, (aval % bval) * SATOSHI);
     }
 
     if (a != Amount::zero()) {
         BOOST_CHECK_EQUAL(b % a, b % aval);
         BOOST_CHECK_EQUAL(b % a, (bval % aval) * SATOSHI);
     }
 
     // OpAssign
     Amount v;
     BOOST_CHECK_EQUAL(v, Amount::zero());
     v += a;
     BOOST_CHECK_EQUAL(v, a);
     v += b;
     BOOST_CHECK_EQUAL(v, a + b);
     v += b;
     BOOST_CHECK_EQUAL(v, a + 2 * b);
     v -= 2 * a;
     BOOST_CHECK_EQUAL(v, 2 * b - a);
 }
 
 BOOST_AUTO_TEST_CASE(AmountTests) {
     std::array<int64_t, 8> values = {{-23, -1, 0, 1, 2, 3, 42, 99999999}};
 
     for (int64_t i : values) {
         for (int64_t j : values) {
             CheckAmounts(i, j);
         }
     }
 
     BOOST_CHECK_EQUAL(COIN + COIN, 2 * COIN);
     BOOST_CHECK_EQUAL(2 * COIN + COIN, 3 * COIN);
     BOOST_CHECK_EQUAL(-1 * COIN + COIN, Amount::zero());
 
     BOOST_CHECK_EQUAL(COIN - COIN, Amount::zero());
     BOOST_CHECK_EQUAL(COIN - 2 * COIN, -1 * COIN);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/arith_uint256_tests.cpp b/src/test/arith_uint256_tests.cpp
index 6176ccaa9..964a070a0 100644
--- a/src/test/arith_uint256_tests.cpp
+++ b/src/test/arith_uint256_tests.cpp
@@ -1,673 +1,674 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "arith_uint256.h"
-#include "uint256.h"
-#include "version.h"
+#include <arith_uint256.h>
 
-#include "test/test_bitcoin.h"
+#include <uint256.h>
+#include <version.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cmath>
 #include <cstdint>
 #include <iomanip>
 #include <limits>
 #include <sstream>
 #include <string>
 
 BOOST_FIXTURE_TEST_SUITE(arith_uint256_tests, BasicTestingSetup)
 
 /// Convert vector to arith_uint256, via uint256 blob
 inline arith_uint256 arith_uint256V(const std::vector<uint8_t> &vch) {
     return UintToArith256(uint256(vch));
 }
 
 const uint8_t R1Array[] =
     "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
     "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
 const char R1ArrayHex[] =
     "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
 // R1L equals roughly R1Ldouble * 2^256
 const double R1Ldouble = 0.4887374590559308955;
 const arith_uint256 R1L =
     arith_uint256V(std::vector<uint8_t>(R1Array, R1Array + 32));
 const uint64_t R1LLow64 = 0x121156cfdb4a529cULL;
 
 const uint8_t R2Array[] =
     "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
     "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
 const arith_uint256 R2L =
     arith_uint256V(std::vector<uint8_t>(R2Array, R2Array + 32));
 
 const char R1LplusR2L[] =
     "549FB09FEA236A1EA3E31D4D58F1B1369288D204211CA751527CFC175767850C";
 
 const uint8_t ZeroArray[] =
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
 const arith_uint256 ZeroL =
     arith_uint256V(std::vector<uint8_t>(ZeroArray, ZeroArray + 32));
 
 const uint8_t OneArray[] =
     "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
 const arith_uint256 OneL =
     arith_uint256V(std::vector<uint8_t>(OneArray, OneArray + 32));
 
 const uint8_t MaxArray[] =
     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
     "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
 const arith_uint256 MaxL =
     arith_uint256V(std::vector<uint8_t>(MaxArray, MaxArray + 32));
 
 const arith_uint256 HalfL = (OneL << 255);
 std::string ArrayToString(const uint8_t A[], unsigned int width) {
     std::stringstream Stream;
     Stream << std::hex;
     for (unsigned int i = 0; i < width; ++i) {
         Stream << std::setw(2) << std::setfill('0')
                << (unsigned int)A[width - i - 1];
     }
     return Stream.str();
 }
 
 // constructors, equality, inequality
 BOOST_AUTO_TEST_CASE(basics) {
     BOOST_CHECK(1 == 0 + 1);
     // constructor arith_uint256(vector<char>):
     BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array, 32));
     BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array, 32));
     BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray, 32));
     BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray, 32));
     BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray, 32));
     BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray, 32));
 
     // == and !=
     BOOST_CHECK(R1L != R2L);
     BOOST_CHECK(ZeroL != OneL);
     BOOST_CHECK(OneL != ZeroL);
     BOOST_CHECK(MaxL != ZeroL);
     BOOST_CHECK(~MaxL == ZeroL);
     BOOST_CHECK(((R1L ^ R2L) ^ R1L) == R2L);
 
     uint64_t Tmp64 = 0xc4dab720d9c7acaaULL;
     for (unsigned int i = 0; i < 256; ++i) {
         BOOST_CHECK(ZeroL != (OneL << i));
         BOOST_CHECK((OneL << i) != ZeroL);
         BOOST_CHECK(R1L != (R1L ^ (OneL << i)));
         BOOST_CHECK(((arith_uint256(Tmp64) ^ (OneL << i)) != Tmp64));
     }
     BOOST_CHECK(ZeroL == (OneL << 256));
 
     // String Constructor and Copy Constructor
     BOOST_CHECK(arith_uint256("0x" + R1L.ToString()) == R1L);
     BOOST_CHECK(arith_uint256("0x" + R2L.ToString()) == R2L);
     BOOST_CHECK(arith_uint256("0x" + ZeroL.ToString()) == ZeroL);
     BOOST_CHECK(arith_uint256("0x" + OneL.ToString()) == OneL);
     BOOST_CHECK(arith_uint256("0x" + MaxL.ToString()) == MaxL);
     BOOST_CHECK(arith_uint256(R1L.ToString()) == R1L);
     BOOST_CHECK(arith_uint256("   0x" + R1L.ToString() + "   ") == R1L);
     BOOST_CHECK(arith_uint256("") == ZeroL);
     BOOST_CHECK(R1L == arith_uint256(R1ArrayHex));
     BOOST_CHECK(arith_uint256(R1L) == R1L);
     BOOST_CHECK((arith_uint256(R1L ^ R2L) ^ R2L) == R1L);
     BOOST_CHECK(arith_uint256(ZeroL) == ZeroL);
     BOOST_CHECK(arith_uint256(OneL) == OneL);
 
     // uint64_t constructor
     BOOST_CHECK((R1L & arith_uint256("0xffffffffffffffff")) ==
                 arith_uint256(R1LLow64));
     BOOST_CHECK(ZeroL == arith_uint256(0));
     BOOST_CHECK(OneL == arith_uint256(1));
     BOOST_CHECK(arith_uint256("0xffffffffffffffff") ==
                 arith_uint256(0xffffffffffffffffULL));
 
     // Assignment (from base_uint)
     arith_uint256 tmpL = ~ZeroL;
     BOOST_CHECK(tmpL == ~ZeroL);
     tmpL = ~OneL;
     BOOST_CHECK(tmpL == ~OneL);
     tmpL = ~R1L;
     BOOST_CHECK(tmpL == ~R1L);
     tmpL = ~R2L;
     BOOST_CHECK(tmpL == ~R2L);
     tmpL = ~MaxL;
     BOOST_CHECK(tmpL == ~MaxL);
 }
 
 void shiftArrayRight(uint8_t *to, const uint8_t *from, unsigned int arrayLength,
                      unsigned int bitsToShift) {
     for (unsigned int T = 0; T < arrayLength; ++T) {
         unsigned int F = (T + bitsToShift / 8);
         if (F < arrayLength) {
             to[T] = from[F] >> (bitsToShift % 8);
         } else {
             to[T] = 0;
         }
         if (F + 1 < arrayLength) {
             to[T] |= from[(F + 1)] << (8 - bitsToShift % 8);
         }
     }
 }
 
 void shiftArrayLeft(uint8_t *to, const uint8_t *from, unsigned int arrayLength,
                     unsigned int bitsToShift) {
     for (unsigned int T = 0; T < arrayLength; ++T) {
         if (T >= bitsToShift / 8) {
             unsigned int F = T - bitsToShift / 8;
             to[T] = from[F] << (bitsToShift % 8);
             if (T >= bitsToShift / 8 + 1) {
                 to[T] |= from[F - 1] >> (8 - bitsToShift % 8);
             }
         } else {
             to[T] = 0;
         }
     }
 }
 
 // "<<"  ">>"  "<<="  ">>="
 BOOST_AUTO_TEST_CASE(shifts) {
     uint8_t TmpArray[32];
     arith_uint256 TmpL;
     for (unsigned int i = 0; i < 256; ++i) {
         shiftArrayLeft(TmpArray, OneArray, 32, i);
         BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(
                         TmpArray, TmpArray + 32)) == (OneL << i));
         TmpL = OneL;
         TmpL <<= i;
         BOOST_CHECK(TmpL == (OneL << i));
         BOOST_CHECK((HalfL >> (255 - i)) == (OneL << i));
         TmpL = HalfL;
         TmpL >>= (255 - i);
         BOOST_CHECK(TmpL == (OneL << i));
 
         shiftArrayLeft(TmpArray, R1Array, 32, i);
         BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(
                         TmpArray, TmpArray + 32)) == (R1L << i));
         TmpL = R1L;
         TmpL <<= i;
         BOOST_CHECK(TmpL == (R1L << i));
 
         shiftArrayRight(TmpArray, R1Array, 32, i);
         BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(
                         TmpArray, TmpArray + 32)) == (R1L >> i));
         TmpL = R1L;
         TmpL >>= i;
         BOOST_CHECK(TmpL == (R1L >> i));
 
         shiftArrayLeft(TmpArray, MaxArray, 32, i);
         BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(
                         TmpArray, TmpArray + 32)) == (MaxL << i));
         TmpL = MaxL;
         TmpL <<= i;
         BOOST_CHECK(TmpL == (MaxL << i));
 
         shiftArrayRight(TmpArray, MaxArray, 32, i);
         BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(
                         TmpArray, TmpArray + 32)) == (MaxL >> i));
         TmpL = MaxL;
         TmpL >>= i;
         BOOST_CHECK(TmpL == (MaxL >> i));
     }
     arith_uint256 c1L = arith_uint256(0x0123456789abcdefULL);
     arith_uint256 c2L = c1L << 128;
     for (unsigned int i = 0; i < 128; ++i) {
         BOOST_CHECK((c1L << i) == (c2L >> (128 - i)));
     }
     for (unsigned int i = 128; i < 256; ++i) {
         BOOST_CHECK((c1L << i) == (c2L << (i - 128)));
     }
 }
 
 // !    ~    -
 BOOST_AUTO_TEST_CASE(unaryOperators) {
     BOOST_CHECK(!ZeroL);
     BOOST_CHECK(!(!OneL));
     for (unsigned int i = 0; i < 256; ++i)
         BOOST_CHECK(!(!(OneL << i)));
     BOOST_CHECK(!(!R1L));
     BOOST_CHECK(!(!MaxL));
 
     BOOST_CHECK(~ZeroL == MaxL);
 
     uint8_t TmpArray[32];
     for (unsigned int i = 0; i < 32; ++i) {
         TmpArray[i] = ~R1Array[i];
     }
     BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(TmpArray, TmpArray + 32)) ==
                 (~R1L));
 
     BOOST_CHECK(-ZeroL == ZeroL);
     BOOST_CHECK(-R1L == (~R1L) + 1);
     for (unsigned int i = 0; i < 256; ++i)
         BOOST_CHECK(-(OneL << i) == (MaxL << i));
 }
 
 // Check if doing _A_ _OP_ _B_ results in the same as applying _OP_ onto each
 // element of Aarray and Barray, and then converting the result into a
 // arith_uint256.
 #define CHECKBITWISEOPERATOR(_A_, _B_, _OP_)                                   \
     for (unsigned int i = 0; i < 32; ++i) {                                    \
         TmpArray[i] = _A_##Array[i] _OP_ _B_##Array[i];                        \
     }                                                                          \
     BOOST_CHECK(arith_uint256V(std::vector<uint8_t>(                           \
                     TmpArray, TmpArray + 32)) == (_A_##L _OP_ _B_##L));
 
 #define CHECKASSIGNMENTOPERATOR(_A_, _B_, _OP_)                                \
     TmpL = _A_##L;                                                             \
     TmpL _OP_## = _B_##L;                                                      \
     BOOST_CHECK(TmpL == (_A_##L _OP_ _B_##L));
 
 BOOST_AUTO_TEST_CASE(bitwiseOperators) {
     uint8_t TmpArray[32];
 
     CHECKBITWISEOPERATOR(R1, R2, |)
     CHECKBITWISEOPERATOR(R1, R2, ^)
     CHECKBITWISEOPERATOR(R1, R2, &)
     CHECKBITWISEOPERATOR(R1, Zero, |)
     CHECKBITWISEOPERATOR(R1, Zero, ^)
     CHECKBITWISEOPERATOR(R1, Zero, &)
     CHECKBITWISEOPERATOR(R1, Max, |)
     CHECKBITWISEOPERATOR(R1, Max, ^)
     CHECKBITWISEOPERATOR(R1, Max, &)
     CHECKBITWISEOPERATOR(Zero, R1, |)
     CHECKBITWISEOPERATOR(Zero, R1, ^)
     CHECKBITWISEOPERATOR(Zero, R1, &)
     CHECKBITWISEOPERATOR(Max, R1, |)
     CHECKBITWISEOPERATOR(Max, R1, ^)
     CHECKBITWISEOPERATOR(Max, R1, &)
 
     arith_uint256 TmpL;
     CHECKASSIGNMENTOPERATOR(R1, R2, |)
     CHECKASSIGNMENTOPERATOR(R1, R2, ^)
     CHECKASSIGNMENTOPERATOR(R1, R2, &)
     CHECKASSIGNMENTOPERATOR(R1, Zero, |)
     CHECKASSIGNMENTOPERATOR(R1, Zero, ^)
     CHECKASSIGNMENTOPERATOR(R1, Zero, &)
     CHECKASSIGNMENTOPERATOR(R1, Max, |)
     CHECKASSIGNMENTOPERATOR(R1, Max, ^)
     CHECKASSIGNMENTOPERATOR(R1, Max, &)
     CHECKASSIGNMENTOPERATOR(Zero, R1, |)
     CHECKASSIGNMENTOPERATOR(Zero, R1, ^)
     CHECKASSIGNMENTOPERATOR(Zero, R1, &)
     CHECKASSIGNMENTOPERATOR(Max, R1, |)
     CHECKASSIGNMENTOPERATOR(Max, R1, ^)
     CHECKASSIGNMENTOPERATOR(Max, R1, &)
 
     uint64_t Tmp64 = 0xe1db685c9a0b47a2ULL;
     TmpL = R1L;
     TmpL |= Tmp64;
     BOOST_CHECK(TmpL == (R1L | arith_uint256(Tmp64)));
     TmpL = R1L;
     TmpL |= 0;
     BOOST_CHECK(TmpL == R1L);
     TmpL ^= 0;
     BOOST_CHECK(TmpL == R1L);
     TmpL ^= Tmp64;
     BOOST_CHECK(TmpL == (R1L ^ arith_uint256(Tmp64)));
 }
 
 // <= >= < >
 BOOST_AUTO_TEST_CASE(comparison) {
     arith_uint256 TmpL;
     for (unsigned int i = 0; i < 256; ++i) {
         TmpL = OneL << i;
         BOOST_CHECK(TmpL >= ZeroL && TmpL > ZeroL && ZeroL < TmpL &&
                     ZeroL <= TmpL);
         BOOST_CHECK(TmpL >= 0 && TmpL > 0 && 0 < TmpL && 0 <= TmpL);
         TmpL |= R1L;
         BOOST_CHECK(TmpL >= R1L);
         BOOST_CHECK((TmpL == R1L) != (TmpL > R1L));
         BOOST_CHECK((TmpL == R1L) || !(TmpL <= R1L));
         BOOST_CHECK(R1L <= TmpL);
         BOOST_CHECK((R1L == TmpL) != (R1L < TmpL));
         BOOST_CHECK((TmpL == R1L) || !(R1L >= TmpL));
         BOOST_CHECK(!(TmpL < R1L));
         BOOST_CHECK(!(R1L > TmpL));
     }
 }
 
 BOOST_AUTO_TEST_CASE(plusMinus) {
     arith_uint256 TmpL = 0;
     BOOST_CHECK(R1L + R2L == arith_uint256(R1LplusR2L));
     TmpL += R1L;
     BOOST_CHECK(TmpL == R1L);
     TmpL += R2L;
     BOOST_CHECK(TmpL == R1L + R2L);
     BOOST_CHECK(OneL + MaxL == ZeroL);
     BOOST_CHECK(MaxL + OneL == ZeroL);
     for (unsigned int i = 1; i < 256; ++i) {
         BOOST_CHECK((MaxL >> i) + OneL == (HalfL >> (i - 1)));
         BOOST_CHECK(OneL + (MaxL >> i) == (HalfL >> (i - 1)));
         TmpL = (MaxL >> i);
         TmpL += OneL;
         BOOST_CHECK(TmpL == (HalfL >> (i - 1)));
         TmpL = (MaxL >> i);
         TmpL += 1;
         BOOST_CHECK(TmpL == (HalfL >> (i - 1)));
         TmpL = (MaxL >> i);
         BOOST_CHECK(TmpL++ == (MaxL >> i));
         BOOST_CHECK(TmpL == (HalfL >> (i - 1)));
     }
     BOOST_CHECK(arith_uint256(0xbedc77e27940a7ULL) + 0xee8d836fce66fbULL ==
                 arith_uint256(0xbedc77e27940a7ULL + 0xee8d836fce66fbULL));
     TmpL = arith_uint256(0xbedc77e27940a7ULL);
     TmpL += 0xee8d836fce66fbULL;
     BOOST_CHECK(TmpL ==
                 arith_uint256(0xbedc77e27940a7ULL + 0xee8d836fce66fbULL));
     TmpL -= 0xee8d836fce66fbULL;
     BOOST_CHECK(TmpL == 0xbedc77e27940a7ULL);
     TmpL = R1L;
     BOOST_CHECK(++TmpL == R1L + 1);
 
     BOOST_CHECK(R1L - (-R2L) == R1L + R2L);
     BOOST_CHECK(R1L - (-OneL) == R1L + OneL);
     BOOST_CHECK(R1L - OneL == R1L + (-OneL));
     for (unsigned int i = 1; i < 256; ++i) {
         BOOST_CHECK((MaxL >> i) - (-OneL) == (HalfL >> (i - 1)));
         BOOST_CHECK((HalfL >> (i - 1)) - OneL == (MaxL >> i));
         TmpL = (HalfL >> (i - 1));
         BOOST_CHECK(TmpL-- == (HalfL >> (i - 1)));
         BOOST_CHECK(TmpL == (MaxL >> i));
         TmpL = (HalfL >> (i - 1));
         BOOST_CHECK(--TmpL == (MaxL >> i));
     }
     TmpL = R1L;
     BOOST_CHECK(--TmpL == R1L - 1);
 }
 
 BOOST_AUTO_TEST_CASE(multiply) {
     BOOST_CHECK(
         (R1L * R1L).ToString() ==
         "62a38c0486f01e45879d7910a7761bf30d5237e9873f9bff3642a732c4d84f10");
     BOOST_CHECK(
         (R1L * R2L).ToString() ==
         "de37805e9986996cfba76ff6ba51c008df851987d9dd323f0e5de07760529c40");
     BOOST_CHECK((R1L * ZeroL) == ZeroL);
     BOOST_CHECK((R1L * OneL) == R1L);
     BOOST_CHECK((R1L * MaxL) == -R1L);
     BOOST_CHECK((R2L * R1L) == (R1L * R2L));
     BOOST_CHECK(
         (R2L * R2L).ToString() ==
         "ac8c010096767d3cae5005dec28bb2b45a1d85ab7996ccd3e102a650f74ff100");
     BOOST_CHECK((R2L * ZeroL) == ZeroL);
     BOOST_CHECK((R2L * OneL) == R2L);
     BOOST_CHECK((R2L * MaxL) == -R2L);
 
     BOOST_CHECK(MaxL * MaxL == OneL);
 
     BOOST_CHECK((R1L * 0) == 0);
     BOOST_CHECK((R1L * 1) == R1L);
     BOOST_CHECK(
         (R1L * 3).ToString() ==
         "7759b1c0ed14047f961ad09b20ff83687876a0181a367b813634046f91def7d4");
     BOOST_CHECK(
         (R2L * 0x87654321UL).ToString() ==
         "23f7816e30c4ae2017257b7a0fa64d60402f5234d46e746b61c960d09a26d070");
 }
 
 BOOST_AUTO_TEST_CASE(divide) {
     arith_uint256 D1L("AD7133AC1977FA2B7");
     arith_uint256 D2L("ECD751716");
     BOOST_CHECK(
         (R1L / D1L).ToString() ==
         "00000000000000000b8ac01106981635d9ed112290f8895545a7654dde28fb3a");
     BOOST_CHECK(
         (R1L / D2L).ToString() ==
         "000000000873ce8efec5b67150bad3aa8c5fcb70e947586153bf2cec7c37c57a");
     BOOST_CHECK(R1L / OneL == R1L);
     BOOST_CHECK(R1L / MaxL == ZeroL);
     BOOST_CHECK(MaxL / R1L == 2);
     BOOST_CHECK_THROW(R1L / ZeroL, uint_error);
     BOOST_CHECK(
         (R2L / D1L).ToString() ==
         "000000000000000013e1665895a1cc981de6d93670105a6b3ec3b73141b3a3c5");
     BOOST_CHECK(
         (R2L / D2L).ToString() ==
         "000000000e8f0abe753bb0afe2e9437ee85d280be60882cf0bd1aaf7fa3cc2c4");
     BOOST_CHECK(R2L / OneL == R2L);
     BOOST_CHECK(R2L / MaxL == ZeroL);
     BOOST_CHECK(MaxL / R2L == 1);
     BOOST_CHECK_THROW(R2L / ZeroL, uint_error);
 }
 
 bool almostEqual(double d1, double d2) {
     return fabs(d1 - d2) <=
            4 * fabs(d1) * std::numeric_limits<double>::epsilon();
 }
 
 // GetHex SetHex size() GetLow64 GetSerializeSize, Serialize, Unserialize
 BOOST_AUTO_TEST_CASE(methods) {
     BOOST_CHECK(R1L.GetHex() == R1L.ToString());
     BOOST_CHECK(R2L.GetHex() == R2L.ToString());
     BOOST_CHECK(OneL.GetHex() == OneL.ToString());
     BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
     arith_uint256 TmpL(R1L);
     BOOST_CHECK(TmpL == R1L);
     TmpL.SetHex(R2L.ToString());
     BOOST_CHECK(TmpL == R2L);
     TmpL.SetHex(ZeroL.ToString());
     BOOST_CHECK(TmpL == 0);
     TmpL.SetHex(HalfL.ToString());
     BOOST_CHECK(TmpL == HalfL);
 
     TmpL.SetHex(R1L.ToString());
     BOOST_CHECK(R1L.size() == 32);
     BOOST_CHECK(R2L.size() == 32);
     BOOST_CHECK(ZeroL.size() == 32);
     BOOST_CHECK(MaxL.size() == 32);
     BOOST_CHECK(R1L.GetLow64() == R1LLow64);
     BOOST_CHECK(HalfL.GetLow64() == 0x0000000000000000ULL);
     BOOST_CHECK(OneL.GetLow64() == 0x0000000000000001ULL);
 
     for (unsigned int i = 0; i < 255; ++i) {
         BOOST_CHECK((OneL << i).getdouble() == ldexp(1.0, i));
     }
     BOOST_CHECK(ZeroL.getdouble() == 0.0);
     for (int i = 256; i > 53; --i)
         BOOST_CHECK(
             almostEqual((R1L >> (256 - i)).getdouble(), ldexp(R1Ldouble, i)));
     uint64_t R1L64part = (R1L >> 192).GetLow64();
     for (int i = 53; i > 0;
          --i) // doubles can store all integers in {0,...,2^54-1} exactly
     {
         BOOST_CHECK((R1L >> (256 - i)).getdouble() ==
                     (double)(R1L64part >> (64 - i)));
     }
 }
 
 BOOST_AUTO_TEST_CASE(bignum_SetCompact) {
     arith_uint256 num;
     bool fNegative;
     bool fOverflow;
     num.SetCompact(0, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x00123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x01003456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x02000056, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x03000000, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x04000000, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x00923456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x01803456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x02800056, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x03800000, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x04800000, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x01123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000000012");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x01120000U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     // Make sure that we don't generate compacts with the 0x00800000 bit set
     num = 0x80;
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x02008000U);
 
     num.SetCompact(0x01fedcba, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "000000000000000000000000000000000000000000000000000000000000007e");
     BOOST_CHECK_EQUAL(num.GetCompact(true), 0x01fe0000U);
     BOOST_CHECK_EQUAL(fNegative, true);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x02123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000001234");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x02123400U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x03123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000000123456");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x03123456U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x04123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000012345600");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x04123456U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x04923456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000012345600");
     BOOST_CHECK_EQUAL(num.GetCompact(true), 0x04923456U);
     BOOST_CHECK_EQUAL(fNegative, true);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x05009234, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "0000000000000000000000000000000000000000000000000000000092340000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x05009234U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0x20123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(
         num.GetHex(),
         "1234560000000000000000000000000000000000000000000000000000000000");
     BOOST_CHECK_EQUAL(num.GetCompact(), 0x20123456U);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, false);
 
     num.SetCompact(0xff123456, &fNegative, &fOverflow);
     BOOST_CHECK_EQUAL(fNegative, false);
     BOOST_CHECK_EQUAL(fOverflow, true);
 }
 
 // some more tests just to get 100% coverage
 BOOST_AUTO_TEST_CASE(getmaxcoverage) {
     // ~R1L give a base_uint<256>
     BOOST_CHECK((~~R1L >> 10) == (R1L >> 10));
     BOOST_CHECK((~~R1L << 10) == (R1L << 10));
     BOOST_CHECK(!(~~R1L < R1L));
     BOOST_CHECK(~~R1L <= R1L);
     BOOST_CHECK(!(~~R1L > R1L));
     BOOST_CHECK(~~R1L >= R1L);
     BOOST_CHECK(!(R1L < ~~R1L));
     BOOST_CHECK(R1L <= ~~R1L);
     BOOST_CHECK(!(R1L > ~~R1L));
     BOOST_CHECK(R1L >= ~~R1L);
 
     BOOST_CHECK(~~R1L + R2L == R1L + ~~R2L);
     BOOST_CHECK(~~R1L - R2L == R1L - ~~R2L);
     BOOST_CHECK(~R1L != R1L);
     BOOST_CHECK(R1L != ~R1L);
     uint8_t TmpArray[32];
     CHECKBITWISEOPERATOR(~R1, R2, |)
     CHECKBITWISEOPERATOR(~R1, R2, ^)
     CHECKBITWISEOPERATOR(~R1, R2, &)
     CHECKBITWISEOPERATOR(R1, ~R2, |)
     CHECKBITWISEOPERATOR(R1, ~R2, ^)
     CHECKBITWISEOPERATOR(R1, ~R2, &)
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/avalanche_tests.cpp b/src/test/avalanche_tests.cpp
index 2f0f85509..5a2561dc6 100644
--- a/src/test/avalanche_tests.cpp
+++ b/src/test/avalanche_tests.cpp
@@ -1,867 +1,868 @@
 // Copyright (c) 2010 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "avalanche.h"
-#include "config.h"
-#include "net_processing.h" // For PeerLogicValidation
+#include <avalanche.h>
 
-#include "test/test_bitcoin.h"
+#include <config.h>
+#include <net_processing.h> // For PeerLogicValidation
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 struct AvalancheTest {
     static void runEventLoop(AvalancheProcessor &p) { p.runEventLoop(); }
 
     static std::vector<CInv> getInvsForNextPoll(const AvalancheProcessor &p) {
         return p.getInvsForNextPoll(false);
     }
 
     static NodeId getSuitableNodeToQuery(AvalancheProcessor &p) {
         return p.getSuitableNodeToQuery();
     }
 
     static uint64_t getRound(const AvalancheProcessor &p) { return p.round; }
 };
 
 BOOST_FIXTURE_TEST_SUITE(avalanche_tests, TestChain100Setup)
 
 #define REGISTER_VOTE_AND_CHECK(vr, vote, state, finalized, confidence)        \
     vr.registerVote(NO_NODE, vote);                                            \
     BOOST_CHECK_EQUAL(vr.isAccepted(), state);                                 \
     BOOST_CHECK_EQUAL(vr.hasFinalized(), finalized);                           \
     BOOST_CHECK_EQUAL(vr.getConfidence(), confidence);
 
 BOOST_AUTO_TEST_CASE(vote_record) {
     VoteRecord vraccepted(true);
 
     // Check initial state.
     BOOST_CHECK_EQUAL(vraccepted.isAccepted(), true);
     BOOST_CHECK_EQUAL(vraccepted.hasFinalized(), false);
     BOOST_CHECK_EQUAL(vraccepted.getConfidence(), 0);
 
     VoteRecord vr(false);
 
     // Check initial state.
     BOOST_CHECK_EQUAL(vr.isAccepted(), false);
     BOOST_CHECK_EQUAL(vr.hasFinalized(), false);
     BOOST_CHECK_EQUAL(vr.getConfidence(), 0);
 
     // We need to register 6 positive votes before we start counting.
     for (int i = 0; i < 6; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, false, false, 0);
     }
 
     // Next vote will flip state, and confidence will increase as long as we
     // vote yes.
     REGISTER_VOTE_AND_CHECK(vr, 0, true, false, 0);
 
     // A single neutral vote do not change anything.
     REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 1);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, true, false, i);
     }
 
     // Two neutral votes will stall progress.
     REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 7);
     REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 7);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, true, false, 7);
     }
 
     // Now confidence will increase as long as we vote yes.
     for (int i = 8; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, true, false, i);
     }
 
     // The next vote will finalize the decision.
     REGISTER_VOTE_AND_CHECK(vr, 1, true, true, AVALANCHE_FINALIZATION_SCORE);
 
     // Now that we have two no votes, confidence stop increasing.
     for (int i = 0; i < 5; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, true, true,
                                 AVALANCHE_FINALIZATION_SCORE);
     }
 
     // Next vote will flip state, and confidence will increase as long as we
     // vote no.
     REGISTER_VOTE_AND_CHECK(vr, 1, false, false, 0);
 
     // A single neutral vote do not change anything.
     REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 1);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, false, false, i);
     }
 
     // Two neutral votes will stall progress.
     REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 7);
     REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 7);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, false, false, 7);
     }
 
     // Now confidence will increase as long as we vote no.
     for (int i = 8; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, false, false, i);
     }
 
     // The next vote will finalize the decision.
     REGISTER_VOTE_AND_CHECK(vr, 0, false, true, AVALANCHE_FINALIZATION_SCORE);
 
     // Check that inflight accounting work as expected.
     VoteRecord vrinflight(false);
     for (int i = 0; i < 2 * AVALANCHE_MAX_INFLIGHT_POLL; i++) {
         bool shouldPoll = vrinflight.shouldPoll();
         BOOST_CHECK_EQUAL(shouldPoll, i < AVALANCHE_MAX_INFLIGHT_POLL);
         BOOST_CHECK_EQUAL(vrinflight.registerPoll(), shouldPoll);
     }
 
     // Clear various number of inflight requests and check everything behaves as
     // expected.
     for (int i = 1; i < AVALANCHE_MAX_INFLIGHT_POLL; i++) {
         vrinflight.clearInflightRequest(i);
         BOOST_CHECK(vrinflight.shouldPoll());
 
         for (int j = 1; j < i; j++) {
             BOOST_CHECK(vrinflight.registerPoll());
             BOOST_CHECK(vrinflight.shouldPoll());
         }
 
         BOOST_CHECK(vrinflight.registerPoll());
         BOOST_CHECK(!vrinflight.shouldPoll());
     }
 }
 
 BOOST_AUTO_TEST_CASE(block_update) {
     CBlockIndex index;
     CBlockIndex *pindex = &index;
 
     std::set<AvalancheBlockUpdate::Status> status{
         AvalancheBlockUpdate::Status::Invalid,
         AvalancheBlockUpdate::Status::Rejected,
         AvalancheBlockUpdate::Status::Accepted,
         AvalancheBlockUpdate::Status::Finalized,
     };
 
     for (auto s : status) {
         AvalancheBlockUpdate abu(pindex, s);
         BOOST_CHECK(abu.getBlockIndex() == pindex);
         BOOST_CHECK_EQUAL(abu.getStatus(), s);
     }
 }
 
 CService ip(uint32_t i) {
     struct in_addr s;
     s.s_addr = i;
     return CService(CNetAddr(s), Params().GetDefaultPort());
 }
 
 std::unique_ptr<CNode> ConnectNode(const Config &config, ServiceFlags nServices,
                                    PeerLogicValidation &peerLogic) {
     static NodeId id = 0;
 
     CAddress addr(ip(GetRandInt(0xffffffff)), NODE_NONE);
     std::unique_ptr<CNode> nodeptr(new CNode(id++, ServiceFlags(NODE_NETWORK),
                                              0, INVALID_SOCKET, addr, 0, 0,
                                              CAddress(), "",
                                              /*fInboundIn=*/false));
     CNode &node = *nodeptr;
     node.SetSendVersion(PROTOCOL_VERSION);
     node.nServices = nServices;
     peerLogic.InitializeNode(config, &node);
     node.nVersion = 1;
     node.fSuccessfullyConnected = true;
 
     CConnmanTest::AddNode(node);
     return nodeptr;
 }
 
 std::array<std::unique_ptr<CNode>, 8>
 ConnectNodes(const Config &config, AvalancheProcessor &p,
              ServiceFlags nServices, PeerLogicValidation &peerLogic) {
     std::array<std::unique_ptr<CNode>, 8> nodes;
     for (auto &n : nodes) {
         n = ConnectNode(config, nServices, peerLogic);
         BOOST_CHECK(p.addPeer(n->GetId(), 0));
     }
 
     return nodes;
 }
 
 static AvalancheResponse next(AvalancheResponse &r) {
     auto copy = r;
     r = {r.getRound() + 1, r.getCooldown(), r.GetVotes()};
     return copy;
 }
 
 BOOST_AUTO_TEST_CASE(block_register) {
     AvalancheProcessor p(g_connman.get());
     std::vector<AvalancheBlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash = block.GetHash();
     const CBlockIndex *pindex = mapBlockIndex[blockHash];
 
     const Config &config = GetConfig();
 
     // Create nodes that supports avalanche.
     auto avanodes = ConnectNodes(config, p, NODE_AVALANCHE, *peerLogic);
 
     // Querying for random block returns false.
     BOOST_CHECK(!p.isAccepted(pindex));
 
     // Add a new block. Check it is added to the polls.
     BOOST_CHECK(p.addBlockToReconcile(pindex));
     auto invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Newly added blocks' state reflect the blockchain.
     BOOST_CHECK(p.isAccepted(pindex));
 
     int nextNodeIndex = 0;
     auto registerNewVote = [&](const AvalancheResponse &resp) {
         AvalancheTest::runEventLoop(p);
         auto nodeid = avanodes[nextNodeIndex++ % avanodes.size()]->GetId();
         BOOST_CHECK(p.registerVotes(nodeid, resp, updates));
     };
 
     // Let's vote for this block a few times.
     AvalancheResponse resp{0, 0, {AvalancheVote(0, blockHash)}};
     for (int i = 0; i < 6; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(p.isAccepted(pindex));
         BOOST_CHECK_EQUAL(p.getConfidence(pindex), 0);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // A single neutral vote do not change anything.
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote(-1, blockHash)}};
     registerNewVote(next(resp));
     BOOST_CHECK(p.isAccepted(pindex));
     BOOST_CHECK_EQUAL(p.getConfidence(pindex), 0);
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote(0, blockHash)}};
     for (int i = 1; i < 7; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(p.isAccepted(pindex));
         BOOST_CHECK_EQUAL(p.getConfidence(pindex), i);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Two neutral votes will stall progress.
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote(-1, blockHash)}};
     registerNewVote(next(resp));
     BOOST_CHECK(p.isAccepted(pindex));
     BOOST_CHECK_EQUAL(p.getConfidence(pindex), 6);
     BOOST_CHECK_EQUAL(updates.size(), 0);
     registerNewVote(next(resp));
     BOOST_CHECK(p.isAccepted(pindex));
     BOOST_CHECK_EQUAL(p.getConfidence(pindex), 6);
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote(0, blockHash)}};
     for (int i = 2; i < 8; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(p.isAccepted(pindex));
         BOOST_CHECK_EQUAL(p.getConfidence(pindex), 6);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // We vote for it numerous times to finalize it.
     for (int i = 7; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(p.isAccepted(pindex));
         BOOST_CHECK_EQUAL(p.getConfidence(pindex), i);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // As long as it is not finalized, we poll.
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Now finalize the decision.
     registerNewVote(next(resp));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
     BOOST_CHECK_EQUAL(updates[0].getStatus(),
                       AvalancheBlockUpdate::Status::Finalized);
     updates = {};
 
     // Once the decision is finalized, there is no poll for it.
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 0);
 
     // Now let's undo this and finalize rejection.
     BOOST_CHECK(p.addBlockToReconcile(pindex));
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote(1, blockHash)}};
     for (int i = 0; i < 6; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(p.isAccepted(pindex));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Now the state will flip.
     registerNewVote(next(resp));
     BOOST_CHECK(!p.isAccepted(pindex));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
     BOOST_CHECK_EQUAL(updates[0].getStatus(),
                       AvalancheBlockUpdate::Status::Rejected);
     updates = {};
 
     // Now it is rejected, but we can vote for it numerous times.
     for (int i = 1; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(!p.isAccepted(pindex));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // As long as it is not finalized, we poll.
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Now finalize the decision.
     registerNewVote(next(resp));
     BOOST_CHECK(!p.isAccepted(pindex));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
     BOOST_CHECK_EQUAL(updates[0].getStatus(),
                       AvalancheBlockUpdate::Status::Invalid);
     updates = {};
 
     // Once the decision is finalized, there is no poll for it.
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 0);
 
     // Adding the block twice does nothing.
     BOOST_CHECK(p.addBlockToReconcile(pindex));
     BOOST_CHECK(!p.addBlockToReconcile(pindex));
     BOOST_CHECK(p.isAccepted(pindex));
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(multi_block_register) {
     AvalancheProcessor p(g_connman.get());
     CBlockIndex indexA, indexB;
 
     std::vector<AvalancheBlockUpdate> updates;
 
     const Config &config = GetConfig();
 
     // Create several nodes that support avalanche.
     auto avanodes = ConnectNodes(config, p, NODE_AVALANCHE, *peerLogic);
 
     // Make sure the block has a hash.
     CBlock blockA = CreateAndProcessBlock({}, CScript());
     const uint256 blockHashA = blockA.GetHash();
     const CBlockIndex *pindexA = mapBlockIndex[blockHashA];
 
     CBlock blockB = CreateAndProcessBlock({}, CScript());
     const uint256 blockHashB = blockB.GetHash();
     const CBlockIndex *pindexB = mapBlockIndex[blockHashB];
 
     // Querying for random block returns false.
     BOOST_CHECK(!p.isAccepted(pindexA));
     BOOST_CHECK(!p.isAccepted(pindexB));
 
     // Start voting on block A.
     BOOST_CHECK(p.addBlockToReconcile(pindexA));
     auto invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHashA);
 
     uint64_t round = AvalancheTest::getRound(p);
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(p.registerVotes(avanodes[0]->GetId(),
                                 {round, 0, {AvalancheVote(0, blockHashA)}},
                                 updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Start voting on block B after one vote.
     AvalancheResponse resp{
         round + 1,
         0,
         {AvalancheVote(0, blockHashB), AvalancheVote(0, blockHashA)}};
     BOOST_CHECK(p.addBlockToReconcile(pindexB));
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 2);
 
     // Ensure B comes before A because it has accumulated more PoW.
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHashB);
     BOOST_CHECK_EQUAL(invs[1].type, MSG_BLOCK);
     BOOST_CHECK(invs[1].hash == blockHashA);
 
     // Let's vote for these blocks a few times.
     for (int i = 0; i < 4; i++) {
         NodeId nodeid = AvalancheTest::getSuitableNodeToQuery(p);
         AvalancheTest::runEventLoop(p);
         BOOST_CHECK(p.registerVotes(nodeid, next(resp), updates));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Now it is accepted, but we can vote for it numerous times.
     for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         NodeId nodeid = AvalancheTest::getSuitableNodeToQuery(p);
         AvalancheTest::runEventLoop(p);
         BOOST_CHECK(p.registerVotes(nodeid, next(resp), updates));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Running two iterration of the event loop so that vote gets triggered on A
     // and B.
     NodeId firstNodeid = AvalancheTest::getSuitableNodeToQuery(p);
     AvalancheTest::runEventLoop(p);
     NodeId secondNodeid = AvalancheTest::getSuitableNodeToQuery(p);
     AvalancheTest::runEventLoop(p);
 
     BOOST_CHECK(firstNodeid != secondNodeid);
 
     // Next vote will finalize block A.
     BOOST_CHECK(p.registerVotes(firstNodeid, next(resp), updates));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindexA);
     BOOST_CHECK_EQUAL(updates[0].getStatus(),
                       AvalancheBlockUpdate::Status::Finalized);
     updates = {};
 
     // We do not vote on A anymore.
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHashB);
 
     // Next vote will finalize block B.
     BOOST_CHECK(p.registerVotes(secondNodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindexB);
     BOOST_CHECK_EQUAL(updates[0].getStatus(),
                       AvalancheBlockUpdate::Status::Finalized);
     updates = {};
 
     // There is nothing left to vote on.
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 0);
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(poll_and_response) {
     AvalancheProcessor p(g_connman.get());
 
     std::vector<AvalancheBlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash = block.GetHash();
     const CBlockIndex *pindex = mapBlockIndex[blockHash];
 
     const Config &config = GetConfig();
 
     // There is no node to query.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), NO_NODE);
 
     // Create a node that supports avalanche and one that doesn't.
     auto oldnode = ConnectNode(config, NODE_NONE, *peerLogic);
     auto avanode = ConnectNode(config, NODE_AVALANCHE, *peerLogic);
     NodeId avanodeid = avanode->GetId();
     BOOST_CHECK(p.addPeer(avanodeid, 0));
 
     // It returns the avalanche peer.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // Register a block and check it is added to the list of elements to poll.
     BOOST_CHECK(p.addBlockToReconcile(pindex));
     auto invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Trigger a poll on avanode.
     uint64_t round = AvalancheTest::getRound(p);
     AvalancheTest::runEventLoop(p);
 
     // There is no more suitable peer available, so return nothing.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), NO_NODE);
 
     // Respond to the request.
     AvalancheResponse resp = {round, 0, {AvalancheVote(0, blockHash)}};
     BOOST_CHECK(p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Now that avanode fullfilled his request, it is added back to the list of
     // queriable nodes.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // Sending a response when not polled fails.
     BOOST_CHECK(!p.registerVotes(avanodeid, next(resp), updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Trigger a poll on avanode.
     round = AvalancheTest::getRound(p);
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), NO_NODE);
 
     // Sending responses that do not match the request also fails.
     // 1. Too many results.
     resp = {
         round, 0, {AvalancheVote(0, blockHash), AvalancheVote(0, blockHash)}};
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(!p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // 2. Not enough results.
     resp = {AvalancheTest::getRound(p), 0, {}};
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(!p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // 3. Do not match the poll.
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote()}};
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(!p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // 4. Invalid round count. Request is not discarded.
     uint64_t queryRound = AvalancheTest::getRound(p);
     AvalancheTest::runEventLoop(p);
 
     resp = {queryRound + 1, 0, {AvalancheVote()}};
     BOOST_CHECK(!p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {queryRound - 1, 0, {AvalancheVote()}};
     BOOST_CHECK(!p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // 5. Making request for invalid nodes do not work. Request is not
     // discarded.
     resp = {queryRound, 0, {AvalancheVote(0, blockHash)}};
     BOOST_CHECK(!p.registerVotes(avanodeid + 1234, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Proper response gets processed and avanode is available again.
     resp = {queryRound, 0, {AvalancheVote(0, blockHash)}};
     BOOST_CHECK(p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // Out of order response are rejected.
     CBlock block2 = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash2 = block2.GetHash();
     CBlockIndex *pindex2 = mapBlockIndex[blockHash2];
     BOOST_CHECK(p.addBlockToReconcile(pindex2));
 
     resp = {AvalancheTest::getRound(p),
             0,
             {AvalancheVote(0, blockHash), AvalancheVote(0, blockHash2)}};
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(!p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // But they are accepted in order.
     resp = {AvalancheTest::getRound(p),
             0,
             {AvalancheVote(0, blockHash2), AvalancheVote(0, blockHash)}};
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     // When a block is marked invalid, stop polling.
     pindex2->nStatus = pindex2->nStatus.withFailed();
     resp = {AvalancheTest::getRound(p), 0, {AvalancheVote(0, blockHash)}};
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK(p.registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(poll_inflight_timeout) {
     AvalancheProcessor p(g_connman.get());
 
     std::vector<AvalancheBlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash = block.GetHash();
     const CBlockIndex *pindex = mapBlockIndex[blockHash];
 
     // Add the block
     BOOST_CHECK(p.addBlockToReconcile(pindex));
 
     // Create a node that supports avalanche.
     const Config &config = GetConfig();
     auto avanode = ConnectNode(config, NODE_AVALANCHE, *peerLogic);
     NodeId avanodeid = avanode->GetId();
     BOOST_CHECK(p.addPeer(avanodeid, 0));
 
     // Expire requests after some time.
     p.setQueryTimeoutDuration(std::chrono::milliseconds(10));
     for (int i = 0; i < 10; i++) {
         AvalancheResponse resp = {
             AvalancheTest::getRound(p), 0, {AvalancheVote(0, blockHash)}};
         AvalancheTest::runEventLoop(p);
         // NB: This could wait longer than 1ms in some cases and make the
         // test flacky. We'll have to come up with a better solution to test
         // this if that were to be the case. I never was able to trigger this
         // myself, so it's probably good enough.
         boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
         AvalancheTest::runEventLoop(p);
         BOOST_CHECK(p.registerVotes(avanodeid, next(resp), updates));
 
         // Now try again but wait.
         AvalancheTest::runEventLoop(p);
         boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
         AvalancheTest::runEventLoop(p);
         BOOST_CHECK(!p.registerVotes(avanodeid, next(resp), updates));
     }
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(poll_inflight_count) {
     AvalancheProcessor p(g_connman.get());
     const Config &config = GetConfig();
 
     // Create enough nodes so that we run into the inflight request limit.
     std::array<std::unique_ptr<CNode>, AVALANCHE_MAX_INFLIGHT_POLL + 1> nodes;
     for (auto &n : nodes) {
         n = ConnectNode(config, NODE_AVALANCHE, *peerLogic);
         BOOST_CHECK(p.addPeer(n->GetId(), 0));
     }
 
     // Add a block to poll
     CBlock block = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash = block.GetHash();
     const CBlockIndex *pindex = mapBlockIndex[blockHash];
     BOOST_CHECK(p.addBlockToReconcile(pindex));
 
     // Ensure there are enough requests in flight.
     std::map<NodeId, uint64_t> node_round_map;
     for (int i = 0; i < AVALANCHE_MAX_INFLIGHT_POLL; i++) {
         NodeId nodeid = AvalancheTest::getSuitableNodeToQuery(p);
         BOOST_CHECK(node_round_map.find(nodeid) == node_round_map.end());
         node_round_map[nodeid] = AvalancheTest::getRound(p);
         auto invs = AvalancheTest::getInvsForNextPoll(p);
         BOOST_CHECK_EQUAL(invs.size(), 1);
         BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
         BOOST_CHECK(invs[0].hash == blockHash);
         AvalancheTest::runEventLoop(p);
     }
 
     // Now that we have enough in flight requests, we shouldn't poll.
     auto suitablenodeid = AvalancheTest::getSuitableNodeToQuery(p);
     BOOST_CHECK(suitablenodeid != NO_NODE);
     auto invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 0);
     AvalancheTest::runEventLoop(p);
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), suitablenodeid);
 
     std::vector<AvalancheBlockUpdate> updates;
 
     // Send one response, now we can poll again.
     auto it = node_round_map.begin();
     AvalancheResponse resp = {it->second, 0, {AvalancheVote(0, blockHash)}};
     BOOST_CHECK(p.registerVotes(it->first, resp, updates));
     node_round_map.erase(it);
 
     invs = AvalancheTest::getInvsForNextPoll(p);
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(quorum_diversity) {
     AvalancheProcessor p(g_connman.get());
     std::vector<AvalancheBlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash = block.GetHash();
     const CBlockIndex *pindex = mapBlockIndex[blockHash];
 
     const Config &config = GetConfig();
 
     // Create nodes that supports avalanche.
     auto avanodes = ConnectNodes(config, p, NODE_AVALANCHE, *peerLogic);
 
     // Querying for random block returns false.
     BOOST_CHECK(!p.isAccepted(pindex));
 
     // Add a new block. Check it is added to the polls.
     BOOST_CHECK(p.addBlockToReconcile(pindex));
 
     // Do one valid round of voting.
     uint64_t round = AvalancheTest::getRound(p);
     AvalancheResponse resp{round, 0, {AvalancheVote(0, blockHash)}};
 
     // Check that all nodes can vote.
     for (size_t i = 0; i < avanodes.size(); i++) {
         AvalancheTest::runEventLoop(p);
         BOOST_CHECK(p.registerVotes(avanodes[i]->GetId(), next(resp), updates));
     }
 
     // Generate a query for every single node.
     const NodeId firstNodeId = AvalancheTest::getSuitableNodeToQuery(p);
     std::map<NodeId, uint64_t> node_round_map;
     round = AvalancheTest::getRound(p);
     for (size_t i = 0; i < avanodes.size(); i++) {
         NodeId nodeid = AvalancheTest::getSuitableNodeToQuery(p);
         BOOST_CHECK(node_round_map.find(nodeid) == node_round_map.end());
         node_round_map[nodeid] = AvalancheTest::getRound(p);
         AvalancheTest::runEventLoop(p);
     }
 
     // Now only tge first node can vote. All others would be duplicate in the
     // quorum.
     auto confidence = p.getConfidence(pindex);
     BOOST_REQUIRE(confidence > 0);
 
     for (auto &pair : node_round_map) {
         NodeId nodeid = pair.first;
         uint64_t r = pair.second;
 
         if (nodeid == firstNodeId) {
             // Node 0 is the only one which can vote at this stage.
             round = r;
             continue;
         }
 
         BOOST_CHECK(p.registerVotes(
             nodeid, {r, 0, {AvalancheVote(0, blockHash)}}, updates));
         BOOST_CHECK_EQUAL(p.getConfidence(pindex), confidence);
     }
 
     BOOST_CHECK(p.registerVotes(
         firstNodeId, {round, 0, {AvalancheVote(0, blockHash)}}, updates));
     BOOST_CHECK_EQUAL(p.getConfidence(pindex), confidence + 1);
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(event_loop) {
     AvalancheProcessor p(g_connman.get());
     CScheduler s;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const uint256 blockHash = block.GetHash();
     const CBlockIndex *pindex = mapBlockIndex[blockHash];
 
     // Starting the event loop.
     BOOST_CHECK(p.startEventLoop(s));
 
     // There is one task planned in the next hour (our event loop).
     boost::chrono::system_clock::time_point start, stop;
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 1);
 
     // Starting twice doesn't start it twice.
     BOOST_CHECK(!p.startEventLoop(s));
 
     // Start the scheduler thread.
     std::thread schedulerThread(std::bind(&CScheduler::serviceQueue, &s));
 
     // Create a node and a block to query.
     const Config &config = GetConfig();
 
     // Create a node that supports avalanche.
     auto avanode = ConnectNode(config, NODE_AVALANCHE, *peerLogic);
     NodeId nodeid = avanode->GetId();
     BOOST_CHECK(p.addPeer(nodeid, 0));
 
     // There is no query in flight at the moment.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), nodeid);
 
     // Add a new block. Check it is added to the polls.
     uint64_t queryRound = AvalancheTest::getRound(p);
     BOOST_CHECK(p.addBlockToReconcile(pindex));
 
     for (int i = 0; i < 1000; i++) {
         // Technically, this is a race condition, but this should do just fine
         // as we wait up to 1s for an event that should take 10ms.
         boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
         if (AvalancheTest::getRound(p) != queryRound) {
             break;
         }
     }
 
     // Check that we effectively got a request and not timed out.
     BOOST_CHECK(AvalancheTest::getRound(p) > queryRound);
 
     // Respond and check the cooldown time is respected.
     uint64_t responseRound = AvalancheTest::getRound(p);
     auto queryTime =
         std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
 
     std::vector<AvalancheBlockUpdate> updates;
     p.registerVotes(nodeid, {queryRound, 100, {AvalancheVote(0, blockHash)}},
                     updates);
     for (int i = 0; i < 1000; i++) {
         // We make sure that we do not get a request before queryTime.
         boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
         if (AvalancheTest::getRound(p) != responseRound) {
             BOOST_CHECK(std::chrono::steady_clock::now() > queryTime);
             break;
         }
     }
 
     // But we eventually get one.
     BOOST_CHECK(AvalancheTest::getRound(p) > responseRound);
 
     // Stop event loop.
     BOOST_CHECK(p.stopEventLoop());
 
     // We don't have any task scheduled anymore.
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 0);
 
     // Can't stop the event loop twice.
     BOOST_CHECK(!p.stopEventLoop());
 
     // Wait for the scheduler to stop.
     s.stop(true);
     schedulerThread.join();
 
     CConnmanTest::ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(destructor) {
     CScheduler s;
     boost::chrono::system_clock::time_point start, stop;
 
     // Start the scheduler thread.
     std::thread schedulerThread(std::bind(&CScheduler::serviceQueue, &s));
 
     {
         AvalancheProcessor p(g_connman.get());
         BOOST_CHECK(p.startEventLoop(s));
         BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 1);
     }
 
     // Now that avalanche is destroyed, there is no more scheduled tasks.
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 0);
 
     // Wait for the scheduler to stop.
     s.stop(true);
     schedulerThread.join();
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/base32_tests.cpp b/src/test/base32_tests.cpp
index 17bdab41c..2666ccd36 100644
--- a/src/test/base32_tests.cpp
+++ b/src/test/base32_tests.cpp
@@ -1,26 +1,27 @@
 // Copyright (c) 2012-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "test/test_bitcoin.h"
-#include "utilstrencodings.h"
+#include <utilstrencodings.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(base32_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(base32_testvectors) {
     static const std::string vstrIn[] = {"",     "f",     "fo",    "foo",
                                          "foob", "fooba", "foobar"};
     static const std::string vstrOut[] = {
         "",         "my======", "mzxq====",        "mzxw6===",
         "mzxw6yq=", "mzxw6ytb", "mzxw6ytboi======"};
     for (unsigned int i = 0; i < sizeof(vstrIn) / sizeof(vstrIn[0]); i++) {
         std::string strEnc = EncodeBase32(vstrIn[i]);
         BOOST_CHECK(strEnc == vstrOut[i]);
         std::string strDec = DecodeBase32(vstrOut[i]);
         BOOST_CHECK(strDec == vstrIn[i]);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp
index d1f18536b..68d90f607 100644
--- a/src/test/base58_tests.cpp
+++ b/src/test/base58_tests.cpp
@@ -1,277 +1,277 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "base58.h"
+#include <base58.h>
 
-#include "data/base58_encode_decode.json.h"
-#include "data/base58_keys_invalid.json.h"
-#include "data/base58_keys_valid.json.h"
+#include <data/base58_encode_decode.json.h>
+#include <data/base58_keys_invalid.json.h>
+#include <data/base58_keys_valid.json.h>
+#include <key.h>
+#include <script/script.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
 
-#include "key.h"
-#include "script/script.h"
-#include "test/jsonutil.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <test/jsonutil.h>
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 BOOST_FIXTURE_TEST_SUITE(base58_tests, BasicTestingSetup)
 
 // Goal: test low-level base58 encoding functionality
 BOOST_AUTO_TEST_CASE(base58_EncodeBase58) {
     UniValue tests =
         read_json(std::string(json_tests::base58_encode_decode,
                               json_tests::base58_encode_decode +
                                   sizeof(json_tests::base58_encode_decode)));
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 2) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::vector<uint8_t> sourcedata = ParseHex(test[0].get_str());
         std::string base58string = test[1].get_str();
         BOOST_CHECK_MESSAGE(
             EncodeBase58(sourcedata.data(),
                          sourcedata.data() + sourcedata.size()) == base58string,
             strTest);
     }
 }
 
 // Goal: test low-level base58 decoding functionality
 BOOST_AUTO_TEST_CASE(base58_DecodeBase58) {
     UniValue tests =
         read_json(std::string(json_tests::base58_encode_decode,
                               json_tests::base58_encode_decode +
                                   sizeof(json_tests::base58_encode_decode)));
     std::vector<uint8_t> result;
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 2) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::vector<uint8_t> expected = ParseHex(test[0].get_str());
         std::string base58string = test[1].get_str();
         BOOST_CHECK_MESSAGE(DecodeBase58(base58string, result), strTest);
         BOOST_CHECK_MESSAGE(
             result.size() == expected.size() &&
                 std::equal(result.begin(), result.end(), expected.begin()),
             strTest);
     }
 
     BOOST_CHECK(!DecodeBase58("invalid", result));
 
     // check that DecodeBase58 skips whitespace, but still fails with unexpected
     // non-whitespace at the end.
     BOOST_CHECK(!DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t a", result));
     BOOST_CHECK(DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t ", result));
     std::vector<uint8_t> expected = ParseHex("971a55");
     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
                                   expected.begin(), expected.end());
 }
 
 // Visitor to check address type
 class TestAddrTypeVisitor : public boost::static_visitor<bool> {
 private:
     std::string exp_addrType;
 
 public:
     explicit TestAddrTypeVisitor(const std::string &_exp_addrType)
         : exp_addrType(_exp_addrType) {}
     bool operator()(const CKeyID &id) const {
         return (exp_addrType == "pubkey");
     }
     bool operator()(const CScriptID &id) const {
         return (exp_addrType == "script");
     }
     bool operator()(const CNoDestination &no) const {
         return (exp_addrType == "none");
     }
 };
 
 // Visitor to check address payload
 class TestPayloadVisitor : public boost::static_visitor<bool> {
 private:
     std::vector<uint8_t> exp_payload;
 
 public:
     explicit TestPayloadVisitor(std::vector<uint8_t> &_exp_payload)
         : exp_payload(_exp_payload) {}
     bool operator()(const CKeyID &id) const {
         uint160 exp_key(exp_payload);
         return exp_key == id;
     }
     bool operator()(const CScriptID &id) const {
         uint160 exp_key(exp_payload);
         return exp_key == id;
     }
     bool operator()(const CNoDestination &no) const {
         return exp_payload.size() == 0;
     }
 };
 
 // Goal: check that parsed keys match test payload
 BOOST_AUTO_TEST_CASE(base58_keys_valid_parse) {
     UniValue tests = read_json(std::string(
         json_tests::base58_keys_valid,
         json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
     CBitcoinSecret secret;
     CTxDestination destination;
     SelectParams(CBaseChainParams::MAIN);
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 3) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::string exp_base58string = test[0].get_str();
         std::vector<uint8_t> exp_payload = ParseHex(test[1].get_str());
         const UniValue &metadata = test[2].get_obj();
         bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
         bool isTestnet = find_value(metadata, "isTestnet").get_bool();
         if (isTestnet)
             SelectParams(CBaseChainParams::TESTNET);
         else
             SelectParams(CBaseChainParams::MAIN);
         if (isPrivkey) {
             bool isCompressed = find_value(metadata, "isCompressed").get_bool();
             // Must be valid private key
             BOOST_CHECK_MESSAGE(secret.SetString(exp_base58string),
                                 "!SetString:" + strTest);
             BOOST_CHECK_MESSAGE(secret.IsValid(), "!IsValid:" + strTest);
             CKey privkey = secret.GetKey();
             BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed,
                                 "compressed mismatch:" + strTest);
             BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() &&
                                     std::equal(privkey.begin(), privkey.end(),
                                                exp_payload.begin()),
                                 "key mismatch:" + strTest);
 
             // Private key must be invalid public key
             destination = DecodeLegacyAddr(exp_base58string, Params());
             BOOST_CHECK_MESSAGE(!IsValidDestination(destination),
                                 "IsValid privkey as pubkey:" + strTest);
         } else {
             // "script" or "pubkey"
             std::string exp_addrType =
                 find_value(metadata, "addrType").get_str();
             // Must be valid public key
             destination = DecodeLegacyAddr(exp_base58string, Params());
             BOOST_CHECK_MESSAGE(IsValidDestination(destination),
                                 "!IsValid:" + strTest);
             BOOST_CHECK_MESSAGE((boost::get<CScriptID>(&destination) !=
                                  nullptr) == (exp_addrType == "script"),
                                 "isScript mismatch" + strTest);
             BOOST_CHECK_MESSAGE(
                 boost::apply_visitor(TestAddrTypeVisitor(exp_addrType),
                                      destination),
                 "addrType mismatch" + strTest);
 
             // Public key must be invalid private key
             secret.SetString(exp_base58string);
             BOOST_CHECK_MESSAGE(!secret.IsValid(),
                                 "IsValid pubkey as privkey:" + strTest);
         }
     }
 }
 
 // Goal: check that generated keys match test vectors
 BOOST_AUTO_TEST_CASE(base58_keys_valid_gen) {
     UniValue tests = read_json(std::string(
         json_tests::base58_keys_valid,
         json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 3) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::string exp_base58string = test[0].get_str();
         std::vector<uint8_t> exp_payload = ParseHex(test[1].get_str());
         const UniValue &metadata = test[2].get_obj();
         bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
         bool isTestnet = find_value(metadata, "isTestnet").get_bool();
         if (isTestnet)
             SelectParams(CBaseChainParams::TESTNET);
         else
             SelectParams(CBaseChainParams::MAIN);
         if (isPrivkey) {
             bool isCompressed = find_value(metadata, "isCompressed").get_bool();
             CKey key;
             key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
             assert(key.IsValid());
             CBitcoinSecret secret;
             secret.SetKey(key);
             BOOST_CHECK_MESSAGE(secret.ToString() == exp_base58string,
                                 "result mismatch: " + strTest);
         } else {
             std::string exp_addrType =
                 find_value(metadata, "addrType").get_str();
             CTxDestination dest;
             if (exp_addrType == "pubkey") {
                 dest = CKeyID(uint160(exp_payload));
             } else if (exp_addrType == "script") {
                 dest = CScriptID(uint160(exp_payload));
             } else if (exp_addrType == "none") {
                 dest = CNoDestination();
             } else {
                 BOOST_ERROR("Bad addrtype: " << strTest);
                 continue;
             }
             std::string address = EncodeLegacyAddr(dest, Params());
             BOOST_CHECK_MESSAGE(address == exp_base58string,
                                 "mismatch: " + strTest);
         }
     }
 
     SelectParams(CBaseChainParams::MAIN);
 }
 
 // Goal: check that base58 parsing code is robust against a variety of corrupted
 // data
 BOOST_AUTO_TEST_CASE(base58_keys_invalid) {
     // Negative testcases
     UniValue tests =
         read_json(std::string(json_tests::base58_keys_invalid,
                               json_tests::base58_keys_invalid +
                                   sizeof(json_tests::base58_keys_invalid)));
     CBitcoinSecret secret;
     CTxDestination destination;
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 1) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::string exp_base58string = test[0].get_str();
 
         // must be invalid as public and as private key
         destination = DecodeLegacyAddr(exp_base58string, Params());
         BOOST_CHECK_MESSAGE(!IsValidDestination(destination),
                             "IsValid pubkey:" + strTest);
         secret.SetString(exp_base58string);
         BOOST_CHECK_MESSAGE(!secret.IsValid(), "IsValid privkey:" + strTest);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/base64_tests.cpp b/src/test/base64_tests.cpp
index f4e915a85..2850ce37e 100644
--- a/src/test/base64_tests.cpp
+++ b/src/test/base64_tests.cpp
@@ -1,25 +1,26 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "test/test_bitcoin.h"
-#include "utilstrencodings.h"
+#include <utilstrencodings.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(base64_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(base64_testvectors) {
     static const std::string vstrIn[] = {"",     "f",     "fo",    "foo",
                                          "foob", "fooba", "foobar"};
     static const std::string vstrOut[] = {
         "", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"};
     for (unsigned int i = 0; i < sizeof(vstrIn) / sizeof(vstrIn[0]); i++) {
         std::string strEnc = EncodeBase64(vstrIn[i]);
         BOOST_CHECK(strEnc == vstrOut[i]);
         std::string strDec = DecodeBase64(strEnc);
         BOOST_CHECK(strDec == vstrIn[i]);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/bip32_tests.cpp b/src/test/bip32_tests.cpp
index 5d628bda4..8a3587352 100644
--- a/src/test/bip32_tests.cpp
+++ b/src/test/bip32_tests.cpp
@@ -1,307 +1,308 @@
 // Copyright (c) 2013-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <boost/test/unit_test.hpp>
+#include <base58.h>
+#include <key.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
+
+#include <test/test_bitcoin.h>
 
-#include "base58.h"
-#include "key.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <boost/test/unit_test.hpp>
 
 #include <string>
 #include <vector>
 
 struct TestDerivation {
     std::string pub;
     std::string prv;
     unsigned int nChild;
 };
 
 struct TestVector {
     std::string strHexMaster;
     std::vector<TestDerivation> vDerive;
 
     explicit TestVector(std::string strHexMasterIn)
         : strHexMaster(strHexMasterIn) {}
 
     TestVector &operator()(std::string pub, std::string prv,
                            unsigned int nChild) {
         vDerive.push_back(TestDerivation());
         TestDerivation &der = vDerive.back();
         der.pub = pub;
         der.prv = prv;
         der.nChild = nChild;
         return *this;
     }
 };
 
 // clang-format off
 TestVector test1 =
   TestVector("000102030405060708090a0b0c0d0e0f")
     ("xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
      "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
      0x80000000)
     ("xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw",
      "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
      1)
     ("xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ",
      "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
      0x80000002)
     ("xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5",
      "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
      2)
     ("xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV",
      "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
      1000000000)
     ("xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy",
      "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
      0);
 
 TestVector test2 =
   TestVector("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542")
     ("xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB",
      "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
      0)
     ("xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH",
      "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
      0xFFFFFFFF)
     ("xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a",
      "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
      1)
     ("xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon",
      "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
      0xFFFFFFFE)
     ("xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL",
      "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
      2)
     ("xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt",
      "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
      0);
 
 TestVector test3 =
   TestVector("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be")
     ("xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13",
      "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
       0x80000000)
     ("xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y",
      "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
       0);
 // clang-format on
 
 void RunTest(const TestVector &test) {
     std::vector<uint8_t> seed = ParseHex(test.strHexMaster);
     CExtKey key;
     CExtPubKey pubkey;
     key.SetMaster(&seed[0], seed.size());
     pubkey = key.Neuter();
     for (const TestDerivation &derive : test.vDerive) {
         uint8_t data[74];
         key.Encode(data);
         pubkey.Encode(data);
 
         // Test private key
         CBitcoinExtKey b58key;
         b58key.SetKey(key);
         BOOST_CHECK(b58key.ToString() == derive.prv);
 
         CBitcoinExtKey b58keyDecodeCheck(derive.prv);
         CExtKey checkKey = b58keyDecodeCheck.GetKey();
         // ensure a base58 decoded key also matches
         assert(checkKey == key);
 
         // Test public key
         CBitcoinExtPubKey b58pubkey;
         b58pubkey.SetKey(pubkey);
         BOOST_CHECK(b58pubkey.ToString() == derive.pub);
 
         CBitcoinExtPubKey b58PubkeyDecodeCheck(derive.pub);
         CExtPubKey checkPubKey = b58PubkeyDecodeCheck.GetKey();
         // ensure a base58 decoded pubkey also matches
         assert(checkPubKey == pubkey);
 
         // Derive new keys
         CExtKey keyNew;
         BOOST_CHECK(key.Derive(keyNew, derive.nChild));
         CExtPubKey pubkeyNew = keyNew.Neuter();
         if (!(derive.nChild & 0x80000000)) {
             // Compare with public derivation
             CExtPubKey pubkeyNew2;
             BOOST_CHECK(pubkey.Derive(pubkeyNew2, derive.nChild));
             BOOST_CHECK(pubkeyNew == pubkeyNew2);
         }
         key = keyNew;
         pubkey = pubkeyNew;
 
         CDataStream ssPub(SER_DISK, CLIENT_VERSION);
         ssPub << pubkeyNew;
         BOOST_CHECK(ssPub.size() == 75);
 
         CDataStream ssPriv(SER_DISK, CLIENT_VERSION);
         ssPriv << keyNew;
         BOOST_CHECK(ssPriv.size() == 75);
 
         CExtPubKey pubCheck;
         CExtKey privCheck;
         ssPub >> pubCheck;
         ssPriv >> privCheck;
 
         BOOST_CHECK(pubCheck == pubkeyNew);
         BOOST_CHECK(privCheck == keyNew);
     }
 }
 
 BOOST_FIXTURE_TEST_SUITE(bip32_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(bip32_test1) {
     RunTest(test1);
 }
 
 BOOST_AUTO_TEST_CASE(bip32_test2) {
     RunTest(test2);
 }
 
 BOOST_AUTO_TEST_CASE(bip32_test3) {
     RunTest(test3);
 }
 
 bool check_key_size_message(const std::runtime_error &e) {
     BOOST_CHECK_EQUAL(e.what(), "Invalid extended key size\n");
     return true;
 }
 
 BOOST_AUTO_TEST_CASE(bip32_serialization) {
     std::vector<std::string> pubkeys{
         "013442193e8000000047fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad1628"
         "2c7ae6236141035a784662a4a20a65bf6aab9ae98a6c068a81c52e4b032c0fb5400c70"
         "6cfccc56",
         "025c1bd648000000012a7857631386ba23dacac34180dd1983734e444fdbf774041578"
         "e9b6adb37c1903501e454bf00751f24b1b489aa925215d66af2234e3891c3b21a52bed"
         "b3cd711c",
         "03bef5a2f98000000204466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3"
         "ff6ec7b1503f0357bfe1e341d01c69fe5654309956cbea516822fba8a601743a012a78"
         "96ee8dc2",
         "04ee7ab90c00000002cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac12"
         "75ac822a3edd02e8445082a72f29b75ca48748a914df60622a609cacfce8ed0e358045"
         "60741d29",
         "05d880d7d83b9aca00c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548"
         "a8b078e65e9e022a471424da5e657499d1ff51cb43c47481a03b1e77f951fe64cec9f5"
         "a48f7011",
         "06d69aa10200000000739379b40b549fdb7f2439c028dac3192d4706deec3f0fef6816"
         "ea36c8fc3fda028817473b2e81a20b60a24fc7a0d7869368ebc36740cfe08a18a19a9d"
         "dafae67c",
         "01bd16bee500000000f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7"
         "412f232f7c9c02fc9e5af0ac8d9b3cecfe2a888e2117ba3d089d8585886c9c826b6b22"
         "a98d12ea",
         "025a61ff8effffffffbe17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b3854"
         "7f585c9a37d903c01e7425647bdefa82b12d9bad5e3e6865bee0502694b94ca58b666a"
         "bc0a5c3b",
         "03d8ab493700000001f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c92"
         "7eb246fb38cb03a7d1d856deb74c508e05031f9895dab54626251b3806e16b4bd12e78"
         "1a7df5b9",
         "0478412e3afffffffe637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06"
         "cc29a65a0e2902d2b36900396c9282fa14628566582f206a5dd0bcc8d5e892611806ca"
         "fb0301f0",
         "0531a507b8000000029452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58"
         "eedf394ed271024d902e1a2fc7a8755ab5b694c575fce742c48d9ff192e63df5193e4c"
         "7afe1f9c",
         "0626132fdb0000000005bcc50a4c1bbfa6d982ae1f410f88ddcbacad781b11b8790c86"
         "f49cdf9e77b0031c0517fff3d483f06ca769bd2326bf30aca1c4de278e676e6ef760c3"
         "301244c6",
         "0141d63b5080000000e5fea12a97b927fc9dc3d2cb0d1ea1cf50aa5a1fdc1f933e8906"
         "bb38df3377bd026557fdda1d5d43d79611f784780471f086d58e8126b8c40acb82272a"
         "7712e7f2",
         "02c61368bb000000007c63ec0429a7324b76014ad222a32b7fdd3ae8755d0d2b2e3dfb"
         "5ede9787af990379e45b3cf75f9c5f9befd8e9506fb962f6a9d185ac87001ec44a8d3d"
         "f8d4a9e3",
     };
 
     for (const std::string &hex : pubkeys) {
         CDataStream ss(SER_DISK, CLIENT_VERSION);
         ss << ParseHex(hex);
         BOOST_CHECK(ss.size() == 75);
 
         CExtPubKey pubkey;
         BOOST_CHECK_NO_THROW(ss >> pubkey);
 
         ss << ParseHex(hex + "00");
         BOOST_CHECK(ss.size() == 76);
         BOOST_CHECK_EXCEPTION(ss >> pubkey, std::runtime_error,
                               check_key_size_message);
 
         ss.clear();
         ss << ParseHex(hex.substr(0, hex.size() - 1));
         BOOST_CHECK(ss.size() == 74);
         BOOST_CHECK_EXCEPTION(ss >> pubkey, std::runtime_error,
                               check_key_size_message);
     }
 
     std::vector<std::string> privkeys{
         "013442193e8000000047fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad1628"
         "2c7ae623614100edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d9"
         "11a0afea",
         "025c1bd648000000012a7857631386ba23dacac34180dd1983734e444fdbf774041578"
         "e9b6adb37c19003c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de931"
         "9dc93368",
         "03bef5a2f98000000204466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3"
         "ff6ec7b1503f00cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59"
         "fa424dca",
         "04ee7ab90c00000002cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac12"
         "75ac822a3edd000f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a"
         "2a764ef4",
         "05d880d7d83b9aca00c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548"
         "a8b078e65e9e00471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6"
         "c3e6e7c8",
         "06d69aa10200000000739379b40b549fdb7f2439c028dac3192d4706deec3f0fef6816"
         "ea36c8fc3fda00996cbe292e59ce1c8ee257522ce969b9faa413f7e9aa4a8785b8f574"
         "e0e2f061",
         "01bd16bee500000000f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7"
         "412f232f7c9c00abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f"
         "15ac7e1e",
         "025a61ff8effffffffbe17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b3854"
         "7f585c9a37d900877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18f"
         "d52e6e93",
         "03d8ab493700000001f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c92"
         "7eb246fb38cb00704addf544a06e5ee4bea37098463c23613da32020d604506da8c051"
         "8e1da4b7",
         "0478412e3afffffffe637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06"
         "cc29a65a0e2900f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b"
         "247d6a2d",
         "0531a507b8000000029452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58"
         "eedf394ed27100bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a484"
         "2125ac23",
         "0626132fdb0000000005bcc50a4c1bbfa6d982ae1f410f88ddcbacad781b11b8790c86"
         "f49cdf9e77b0004b7e8b1aa263519f7fbed001d5b0c4a5fdac81db8abe14c327e2f534"
         "92e55fa7",
         "0141d63b5080000000e5fea12a97b927fc9dc3d2cb0d1ea1cf50aa5a1fdc1f933e8906"
         "bb38df3377bd00491f7a2eebc7b57028e0d3faa0acda02e75c33b03c48fb288c41e2ea"
         "44e1daef",
         "02c61368bb000000007c63ec0429a7324b76014ad222a32b7fdd3ae8755d0d2b2e3dfb"
         "5ede9787af9900129ee831061c31be7d636fc0402fd2299855f40015a2c60b2e5755c5"
         "7270460d",
     };
 
     for (const std::string &hex : privkeys) {
         CDataStream ss(SER_DISK, CLIENT_VERSION);
         ss << ParseHex(hex);
         BOOST_CHECK(ss.size() == 75);
 
         CExtKey privkey;
         BOOST_CHECK_NO_THROW(ss >> privkey);
 
         ss << ParseHex(hex + "00");
         BOOST_CHECK(ss.size() == 76);
         BOOST_CHECK_EXCEPTION(ss >> privkey, std::runtime_error,
                               check_key_size_message);
 
         ss.clear();
         ss << ParseHex(hex.substr(0, hex.size() - 1));
         BOOST_CHECK(ss.size() == 74);
         BOOST_CHECK_EXCEPTION(ss >> privkey, std::runtime_error,
                               check_key_size_message);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockcheck_tests.cpp b/src/test/blockcheck_tests.cpp
index e333c20a6..1ee9e69a4 100644
--- a/src/test/blockcheck_tests.cpp
+++ b/src/test/blockcheck_tests.cpp
@@ -1,99 +1,99 @@
 // Copyright (c) 2013-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "chainparams.h"
-#include "config.h"
-#include "consensus/consensus.h"
-#include "consensus/validation.h"
-#include "validation.h"
+#include <chainparams.h>
+#include <config.h>
+#include <consensus/consensus.h>
+#include <consensus/validation.h>
+#include <validation.h>
 
-#include "test/test_bitcoin.h"
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(blockcheck_tests, BasicTestingSetup)
 
 static void RunCheckOnBlockImpl(const GlobalConfig &config, const CBlock &block,
                                 CValidationState &state, bool expected) {
     block.fChecked = false;
     BlockValidationOptions validationOptions =
         BlockValidationOptions(false, false);
     bool fValid = CheckBlock(config, block, state, validationOptions);
 
     BOOST_CHECK_EQUAL(fValid, expected);
     BOOST_CHECK_EQUAL(fValid, state.IsValid());
 }
 
 static void RunCheckOnBlock(const GlobalConfig &config, const CBlock &block) {
     CValidationState state;
     RunCheckOnBlockImpl(config, block, state, true);
 }
 
 static void RunCheckOnBlock(const GlobalConfig &config, const CBlock &block,
                             const std::string &reason) {
     CValidationState state;
     RunCheckOnBlockImpl(config, block, state, false);
 
     BOOST_CHECK_EQUAL(state.GetRejectCode(), REJECT_INVALID);
     BOOST_CHECK_EQUAL(state.GetRejectReason(), reason);
 }
 
 BOOST_AUTO_TEST_CASE(blockfail) {
     SelectParams(CBaseChainParams::MAIN);
 
     // Set max blocksize to default in case other tests left it dirty
     GlobalConfig config;
     config.SetMaxBlockSize(DEFAULT_MAX_BLOCK_SIZE);
 
     CBlock block;
     RunCheckOnBlock(config, block, "bad-cb-missing");
 
     CMutableTransaction tx;
 
     // Coinbase only.
     tx.vin.resize(1);
     tx.vin[0].scriptSig.resize(10);
     tx.vout.resize(1);
     tx.vout[0].nValue = 42 * SATOSHI;
     auto coinbaseTx = CTransaction(tx);
 
     block.vtx.resize(1);
     block.vtx[0] = MakeTransactionRef(tx);
     RunCheckOnBlock(config, block);
 
     // No coinbase
     tx.vin[0].prevout = COutPoint(InsecureRand256(), 0);
     block.vtx[0] = MakeTransactionRef(tx);
 
     RunCheckOnBlock(config, block, "bad-cb-missing");
 
     // Invalid coinbase
     tx = CMutableTransaction(coinbaseTx);
     tx.vin[0].scriptSig.resize(0);
     block.vtx[0] = MakeTransactionRef(tx);
 
     RunCheckOnBlock(config, block, "bad-cb-length");
 
     // Oversize block.
     tx = CMutableTransaction(coinbaseTx);
     block.vtx[0] = MakeTransactionRef(tx);
     auto txSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
     auto maxTxCount = ((DEFAULT_MAX_BLOCK_SIZE - 1) / txSize) - 1;
 
     for (size_t i = 1; i < maxTxCount; i++) {
         tx.vin[0].prevout = COutPoint(InsecureRand256(), 0);
         block.vtx.push_back(MakeTransactionRef(tx));
     }
 
     // Check that at this point, we still accept the block.
     RunCheckOnBlock(config, block);
 
     // But reject it with one more transaction as it goes over the maximum
     // allowed block size.
     tx.vin[0].prevout = COutPoint(InsecureRand256(), 0);
     block.vtx.push_back(MakeTransactionRef(tx));
     RunCheckOnBlock(config, block, "bad-blk-length");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockencodings_tests.cpp b/src/test/blockencodings_tests.cpp
index 90faa4299..127bf0516 100644
--- a/src/test/blockencodings_tests.cpp
+++ b/src/test/blockencodings_tests.cpp
@@ -1,391 +1,392 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "blockencodings.h"
-#include "chainparams.h"
-#include "config.h"
-#include "consensus/merkle.h"
-#include "random.h"
+#include <blockencodings.h>
 
-#include "test/test_bitcoin.h"
+#include <chainparams.h>
+#include <config.h>
+#include <consensus/merkle.h>
+#include <random.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 std::vector<std::pair<uint256, CTransactionRef>> extra_txn;
 
 struct RegtestingSetup : public TestingSetup {
     RegtestingSetup() : TestingSetup(CBaseChainParams::REGTEST) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(blockencodings_tests, RegtestingSetup)
 
 static CBlock BuildBlockTestCase() {
     CBlock block;
     CMutableTransaction tx;
     tx.vin.resize(1);
     tx.vin[0].scriptSig.resize(10);
     tx.vout.resize(1);
     tx.vout[0].nValue = 42 * SATOSHI;
 
     block.vtx.resize(3);
     block.vtx[0] = MakeTransactionRef(tx);
     block.nVersion = 42;
     block.hashPrevBlock = InsecureRand256();
     block.nBits = 0x207fffff;
 
     tx.vin[0].prevout = COutPoint(InsecureRand256(), 0);
     block.vtx[1] = MakeTransactionRef(tx);
 
     tx.vin.resize(10);
     for (size_t i = 0; i < tx.vin.size(); i++) {
         tx.vin[i].prevout = COutPoint(InsecureRand256(), 0);
     }
     block.vtx[2] = MakeTransactionRef(tx);
 
     bool mutated;
     block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
     assert(!mutated);
 
     GlobalConfig config;
     while (!CheckProofOfWork(block.GetHash(), block.nBits, config)) {
         ++block.nNonce;
     }
 
     return block;
 }
 
 // Number of shared use_counts we expect for a tx we havent touched
 // == 2 (mempool + our copy from the GetSharedTx call)
 #define SHARED_TX_OFFSET 2
 
 BOOST_AUTO_TEST_CASE(SimpleRoundTripTest) {
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
     CBlock block(BuildBlockTestCase());
 
     pool.addUnchecked(block.vtx[2]->GetId(), entry.FromTx(*block.vtx[2]));
     LOCK(pool.cs);
     BOOST_CHECK_EQUAL(
         pool.mapTx.find(block.vtx[2]->GetId())->GetSharedTx().use_count(),
         SHARED_TX_OFFSET + 0);
 
     // Do a simple ShortTxIDs RT
     {
         CBlockHeaderAndShortTxIDs shortIDs(block);
 
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << shortIDs;
 
         CBlockHeaderAndShortTxIDs shortIDs2;
         stream >> shortIDs2;
 
         PartiallyDownloadedBlock partialBlock(GetConfig(), &pool);
         BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) ==
                     READ_STATUS_OK);
         BOOST_CHECK(partialBlock.IsTxAvailable(0));
         BOOST_CHECK(!partialBlock.IsTxAvailable(1));
         BOOST_CHECK(partialBlock.IsTxAvailable(2));
 
         BOOST_CHECK_EQUAL(
             pool.mapTx.find(block.vtx[2]->GetId())->GetSharedTx().use_count(),
             SHARED_TX_OFFSET + 1);
 
         size_t poolSize = pool.size();
         pool.removeRecursive(*block.vtx[2]);
         BOOST_CHECK_EQUAL(pool.size(), poolSize - 1);
 
         CBlock block2;
         {
             // No transactions.
             PartiallyDownloadedBlock tmp = partialBlock;
             BOOST_CHECK(partialBlock.FillBlock(block2, {}) ==
                         READ_STATUS_INVALID);
             partialBlock = tmp;
         }
 
         // Wrong transaction
         {
             // Current implementation doesn't check txn here, but don't require
             // that.
             PartiallyDownloadedBlock tmp = partialBlock;
             partialBlock.FillBlock(block2, {block.vtx[2]});
             partialBlock = tmp;
         }
         bool mutated;
         BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));
 
         CBlock block3;
         BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[1]}) ==
                     READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(),
                           block3.GetHash().ToString());
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(),
                           BlockMerkleRoot(block3, &mutated).ToString());
         BOOST_CHECK(!mutated);
     }
 }
 
 class TestHeaderAndShortIDs {
     // Utility to encode custom CBlockHeaderAndShortTxIDs
 public:
     CBlockHeader header;
     uint64_t nonce;
     std::vector<uint64_t> shorttxids;
     std::vector<PrefilledTransaction> prefilledtxn;
 
     explicit TestHeaderAndShortIDs(const CBlockHeaderAndShortTxIDs &orig) {
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << orig;
         stream >> *this;
     }
     explicit TestHeaderAndShortIDs(const CBlock &block)
         : TestHeaderAndShortIDs(CBlockHeaderAndShortTxIDs(block)) {}
 
     uint64_t GetShortID(const uint256 &txhash) const {
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << *this;
         CBlockHeaderAndShortTxIDs base;
         stream >> base;
         return base.GetShortID(txhash);
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(header);
         READWRITE(nonce);
         size_t shorttxids_size = shorttxids.size();
         READWRITE(VARINT(shorttxids_size));
         shorttxids.resize(shorttxids_size);
         for (size_t i = 0; i < shorttxids.size(); i++) {
             uint32_t lsb = shorttxids[i] & 0xffffffff;
             uint16_t msb = (shorttxids[i] >> 32) & 0xffff;
             READWRITE(lsb);
             READWRITE(msb);
             shorttxids[i] = (uint64_t(msb) << 32) | uint64_t(lsb);
         }
         READWRITE(prefilledtxn);
     }
 };
 
 BOOST_AUTO_TEST_CASE(NonCoinbasePreforwardRTTest) {
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
     CBlock block(BuildBlockTestCase());
 
     pool.addUnchecked(block.vtx[2]->GetId(), entry.FromTx(*block.vtx[2]));
     LOCK(pool.cs);
     BOOST_CHECK_EQUAL(
         pool.mapTx.find(block.vtx[2]->GetId())->GetSharedTx().use_count(),
         SHARED_TX_OFFSET + 0);
 
     uint256 txhash;
 
     // Test with pre-forwarding tx 1, but not coinbase
     {
         TestHeaderAndShortIDs shortIDs(block);
         shortIDs.prefilledtxn.resize(1);
         shortIDs.prefilledtxn[0] = {1, block.vtx[1]};
         shortIDs.shorttxids.resize(2);
         shortIDs.shorttxids[0] = shortIDs.GetShortID(block.vtx[0]->GetId());
         shortIDs.shorttxids[1] = shortIDs.GetShortID(block.vtx[2]->GetId());
 
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << shortIDs;
 
         CBlockHeaderAndShortTxIDs shortIDs2;
         stream >> shortIDs2;
 
         PartiallyDownloadedBlock partialBlock(GetConfig(), &pool);
         BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) ==
                     READ_STATUS_OK);
         BOOST_CHECK(!partialBlock.IsTxAvailable(0));
         BOOST_CHECK(partialBlock.IsTxAvailable(1));
         BOOST_CHECK(partialBlock.IsTxAvailable(2));
 
         BOOST_CHECK_EQUAL(
             pool.mapTx.find(block.vtx[2]->GetId())->GetSharedTx().use_count(),
             SHARED_TX_OFFSET + 1);
 
         CBlock block2;
         {
             // No transactions.
             PartiallyDownloadedBlock tmp = partialBlock;
             BOOST_CHECK(partialBlock.FillBlock(block2, {}) ==
                         READ_STATUS_INVALID);
             partialBlock = tmp;
         }
 
         // Wrong transaction
         {
             // Current implementation doesn't check txn here, but don't require
             // that.
             PartiallyDownloadedBlock tmp = partialBlock;
             partialBlock.FillBlock(block2, {block.vtx[1]});
             partialBlock = tmp;
         }
         bool mutated;
         BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));
 
         CBlock block3;
         PartiallyDownloadedBlock partialBlockCopy = partialBlock;
         BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[0]}) ==
                     READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(),
                           block3.GetHash().ToString());
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(),
                           BlockMerkleRoot(block3, &mutated).ToString());
         BOOST_CHECK(!mutated);
 
         txhash = block.vtx[2]->GetId();
         block.vtx.clear();
         block2.vtx.clear();
         block3.vtx.clear();
 
         // + 1 because of partialBlockCopy.
         BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(),
                           SHARED_TX_OFFSET + 1);
     }
     BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(),
                       SHARED_TX_OFFSET + 0);
 }
 
 BOOST_AUTO_TEST_CASE(SufficientPreforwardRTTest) {
     CTxMemPool pool;
     TestMemPoolEntryHelper entry;
     CBlock block(BuildBlockTestCase());
 
     pool.addUnchecked(block.vtx[1]->GetId(), entry.FromTx(*block.vtx[1]));
     LOCK(pool.cs);
     BOOST_CHECK_EQUAL(
         pool.mapTx.find(block.vtx[1]->GetId())->GetSharedTx().use_count(),
         SHARED_TX_OFFSET + 0);
 
     uint256 txhash;
 
     // Test with pre-forwarding coinbase + tx 2 with tx 1 in mempool
     {
         TestHeaderAndShortIDs shortIDs(block);
         shortIDs.prefilledtxn.resize(2);
         shortIDs.prefilledtxn[0] = {0, block.vtx[0]};
         // id == 1 as it is 1 after index 1
         shortIDs.prefilledtxn[1] = {1, block.vtx[2]};
         shortIDs.shorttxids.resize(1);
         shortIDs.shorttxids[0] = shortIDs.GetShortID(block.vtx[1]->GetId());
 
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << shortIDs;
 
         CBlockHeaderAndShortTxIDs shortIDs2;
         stream >> shortIDs2;
 
         PartiallyDownloadedBlock partialBlock(GetConfig(), &pool);
         BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) ==
                     READ_STATUS_OK);
         BOOST_CHECK(partialBlock.IsTxAvailable(0));
         BOOST_CHECK(partialBlock.IsTxAvailable(1));
         BOOST_CHECK(partialBlock.IsTxAvailable(2));
 
         BOOST_CHECK_EQUAL(
             pool.mapTx.find(block.vtx[1]->GetId())->GetSharedTx().use_count(),
             SHARED_TX_OFFSET + 1);
 
         CBlock block2;
         PartiallyDownloadedBlock partialBlockCopy = partialBlock;
         BOOST_CHECK(partialBlock.FillBlock(block2, {}) == READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(),
                           block2.GetHash().ToString());
         bool mutated;
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(),
                           BlockMerkleRoot(block2, &mutated).ToString());
         BOOST_CHECK(!mutated);
 
         txhash = block.vtx[1]->GetId();
         block.vtx.clear();
         block2.vtx.clear();
 
         // + 1 because of partialBlockCopy.
         BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(),
                           SHARED_TX_OFFSET + 1);
     }
     BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(),
                       SHARED_TX_OFFSET + 0);
 }
 
 BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest) {
     CTxMemPool pool;
     CMutableTransaction coinbase;
     coinbase.vin.resize(1);
     coinbase.vin[0].scriptSig.resize(10);
     coinbase.vout.resize(1);
     coinbase.vout[0].nValue = 42 * SATOSHI;
 
     CBlock block;
     block.vtx.resize(1);
     block.vtx[0] = MakeTransactionRef(std::move(coinbase));
     block.nVersion = 42;
     block.hashPrevBlock = InsecureRand256();
     block.nBits = 0x207fffff;
 
     bool mutated;
     block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
     assert(!mutated);
 
     GlobalConfig config;
     while (!CheckProofOfWork(block.GetHash(), block.nBits, config)) {
         ++block.nNonce;
     }
 
     // Test simple header round-trip with only coinbase
     {
         CBlockHeaderAndShortTxIDs shortIDs(block);
 
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << shortIDs;
 
         CBlockHeaderAndShortTxIDs shortIDs2;
         stream >> shortIDs2;
 
         PartiallyDownloadedBlock partialBlock(GetConfig(), &pool);
         BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) ==
                     READ_STATUS_OK);
         BOOST_CHECK(partialBlock.IsTxAvailable(0));
 
         CBlock block2;
         std::vector<CTransactionRef> vtx_missing;
         BOOST_CHECK(partialBlock.FillBlock(block2, vtx_missing) ==
                     READ_STATUS_OK);
         BOOST_CHECK_EQUAL(block.GetHash().ToString(),
                           block2.GetHash().ToString());
         BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(),
                           BlockMerkleRoot(block2, &mutated).ToString());
         BOOST_CHECK(!mutated);
     }
 }
 
 BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) {
     BlockTransactionsRequest req1;
     req1.blockhash = InsecureRand256();
     req1.indices.resize(4);
     req1.indices[0] = 0;
     req1.indices[1] = 1;
     req1.indices[2] = 3;
     req1.indices[3] = 4;
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << req1;
 
     BlockTransactionsRequest req2;
     stream >> req2;
 
     BOOST_CHECK_EQUAL(req1.blockhash.ToString(), req2.blockhash.ToString());
     BOOST_CHECK_EQUAL(req1.indices.size(), req2.indices.size());
     BOOST_CHECK_EQUAL(req1.indices[0], req2.indices[0]);
     BOOST_CHECK_EQUAL(req1.indices[1], req2.indices[1]);
     BOOST_CHECK_EQUAL(req1.indices[2], req2.indices[2]);
     BOOST_CHECK_EQUAL(req1.indices[3], req2.indices[3]);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockindex_tests.cpp b/src/test/blockindex_tests.cpp
index fd144926b..26467bc82 100644
--- a/src/test/blockindex_tests.cpp
+++ b/src/test/blockindex_tests.cpp
@@ -1,424 +1,425 @@
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "blockvalidity.h"
-#include "chain.h"
-#include "diskblockpos.h"
-#include "uint256.h"
+#include <blockvalidity.h>
+#include <chain.h>
+#include <diskblockpos.h>
+#include <uint256.h>
 
-#include "test/test_bitcoin.h"
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
+
 #include <limits>
 
 BOOST_FIXTURE_TEST_SUITE(blockindex_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(get_block_header) {
     const int32_t expectedVersion = 4;
     const uint256 expectedMerkleRoot = uint256();
     const uint32_t expectedBlockTime = 123;
     const uint32_t expectedDifficultyBits = 234;
     const uint32_t expectedNonce = 345;
 
     CBlockHeader header;
     header.nVersion = expectedVersion;
     header.hashMerkleRoot = expectedMerkleRoot;
     header.nTime = expectedBlockTime;
     header.nBits = expectedDifficultyBits;
     header.nNonce = expectedNonce;
 
     CBlockIndex index = CBlockIndex(header);
 
     CBlockHeader checkHeader = index.GetBlockHeader();
     BOOST_CHECK(checkHeader.nVersion == expectedVersion);
     BOOST_CHECK(checkHeader.hashMerkleRoot == expectedMerkleRoot);
     BOOST_CHECK(checkHeader.nTime == expectedBlockTime);
     BOOST_CHECK(checkHeader.nBits == expectedDifficultyBits);
     BOOST_CHECK(checkHeader.nNonce == expectedNonce);
 }
 
 BOOST_AUTO_TEST_CASE(get_disk_positions) {
     // Test against all validity values
     std::set<BlockValidity> validityValues{
         BlockValidity::UNKNOWN, BlockValidity::HEADER,
         BlockValidity::TREE,    BlockValidity::TRANSACTIONS,
         BlockValidity::CHAIN,   BlockValidity::SCRIPTS};
     for (BlockValidity validity : validityValues) {
         // Test against all combinations of data and undo flags
         for (int flags = 0; flags <= 0x03; flags++) {
             // Generate some values to test against
             const int expectedFile = flags * 123;
             const unsigned int expectedDataPosition = flags * 234;
             const unsigned int expectedUndoPosition = flags * 345;
 
             CBlockIndex index;
             index.nStatus = index.nStatus.withValidity(BlockValidity(validity));
 
             // All combinations of data and undo
             if (flags & 0x01) {
                 index.nStatus = index.nStatus.withData();
                 index.nFile = expectedFile;
                 index.nDataPos = expectedDataPosition;
             }
             if (flags & 0x02) {
                 index.nStatus = index.nStatus.withUndo();
                 index.nFile = expectedFile;
                 index.nUndoPos = expectedUndoPosition;
             }
 
             // Data and undo positions should be unmodified
             CDiskBlockPos dataPosition = index.GetBlockPos();
             if (flags & 0x01) {
                 BOOST_CHECK(dataPosition.nFile == expectedFile);
                 BOOST_CHECK(dataPosition.nPos == expectedDataPosition);
             } else {
                 BOOST_CHECK(dataPosition == CDiskBlockPos());
             }
 
             CDiskBlockPos undoPosition = index.GetUndoPos();
             if (flags & 0x02) {
                 BOOST_CHECK(undoPosition.nFile == expectedFile);
                 BOOST_CHECK(undoPosition.nPos == expectedUndoPosition);
             } else {
                 BOOST_CHECK(undoPosition == CDiskBlockPos());
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(get_block_hash) {
     CBlockIndex index = CBlockIndex();
 
     /* Test with all 0 hash */
     const uint256 zeroHash = uint256();
     index.phashBlock = &zeroHash;
     uint256 hash = index.GetBlockHash();
     BOOST_CHECK(hash == zeroHash);
 
     /* Test with a random hash */
     std::vector<uint8_t> hashBytes(32);
 
     std::generate(hashBytes.begin(), hashBytes.end(),
                   []() { return uint8_t(rand() % 255); });
 
     const uint256 randomHash = uint256(hashBytes);
     index.phashBlock = &randomHash;
     hash = index.GetBlockHash();
     BOOST_CHECK(hash == randomHash);
 }
 
 BOOST_AUTO_TEST_CASE(received_time) {
     // Set to UINT32_MAX because that's the maximum value header.nTime can hold
     const int64_t expectedBlockTime = std::numeric_limits<uint32_t>::max();
 
     CBlockHeader header;
     header.nTime = uint32_t(expectedBlockTime);
 
     CBlockIndex index = CBlockIndex(header);
 
     // nTimeReceived defaults to 0
     BOOST_CHECK_EQUAL(index.nTimeReceived, 0);
 
     // nTimeReceived can be updated to the actual received time, which may
     // be before or after the miner's time.
     for (int64_t receivedTime = expectedBlockTime - 10;
          // Make sure that receivedTime is tested beyond 32-bit values.
          receivedTime <= expectedBlockTime + 10; receivedTime++) {
         index.nTimeReceived = receivedTime;
         BOOST_CHECK_EQUAL(index.GetBlockTime(), expectedBlockTime);
         BOOST_CHECK_EQUAL(index.GetHeaderReceivedTime(), receivedTime);
         BOOST_CHECK_EQUAL(index.GetReceivedTimeDiff(),
                           receivedTime - expectedBlockTime);
     }
 }
 
 BOOST_AUTO_TEST_CASE(median_time_past) {
     std::array<CBlockIndex, 12> indices;
 
     // times in this test are pairs of <blockTime, MTP>
 
     // Check that MTP is correctly calculated for all cases when block times
     // are consecutive and greater than previous block times:
     // 1) All cases where the number of blocks is < 11
     // 2) The case where the number of blocks is exactly 11
     // 3) The case where the number of blocks is > 11 (but only 11 are used to
     //    calculate MTP.
     std::array<std::pair<int, int>, 12> times = {{{0, 0},
                                                   {1, 1},
                                                   {2, 1},
                                                   {4, 2},
                                                   {4, 2},
                                                   {5, 4},
                                                   {7, 4},
                                                   {10, 4},
                                                   {12, 4},
                                                   {14, 5},
                                                   {17, 5},
                                                   {20, 7}}};
     for (size_t i = 0; i < indices.size(); i++) {
         indices[i].nTime = times[i].first;
         if (i > 0) {
             indices[i].pprev = &indices[i - 1];
         }
 
         BOOST_CHECK(indices[i].GetMedianTimePast() == times[i].second);
     }
 
     // Test against non-consecutive block times
     std::array<std::pair<int, int>, 12> times2 = {{{0, 0},
                                                    {0, 0},
                                                    {1, 0},
                                                    {3, 1},
                                                    {2, 1},
                                                    {3, 2},
                                                    {4, 2},
                                                    {5, 3},
                                                    {6, 3},
                                                    {7, 3},
                                                    {8, 3},
                                                    {9, 4}}};
     for (size_t i = 0; i < indices.size(); i++) {
         indices[i].nTime = times2[i].first;
         BOOST_CHECK(indices[i].GetMedianTimePast() == times2[i].second);
     }
 }
 
 BOOST_AUTO_TEST_CASE(to_string) {
     CBlockHeader header = CBlockHeader();
     header.hashMerkleRoot = uint256();
 
     CBlockIndex index = CBlockIndex(header);
     const uint256 hashBlock = uint256();
     index.phashBlock = &hashBlock;
     index.nHeight = 123;
 
     CBlockIndex indexPrev = CBlockIndex();
 
     std::string expectedString = "";
     std::string indexString = "";
 
     /* CASE 1 : pprev is null */
     expectedString = strprintf(
         "CBlockIndex(pprev=%p, nHeight=123, "
         "merkle="
         "0000000000000000000000000000000000000000000000000000000000000000, "
         "hashBlock="
         "0000000000000000000000000000000000000000000000000000000000000000)",
         (void *)(nullptr));
     index.pprev = nullptr;
     indexString = index.ToString();
     BOOST_CHECK_EQUAL(indexString, expectedString);
 
     /* CASE 2 : pprev is indexPrev */
     expectedString = strprintf(
         "CBlockIndex(pprev=%p, nHeight=123, "
         "merkle="
         "0000000000000000000000000000000000000000000000000000000000000000, "
         "hashBlock="
         "0000000000000000000000000000000000000000000000000000000000000000)",
         &indexPrev);
     index.pprev = &indexPrev;
     indexString = index.ToString();
     BOOST_CHECK_EQUAL(indexString, expectedString);
 
     /* CASE 3 : height is max(int) */
     expectedString = strprintf(
         "CBlockIndex(pprev=%p, nHeight=2147483647, "
         "merkle="
         "0000000000000000000000000000000000000000000000000000000000000000, "
         "hashBlock="
         "0000000000000000000000000000000000000000000000000000000000000000)",
         &indexPrev);
     index.nHeight = INT32_MAX;
     indexString = index.ToString();
     BOOST_CHECK_EQUAL(indexString, expectedString);
 
     /* CASE 4 : set some Merkle root hash */
     expectedString = strprintf(
         "CBlockIndex(pprev=%p, nHeight=2147483647, "
         "merkle="
         "0000000000000000000000000000000000000000000000000123456789abcdef, "
         "hashBlock="
         "0000000000000000000000000000000000000000000000000000000000000000)",
         &indexPrev);
     index.hashMerkleRoot = uint256S("0123456789ABCDEF");
     indexString = index.ToString();
     BOOST_CHECK_EQUAL(indexString, expectedString);
 
     /* CASE 5 : set some block hash */
     expectedString = strprintf(
         "CBlockIndex(pprev=%p, nHeight=2147483647, "
         "merkle="
         "0000000000000000000000000000000000000000000000000123456789abcdef, "
         "hashBlock="
         "000000000000000000000000000000000000000000000000fedcba9876543210)",
         &indexPrev);
     const uint256 emptyHashBlock = uint256S("FEDCBA9876543210");
     index.phashBlock = &emptyHashBlock;
     indexString = index.ToString();
     BOOST_CHECK_EQUAL(indexString, expectedString);
 }
 
 BOOST_AUTO_TEST_CASE(index_validity_tests) {
     CBlockIndex index;
 
     // Test against all validity values
     std::set<BlockValidity> validityValues{
         BlockValidity::UNKNOWN, BlockValidity::HEADER,
         BlockValidity::TREE,    BlockValidity::TRANSACTIONS,
         BlockValidity::CHAIN,   BlockValidity::SCRIPTS};
     std::set<bool> boolValues = {false, true};
     for (BlockValidity validity : validityValues) {
         for (bool withFailed : boolValues) {
             for (bool withFailedParent : boolValues) {
                 index.nStatus = BlockStatus()
                                     .withValidity(validity)
                                     .withFailed(withFailed)
                                     .withFailedParent(withFailedParent);
 
                 for (BlockValidity validUpTo : validityValues) {
                     // Test isValidity()
                     bool isValid = index.IsValid(validUpTo);
                     if (validUpTo <= validity && !withFailed &&
                         !withFailedParent) {
                         BOOST_CHECK(isValid);
                     } else {
                         BOOST_CHECK(!isValid);
                     }
 
                     // Test RaiseValidity()
                     CBlockIndex indexRaiseValidity;
                     for (BlockValidity validFrom : validityValues) {
                         indexRaiseValidity.nStatus =
                             BlockStatus()
                                 .withValidity(validFrom)
                                 .withFailed(withFailed)
                                 .withFailedParent(withFailedParent);
 
                         bool raisedValidity =
                             indexRaiseValidity.RaiseValidity(validUpTo);
                         if (validFrom < validUpTo && !withFailed &&
                             !withFailedParent) {
                             BOOST_CHECK(raisedValidity);
                             BOOST_CHECK(
                                 indexRaiseValidity.nStatus.getValidity() ==
                                 validUpTo);
                         } else {
                             BOOST_CHECK(!raisedValidity);
                             BOOST_CHECK(
                                 indexRaiseValidity.nStatus.getValidity() ==
                                 validFrom);
                         }
                     }
                 }
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(index_ancestors) {
     std::array<CBlockIndex, 256> indexes;
 
     /* Check the skip pointer don't build when there is no precedence */
     for (size_t i = 0; i < indexes.size(); i++) {
         indexes[i] = CBlockIndex();
         indexes[i].nHeight = i;
 
         indexes[i].pprev = nullptr;
         indexes[i].pskip = nullptr;
 
         indexes[i].BuildSkip();
 
         /* Check that skip not rebuilt if there is no preceding index */
         BOOST_CHECK(indexes[i].pskip == nullptr);
     }
 
     for (size_t i = 0; i < indexes.size(); i++) {
         if (i > 0) {
             indexes[i].pprev = &indexes[i - 1];
             indexes[i].BuildSkip();
 
             /* Check that skip is built */
             BOOST_CHECK(indexes[i].pskip != nullptr);
 
             /*
              * Starting from height 2, pskip should be more efficient that
              * pprev.
              * Ensure pskip.nHeight < pprev.nHeight
              */
             if (i > 1) {
                 BOOST_CHECK(indexes[i].pskip->nHeight <
                             indexes[i].pprev->nHeight);
             }
 
             /* Find an ancestor 16 indexes behind */
             if (i > 16) {
                 CBlockIndex *ancestor =
                     indexes[i].GetAncestor(indexes[i].nHeight - 16);
                 BOOST_CHECK(ancestor != nullptr);
                 BOOST_CHECK(ancestor->nHeight == (indexes[i].nHeight - 16));
             }
         }
     }
 
     /*
      * Reorder these indexes to setup multiple branches:
      *
      *                                     (248)->(...)->(255)
      *                                    /
      *                 (128)->(...)->(191)->(...)->(247)
      *                /
      * (0)->(...)->(63)->(...)->(127)
      */
     for (size_t i = 0; i < indexes.size(); i++) {
         /* Build the tree */
         indexes[i].pskip = nullptr;
         if (i > 0) {
             indexes[i].pprev = &indexes[i - 1];
         }
         if (i < 128) {
             indexes[i].nHeight = i;
         } else if (i < 248) {
             /* Branch at 128 */
             if (i == 128) {
                 indexes[i].pprev = &indexes[63];
             }
             indexes[i].nHeight = i - 64;
         } else {
             /* Branch at 248 */
             if (i == 248) {
                 indexes[i].pprev = &indexes[191];
             }
             indexes[i].nHeight = i - 128 + 8;
         }
 
         /* Build and test skip pointer */
         if (i > 0) {
             indexes[i].BuildSkip();
 
             /* Check that skip is built */
             BOOST_CHECK(indexes[i].pskip != nullptr);
 
             /*
              * Starting from height 2, pskip should be more efficient that
              * pprev.
              * Ensure pskip.nHeight < pprev.nHeight
              */
             if (i > 1) {
                 BOOST_CHECK(indexes[i].pskip->nHeight <
                             indexes[i].pprev->nHeight);
             }
         }
 
         /* Find an ancestor 37 indexes behind */
         if (i > 37) {
             CBlockIndex *ancestor =
                 indexes[i].GetAncestor(indexes[i].nHeight - 37);
             BOOST_CHECK(ancestor != nullptr);
             BOOST_CHECK(ancestor->nHeight == (indexes[i].nHeight - 37));
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockstatus_tests.cpp b/src/test/blockstatus_tests.cpp
index e91d1751b..8ecf8d5c7 100644
--- a/src/test/blockstatus_tests.cpp
+++ b/src/test/blockstatus_tests.cpp
@@ -1,134 +1,136 @@
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "blockstatus.h"
-#include "blockvalidity.h"
-#include "test/test_bitcoin.h"
+#include <blockstatus.h>
+
+#include <blockvalidity.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <set>
 
 BOOST_FIXTURE_TEST_SUITE(blockstatus_tests, BasicTestingSetup)
 
 static void CheckBlockStatus(const BlockStatus s, BlockValidity validity,
                              bool hasData, bool hasUndo, bool hasFailed,
                              bool hasFailedParent, bool isParked,
                              bool hasParkedParent) {
     BOOST_CHECK(s.getValidity() == validity);
     BOOST_CHECK_EQUAL(s.hasData(), hasData);
     BOOST_CHECK_EQUAL(s.hasUndo(), hasUndo);
     BOOST_CHECK_EQUAL(s.hasFailed(), hasFailed);
     BOOST_CHECK_EQUAL(s.hasFailedParent(), hasFailedParent);
     BOOST_CHECK_EQUAL(s.isInvalid(), hasFailed || hasFailedParent);
     BOOST_CHECK_EQUAL(s.isParked(), isParked);
     BOOST_CHECK_EQUAL(s.hasParkedParent(), hasParkedParent);
     BOOST_CHECK_EQUAL(s.isOnParkedChain(), isParked || hasParkedParent);
 }
 
 static void CheckAllPermutations(const BlockStatus base, bool hasData,
                                  bool hasUndo, bool hasFailed,
                                  bool hasFailedParent, bool isParked,
                                  bool hasParkedParent) {
     // Check all possible permutations.
     std::set<BlockValidity> baseValidities{
         BlockValidity::UNKNOWN, BlockValidity::HEADER,
         BlockValidity::TREE,    BlockValidity::TRANSACTIONS,
         BlockValidity::CHAIN,   BlockValidity::SCRIPTS};
 
     for (BlockValidity validity : baseValidities) {
         const BlockStatus s = base.withValidity(validity);
         CheckBlockStatus(s, validity, hasData, hasUndo, hasFailed,
                          hasFailedParent, isParked, hasParkedParent);
 
         // Clear various flags.
         CheckBlockStatus(s.withClearedFailureFlags(), validity, hasData,
                          hasUndo, false, false, isParked, hasParkedParent);
         CheckBlockStatus(s.withClearedParkedFlags(), validity, hasData, hasUndo,
                          hasFailed, hasFailedParent, false, false);
 
         // Also check all possible alterations.
         CheckBlockStatus(s.withData(true), validity, true, hasUndo, hasFailed,
                          hasFailedParent, isParked, hasParkedParent);
         CheckBlockStatus(s.withData(false), validity, false, hasUndo, hasFailed,
                          hasFailedParent, isParked, hasParkedParent);
         CheckBlockStatus(s.withUndo(true), validity, hasData, true, hasFailed,
                          hasFailedParent, isParked, hasParkedParent);
         CheckBlockStatus(s.withUndo(false), validity, hasData, false, hasFailed,
                          hasFailedParent, isParked, hasParkedParent);
         CheckBlockStatus(s.withFailed(true), validity, hasData, hasUndo, true,
                          hasFailedParent, isParked, hasParkedParent);
         CheckBlockStatus(s.withFailed(false), validity, hasData, hasUndo, false,
                          hasFailedParent, isParked, hasParkedParent);
         CheckBlockStatus(s.withFailedParent(true), validity, hasData, hasUndo,
                          hasFailed, true, isParked, hasParkedParent);
         CheckBlockStatus(s.withFailedParent(false), validity, hasData, hasUndo,
                          hasFailed, false, isParked, hasParkedParent);
 
         CheckBlockStatus(s.withParked(true), validity, hasData, hasUndo,
                          hasFailed, hasFailedParent, true, hasParkedParent);
         CheckBlockStatus(s.withParked(false), validity, hasData, hasUndo,
                          hasFailed, hasFailedParent, false, hasParkedParent);
         CheckBlockStatus(s.withParkedParent(true), validity, hasData, hasUndo,
                          hasFailed, hasFailedParent, isParked, true);
         CheckBlockStatus(s.withParkedParent(false), validity, hasData, hasUndo,
                          hasFailed, hasFailedParent, isParked, false);
 
         for (BlockValidity newValidity : baseValidities) {
             CheckBlockStatus(s.withValidity(newValidity), newValidity, hasData,
                              hasUndo, hasFailed, hasFailedParent, isParked,
                              hasParkedParent);
         }
     }
 }
 
 static void CheckParked(const BlockStatus s, bool hasData, bool hasUndo,
                         bool hasFailed, bool hasFailedParent) {
     std::set<bool> isParkedValues{false, true};
     std::set<bool> hasParkedParentValues{false, true};
 
     for (bool isParked : isParkedValues) {
         for (bool hasParkedParent : hasParkedParentValues) {
             CheckAllPermutations(
                 s.withParked(isParked).withParkedParent(hasParkedParent),
                 hasData, hasUndo, hasFailed, hasFailedParent, isParked,
                 hasParkedParent);
         }
     }
 }
 
 static void CheckFailures(const BlockStatus s, bool hasData, bool hasUndo) {
     std::set<bool> hasFailedValues{false, true};
     std::set<bool> hasFailedParentValues{false, true};
 
     for (bool hasFailed : hasFailedValues) {
         for (bool hasFailedParent : hasFailedParentValues) {
             CheckParked(
                 s.withFailed(hasFailed).withFailedParent(hasFailedParent),
                 hasData, hasUndo, hasFailed, hasFailedParent);
         }
     }
 }
 
 static void CheckHaveDataAndUndo(const BlockStatus s) {
     std::set<bool> hasDataValues{false, true};
     std::set<bool> hasUndoValues{false, true};
 
     for (bool hasData : hasDataValues) {
         for (bool hasUndo : hasUndoValues) {
             CheckFailures(s.withData(hasData).withUndo(hasUndo), hasData,
                           hasUndo);
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(sighash_construction_test) {
     // Check default values.
     CheckBlockStatus(BlockStatus(), BlockValidity::UNKNOWN, false, false, false,
                      false, false, false);
 
     CheckHaveDataAndUndo(BlockStatus());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/bloom_tests.cpp b/src/test/bloom_tests.cpp
index 5c74d8f94..f8aebb437 100644
--- a/src/test/bloom_tests.cpp
+++ b/src/test/bloom_tests.cpp
@@ -1,1129 +1,1130 @@
 // Copyright (c) 2012-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "bloom.h"
-
-#include "base58.h"
-#include "clientversion.h"
-#include "key.h"
-#include "merkleblock.h"
-#include "random.h"
-#include "serialize.h"
-#include "streams.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <bloom.h>
 
-#include <vector>
+#include <base58.h>
+#include <clientversion.h>
+#include <key.h>
+#include <merkleblock.h>
+#include <random.h>
+#include <serialize.h>
+#include <streams.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <vector>
+
 BOOST_FIXTURE_TEST_SUITE(bloom_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize) {
     CBloomFilter filter(3, 0.01, 0, BLOOM_UPDATE_ALL);
 
     filter.insert(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8"));
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")),
         "Bloom filter doesn't contain just-inserted object!");
     // One bit different in first byte
     BOOST_CHECK_MESSAGE(
         !filter.contains(ParseHex("19108ad8ed9bb6274d3980bab5a85c048f0950c8")),
         "Bloom filter contains something it shouldn't!");
 
     filter.insert(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee"));
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee")),
         "Bloom filter doesn't contain just-inserted object (2)!");
 
     filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5"));
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")),
         "Bloom filter doesn't contain just-inserted object (3)!");
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;
 
     std::vector<uint8_t> vch = ParseHex("03614e9b050000000000000001");
     std::vector<char> expected(vch.size());
 
     for (unsigned int i = 0; i < vch.size(); i++)
         expected[i] = (char)vch[i];
 
     BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(),
                                   expected.begin(), expected.end());
 
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")),
         "Bloom filter doesn't contain just-inserted object!");
     filter.clear();
     BOOST_CHECK_MESSAGE(
         !filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")),
         "Bloom filter should be empty!");
 }
 
 BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak) {
     // Same test as bloom_create_insert_serialize, but we add a nTweak of 100
     CBloomFilter filter(3, 0.01, 2147483649UL, BLOOM_UPDATE_ALL);
 
     filter.insert(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8"));
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")),
         "Bloom filter doesn't contain just-inserted object!");
     // One bit different in first byte
     BOOST_CHECK_MESSAGE(
         !filter.contains(ParseHex("19108ad8ed9bb6274d3980bab5a85c048f0950c8")),
         "Bloom filter contains something it shouldn't!");
 
     filter.insert(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee"));
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee")),
         "Bloom filter doesn't contain just-inserted object (2)!");
 
     filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5"));
     BOOST_CHECK_MESSAGE(
         filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")),
         "Bloom filter doesn't contain just-inserted object (3)!");
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;
 
     std::vector<uint8_t> vch = ParseHex("03ce4299050000000100008001");
     std::vector<char> expected(vch.size());
 
     for (unsigned int i = 0; i < vch.size(); i++)
         expected[i] = (char)vch[i];
 
     BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(),
                                   expected.begin(), expected.end());
 }
 
 BOOST_AUTO_TEST_CASE(bloom_create_insert_key) {
     std::string strSecret =
         std::string("5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C");
     CBitcoinSecret vchSecret;
     BOOST_CHECK(vchSecret.SetString(strSecret));
 
     CKey key = vchSecret.GetKey();
     CPubKey pubkey = key.GetPubKey();
     std::vector<uint8_t> vchPubKey(pubkey.begin(), pubkey.end());
 
     CBloomFilter filter(2, 0.001, 0, BLOOM_UPDATE_ALL);
     filter.insert(vchPubKey);
     uint160 hash = pubkey.GetID();
     filter.insert(std::vector<uint8_t>(hash.begin(), hash.end()));
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << filter;
 
     std::vector<uint8_t> vch = ParseHex("038fc16b080000000000000001");
     std::vector<char> expected(vch.size());
 
     for (unsigned int i = 0; i < vch.size(); i++)
         expected[i] = (char)vch[i];
 
     BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(),
                                   expected.begin(), expected.end());
 }
 
 BOOST_AUTO_TEST_CASE(bloom_match) {
     // Random real transaction
     // (b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b)
     CDataStream stream(
         ParseHex("01000000010b26e9b7735eb6aabdf358bab62f9816a21ba9ebdb719d5299e"
                  "88607d722c190000000008b4830450220070aca44506c5cef3a16ed519d7c"
                  "3c39f8aab192c4e1c90d065f37b8a4af6141022100a8e160b856c2d43d27d"
                  "8fba71e5aef6405b8643ac4cb7cb3c462aced7f14711a0141046d11fee51b"
                  "0e60666d5049a9101a72741df480b96ee26488a4d3466b95c9a40ac5eeef8"
                  "7e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe76036c339ffff"
                  "ffff021bff3d11000000001976a91404943fdd508053c75000106d3bc6e27"
                  "54dbcff1988ac2f15de00000000001976a914a266436d2965547608b9e15d"
                  "9032a7b9d64fa43188ac00000000"),
         SER_DISK, CLIENT_VERSION);
     CTransaction tx(deserialize, stream);
 
     // and one which spends it
     // (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
     uint8_t ch[] = {
         0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65,
         0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8,
         0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74,
         0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00,
         0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77,
         0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f,
         0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2,
         0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e,
         0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4,
         0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2,
         0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a,
         0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34,
         0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97,
         0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b,
         0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f,
         0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00,
         0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef,
         0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39,
         0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00,
         0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93,
         0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43,
         0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
     std::vector<uint8_t> vch(ch, ch + sizeof(ch) - 1);
     CDataStream spendStream(vch, SER_DISK, CLIENT_VERSION);
     CTransaction spendingTx(deserialize, spendStream);
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(uint256S(
         "0xb4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b"));
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter didn't match tx hash");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     // byte-reversed tx hash
     filter.insert(ParseHex(
         "6bff7fcd4f8565ef406dd5d63d4ff94f318fe82027fd4dc451b04474019f74b4"));
     BOOST_CHECK_MESSAGE(
         filter.IsRelevantAndUpdate(tx),
         "Simple Bloom filter didn't match manually serialized tx hash");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(ParseHex("30450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e"
                            "1c90d065f37b8a4af6141022100a8e160b856c2d43d27d8fba7"
                            "1e5aef6405b8643ac4cb7cb3c462aced7f14711a01"));
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter didn't match input signature");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(ParseHex("046d11fee51b0e60666d5049a9101a72741df480b96ee26488a"
                            "4d3466b95c9a40ac5eeef87e10a5cd336c19a84565f80fa6c54"
                            "7957b7700ff4dfbdefe76036c339"));
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter didn't match input pub key");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(ParseHex("04943fdd508053c75000106d3bc6e2754dbcff19"));
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter didn't match output address");
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(spendingTx),
                         "Simple Bloom filter didn't add output");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(ParseHex("a266436d2965547608b9e15d9032a7b9d64fa431"));
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter didn't match output address");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(COutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb"
                                      "6ba58f3bdaab65e73b7e9260b"),
                             0));
     BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter didn't match COutPoint");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     COutPoint prevOutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb6"
                                     "ba58f3bdaab65e73b7e9260b"),
                            0);
     {
         std::vector<uint8_t> data(32 + sizeof(unsigned int));
         memcpy(&data[0], prevOutPoint.GetTxId().begin(), 32);
         uint32_t n = prevOutPoint.GetN();
         memcpy(&data[32], &n, sizeof(uint32_t));
         filter.insert(data);
     }
     BOOST_CHECK_MESSAGE(
         filter.IsRelevantAndUpdate(tx),
         "Simple Bloom filter didn't match manually serialized COutPoint");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(uint256S(
         "00000009e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436"));
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter matched random tx hash");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(ParseHex("0000006d2965547608b9e15d9032a7b9d64fa431"));
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter matched random address");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(COutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb"
                                      "6ba58f3bdaab65e73b7e9260b"),
                             1));
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter matched COutPoint for an output "
                         "we didn't care about");
 
     filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     filter.insert(COutPoint(uint256S("0x000000d70786e899529d71dbeba91ba216982fb"
                                      "6ba58f3bdaab65e73b7e9260b"),
                             0));
     BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx),
                         "Simple Bloom filter matched COutPoint for an output "
                         "we didn't care about");
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_1) {
     // Random real block
     // (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af)
     // With 9 txes
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000090f0a9f110702f808219ebea1173056042a714bad51b916cb680000000"
             "0000005275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558"
             "da2fdb261b4d4c86041b1ab1bf9309010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff07044c86041b0146ffff"
             "ffff0100f2052a01000000434104e18f7afbe4721580e81e8414fc8c24d7cfacf2"
             "54bb5c7b949450c3e997c2dc1242487a8169507b631eb3771f2b425483fb13102c"
             "4eb5d858eef260fe70fbfae0ac00000000010000000196608ccbafa16abada9027"
             "80da4dc35dafd7af05fa0da08cf833575f8cf9e836000000004a493046022100da"
             "b24889213caf43ae6adc41cf1c9396c08240c199f5225acf45416330fd7dbd0221"
             "00fe37900e0644bf574493a07fc5edba06dbc07c311b947520c2d514bc5725dcb4"
             "01ffffffff0100f2052a010000001976a914f15d1921f52e4007b146dfa60f369e"
             "d2fc393ce288ac000000000100000001fb766c1288458c2bafcfec81e48b24d98e"
             "c706de6b8af7c4e3c29419bfacb56d000000008c493046022100f268ba165ce0ad"
             "2e6d93f089cfcd3785de5c963bb5ea6b8c1b23f1ce3e517b9f022100da7c0f21ad"
             "c6c401887f2bfd1922f11d76159cbc597fbd756a23dcbb00f4d7290141042b4e86"
             "25a96127826915a5b109852636ad0da753c9e1d5606a50480cd0c40f1f8b8d8982"
             "35e571fe9357d9ec842bc4bba1827daaf4de06d71844d0057707966affffffff02"
             "80969800000000001976a9146963907531db72d0ed1a0cfb471ccb63923446f388"
             "ac80d6e34c000000001976a914f0688ba1c0d1ce182c7af6741e02658c7d4dfcd3"
             "88ac000000000100000002c40297f730dd7b5a99567eb8d27b78758f607507c522"
             "92d02d4031895b52f2ff010000008b483045022100f7edfd4b0aac404e5bab4fd3"
             "889e0c6c41aa8d0e6fa122316f68eddd0a65013902205b09cc8b2d56e1cd1f7f2f"
             "afd60a129ed94504c4ac7bdc67b56fe67512658b3e014104732012cb962afa90d3"
             "1b25d8fb0e32c94e513ab7a17805c14ca4c3423e18b4fb5d0e676841733cb83aba"
             "f975845c9f6f2a8097b7d04f4908b18368d6fc2d68ecffffffffca5065ff9617cb"
             "cba45eb23726df6498a9b9cafed4f54cbab9d227b0035ddefb000000008a473044"
             "022068010362a13c7f9919fa832b2dee4e788f61f6f5d344a7c2a0da6ae7406056"
             "58022006d1af525b9a14a35c003b78b72bd59738cd676f845d1ff3fc25049e0100"
             "3614014104732012cb962afa90d31b25d8fb0e32c94e513ab7a17805c14ca4c342"
             "3e18b4fb5d0e676841733cb83abaf975845c9f6f2a8097b7d04f4908b18368d6fc"
             "2d68ecffffffff01001ec4110200000043410469ab4181eceb28985b9b4e895c13"
             "fa5e68d85761b7eee311db5addef76fa8621865134a221bd01f28ec9999ee3e021"
             "e60766e9d1f3458c115fb28650605f11c9ac000000000100000001cdaf2f758e91"
             "c514655e2dc50633d1e4c84989f8aa90a0dbc883f0d23ed5c2fa010000008b4830"
             "4502207ab51be6f12a1962ba0aaaf24a20e0b69b27a94fac5adf45aa7d2d18ffd9"
             "236102210086ae728b370e5329eead9accd880d0cb070aea0c96255fae6c4f1ddc"
             "ce1fd56e014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
             "4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
             "ebbb12dcd4ffffffff02404b4c00000000001976a9142b6ba7c9d796b75eef7942"
             "fc9288edd37c32f5c388ac002d3101000000001976a9141befba0cdc1ad5652937"
             "1864d9f6cb042faa06b588ac000000000100000001b4a47603e71b61bc3326efd9"
             "0111bf02d2f549b067f4c4a8fa183b57a0f800cb010000008a4730440220177c37"
             "f9a505c3f1a1f0ce2da777c339bd8339ffa02c7cb41f0a5804f473c9230220585b"
             "25a2ee80eb59292e52b987dad92acb0c64eced92ed9ee105ad153cdb12d0014104"
             "43bd44f683467e549dae7d20d1d79cbdb6df985c6e9c029c8d0c6cb46cc1a4d3cf"
             "7923c5021b27f7a0b562ada113bc85d5fda5a1b41e87fe6e8802817cf69996ffff"
             "ffff0280651406000000001976a9145505614859643ab7b547cd7f1f5e7e2a1232"
             "2d3788ac00aa0271000000001976a914ea4720a7a52fc166c55ff2298e07baf70a"
             "e67e1b88ac00000000010000000586c62cd602d219bb60edb14a3e204de0705176"
             "f9022fe49a538054fb14abb49e010000008c493046022100f2bc2aba2534becbdf"
             "062eb993853a42bbbc282083d0daf9b4b585bd401aa8c9022100b1d7fd7ee0b956"
             "00db8535bbf331b19eed8d961f7a8e54159c53675d5f69df8c014104462e76fd40"
             "67b3a0aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c6"
             "9b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff03ad0e"
             "58ccdac3df9dc28a218bcf6f1997b0a93306faaa4b3a28ae83447b217901000000"
             "8b483045022100be12b2937179da88599e27bb31c3525097a07cdb52422d165b3c"
             "a2f2020ffcf702200971b51f853a53d644ebae9ec8f3512e442b1bcb6c315a5b49"
             "1d119d10624c83014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33"
             "d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312e"
             "f1c0e8ebbb12dcd4ffffffff2acfcab629bbc8685792603762c921580030ba144a"
             "f553d271716a95089e107b010000008b483045022100fa579a840ac258871365dd"
             "48cd7552f96c8eea69bd00d84f05b283a0dab311e102207e3c0ee9234814cfbb1b"
             "659b83671618f45abc1326b9edcc77d552a4f2a805c0014104462e76fd4067b3a0"
             "aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc3"
             "1895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffffdcdc6023bbc9"
             "944a658ddc588e61eacb737ddf0a3cd24f113b5a8634c517fcd2000000008b4830"
             "450221008d6df731df5d32267954bd7d2dda2302b74c6c2a6aa5c0ca64ecbabc1a"
             "f03c75022010e55c571d65da7701ae2da1956c442df81bbf076cdbac25133f99d9"
             "8a9ed34c014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
             "4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
             "ebbb12dcd4ffffffffe15557cd5ce258f479dfd6dc6514edf6d7ed5b21fcfa4a03"
             "8fd69f06b83ac76e010000008b483045022023b3e0ab071eb11de2eb1cc3a67261"
             "b866f86bf6867d4558165f7c8c8aca2d86022100dc6e1f53a91de3efe8f6351285"
             "0811f26284b62f850c70ca73ed5de8771fb451014104462e76fd4067b3a0aa4207"
             "0082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0"
             "c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff01404b4c0000000000"
             "1976a9142b6ba7c9d796b75eef7942fc9288edd37c32f5c388ac00000000010000"
             "000166d7577163c932b4f9690ca6a80b6e4eb001f0a2fa9023df5595602aae96ed"
             "8d000000008a4730440220262b42546302dfb654a229cefc86432b89628ff259dc"
             "87edd1154535b16a67e102207b4634c020a97c3e7bbd0d4d19da6aa2269ad9dded"
             "4026e896b213d73ca4b63f014104979b82d02226b3a4597523845754d44f13639e"
             "3bf2df5e82c6aab2bdc79687368b01b1ab8b19875ae3c90d661a3d0a33161dab29"
             "934edeb36aa01976be3baf8affffffff02404b4c00000000001976a9144854e695"
             "a02af0aeacb823ccbc272134561e0a1688ac40420f00000000001976a914abee93"
             "376d6b37b5c2940655a6fcaf1c8e74237988ac0000000001000000014e3f8ef2e9"
             "1349a9059cb4f01e54ab2597c1387161d3da89919f7ea6acdbb371010000008c49"
             "304602210081f3183471a5ca22307c0800226f3ef9c353069e0773ac76bb580654"
             "d56aa523022100d4c56465bdc069060846f4fbf2f6b20520b2a80b08b168b31e66"
             "ddb9c694e240014104976c79848e18251612f8940875b2b08d06e6dc73b9840e88"
             "60c066b7e87432c477e9a59a453e71e6d76d5fe34058b800a098fc1740ce3012e8"
             "fc8a00c96af966ffffffff02c0e1e400000000001976a9144134e75a6fcb604203"
             "4aab5e18570cf1f844f54788ac404b4c00000000001976a9142b6ba7c9d796b75e"
             "ef7942fc9288edd37c32f5c388ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     // Match the last transaction
     filter.insert(uint256S(
         "0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
     std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b"
                          "586ec87451f20"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 8);
 
     std::vector<uint256> vMatched;
     std::vector<unsigned int> vIndex;
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 
     // Also match the 8th transaction
     filter.insert(uint256S(
         "0xdd1fd2a6fc16404faf339881a90adbde7f4f728691ac62e8f168809cdfae1053"));
     merkleBlock = CMerkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 2);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[1] == pair);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0xdd1fd2a6fc16404faf339881a90adbde7f4f728691ac62e8f16"
                          "8809cdfae1053"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 7);
 
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_2) {
     // Random real block
     // (000000005a4ded781e667e06ceefafb71410b511fe0d5adc3e5a27ecbec34ae6)
     // With 4 txes
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000075616236cc2126035fadb38deb65b9102cc2c41c09cdf29fc051906800"
             "000000fe7d5e12ef0ff901f6050211249919b1c0653771832b3a80c66cea42847f"
             "0ae1d4d26e49ffff001d00f0a44104010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff0804ffff001d029105ff"
             "ffffff0100f2052a010000004341046d8709a041d34357697dfcb30a9d05900a62"
             "94078012bf3bb09c6f9b525f1d16d5503d7905db1ada9501446ea00728668fc571"
             "9aa80be2fdfc8a858a4dbdd4fbac00000000010000000255605dc6f5c3dc148b6d"
             "a58442b0b2cd422be385eab2ebea4119ee9c268d28350000000049483045022100"
             "aa46504baa86df8a33b1192b1b9367b4d729dc41e389f2c04f3e5c7f0559aae702"
             "205e82253a54bf5c4f65b7428551554b2045167d6d206dfe6a2e198127d3f7df15"
             "01ffffffff55605dc6f5c3dc148b6da58442b0b2cd422be385eab2ebea4119ee9c"
             "268d2835010000004847304402202329484c35fa9d6bb32a55a70c0982f606ce0e"
             "3634b69006138683bcd12cbb6602200c28feb1e2555c3210f1dddb299738b4ff8b"
             "be9667b68cb8764b5ac17b7adf0001ffffffff0200e1f505000000004341046a07"
             "65b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a"
             "68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00180d"
             "8f000000004341044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad7"
             "69f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cf"
             "c617c0ea45afac0000000001000000025f9a06d3acdceb56be1bfeaa3e8a25e62d"
             "182fa24fefe899d1c17f1dad4c2028000000004847304402205d6058484157235b"
             "06028c30736c15613a28bdb768ee628094ca8b0030d4d6eb0220328789c9a2ec27"
             "ddaec0ad5ef58efded42e6ea17c2e1ce838f3d6913f5e95db601ffffffff5f9a06"
             "d3acdceb56be1bfeaa3e8a25e62d182fa24fefe899d1c17f1dad4c202801000000"
             "4a493046022100c45af050d3cea806cedd0ab22520c53ebe63b987b8954146cdca"
             "42487b84bdd6022100b9b027716a6b59e640da50a864d6dd8a0ef24c76ce62391f"
             "a3eabaf4d2886d2d01ffffffff0200e1f505000000004341046a0765b5865641ce"
             "08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d484"
             "8b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00180d8f0000000043"
             "41046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef1"
             "70e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0c"
             "ac000000000100000002e2274e5fea1bf29d963914bd301aa63b64daaf8a3e88f1"
             "19b5046ca5738a0f6b0000000048473044022016e7a727a061ea2254a6c358376a"
             "aa617ac537eb836c77d646ebda4c748aac8b0220192ce28bf9f2c06a6467e6531e"
             "27648d2b3e2e2bae85159c9242939840295ba501ffffffffe2274e5fea1bf29d96"
             "3914bd301aa63b64daaf8a3e88f119b5046ca5738a0f6b010000004a4930460221"
             "00b7a1a755588d4190118936e15cd217d133b0e4a53c3c15924010d5648d8925c9"
             "022100aaef031874db2114f2d869ac2de4ae53908fbfea5b2b1862e181626bb900"
             "5c9f01ffffffff0200e1f505000000004341044a656f065871a353f216ca26cef8"
             "dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8d"
             "d2c875a390f67c1f6c94cfc617c0ea45afac00180d8f000000004341046a0765b5"
             "865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68ae"
             "e3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     // Match the first transaction
     filter.insert(uint256S(
         "0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
     std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df"
                          "5b47aecb93b70"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
 
     std::vector<uint256> vMatched;
     std::vector<unsigned int> vIndex;
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 
     // Match an output from the second transaction (the pubkey for address
     // 1DZTzaBHUDM7T3QvUKBz4qXMRpkg8jsfB5)
     // This should match the third transaction because it spends the output
     // matched
     // It also matches the fourth transaction, which spends to the pubkey again
     filter.insert(ParseHex("044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad"
                            "769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875"
                            "a390f67c1f6c94cfc617c0ea45af"));
 
     merkleBlock = CMerkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 4);
 
     BOOST_CHECK(pair == merkleBlock.vMatchedTxn[0]);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[1].second ==
                 uint256S("0x28204cad1d7fc1d199e8ef4fa22f182de6258a3eaafe1bbe56e"
                          "bdcacd3069a5f"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[1].first == 1);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[2].second ==
                 uint256S("0x6b0f8a73a56c04b519f1883e8aafda643ba61a30bd1439969df"
                          "21bea5f4e27e2"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[2].first == 2);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[3].second ==
                 uint256S("0x3c1d7e82342158e4109df2e0b6348b6e84e403d8b4046d70076"
                          "63ace63cddb23"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[3].first == 3);
 
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_2_with_update_none) {
     // Random real block
     // (000000005a4ded781e667e06ceefafb71410b511fe0d5adc3e5a27ecbec34ae6)
     // With 4 txes
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000075616236cc2126035fadb38deb65b9102cc2c41c09cdf29fc051906800"
             "000000fe7d5e12ef0ff901f6050211249919b1c0653771832b3a80c66cea42847f"
             "0ae1d4d26e49ffff001d00f0a44104010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff0804ffff001d029105ff"
             "ffffff0100f2052a010000004341046d8709a041d34357697dfcb30a9d05900a62"
             "94078012bf3bb09c6f9b525f1d16d5503d7905db1ada9501446ea00728668fc571"
             "9aa80be2fdfc8a858a4dbdd4fbac00000000010000000255605dc6f5c3dc148b6d"
             "a58442b0b2cd422be385eab2ebea4119ee9c268d28350000000049483045022100"
             "aa46504baa86df8a33b1192b1b9367b4d729dc41e389f2c04f3e5c7f0559aae702"
             "205e82253a54bf5c4f65b7428551554b2045167d6d206dfe6a2e198127d3f7df15"
             "01ffffffff55605dc6f5c3dc148b6da58442b0b2cd422be385eab2ebea4119ee9c"
             "268d2835010000004847304402202329484c35fa9d6bb32a55a70c0982f606ce0e"
             "3634b69006138683bcd12cbb6602200c28feb1e2555c3210f1dddb299738b4ff8b"
             "be9667b68cb8764b5ac17b7adf0001ffffffff0200e1f505000000004341046a07"
             "65b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a"
             "68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00180d"
             "8f000000004341044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad7"
             "69f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cf"
             "c617c0ea45afac0000000001000000025f9a06d3acdceb56be1bfeaa3e8a25e62d"
             "182fa24fefe899d1c17f1dad4c2028000000004847304402205d6058484157235b"
             "06028c30736c15613a28bdb768ee628094ca8b0030d4d6eb0220328789c9a2ec27"
             "ddaec0ad5ef58efded42e6ea17c2e1ce838f3d6913f5e95db601ffffffff5f9a06"
             "d3acdceb56be1bfeaa3e8a25e62d182fa24fefe899d1c17f1dad4c202801000000"
             "4a493046022100c45af050d3cea806cedd0ab22520c53ebe63b987b8954146cdca"
             "42487b84bdd6022100b9b027716a6b59e640da50a864d6dd8a0ef24c76ce62391f"
             "a3eabaf4d2886d2d01ffffffff0200e1f505000000004341046a0765b5865641ce"
             "08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d484"
             "8b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00180d8f0000000043"
             "41046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef1"
             "70e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0c"
             "ac000000000100000002e2274e5fea1bf29d963914bd301aa63b64daaf8a3e88f1"
             "19b5046ca5738a0f6b0000000048473044022016e7a727a061ea2254a6c358376a"
             "aa617ac537eb836c77d646ebda4c748aac8b0220192ce28bf9f2c06a6467e6531e"
             "27648d2b3e2e2bae85159c9242939840295ba501ffffffffe2274e5fea1bf29d96"
             "3914bd301aa63b64daaf8a3e88f119b5046ca5738a0f6b010000004a4930460221"
             "00b7a1a755588d4190118936e15cd217d133b0e4a53c3c15924010d5648d8925c9"
             "022100aaef031874db2114f2d869ac2de4ae53908fbfea5b2b1862e181626bb900"
             "5c9f01ffffffff0200e1f505000000004341044a656f065871a353f216ca26cef8"
             "dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8d"
             "d2c875a390f67c1f6c94cfc617c0ea45afac00180d8f000000004341046a0765b5"
             "865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68ae"
             "e3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_NONE);
     // Match the first transaction
     filter.insert(uint256S(
         "0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
     std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df"
                          "5b47aecb93b70"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
 
     std::vector<uint256> vMatched;
     std::vector<unsigned int> vIndex;
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 
     // Match an output from the second transaction (the pubkey for address
     // 1DZTzaBHUDM7T3QvUKBz4qXMRpkg8jsfB5)
     // This should not match the third transaction though it spends the output
     // matched
     // It will match the fourth transaction, which has another pay-to-pubkey
     // output to the same address
     filter.insert(ParseHex("044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad"
                            "769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875"
                            "a390f67c1f6c94cfc617c0ea45af"));
 
     merkleBlock = CMerkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 3);
 
     BOOST_CHECK(pair == merkleBlock.vMatchedTxn[0]);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[1].second ==
                 uint256S("0x28204cad1d7fc1d199e8ef4fa22f182de6258a3eaafe1bbe56e"
                          "bdcacd3069a5f"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[1].first == 1);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[2].second ==
                 uint256S("0x3c1d7e82342158e4109df2e0b6348b6e84e403d8b4046d70076"
                          "63ace63cddb23"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[2].first == 3);
 
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize) {
     // Random real block
     // (000000000000dab0130bbcc991d3d7ae6b81aa6f50a798888dfe62337458dc45)
     // With one tx
     CBlock block;
     CDataStream stream(
         ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b00"
                  "00000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3f"
                  "f60abe184f196367291b4d4c86041b8fa45d6301010000000100000000000"
                  "00000000000000000000000000000000000000000000000000000ffffffff"
                  "08044c86041b020a02ffffffff0100f2052a01000000434104ecd3229b057"
                  "1c3be876feaac0442a9f13c5a572742927af1dc623353ecf8c202225f6486"
                  "8137a18cdd85cbbb4c74fbccfd4f49639cf1bdc94a5672bb15ad5d4cac000"
                  "00000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     // Match the only transaction
     filter.insert(uint256S(
         "0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee"
                          "3a3d669c00cb5"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
 
     std::vector<uint256> vMatched;
     std::vector<unsigned int> vIndex;
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 
     CDataStream merkleStream(SER_NETWORK, PROTOCOL_VERSION);
     merkleStream << merkleBlock;
 
     std::vector<uint8_t> vch =
         ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b00"
                  "00000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3f"
                  "f60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e"
                  "33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");
     std::vector<char> expected(vch.size());
 
     for (unsigned int i = 0; i < vch.size(); i++)
         expected[i] = (char)vch[i];
 
     BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(),
                                   merkleStream.begin(), merkleStream.end());
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_4) {
     // Random real block
     // (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
     // With 7 txes
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000082bb869cf3a793432a66e826e05a6fc37469f8efb7421dc88067010000"
             "0000007f16c5962e8bd963659c793ce370d95f093bc7e367117b3c30c1f8fdd0d9"
             "728776381b4d4c86041b554b852907010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff07044c86041b0136ffff"
             "ffff0100f2052a01000000434104eaafc2314def4ca98ac970241bcab022b9c1e1"
             "f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad"
             "1357231a2252247d97a46a91ac000000000100000001bcad20a6a29827d1424f08"
             "989255120bf7f3e9e3cdaaa6bb31b0737fe048724300000000494830450220356e"
             "834b046cadc0f8ebb5a8a017b02de59c86305403dad52cd77b55af062ea1022100"
             "9253cd6c119d4729b77c978e1e2aa19f5ea6e0e52b3f16e32fa608cd5bab753901"
             "ffffffff02008d380c010000001976a9142b4b8072ecbba129b6453c63e129e643"
             "207249ca88ac0065cd1d000000001976a9141b8dd13b994bcfc787b32aeadf58cc"
             "b3615cbd5488ac000000000100000003fdacf9b3eb077412e7a968d2e4f11b9a9d"
             "ee312d666187ed77ee7d26af16cb0b000000008c493046022100ea1608e70911ca"
             "0de5af51ba57ad23b9a51db8d28f82c53563c56a05c20f5a87022100a8bdc8b4a8"
             "acc8634c6b420410150775eb7f2474f5615f7fccd65af30f310fbf01410465fdf4"
             "9e29b06b9a1582287b6279014f834edc317695d125ef623c1cc3aaece245bd69fc"
             "ad7508666e9c74a49dc9056d5fc14338ef38118dc4afae5fe2c585caffffffff30"
             "9e1913634ecb50f3c4f83e96e70b2df071b497b8973a3e75429df397b5af830000"
             "00004948304502202bdb79c596a9ffc24e96f4386199aba386e9bc7b6071516e2b"
             "51dda942b3a1ed022100c53a857e76b724fc14d45311eac5019650d415c3abb542"
             "8f3aae16d8e69bec2301ffffffff2089e33491695080c9edc18a428f7d834db5b6"
             "d372df13ce2b1b0e0cbcb1e6c10000000049483045022100d4ce67c5896ee251c8"
             "10ac1ff9ceccd328b497c8f553ab6e08431e7d40bad6b5022033119c0c2b7d792d"
             "31f1187779c7bd95aefd93d90a715586d73801d9b47471c601ffffffff01007144"
             "60030000001976a914c7b55141d097ea5df7a0ed330cf794376e53ec8d88ac0000"
             "000001000000045bf0e214aa4069a3e792ecee1e1bf0c1d397cde8dd08138f4b72"
             "a00681743447000000008b48304502200c45de8c4f3e2c1821f2fc878cba97b1e6"
             "f8807d94930713aa1c86a67b9bf1e40221008581abfef2e30f957815fc89978423"
             "746b2086375ca8ecf359c85c2a5b7c88ad01410462bb73f76ca0994fcb8b4271e6"
             "fb7561f5c0f9ca0cf6485261c4a0dc894f4ab844c6cdfb97cd0b60ffb5018ffd62"
             "38f4d87270efb1d3ae37079b794a92d7ec95ffffffffd669f7d7958d40fc59d225"
             "3d88e0f248e29b599c80bbcec344a83dda5f9aa72c000000008a47304402207812"
             "4c8beeaa825f9e0b30bff96e564dd859432f2d0cb3b72d3d5d93d38d7e93022069"
             "1d233b6c0f995be5acb03d70a7f7a65b6bc9bdd426260f38a1346669507a360141"
             "0462bb73f76ca0994fcb8b4271e6fb7561f5c0f9ca0cf6485261c4a0dc894f4ab8"
             "44c6cdfb97cd0b60ffb5018ffd6238f4d87270efb1d3ae37079b794a92d7ec95ff"
             "fffffff878af0d93f5229a68166cf051fd372bb7a537232946e0a46f53636b4daf"
             "daa4000000008c493046022100c717d1714551663f69c3c5759bdbb3a0fcd3fab0"
             "23abc0e522fe6440de35d8290221008d9cbe25bffc44af2b18e81c58eb37293fd7"
             "fe1c2e7b46fc37ee8c96c50ab1e201410462bb73f76ca0994fcb8b4271e6fb7561"
             "f5c0f9ca0cf6485261c4a0dc894f4ab844c6cdfb97cd0b60ffb5018ffd6238f4d8"
             "7270efb1d3ae37079b794a92d7ec95ffffffff27f2b668859cd7f2f894aa0fd2d9"
             "e60963bcd07c88973f425f999b8cbfd7a1e2000000008c493046022100e0084714"
             "7cbf517bcc2f502f3ddc6d284358d102ed20d47a8aa788a62f0db780022100d17b"
             "2d6fa84dcaf1c95d88d7e7c30385aecf415588d749afd3ec81f6022cecd7014104"
             "62bb73f76ca0994fcb8b4271e6fb7561f5c0f9ca0cf6485261c4a0dc894f4ab844"
             "c6cdfb97cd0b60ffb5018ffd6238f4d87270efb1d3ae37079b794a92d7ec95ffff"
             "ffff0100c817a8040000001976a914b6efd80d99179f4f4ff6f4dd0a007d018c38"
             "5d2188ac000000000100000001834537b2f1ce8ef9373a258e10545ce5a50b758d"
             "f616cd4356e0032554ebd3c4000000008b483045022100e68f422dd7c34fdce11e"
             "eb4509ddae38201773dd62f284e8aa9d96f85099d0b002202243bd399ff96b649a"
             "0fad05fa759d6a882f0af8c90cf7632c2840c29070aec20141045e58067e815c2f"
             "464c6a2a15f987758374203895710c2d452442e28496ff38ba8f5fd901dc20e29e"
             "88477167fe4fc299bf818fd0d9e1632d467b2a3d9503b1aaffffffff0280d7e636"
             "030000001976a914f34c3e10eb387efe872acb614c89e78bfca7815d88ac404b4c"
             "00000000001976a914a84e272933aaf87e1715d7786c51dfaeb5b65a6f88ac0000"
             "0000010000000143ac81c8e6f6ef307dfe17f3d906d999e23e0189fda838c5510d"
             "850927e03ae7000000008c4930460221009c87c344760a64cb8ae6685a3eec2c1a"
             "c1bed5b88c87de51acd0e124f266c16602210082d07c037359c3a257b5c63ebd90"
             "f5a5edf97b2ac1c434b08ca998839f346dd40141040ba7e521fa7946d12edbb1d1"
             "e95a15c34bd4398195e86433c92b431cd315f455fe30032ede69cad9d1e1ed6c3c"
             "4ec0dbfced53438c625462afb792dcb098544bffffffff0240420f000000000019"
             "76a9144676d1b820d63ec272f1900d59d43bc6463d96f888ac40420f0000000000"
             "1976a914648d04341d00d7968b3405c034adc38d4d8fb9bd88ac00000000010000"
             "000248cc917501ea5c55f4a8d2009c0567c40cfe037c2e71af017d0a452ff705e3"
             "f1000000008b483045022100bf5fdc86dc5f08a5d5c8e43a8c9d5b1ed8c65562e2"
             "80007b52b133021acd9acc02205e325d613e555f772802bf413d36ba807892ed1a"
             "690a77811d3033b3de226e0a01410429fa713b124484cb2bd7b5557b2c0b9df7b2"
             "b1fee61825eadc5ae6c37a9920d38bfccdc7dc3cb0c47d7b173dbc9db8d37db0a3"
             "3ae487982c59c6f8606e9d1791ffffffff41ed70551dd7e841883ab8f0b16bf041"
             "76b7d1480e4f0af9f3d4c3595768d068000000008b4830450221008513ad65187b"
             "903aed1102d1d0c47688127658c51106753fed0151ce9c16b80902201432b9ebcb"
             "87bd04ceb2de66035fbbaf4bf8b00d1cfe41f1a1f7338f9ad79d210141049d4cf8"
             "0125bf50be1709f718c07ad15d0fc612b7da1f5570dddc35f2a352f0f27c978b06"
             "820edca9ef982c35fda2d255afba340068c5035552368bc7200c1488ffffffff01"
             "00093d00000000001976a9148edb68822f1ad580b043c7b3df2e400f8699eb4888"
             "ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
     // Match the last transaction
     filter.insert(uint256S(
         "0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
     std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f"
                          "19b15df0ac154"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 6);
 
     std::vector<uint256> vMatched;
     std::vector<unsigned int> vIndex;
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 
     // Also match the 4th transaction
     filter.insert(uint256S(
         "0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"));
     merkleBlock = CMerkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 2);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].second ==
                 uint256S("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de673"
                          "26471df5bc041"));
     BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 3);
 
     BOOST_CHECK(merkleBlock.vMatchedTxn[1] == pair);
 
     BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) ==
                 block.hashMerkleRoot);
     BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
     for (unsigned int i = 0; i < vMatched.size(); i++)
         BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_4_test_p2pubkey_only) {
     // Random real block
     // (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
     // With 7 txes
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000082bb869cf3a793432a66e826e05a6fc37469f8efb7421dc88067010000"
             "0000007f16c5962e8bd963659c793ce370d95f093bc7e367117b3c30c1f8fdd0d9"
             "728776381b4d4c86041b554b852907010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff07044c86041b0136ffff"
             "ffff0100f2052a01000000434104eaafc2314def4ca98ac970241bcab022b9c1e1"
             "f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad"
             "1357231a2252247d97a46a91ac000000000100000001bcad20a6a29827d1424f08"
             "989255120bf7f3e9e3cdaaa6bb31b0737fe048724300000000494830450220356e"
             "834b046cadc0f8ebb5a8a017b02de59c86305403dad52cd77b55af062ea1022100"
             "9253cd6c119d4729b77c978e1e2aa19f5ea6e0e52b3f16e32fa608cd5bab753901"
             "ffffffff02008d380c010000001976a9142b4b8072ecbba129b6453c63e129e643"
             "207249ca88ac0065cd1d000000001976a9141b8dd13b994bcfc787b32aeadf58cc"
             "b3615cbd5488ac000000000100000003fdacf9b3eb077412e7a968d2e4f11b9a9d"
             "ee312d666187ed77ee7d26af16cb0b000000008c493046022100ea1608e70911ca"
             "0de5af51ba57ad23b9a51db8d28f82c53563c56a05c20f5a87022100a8bdc8b4a8"
             "acc8634c6b420410150775eb7f2474f5615f7fccd65af30f310fbf01410465fdf4"
             "9e29b06b9a1582287b6279014f834edc317695d125ef623c1cc3aaece245bd69fc"
             "ad7508666e9c74a49dc9056d5fc14338ef38118dc4afae5fe2c585caffffffff30"
             "9e1913634ecb50f3c4f83e96e70b2df071b497b8973a3e75429df397b5af830000"
             "00004948304502202bdb79c596a9ffc24e96f4386199aba386e9bc7b6071516e2b"
             "51dda942b3a1ed022100c53a857e76b724fc14d45311eac5019650d415c3abb542"
             "8f3aae16d8e69bec2301ffffffff2089e33491695080c9edc18a428f7d834db5b6"
             "d372df13ce2b1b0e0cbcb1e6c10000000049483045022100d4ce67c5896ee251c8"
             "10ac1ff9ceccd328b497c8f553ab6e08431e7d40bad6b5022033119c0c2b7d792d"
             "31f1187779c7bd95aefd93d90a715586d73801d9b47471c601ffffffff01007144"
             "60030000001976a914c7b55141d097ea5df7a0ed330cf794376e53ec8d88ac0000"
             "000001000000045bf0e214aa4069a3e792ecee1e1bf0c1d397cde8dd08138f4b72"
             "a00681743447000000008b48304502200c45de8c4f3e2c1821f2fc878cba97b1e6"
             "f8807d94930713aa1c86a67b9bf1e40221008581abfef2e30f957815fc89978423"
             "746b2086375ca8ecf359c85c2a5b7c88ad01410462bb73f76ca0994fcb8b4271e6"
             "fb7561f5c0f9ca0cf6485261c4a0dc894f4ab844c6cdfb97cd0b60ffb5018ffd62"
             "38f4d87270efb1d3ae37079b794a92d7ec95ffffffffd669f7d7958d40fc59d225"
             "3d88e0f248e29b599c80bbcec344a83dda5f9aa72c000000008a47304402207812"
             "4c8beeaa825f9e0b30bff96e564dd859432f2d0cb3b72d3d5d93d38d7e93022069"
             "1d233b6c0f995be5acb03d70a7f7a65b6bc9bdd426260f38a1346669507a360141"
             "0462bb73f76ca0994fcb8b4271e6fb7561f5c0f9ca0cf6485261c4a0dc894f4ab8"
             "44c6cdfb97cd0b60ffb5018ffd6238f4d87270efb1d3ae37079b794a92d7ec95ff"
             "fffffff878af0d93f5229a68166cf051fd372bb7a537232946e0a46f53636b4daf"
             "daa4000000008c493046022100c717d1714551663f69c3c5759bdbb3a0fcd3fab0"
             "23abc0e522fe6440de35d8290221008d9cbe25bffc44af2b18e81c58eb37293fd7"
             "fe1c2e7b46fc37ee8c96c50ab1e201410462bb73f76ca0994fcb8b4271e6fb7561"
             "f5c0f9ca0cf6485261c4a0dc894f4ab844c6cdfb97cd0b60ffb5018ffd6238f4d8"
             "7270efb1d3ae37079b794a92d7ec95ffffffff27f2b668859cd7f2f894aa0fd2d9"
             "e60963bcd07c88973f425f999b8cbfd7a1e2000000008c493046022100e0084714"
             "7cbf517bcc2f502f3ddc6d284358d102ed20d47a8aa788a62f0db780022100d17b"
             "2d6fa84dcaf1c95d88d7e7c30385aecf415588d749afd3ec81f6022cecd7014104"
             "62bb73f76ca0994fcb8b4271e6fb7561f5c0f9ca0cf6485261c4a0dc894f4ab844"
             "c6cdfb97cd0b60ffb5018ffd6238f4d87270efb1d3ae37079b794a92d7ec95ffff"
             "ffff0100c817a8040000001976a914b6efd80d99179f4f4ff6f4dd0a007d018c38"
             "5d2188ac000000000100000001834537b2f1ce8ef9373a258e10545ce5a50b758d"
             "f616cd4356e0032554ebd3c4000000008b483045022100e68f422dd7c34fdce11e"
             "eb4509ddae38201773dd62f284e8aa9d96f85099d0b002202243bd399ff96b649a"
             "0fad05fa759d6a882f0af8c90cf7632c2840c29070aec20141045e58067e815c2f"
             "464c6a2a15f987758374203895710c2d452442e28496ff38ba8f5fd901dc20e29e"
             "88477167fe4fc299bf818fd0d9e1632d467b2a3d9503b1aaffffffff0280d7e636"
             "030000001976a914f34c3e10eb387efe872acb614c89e78bfca7815d88ac404b4c"
             "00000000001976a914a84e272933aaf87e1715d7786c51dfaeb5b65a6f88ac0000"
             "0000010000000143ac81c8e6f6ef307dfe17f3d906d999e23e0189fda838c5510d"
             "850927e03ae7000000008c4930460221009c87c344760a64cb8ae6685a3eec2c1a"
             "c1bed5b88c87de51acd0e124f266c16602210082d07c037359c3a257b5c63ebd90"
             "f5a5edf97b2ac1c434b08ca998839f346dd40141040ba7e521fa7946d12edbb1d1"
             "e95a15c34bd4398195e86433c92b431cd315f455fe30032ede69cad9d1e1ed6c3c"
             "4ec0dbfced53438c625462afb792dcb098544bffffffff0240420f000000000019"
             "76a9144676d1b820d63ec272f1900d59d43bc6463d96f888ac40420f0000000000"
             "1976a914648d04341d00d7968b3405c034adc38d4d8fb9bd88ac00000000010000"
             "000248cc917501ea5c55f4a8d2009c0567c40cfe037c2e71af017d0a452ff705e3"
             "f1000000008b483045022100bf5fdc86dc5f08a5d5c8e43a8c9d5b1ed8c65562e2"
             "80007b52b133021acd9acc02205e325d613e555f772802bf413d36ba807892ed1a"
             "690a77811d3033b3de226e0a01410429fa713b124484cb2bd7b5557b2c0b9df7b2"
             "b1fee61825eadc5ae6c37a9920d38bfccdc7dc3cb0c47d7b173dbc9db8d37db0a3"
             "3ae487982c59c6f8606e9d1791ffffffff41ed70551dd7e841883ab8f0b16bf041"
             "76b7d1480e4f0af9f3d4c3595768d068000000008b4830450221008513ad65187b"
             "903aed1102d1d0c47688127658c51106753fed0151ce9c16b80902201432b9ebcb"
             "87bd04ceb2de66035fbbaf4bf8b00d1cfe41f1a1f7338f9ad79d210141049d4cf8"
             "0125bf50be1709f718c07ad15d0fc612b7da1f5570dddc35f2a352f0f27c978b06"
             "820edca9ef982c35fda2d255afba340068c5035552368bc7200c1488ffffffff01"
             "00093d00000000001976a9148edb68822f1ad580b043c7b3df2e400f8699eb4888"
             "ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_P2PUBKEY_ONLY);
     // Match the generation pubkey
     filter.insert(ParseHex("04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f"
                            "134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce"
                            "13ad1357231a2252247d97a46a91"));
     // ...and the output address of the 4th transaction
     filter.insert(ParseHex("b6efd80d99179f4f4ff6f4dd0a007d018c385d21"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     // We should match the generation outpoint
     BOOST_CHECK(
         filter.contains(COutPoint(uint256S("0x147caa76786596590baa4e98f5d9f48b8"
                                            "6c7765e489f7a6ff3360fe5c674360b"),
                                   0)));
     // ... but not the 4th transaction's output (its not pay-2-pubkey)
     BOOST_CHECK(
         !filter.contains(COutPoint(uint256S("0x02981fa052f0481dbc5868f4fc216603"
                                             "5a10f27a03cfd2de67326471df5bc041"),
                                    0)));
 }
 
 BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none) {
     // Random real block
     // (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
     // With 7 txes
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000082bb869cf3a793432a66e826e05a6fc37469f8efb7421dc88067010000"
             "0000007f16c5962e8bd963659c793ce370d95f093bc7e367117b3c30c1f8fdd0d9"
             "728776381b4d4c86041b554b852907010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff07044c86041b0136ffff"
             "ffff0100f2052a01000000434104eaafc2314def4ca98ac970241bcab022b9c1e1"
             "f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad"
             "1357231a2252247d97a46a91ac000000000100000001bcad20a6a29827d1424f08"
             "989255120bf7f3e9e3cdaaa6bb31b0737fe048724300000000494830450220356e"
             "834b046cadc0f8ebb5a8a017b02de59c86305403dad52cd77b55af062ea1022100"
             "9253cd6c119d4729b77c978e1e2aa19f5ea6e0e52b3f16e32fa608cd5bab753901"
             "ffffffff02008d380c010000001976a9142b4b8072ecbba129b6453c63e129e643"
             "207249ca88ac0065cd1d000000001976a9141b8dd13b994bcfc787b32aeadf58cc"
             "b3615cbd5488ac000000000100000003fdacf9b3eb077412e7a968d2e4f11b9a9d"
             "ee312d666187ed77ee7d26af16cb0b000000008c493046022100ea1608e70911ca"
             "0de5af51ba57ad23b9a51db8d28f82c53563c56a05c20f5a87022100a8bdc8b4a8"
             "acc8634c6b420410150775eb7f2474f5615f7fccd65af30f310fbf01410465fdf4"
             "9e29b06b9a1582287b6279014f834edc317695d125ef623c1cc3aaece245bd69fc"
             "ad7508666e9c74a49dc9056d5fc14338ef38118dc4afae5fe2c585caffffffff30"
             "9e1913634ecb50f3c4f83e96e70b2df071b497b8973a3e75429df397b5af830000"
             "00004948304502202bdb79c596a9ffc24e96f4386199aba386e9bc7b6071516e2b"
             "51dda942b3a1ed022100c53a857e76b724fc14d45311eac5019650d415c3abb542"
             "8f3aae16d8e69bec2301ffffffff2089e33491695080c9edc18a428f7d834db5b6"
             "d372df13ce2b1b0e0cbcb1e6c10000000049483045022100d4ce67c5896ee251c8"
             "10ac1ff9ceccd328b497c8f553ab6e08431e7d40bad6b5022033119c0c2b7d792d"
             "31f1187779c7bd95aefd93d90a715586d73801d9b47471c601ffffffff01007144"
             "60030000001976a914c7b55141d097ea5df7a0ed330cf794376e53ec8d88ac0000"
             "000001000000045bf0e214aa4069a3e792ecee1e1bf0c1d397cde8dd08138f4b72"
             "a00681743447000000008b48304502200c45de8c4f3e2c1821f2fc878cba97b1e6"
             "f8807d94930713aa1c86a67b9bf1e40221008581abfef2e30f957815fc89978423"
             "746b2086375ca8ecf359c85c2a5b7c88ad01410462bb73f76ca0994fcb8b4271e6"
             "fb7561f5c0f9ca0cf6485261c4a0dc894f4ab844c6cdfb97cd0b60ffb5018ffd62"
             "38f4d87270efb1d3ae37079b794a92d7ec95ffffffffd669f7d7958d40fc59d225"
             "3d88e0f248e29b599c80bbcec344a83dda5f9aa72c000000008a47304402207812"
             "4c8beeaa825f9e0b30bff96e564dd859432f2d0cb3b72d3d5d93d38d7e93022069"
             "1d233b6c0f995be5acb03d70a7f7a65b6bc9bdd426260f38a1346669507a360141"
             "0462bb73f76ca0994fcb8b4271e6fb7561f5c0f9ca0cf6485261c4a0dc894f4ab8"
             "44c6cdfb97cd0b60ffb5018ffd6238f4d87270efb1d3ae37079b794a92d7ec95ff"
             "fffffff878af0d93f5229a68166cf051fd372bb7a537232946e0a46f53636b4daf"
             "daa4000000008c493046022100c717d1714551663f69c3c5759bdbb3a0fcd3fab0"
             "23abc0e522fe6440de35d8290221008d9cbe25bffc44af2b18e81c58eb37293fd7"
             "fe1c2e7b46fc37ee8c96c50ab1e201410462bb73f76ca0994fcb8b4271e6fb7561"
             "f5c0f9ca0cf6485261c4a0dc894f4ab844c6cdfb97cd0b60ffb5018ffd6238f4d8"
             "7270efb1d3ae37079b794a92d7ec95ffffffff27f2b668859cd7f2f894aa0fd2d9"
             "e60963bcd07c88973f425f999b8cbfd7a1e2000000008c493046022100e0084714"
             "7cbf517bcc2f502f3ddc6d284358d102ed20d47a8aa788a62f0db780022100d17b"
             "2d6fa84dcaf1c95d88d7e7c30385aecf415588d749afd3ec81f6022cecd7014104"
             "62bb73f76ca0994fcb8b4271e6fb7561f5c0f9ca0cf6485261c4a0dc894f4ab844"
             "c6cdfb97cd0b60ffb5018ffd6238f4d87270efb1d3ae37079b794a92d7ec95ffff"
             "ffff0100c817a8040000001976a914b6efd80d99179f4f4ff6f4dd0a007d018c38"
             "5d2188ac000000000100000001834537b2f1ce8ef9373a258e10545ce5a50b758d"
             "f616cd4356e0032554ebd3c4000000008b483045022100e68f422dd7c34fdce11e"
             "eb4509ddae38201773dd62f284e8aa9d96f85099d0b002202243bd399ff96b649a"
             "0fad05fa759d6a882f0af8c90cf7632c2840c29070aec20141045e58067e815c2f"
             "464c6a2a15f987758374203895710c2d452442e28496ff38ba8f5fd901dc20e29e"
             "88477167fe4fc299bf818fd0d9e1632d467b2a3d9503b1aaffffffff0280d7e636"
             "030000001976a914f34c3e10eb387efe872acb614c89e78bfca7815d88ac404b4c"
             "00000000001976a914a84e272933aaf87e1715d7786c51dfaeb5b65a6f88ac0000"
             "0000010000000143ac81c8e6f6ef307dfe17f3d906d999e23e0189fda838c5510d"
             "850927e03ae7000000008c4930460221009c87c344760a64cb8ae6685a3eec2c1a"
             "c1bed5b88c87de51acd0e124f266c16602210082d07c037359c3a257b5c63ebd90"
             "f5a5edf97b2ac1c434b08ca998839f346dd40141040ba7e521fa7946d12edbb1d1"
             "e95a15c34bd4398195e86433c92b431cd315f455fe30032ede69cad9d1e1ed6c3c"
             "4ec0dbfced53438c625462afb792dcb098544bffffffff0240420f000000000019"
             "76a9144676d1b820d63ec272f1900d59d43bc6463d96f888ac40420f0000000000"
             "1976a914648d04341d00d7968b3405c034adc38d4d8fb9bd88ac00000000010000"
             "000248cc917501ea5c55f4a8d2009c0567c40cfe037c2e71af017d0a452ff705e3"
             "f1000000008b483045022100bf5fdc86dc5f08a5d5c8e43a8c9d5b1ed8c65562e2"
             "80007b52b133021acd9acc02205e325d613e555f772802bf413d36ba807892ed1a"
             "690a77811d3033b3de226e0a01410429fa713b124484cb2bd7b5557b2c0b9df7b2"
             "b1fee61825eadc5ae6c37a9920d38bfccdc7dc3cb0c47d7b173dbc9db8d37db0a3"
             "3ae487982c59c6f8606e9d1791ffffffff41ed70551dd7e841883ab8f0b16bf041"
             "76b7d1480e4f0af9f3d4c3595768d068000000008b4830450221008513ad65187b"
             "903aed1102d1d0c47688127658c51106753fed0151ce9c16b80902201432b9ebcb"
             "87bd04ceb2de66035fbbaf4bf8b00d1cfe41f1a1f7338f9ad79d210141049d4cf8"
             "0125bf50be1709f718c07ad15d0fc612b7da1f5570dddc35f2a352f0f27c978b06"
             "820edca9ef982c35fda2d255afba340068c5035552368bc7200c1488ffffffff01"
             "00093d00000000001976a9148edb68822f1ad580b043c7b3df2e400f8699eb4888"
             "ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
 
     CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_NONE);
     // Match the generation pubkey
     filter.insert(ParseHex("04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f"
                            "134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce"
                            "13ad1357231a2252247d97a46a91"));
     // ...and the output address of the 4th transaction
     filter.insert(ParseHex("b6efd80d99179f4f4ff6f4dd0a007d018c385d21"));
 
     CMerkleBlock merkleBlock(block, filter);
     BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
 
     // We shouldn't match any outpoints (UPDATE_NONE)
     BOOST_CHECK(
         !filter.contains(COutPoint(uint256S("0x147caa76786596590baa4e98f5d9f48b"
                                             "86c7765e489f7a6ff3360fe5c674360b"),
                                    0)));
     BOOST_CHECK(
         !filter.contains(COutPoint(uint256S("0x02981fa052f0481dbc5868f4fc216603"
                                             "5a10f27a03cfd2de67326471df5bc041"),
                                    0)));
 }
 
 static std::vector<uint8_t> RandomData() {
     uint256 r = InsecureRand256();
     return std::vector<uint8_t>(r.begin(), r.end());
 }
 
 BOOST_AUTO_TEST_CASE(rolling_bloom) {
     // last-100-entry, 1% false positive:
     CRollingBloomFilter rb1(100, 0.01);
 
     // Overfill:
     static const int DATASIZE = 399;
     std::vector<uint8_t> data[DATASIZE];
     for (int i = 0; i < DATASIZE; i++) {
         data[i] = RandomData();
         rb1.insert(data[i]);
     }
     // Last 100 guaranteed to be remembered:
     for (int i = 299; i < DATASIZE; i++) {
         BOOST_CHECK(rb1.contains(data[i]));
     }
 
     // false positive rate is 1%, so we should get about 100 hits if
     // testing 10,000 random keys. We get worst-case false positive
     // behavior when the filter is as full as possible, which is
     // when we've inserted one minus an integer multiple of nElement*2.
     unsigned int nHits = 0;
     for (int i = 0; i < 10000; i++) {
         if (rb1.contains(RandomData())) ++nHits;
     }
     // Run test_bitcoin with --log_level=message to see BOOST_TEST_MESSAGEs:
     BOOST_TEST_MESSAGE("RollingBloomFilter got "
                        << nHits << " false positives (~100 expected)");
 
     // Insanely unlikely to get a fp count outside this range:
     BOOST_CHECK(nHits > 25);
     BOOST_CHECK(nHits < 175);
 
     BOOST_CHECK(rb1.contains(data[DATASIZE - 1]));
     rb1.reset();
     BOOST_CHECK(!rb1.contains(data[DATASIZE - 1]));
 
     // Now roll through data, make sure last 100 entries
     // are always remembered:
     for (int i = 0; i < DATASIZE; i++) {
         if (i >= 100) BOOST_CHECK(rb1.contains(data[i - 100]));
         rb1.insert(data[i]);
         BOOST_CHECK(rb1.contains(data[i]));
     }
 
     // Insert 999 more random entries:
     for (int i = 0; i < 999; i++) {
         std::vector<uint8_t> d = RandomData();
         rb1.insert(d);
         BOOST_CHECK(rb1.contains(d));
     }
     // Sanity check to make sure the filter isn't just filling up:
     nHits = 0;
     for (int i = 0; i < DATASIZE; i++) {
         if (rb1.contains(data[i])) ++nHits;
     }
     // Expect about 5 false positives, more than 100 means
     // something is definitely broken.
     BOOST_TEST_MESSAGE("RollingBloomFilter got "
                        << nHits << " false positives (~5 expected)");
     BOOST_CHECK(nHits < 100);
 
     // last-1000-entry, 0.01% false positive:
     CRollingBloomFilter rb2(1000, 0.001);
     for (int i = 0; i < DATASIZE; i++) {
         rb2.insert(data[i]);
     }
     // ... room for all of them:
     for (int i = 0; i < DATASIZE; i++) {
         BOOST_CHECK(rb2.contains(data[i]));
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/bswap_tests.cpp b/src/test/bswap_tests.cpp
index f6ccec9d9..7db6c5074 100644
--- a/src/test/bswap_tests.cpp
+++ b/src/test/bswap_tests.cpp
@@ -1,25 +1,26 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "compat/byteswap.h"
-#include "test/test_bitcoin.h"
+#include <compat/byteswap.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(bswap_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(bswap_tests) {
     // Sibling in bitcoin/src/qt/test/compattests.cpp
     uint16_t u1 = 0x1234;
     uint32_t u2 = 0x56789abc;
     uint64_t u3 = 0xdef0123456789abc;
     uint16_t e1 = 0x3412;
     uint32_t e2 = 0xbc9a7856;
     uint64_t e3 = 0xbc9a78563412f0de;
     BOOST_CHECK(bswap_16(u1) == e1);
     BOOST_CHECK(bswap_32(u2) == e2);
     BOOST_CHECK(bswap_64(u3) == e3);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/cashaddr_tests.cpp b/src/test/cashaddr_tests.cpp
index 565a4d4a4..a7ac589eb 100644
--- a/src/test/cashaddr_tests.cpp
+++ b/src/test/cashaddr_tests.cpp
@@ -1,117 +1,118 @@
 // Copyright (c) 2017 Pieter Wuille
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "cashaddr.h"
-#include "test/test_bitcoin.h"
+#include <cashaddr.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 static std::pair<std::string, std::vector<uint8_t>>
 CashAddrDecode(const std::string &str) {
     return cashaddr::Decode(str, "");
 }
 
 BOOST_FIXTURE_TEST_SUITE(cashaddr_tests, BasicTestingSetup)
 
 bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2) {
     if (s1.size() != s2.size()) {
         return false;
     }
 
     for (size_t i = 0; i < s1.size(); ++i) {
         char c1 = s1[i];
         if (c1 >= 'A' && c1 <= 'Z') {
             c1 -= ('A' - 'a');
         }
         char c2 = s2[i];
         if (c2 >= 'A' && c2 <= 'Z') {
             c2 -= ('A' - 'a');
         }
         if (c1 != c2) {
             return false;
         }
     }
 
     return true;
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_valid) {
     static const std::string CASES[] = {
         "prefix:x64nx6hz",
         "PREFIX:X64NX6HZ",
         "p:gpf8m4h7",
         "bitcoincash:qpzry9x8gf2tvdw0s3jn54khce6mua7lcw20ayyn",
         "bchtest:testnetaddress4d6njnut",
         "bchreg:555555555555555555555555555555555555555555555udxmlmrz",
     };
 
     for (const std::string &str : CASES) {
         auto ret = CashAddrDecode(str);
         BOOST_CHECK_MESSAGE(!ret.first.empty(), str);
         std::string recode = cashaddr::Encode(ret.first, ret.second);
         BOOST_CHECK_MESSAGE(!recode.empty(), str);
         BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(str, recode), str);
     }
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_invalid) {
     static const std::string CASES[] = {
         "prefix:x32nx6hz",
         "prEfix:x64nx6hz",
         "prefix:x64nx6Hz",
         "pref1x:6m8cxv73",
         "prefix:",
         ":u9wsx07j",
         "bchreg:555555555555555555x55555555555555555555555555udxmlmrz",
         "bchreg:555555555555555555555555555555551555555555555udxmlmrz",
         "pre:fix:x32nx6hz",
         "prefixx64nx6hz",
     };
 
     for (const std::string &str : CASES) {
         auto ret = CashAddrDecode(str);
         BOOST_CHECK_MESSAGE(ret.first.empty(), str);
     }
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_rawencode) {
     typedef std::pair<std::string, std::vector<uint8_t>> raw;
 
     raw toEncode;
     toEncode.first = "helloworld";
     toEncode.second = {0x1f, 0x0d};
 
     std::string encoded = cashaddr::Encode(toEncode.first, toEncode.second);
     raw decoded = CashAddrDecode(encoded);
 
     BOOST_CHECK_EQUAL(toEncode.first, decoded.first);
     BOOST_CHECK_EQUAL_COLLECTIONS(begin(toEncode.second), end(toEncode.second),
                                   begin(decoded.second), end(decoded.second));
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_noprefix) {
     static const std::pair<std::string, std::string> CASES[] = {
         {"bitcoincash", "qpzry9x8gf2tvdw0s3jn54khce6mua7lcw20ayyn"},
         {"prefix", "x64nx6hz"},
         {"PREFIX", "X64NX6HZ"},
         {"p", "gpf8m4h7"},
         {"bitcoincash", "qpzry9x8gf2tvdw0s3jn54khce6mua7lcw20ayyn"},
         {"bchtest", "testnetaddress4d6njnut"},
         {"bchreg", "555555555555555555555555555555555555555555555udxmlmrz"},
     };
 
     for (const std::pair<std::string, std::string> &c : CASES) {
         std::string prefix = c.first;
         std::string payload = c.second;
         std::string addr = prefix + ":" + payload;
         auto ret = cashaddr::Decode(payload, prefix);
         BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(ret.first, prefix), addr);
         std::string recode = cashaddr::Encode(ret.first, ret.second);
         BOOST_CHECK_MESSAGE(!recode.empty(), addr);
         BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(addr, recode), addr);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/cashaddrenc_tests.cpp b/src/test/cashaddrenc_tests.cpp
index 1dbfa82ee..daec09ad4 100644
--- a/src/test/cashaddrenc_tests.cpp
+++ b/src/test/cashaddrenc_tests.cpp
@@ -1,452 +1,454 @@
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "cashaddr.h"
-#include "cashaddrenc.h"
-#include "chainparams.h"
-#include "random.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
+#include <cashaddrenc.h>
+
+#include <cashaddr.h>
+#include <chainparams.h>
+#include <random.h>
+#include <uint256.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 namespace {
 
 std::vector<std::string> GetNetworks() {
     return {CBaseChainParams::MAIN, CBaseChainParams::TESTNET,
             CBaseChainParams::REGTEST};
 }
 
 uint160 insecure_GetRandUInt160(FastRandomContext &rand) {
     uint160 n;
     for (uint8_t *c = n.begin(); c != n.end(); ++c) {
         *c = static_cast<uint8_t>(rand.rand32());
     }
     return n;
 }
 
 std::vector<uint8_t> insecure_GetRandomByteArray(FastRandomContext &rand,
                                                  size_t n) {
     std::vector<uint8_t> out;
     out.reserve(n);
 
     for (size_t i = 0; i < n; i++) {
         out.push_back(uint8_t(rand.randbits(8)));
     }
     return out;
 }
 
 class DstTypeChecker : public boost::static_visitor<void> {
 public:
     void operator()(const CKeyID &id) { isKey = true; }
     void operator()(const CScriptID &id) { isScript = true; }
     void operator()(const CNoDestination &) {}
 
     static bool IsScriptDst(const CTxDestination &d) {
         DstTypeChecker checker;
         boost::apply_visitor(checker, d);
         return checker.isScript;
     }
 
     static bool IsKeyDst(const CTxDestination &d) {
         DstTypeChecker checker;
         boost::apply_visitor(checker, d);
         return checker.isKey;
     }
 
 private:
     DstTypeChecker() : isKey(false), isScript(false) {}
     bool isKey;
     bool isScript;
 };
 
 // Map all possible size bits in the version to the expected size of the
 // hash in bytes.
 const std::array<std::pair<uint8_t, uint32_t>, 8> valid_sizes = {
     {{0, 20}, {1, 24}, {2, 28}, {3, 32}, {4, 40}, {5, 48}, {6, 56}, {7, 64}}};
 
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(cashaddrenc_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(encode_decode_all_sizes) {
     FastRandomContext rand(true);
     const std::string prefix = "bitcoincash";
 
     for (auto ps : valid_sizes) {
         std::vector<uint8_t> data =
             insecure_GetRandomByteArray(rand, ps.second);
         CashAddrContent content = {PUBKEY_TYPE, data};
         std::vector<uint8_t> packed_data = PackCashAddrContent(content);
 
         // Check that the packed size is correct
         BOOST_CHECK_EQUAL(packed_data[1] >> 2, ps.first);
         std::string address = cashaddr::Encode(prefix, packed_data);
 
         // Check that the address decodes properly
         CashAddrContent decoded = DecodeCashAddrContent(address, prefix);
         BOOST_CHECK_EQUAL_COLLECTIONS(
             std::begin(content.hash), std::end(content.hash),
             std::begin(decoded.hash), std::end(decoded.hash));
     }
 }
 
 BOOST_AUTO_TEST_CASE(check_packaddr_throws) {
     FastRandomContext rand(true);
 
     for (auto ps : valid_sizes) {
         std::vector<uint8_t> data =
             insecure_GetRandomByteArray(rand, ps.second - 1);
         CashAddrContent content = {PUBKEY_TYPE, data};
         BOOST_CHECK_THROW(PackCashAddrContent(content), std::runtime_error);
     }
 }
 
 BOOST_AUTO_TEST_CASE(encode_decode) {
     std::vector<CTxDestination> toTest = {CNoDestination{},
                                           CKeyID(uint160S("badf00d")),
                                           CScriptID(uint160S("f00dbad"))};
 
     for (auto dst : toTest) {
         for (auto net : GetNetworks()) {
             const auto netParams = CreateChainParams(net);
             std::string encoded = EncodeCashAddr(dst, *netParams);
             CTxDestination decoded = DecodeCashAddr(encoded, *netParams);
             BOOST_CHECK(dst == decoded);
         }
     }
 }
 
 // Check that an encoded cash address is not valid on another network.
 BOOST_AUTO_TEST_CASE(invalid_on_wrong_network) {
     const CTxDestination dst = CKeyID(uint160S("c0ffee"));
     const CTxDestination invalidDst = CNoDestination{};
 
     for (auto net : GetNetworks()) {
         for (auto otherNet : GetNetworks()) {
             if (net == otherNet) continue;
 
             const auto netParams = CreateChainParams(net);
             std::string encoded = EncodeCashAddr(dst, *netParams);
 
             const auto otherNetParams = CreateChainParams(otherNet);
             CTxDestination decoded = DecodeCashAddr(encoded, *otherNetParams);
             BOOST_CHECK(decoded != dst);
             BOOST_CHECK(decoded == invalidDst);
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(random_dst) {
     FastRandomContext rand(true);
 
     const size_t NUM_TESTS = 5000;
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     for (size_t i = 0; i < NUM_TESTS; ++i) {
         uint160 hash = insecure_GetRandUInt160(rand);
         const CTxDestination dst_key = CKeyID(hash);
         const CTxDestination dst_scr = CScriptID(hash);
 
         const std::string encoded_key = EncodeCashAddr(dst_key, *params);
         const CTxDestination decoded_key = DecodeCashAddr(encoded_key, *params);
 
         const std::string encoded_scr = EncodeCashAddr(dst_scr, *params);
         const CTxDestination decoded_scr = DecodeCashAddr(encoded_scr, *params);
 
         std::string err("cashaddr failed for hash: ");
         err += hash.ToString();
 
         BOOST_CHECK_MESSAGE(dst_key == decoded_key, err);
         BOOST_CHECK_MESSAGE(dst_scr == decoded_scr, err);
 
         BOOST_CHECK_MESSAGE(DstTypeChecker::IsKeyDst(decoded_key), err);
         BOOST_CHECK_MESSAGE(DstTypeChecker::IsScriptDst(decoded_scr), err);
     }
 }
 
 /**
  * Cashaddr payload made of 5-bit nibbles. The last one is padded. When
  * converting back to bytes, this extra padding is truncated. In order to ensure
  * cashaddr are cannonicals, we check that the data we truncate is zeroed.
  */
 BOOST_AUTO_TEST_CASE(check_padding) {
     uint8_t version = 0;
     std::vector<uint8_t> data = {version};
     for (size_t i = 0; i < 33; ++i) {
         data.push_back(1);
     }
 
     BOOST_CHECK_EQUAL(data.size(), 34UL);
 
     const CTxDestination nodst = CNoDestination{};
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     for (uint8_t i = 0; i < 32; i++) {
         data[data.size() - 1] = i;
         std::string fake = cashaddr::Encode(params->CashAddrPrefix(), data);
         CTxDestination dst = DecodeCashAddr(fake, *params);
 
         // We have 168 bits of payload encoded as 170 bits in 5 bits nimbles. As
         // a result, we must have 2 zeros.
         if (i & 0x03) {
             BOOST_CHECK(dst == nodst);
         } else {
             BOOST_CHECK(dst != nodst);
         }
     }
 }
 
 /**
  * We ensure type is extracted properly from the version.
  */
 BOOST_AUTO_TEST_CASE(check_type) {
     std::vector<uint8_t> data;
     data.resize(34);
 
     const std::string prefix = "bitcoincash";
 
     for (uint8_t v = 0; v < 16; v++) {
         std::fill(begin(data), end(data), 0);
         data[0] = v;
         auto content =
             DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
         BOOST_CHECK_EQUAL(content.type, v);
         BOOST_CHECK_EQUAL(content.hash.size(), 20UL);
 
         // Check that using the reserved bit result in a failure.
         data[0] |= 0x10;
         content = DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), 0UL);
     }
 }
 
 /**
  * We ensure size is extracted and checked properly.
  */
 BOOST_AUTO_TEST_CASE(check_size) {
     const CTxDestination nodst = CNoDestination{};
     const std::string prefix = "bitcoincash";
 
     std::vector<uint8_t> data;
 
     for (auto ps : valid_sizes) {
         // Number of bytes required for a 5-bit packed version of a hash, with
         // version byte.  Add half a byte(4) so integer math provides the next
         // multiple-of-5 that would fit all the data.
         size_t expectedSize = (8 * (1 + ps.second) + 4) / 5;
         data.resize(expectedSize);
         std::fill(begin(data), end(data), 0);
         // After conversion from 8 bit packing to 5 bit packing, the size will
         // be in the second 5-bit group, shifted left twice.
         data[1] = ps.first << 2;
 
         auto content =
             DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
 
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), ps.second);
 
         data.push_back(0);
         content = DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
 
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), 0UL);
 
         data.pop_back();
         data.pop_back();
         content = DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
 
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), 0UL);
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_encode_address) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     std::vector<std::vector<uint8_t>> hash{
         {118, 160, 64,  83, 189, 160, 168, 139, 218, 81,
          119, 184, 106, 21, 195, 178, 159, 85,  152, 115},
         {203, 72, 18, 50, 41,  156, 213, 116, 49,  81,
          172, 75, 45, 99, 174, 25,  142, 123, 176, 169},
         {1,   31, 40,  228, 115, 201, 95, 64,  19,  215,
          213, 62, 197, 251, 195, 180, 45, 248, 237, 16}};
 
     std::vector<std::string> pubkey = {
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
         "bitcoincash:qr95sy3j9xwd2ap32xkykttr4cvcu7as4y0qverfuy",
         "bitcoincash:qqq3728yw0y47sqn6l2na30mcw6zm78dzqre909m2r"};
     std::vector<std::string> script = {
         "bitcoincash:ppm2qsznhks23z7629mms6s4cwef74vcwvn0h829pq",
         "bitcoincash:pr95sy3j9xwd2ap32xkykttr4cvcu7as4yc93ky28e",
         "bitcoincash:pqq3728yw0y47sqn6l2na30mcw6zm78dzq5ucqzc37"};
 
     for (size_t i = 0; i < hash.size(); ++i) {
         const CTxDestination dstKey = CKeyID(uint160(hash[i]));
         BOOST_CHECK_EQUAL(pubkey[i], EncodeCashAddr(dstKey, *params));
 
         CashAddrContent keyContent{PUBKEY_TYPE, hash[i]};
         BOOST_CHECK_EQUAL(pubkey[i], EncodeCashAddr("bitcoincash", keyContent));
 
         const CTxDestination dstScript = CScriptID(uint160(hash[i]));
         BOOST_CHECK_EQUAL(script[i], EncodeCashAddr(dstScript, *params));
 
         CashAddrContent scriptContent{SCRIPT_TYPE, hash[i]};
         BOOST_CHECK_EQUAL(script[i],
                           EncodeCashAddr("bitcoincash", scriptContent));
     }
 }
 
 struct CashAddrTestVector {
     std::string prefix;
     CashAddrType type;
     std::vector<uint8_t> hash;
     std::string addr;
 };
 
 BOOST_AUTO_TEST_CASE(test_vectors) {
     std::vector<CashAddrTestVector> cases = {
         // 20 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),
          "bitcoincash:qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg2"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),
          "bchtest:pr6m7j9njldwwzlg9v7v53unlr4jkmx6eyvwc0uz5t"},
         {"prefix", CashAddrType(15),
          ParseHex("F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),
          "prefix:0r6m7j9njldwwzlg9v7v53unlr4jkmx6ey3qnjwsrf"},
         // 24 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),
          "bitcoincash:q9adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2ws4mr9g0"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),
          "bchtest:p9adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2u94tsynr"},
         {"prefix", CashAddrType(15),
          ParseHex("7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),
          "prefix:09adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2p29kc2lp"},
         // 28 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),
          "bitcoincash:qgagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkcw59jxxuz"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),
          "bchtest:pgagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkcvs7md7wt"},
         {"prefix", CashAddrType(15),
          ParseHex("3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),
          "prefix:0gagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkc5djw8s9g"},
         // 32 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825"
                   "C060"),
          "bitcoincash:"
          "qvch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxq5nlegake"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825"
                   "C060"),
          "bchtest:"
          "pvch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxq7fqng6m6"},
         {"prefix", CashAddrType(15),
          ParseHex("3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825"
                   "C060"),
          "prefix:"
          "0vch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxqsh6jgp6w"},
         // 40 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("C07138323E00FA4FC122D3B85B9628EA810B3F381706385E289B0B256311"
                   "97D194B5C238BEB136FB"),
          "bitcoincash:"
          "qnq8zwpj8cq05n7pytfmskuk9r4gzzel8qtsvwz79zdskftrzxtar994cgutavfklv39g"
          "r3uvz"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("C07138323E00FA4FC122D3B85B9628EA810B3F381706385E289B0B256311"
                   "97D194B5C238BEB136FB"),
          "bchtest:"
          "pnq8zwpj8cq05n7pytfmskuk9r4gzzel8qtsvwz79zdskftrzxtar994cgutavfklvmgm"
          "6ynej"},
         {"prefix", CashAddrType(15),
          ParseHex("C07138323E00FA4FC122D3B85B9628EA810B3F381706385E289B0B256311"
                   "97D194B5C238BEB136FB"),
          "prefix:"
          "0nq8zwpj8cq05n7pytfmskuk9r4gzzel8qtsvwz79zdskftrzxtar994cgutavfklvwsv"
          "ctzqy"},
         // 48 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("E361CA9A7F99107C17A622E047E3745D3E19CF804ED63C5C40C6BA763696"
                   "B98241223D8CE62AD48D863F4CB18C930E4C"),
          "bitcoincash:"
          "qh3krj5607v3qlqh5c3wq3lrw3wnuxw0sp8dv0zugrrt5a3kj6ucysfz8kxwv2k53krr7"
          "n933jfsunqex2w82sl"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("E361CA9A7F99107C17A622E047E3745D3E19CF804ED63C5C40C6BA763696"
                   "B98241223D8CE62AD48D863F4CB18C930E4C"),
          "bchtest:"
          "ph3krj5607v3qlqh5c3wq3lrw3wnuxw0sp8dv0zugrrt5a3kj6ucysfz8kxwv2k53krr7"
          "n933jfsunqnzf7mt6x"},
         {"prefix", CashAddrType(15),
          ParseHex("E361CA9A7F99107C17A622E047E3745D3E19CF804ED63C5C40C6BA763696"
                   "B98241223D8CE62AD48D863F4CB18C930E4C"),
          "prefix:"
          "0h3krj5607v3qlqh5c3wq3lrw3wnuxw0sp8dv0zugrrt5a3kj6ucysfz8kxwv2k53krr7"
          "n933jfsunqakcssnmn"},
         // 56 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("D9FA7C4C6EF56DC4FF423BAAE6D495DBFF663D034A72D1DC7D52CBFE7D1E"
                   "6858F9D523AC0A7A5C34077638E4DD1A701BD017842789982041"),
          "bitcoincash:"
          "qmvl5lzvdm6km38lgga64ek5jhdl7e3aqd9895wu04fvhlnare5937w4ywkq57juxsrhv"
          "w8ym5d8qx7sz7zz0zvcypqscw8jd03f"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("D9FA7C4C6EF56DC4FF423BAAE6D495DBFF663D034A72D1DC7D52CBFE7D1E"
                   "6858F9D523AC0A7A5C34077638E4DD1A701BD017842789982041"),
          "bchtest:"
          "pmvl5lzvdm6km38lgga64ek5jhdl7e3aqd9895wu04fvhlnare5937w4ywkq57juxsrhv"
          "w8ym5d8qx7sz7zz0zvcypqs6kgdsg2g"},
         {"prefix", CashAddrType(15),
          ParseHex("D9FA7C4C6EF56DC4FF423BAAE6D495DBFF663D034A72D1DC7D52CBFE7D1E"
                   "6858F9D523AC0A7A5C34077638E4DD1A701BD017842789982041"),
          "prefix:"
          "0mvl5lzvdm6km38lgga64ek5jhdl7e3aqd9895wu04fvhlnare5937w4ywkq57juxsrhv"
          "w8ym5d8qx7sz7zz0zvcypqsgjrqpnw8"},
         // 64 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("D0F346310D5513D9E01E299978624BA883E6BDA8F4C60883C10F28C2967E"
                   "67EC77ECC7EEEAEAFC6DA89FAD72D11AC961E164678B868AEEEC5F2C1DA0"
                   "8884175B"),
          "bitcoincash:"
          "qlg0x333p4238k0qrc5ej7rzfw5g8e4a4r6vvzyrcy8j3s5k0en7calvclhw46hudk5fl"
          "ttj6ydvjc0pv3nchp52amk97tqa5zygg96mtky5sv5w"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("D0F346310D5513D9E01E299978624BA883E6BDA8F4C60883C10F28C2967E"
                   "67EC77ECC7EEEAEAFC6DA89FAD72D11AC961E164678B868AEEEC5F2C1DA0"
                   "8884175B"),
          "bchtest:"
          "plg0x333p4238k0qrc5ej7rzfw5g8e4a4r6vvzyrcy8j3s5k0en7calvclhw46hudk5fl"
          "ttj6ydvjc0pv3nchp52amk97tqa5zygg96mc773cwez"},
         {"prefix", CashAddrType(15),
          ParseHex("D0F346310D5513D9E01E299978624BA883E6BDA8F4C60883C10F28C2967E"
                   "67EC77ECC7EEEAEAFC6DA89FAD72D11AC961E164678B868AEEEC5F2C1DA0"
                   "8884175B"),
          "prefix:"
          "0lg0x333p4238k0qrc5ej7rzfw5g8e4a4r6vvzyrcy8j3s5k0en7calvclhw46hudk5fl"
          "ttj6ydvjc0pv3nchp52amk97tqa5zygg96ms92w6845"},
     };
 
     for (const auto &t : cases) {
         CashAddrContent content{t.type, t.hash};
         BOOST_CHECK_EQUAL(t.addr, EncodeCashAddr(t.prefix, content));
 
         std::string err("hash mistmatch for address: ");
         err += t.addr;
 
         content = DecodeCashAddrContent(t.addr, t.prefix);
         BOOST_CHECK_EQUAL(t.type, content.type);
         BOOST_CHECK_MESSAGE(t.hash == content.hash, err);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/checkdatasig_tests.cpp b/src/test/checkdatasig_tests.cpp
index 6ab745f61..08415ffd8 100644
--- a/src/test/checkdatasig_tests.cpp
+++ b/src/test/checkdatasig_tests.cpp
@@ -1,255 +1,255 @@
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "test/lcg.h"
-#include "test/test_bitcoin.h"
+#include <policy/policy.h>
+#include <script/interpreter.h>
 
-#include "policy/policy.h"
-#include "script/interpreter.h"
+#include <test/lcg.h>
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <array>
 #include <bitset>
 
 typedef std::vector<uint8_t> valtype;
 typedef std::vector<valtype> stacktype;
 
 BOOST_FIXTURE_TEST_SUITE(checkdatasig_tests, BasicTestingSetup)
 
 std::array<uint32_t, 3> flagset{
     {0, STANDARD_SCRIPT_VERIFY_FLAGS, MANDATORY_SCRIPT_VERIFY_FLAGS}};
 
 const uint8_t vchPrivkey[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
 struct KeyData {
     CKey privkey, privkeyC;
     CPubKey pubkey, pubkeyC, pubkeyH;
 
     KeyData() {
         privkey.Set(vchPrivkey, vchPrivkey + 32, false);
         privkeyC.Set(vchPrivkey, vchPrivkey + 32, true);
         pubkey = privkey.GetPubKey();
         pubkeyH = privkey.GetPubKey();
         pubkeyC = privkeyC.GetPubKey();
         *const_cast<uint8_t *>(&pubkeyH[0]) = 0x06 | (pubkeyH[64] & 1);
     }
 };
 
 static void CheckError(uint32_t flags, const stacktype &original_stack,
                        const CScript &script, ScriptError expected) {
     BaseSignatureChecker sigchecker;
     ScriptError err = SCRIPT_ERR_OK;
     stacktype stack{original_stack};
     bool r = EvalScript(stack, script, flags, sigchecker, &err);
     BOOST_CHECK(!r);
     BOOST_CHECK_EQUAL(err, expected);
 }
 
 static void CheckPass(uint32_t flags, const stacktype &original_stack,
                       const CScript &script, const stacktype &expected) {
     BaseSignatureChecker sigchecker;
     ScriptError err = SCRIPT_ERR_OK;
     stacktype stack{original_stack};
     bool r = EvalScript(stack, script, flags, sigchecker, &err);
     BOOST_CHECK(r);
     BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
     BOOST_CHECK(stack == expected);
 }
 
 /**
  * General utility functions to check for script passing/failing.
  */
 static void CheckTestResultForAllFlags(const stacktype &original_stack,
                                        const CScript &script,
                                        const stacktype &expected) {
     for (uint32_t flags : flagset) {
         // Make sure that we get a bad opcode when the activation flag is not
         // passed.
         CheckError(flags, original_stack, script, SCRIPT_ERR_BAD_OPCODE);
 
         // The script execute as expected if the opcodes are activated.
         CheckPass(flags | SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
                   expected);
     }
 }
 
 static void CheckErrorForAllFlags(const stacktype &original_stack,
                                   const CScript &script, ScriptError expected) {
     for (uint32_t flags : flagset) {
         // Make sure that we get a bad opcode when the activation flag is not
         // passed.
         CheckError(flags, original_stack, script, SCRIPT_ERR_BAD_OPCODE);
 
         // The script generates the proper error if the opcodes are activated.
         CheckError(flags | SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
                    expected);
     }
 }
 
 BOOST_AUTO_TEST_CASE(checkdatasig_test) {
     // Empty stack.
     CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIG,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIG,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIG,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
 
     // Check various pubkey encoding.
     const valtype message{};
     valtype vchHash(32);
     CSHA256().Write(message.data(), message.size()).Finalize(vchHash.data());
     uint256 messageHash(vchHash);
 
     KeyData kd;
     valtype pubkey = ToByteVector(kd.pubkey);
     valtype pubkeyC = ToByteVector(kd.pubkeyC);
     valtype pubkeyH = ToByteVector(kd.pubkeyH);
 
     CheckTestResultForAllFlags({{}, message, pubkey},
                                CScript() << OP_CHECKDATASIG, {{}});
     CheckTestResultForAllFlags({{}, message, pubkeyC},
                                CScript() << OP_CHECKDATASIG, {{}});
     CheckErrorForAllFlags({{}, message, pubkey},
                           CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_CHECKDATASIGVERIFY);
     CheckErrorForAllFlags({{}, message, pubkeyC},
                           CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_CHECKDATASIGVERIFY);
 
     // Flags dependent checks.
     const CScript script = CScript() << OP_CHECKDATASIG << OP_NOT << OP_VERIFY;
     const CScript scriptverify = CScript() << OP_CHECKDATASIGVERIFY;
 
     // Check valid signatures (as in the signature format is valid).
     valtype validsig;
     kd.privkey.SignECDSA(messageHash, validsig);
 
     CheckTestResultForAllFlags({validsig, message, pubkey},
                                CScript() << OP_CHECKDATASIG, {{0x01}});
     CheckTestResultForAllFlags({validsig, message, pubkey},
                                CScript() << OP_CHECKDATASIGVERIFY, {});
 
     const valtype minimalsig{0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
     const valtype nondersig{0x30, 0x80, 0x06, 0x02, 0x01,
                             0x01, 0x02, 0x01, 0x01};
     const valtype highSSig{
         0x30, 0x45, 0x02, 0x20, 0x3e, 0x45, 0x16, 0xda, 0x72, 0x53, 0xcf, 0x06,
         0x8e, 0xff, 0xec, 0x6b, 0x95, 0xc4, 0x12, 0x21, 0xc0, 0xcf, 0x3a, 0x8e,
         0x6c, 0xcb, 0x8c, 0xbf, 0x17, 0x25, 0xb5, 0x62, 0xe9, 0xaf, 0xde, 0x2c,
         0x02, 0x21, 0x00, 0xab, 0x1e, 0x3d, 0xa7, 0x3d, 0x67, 0xe3, 0x20, 0x45,
         0xa2, 0x0e, 0x0b, 0x99, 0x9e, 0x04, 0x99, 0x78, 0xea, 0x8d, 0x6e, 0xe5,
         0x48, 0x0d, 0x48, 0x5f, 0xcf, 0x2c, 0xe0, 0xd0, 0x3b, 0x2e, 0xf0};
 
     MMIXLinearCongruentialGenerator lcg;
     for (int i = 0; i < 4096; i++) {
         uint32_t flags = lcg.next() | SCRIPT_ENABLE_CHECKDATASIG;
 
         if (flags & SCRIPT_VERIFY_STRICTENC) {
             // When strict encoding is enforced, hybrid keys are invalid.
             CheckError(flags, {{}, message, pubkeyH}, script,
                        SCRIPT_ERR_PUBKEYTYPE);
             CheckError(flags, {{}, message, pubkeyH}, scriptverify,
                        SCRIPT_ERR_PUBKEYTYPE);
         } else if (flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) {
             // When compressed-only is enforced, hybrid keys are invalid.
             CheckError(flags, {{}, message, pubkeyH}, script,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
             CheckError(flags, {{}, message, pubkeyH}, scriptverify,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
         } else {
             // Otherwise, hybrid keys are valid.
             CheckPass(flags, {{}, message, pubkeyH}, script, {});
             CheckError(flags, {{}, message, pubkeyH}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) {
             // When compressed-only is enforced, uncompressed keys are invalid.
             CheckError(flags, {{}, message, pubkey}, script,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
             CheckError(flags, {{}, message, pubkey}, scriptverify,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
         } else {
             // Otherwise, uncompressed keys are valid.
             CheckPass(flags, {{}, message, pubkey}, script, {});
             CheckError(flags, {{}, message, pubkey}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & SCRIPT_VERIFY_NULLFAIL) {
             // Invalid signature causes checkdatasig to fail.
             CheckError(flags, {minimalsig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {minimalsig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
 
             // Invalid message causes checkdatasig to fail.
             CheckError(flags, {validsig, {0x01}, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {validsig, {0x01}, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
         } else {
             // When nullfail is not enforced, invalid signature are just false.
             CheckPass(flags, {minimalsig, message, pubkeyC}, script, {});
             CheckError(flags, {minimalsig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
 
             // Invalid message cause checkdatasig to fail.
             CheckPass(flags, {validsig, {0x01}, pubkeyC}, script, {});
             CheckError(flags, {validsig, {0x01}, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & SCRIPT_VERIFY_LOW_S) {
             // If we do enforce low S, then high S sigs are rejected.
             CheckError(flags, {highSSig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_HIGH_S);
             CheckError(flags, {highSSig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_HIGH_S);
         } else if (flags & SCRIPT_VERIFY_NULLFAIL) {
             // If we do enforce nullfail, these invalid sigs hit this.
             CheckError(flags, {highSSig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {highSSig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
         } else {
             // If we do not enforce low S, then high S sigs are accepted.
             CheckPass(flags, {highSSig, message, pubkeyC}, script, {});
             CheckError(flags, {highSSig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S |
                      SCRIPT_VERIFY_STRICTENC)) {
             // If we get any of the dersig flags, the non canonical dersig
             // signature fails.
             CheckError(flags, {nondersig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_DER);
             CheckError(flags, {nondersig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_DER);
         } else if (flags & SCRIPT_VERIFY_NULLFAIL) {
             // If we do enforce nullfail, these invalid sigs hit this.
             CheckError(flags, {nondersig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {nondersig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
         } else {
             // If we do not check, then it is accepted.
             CheckPass(flags, {nondersig, message, pubkeyC}, script, {});
             CheckError(flags, {nondersig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()