diff --git a/src/test/checkpoints_tests.cpp b/src/test/checkpoints_tests.cpp
index a2b9b4336e..24dfb05f7f 100644
--- a/src/test/checkpoints_tests.cpp
+++ b/src/test/checkpoints_tests.cpp
@@ -1,39 +1,40 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // 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.
 
 //
 // Unit tests for block-chain checkpoints
 //
 
-#include "checkpoints.h"
+#include <checkpoints.h>
 
-#include "chainparams.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
+#include <chainparams.h>
+#include <uint256.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(checkpoints_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(sanity) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
     const CCheckpointData &checkpoints = params->Checkpoints();
     uint256 p11111 = uint256S(
         "0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d");
     uint256 p134444 = uint256S(
         "00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe");
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 11111, p11111));
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 134444, p134444));
 
     // Wrong hashes at checkpoints should fail:
     BOOST_CHECK(!Checkpoints::CheckBlock(checkpoints, 11111, p134444));
     BOOST_CHECK(!Checkpoints::CheckBlock(checkpoints, 134444, p11111));
 
     // ... but any hash not at a checkpoint should succeed:
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 11111 + 1, p134444));
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 134444 + 1, p11111));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index 1efc6d2bb0..b515ca60a7 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -1,896 +1,898 @@
 // Copyright (c) 2014-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 "coins.h"
-#include "consensus/validation.h"
-#include "script/standard.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
-#include "undo.h"
-#include "utilstrencodings.h"
-#include "validation.h"
+#include <coins.h>
 
-#include <map>
-#include <vector>
+#include <consensus/validation.h>
+#include <script/standard.h>
+#include <uint256.h>
+#include <undo.h>
+#include <utilstrencodings.h>
+#include <validation.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <map>
+#include <vector>
+
 namespace {
 
 //! equality test
 bool operator==(const Coin &a, const Coin &b) {
     // Empty Coin objects are always equal.
     if (a.IsSpent() && b.IsSpent()) {
         return true;
     }
 
     return a.IsCoinBase() == b.IsCoinBase() && a.GetHeight() == b.GetHeight() &&
            a.GetTxOut() == b.GetTxOut();
 }
 
 class CCoinsViewTest : public CCoinsView {
     uint256 hashBestBlock_;
     std::map<COutPoint, Coin> map_;
 
 public:
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override {
         std::map<COutPoint, Coin>::const_iterator it = map_.find(outpoint);
         if (it == map_.end()) {
             return false;
         }
         coin = it->second;
         if (coin.IsSpent() && InsecureRandBool() == 0) {
             // Randomly return false in case of an empty entry.
             return false;
         }
         return true;
     }
 
     bool HaveCoin(const COutPoint &outpoint) const override {
         Coin coin;
         return GetCoin(outpoint, coin);
     }
 
     uint256 GetBestBlock() const override { return hashBestBlock_; }
 
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) override {
         for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
             if (it->second.flags & CCoinsCacheEntry::DIRTY) {
                 // Same optimization used in CCoinsViewDB is to only write dirty
                 // entries.
                 map_[it->first] = it->second.coin;
                 if (it->second.coin.IsSpent() && InsecureRandRange(3) == 0) {
                     // Randomly delete empty entries on write.
                     map_.erase(it->first);
                 }
             }
             mapCoins.erase(it++);
         }
         if (!hashBlock.IsNull()) {
             hashBestBlock_ = hashBlock;
         }
         return true;
     }
 };
 
 class CCoinsViewCacheTest : public CCoinsViewCache {
 public:
     explicit CCoinsViewCacheTest(CCoinsView *_base) : CCoinsViewCache(_base) {}
 
     void SelfTest() const {
         // Manually recompute the dynamic usage of the whole data, and compare
         // it.
         size_t ret = memusage::DynamicUsage(cacheCoins);
         size_t count = 0;
         for (const auto &entry : cacheCoins) {
             ret += entry.second.coin.DynamicMemoryUsage();
             count++;
         }
         BOOST_CHECK_EQUAL(GetCacheSize(), count);
         BOOST_CHECK_EQUAL(DynamicMemoryUsage(), ret);
     }
 
     CCoinsMap &map() const { return cacheCoins; }
     size_t &usage() const { return cachedCoinsUsage; }
 };
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(coins_tests, BasicTestingSetup)
 
 static const unsigned int NUM_SIMULATION_ITERATIONS = 40000;
 
 // This is a large randomized insert/remove simulation test on a variable-size
 // stack of caches on top of CCoinsViewTest.
 //
 // It will randomly create/update/delete Coin entries to a tip of caches, with
 // txids picked from a limited list of random 256-bit hashes. Occasionally, a
 // new tip is added to the stack of caches, or the tip is flushed and removed.
 //
 // During the process, booleans are kept to make sure that the randomized
 // operation hits all branches.
 BOOST_AUTO_TEST_CASE(coins_cache_simulation_test) {
     // Various coverage trackers.
     bool removed_all_caches = false;
     bool reached_4_caches = false;
     bool added_an_entry = false;
     bool added_an_unspendable_entry = false;
     bool removed_an_entry = false;
     bool updated_an_entry = false;
     bool found_an_entry = false;
     bool missed_an_entry = false;
     bool uncached_an_entry = false;
 
     // A simple map to track what we expect the cache stack to represent.
     std::map<COutPoint, Coin> result;
 
     // The cache stack.
     // A CCoinsViewTest at the bottom.
     CCoinsViewTest base;
     // A stack of CCoinsViewCaches on top.
     std::vector<CCoinsViewCacheTest *> stack;
     // Start with one cache.
     stack.push_back(new CCoinsViewCacheTest(&base));
 
     // Use a limited set of random transaction ids, so we do test overwriting
     // entries.
     std::vector<TxId> txids;
     txids.resize(NUM_SIMULATION_ITERATIONS / 8);
     for (size_t i = 0; i < txids.size(); i++) {
         txids[i] = TxId(InsecureRand256());
     }
 
     for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
         // Do a random modification.
         {
             // txid we're going to modify in this iteration.
             TxId txid = txids[InsecureRandRange(txids.size())];
             Coin &coin = result[COutPoint(txid, 0)];
             const Coin &entry =
                 (InsecureRandRange(500) == 0)
                     ? AccessByTxid(*stack.back(), txid)
                     : stack.back()->AccessCoin(COutPoint(txid, 0));
             BOOST_CHECK(coin == entry);
 
             if (InsecureRandRange(5) == 0 || coin.IsSpent()) {
                 CTxOut txout;
                 txout.nValue = int64_t(insecure_rand()) * SATOSHI;
                 if (InsecureRandRange(16) == 0 && coin.IsSpent()) {
                     txout.scriptPubKey.assign(1 + InsecureRandBits(6),
                                               OP_RETURN);
                     BOOST_CHECK(txout.scriptPubKey.IsUnspendable());
                     added_an_unspendable_entry = true;
                 } else {
                     // Random sizes so we can test memory usage accounting
                     txout.scriptPubKey.assign(InsecureRandBits(6), 0);
                     (coin.IsSpent() ? added_an_entry : updated_an_entry) = true;
                     coin = Coin(txout, 1, false);
                 }
 
                 Coin newcoin(txout, 1, false);
                 stack.back()->AddCoin(COutPoint(txid, 0), newcoin,
                                       !coin.IsSpent() || insecure_rand() & 1);
             } else {
                 removed_an_entry = true;
                 coin.Clear();
                 stack.back()->SpendCoin(COutPoint(txid, 0));
             }
         }
 
         // One every 10 iterations, remove a random entry from the cache
         if (InsecureRandRange(10)) {
             COutPoint out(txids[insecure_rand() % txids.size()], 0);
             int cacheid = insecure_rand() % stack.size();
             stack[cacheid]->Uncache(out);
             uncached_an_entry |= !stack[cacheid]->HaveCoinInCache(out);
         }
 
         // Once every 1000 iterations and at the end, verify the full cache.
         if (InsecureRandRange(1000) == 1 ||
             i == NUM_SIMULATION_ITERATIONS - 1) {
             for (const auto &entry : result) {
                 bool have = stack.back()->HaveCoin(entry.first);
                 const Coin &coin = stack.back()->AccessCoin(entry.first);
                 BOOST_CHECK(have == !coin.IsSpent());
                 BOOST_CHECK(coin == entry.second);
                 if (coin.IsSpent()) {
                     missed_an_entry = true;
                 } else {
                     BOOST_CHECK(stack.back()->HaveCoinInCache(entry.first));
                     found_an_entry = true;
                 }
             }
             for (const CCoinsViewCacheTest *test : stack) {
                 test->SelfTest();
             }
         }
 
         // Every 100 iterations, flush an intermediate cache
         if (InsecureRandRange(100) == 0) {
             if (stack.size() > 1 && InsecureRandBool() == 0) {
                 unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
                 stack[flushIndex]->Flush();
             }
         }
         if (InsecureRandRange(100) == 0) {
             // Every 100 iterations, change the cache stack.
             if (stack.size() > 0 && InsecureRandBool() == 0) {
                 // Remove the top cache
                 stack.back()->Flush();
                 delete stack.back();
                 stack.pop_back();
             }
             if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
                 // Add a new cache
                 CCoinsView *tip = &base;
                 if (stack.size() > 0) {
                     tip = stack.back();
                 } else {
                     removed_all_caches = true;
                 }
                 stack.push_back(new CCoinsViewCacheTest(tip));
                 if (stack.size() == 4) {
                     reached_4_caches = true;
                 }
             }
         }
     }
 
     // Clean up the stack.
     while (stack.size() > 0) {
         delete stack.back();
         stack.pop_back();
     }
 
     // Verify coverage.
     BOOST_CHECK(removed_all_caches);
     BOOST_CHECK(reached_4_caches);
     BOOST_CHECK(added_an_entry);
     BOOST_CHECK(added_an_unspendable_entry);
     BOOST_CHECK(removed_an_entry);
     BOOST_CHECK(updated_an_entry);
     BOOST_CHECK(found_an_entry);
     BOOST_CHECK(missed_an_entry);
     BOOST_CHECK(uncached_an_entry);
 }
 
 // Store of all necessary tx and undo data for next test
 typedef std::map<COutPoint, std::tuple<CTransaction, CTxUndo, Coin>> UtxoData;
 UtxoData utxoData;
 
 UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
     assert(utxoSet.size());
     auto utxoSetIt = utxoSet.lower_bound(COutPoint(InsecureRand256(), 0));
     if (utxoSetIt == utxoSet.end()) {
         utxoSetIt = utxoSet.begin();
     }
     auto utxoDataIt = utxoData.find(*utxoSetIt);
     assert(utxoDataIt != utxoData.end());
     return utxoDataIt;
 }
 
 // This test is similar to the previous test except the emphasis is on testing
 // the functionality of UpdateCoins random txs are created and UpdateCoins is
 // used to update the cache stack. In particular it is tested that spending a
 // duplicate coinbase tx has the expected effect (the other duplicate is
 // overwitten at all cache levels)
 BOOST_AUTO_TEST_CASE(updatecoins_simulation_test) {
     bool spent_a_duplicate_coinbase = false;
     // A simple map to track what we expect the cache stack to represent.
     std::map<COutPoint, Coin> result;
 
     // The cache stack.
     // A CCoinsViewTest at the bottom.
     CCoinsViewTest base;
     // A stack of CCoinsViewCaches on top.
     std::vector<CCoinsViewCacheTest *> stack;
     // Start with one cache.
     stack.push_back(new CCoinsViewCacheTest(&base));
 
     // Track the txids we've used in various sets
     std::set<COutPoint> coinbase_coins;
     std::set<COutPoint> disconnected_coins;
     std::set<COutPoint> duplicate_coins;
     std::set<COutPoint> utxoset;
 
     for (int64_t i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
         uint32_t randiter = insecure_rand();
 
         // 19/20 txs add a new transaction
         if (randiter % 20 < 19) {
             CMutableTransaction tx;
             tx.vin.resize(1);
             tx.vout.resize(1);
             // Keep txs unique unless intended to duplicate.
             tx.vout[0].nValue = i * SATOSHI;
             // Random sizes so we can test memory usage accounting
             tx.vout[0].scriptPubKey.assign(insecure_rand() & 0x3F, 0);
             unsigned int height = insecure_rand();
             Coin old_coin;
 
             // 2/20 times create a new coinbase
             if (randiter % 20 < 2 || coinbase_coins.size() < 10) {
                 // 1/10 of those times create a duplicate coinbase
                 if (InsecureRandRange(10) == 0 && coinbase_coins.size()) {
                     auto utxod = FindRandomFrom(coinbase_coins);
                     // Reuse the exact same coinbase
                     tx = std::get<0>(utxod->second);
                     // shouldn't be available for reconnection if its been
                     // duplicated
                     disconnected_coins.erase(utxod->first);
 
                     duplicate_coins.insert(utxod->first);
                 } else {
                     coinbase_coins.insert(COutPoint(tx.GetId(), 0));
                 }
                 assert(CTransaction(tx).IsCoinBase());
             }
 
             // 17/20 times reconnect previous or add a regular tx
             else {
 
                 COutPoint prevout;
                 // 1/20 times reconnect a previously disconnected tx
                 if (randiter % 20 == 2 && disconnected_coins.size()) {
                     auto utxod = FindRandomFrom(disconnected_coins);
                     tx = std::get<0>(utxod->second);
                     prevout = tx.vin[0].prevout;
                     if (!CTransaction(tx).IsCoinBase() &&
                         !utxoset.count(prevout)) {
                         disconnected_coins.erase(utxod->first);
                         continue;
                     }
 
                     // If this tx is already IN the UTXO, then it must be a
                     // coinbase, and it must be a duplicate
                     if (utxoset.count(utxod->first)) {
                         assert(CTransaction(tx).IsCoinBase());
                         assert(duplicate_coins.count(utxod->first));
                     }
                     disconnected_coins.erase(utxod->first);
                 }
 
                 // 16/20 times create a regular tx
                 else {
                     auto utxod = FindRandomFrom(utxoset);
                     prevout = utxod->first;
 
                     // Construct the tx to spend the coins of prevouthash
                     tx.vin[0].prevout = COutPoint(prevout.GetTxId(), 0);
                     assert(!CTransaction(tx).IsCoinBase());
                 }
 
                 // In this simple test coins only have two states, spent or
                 // unspent, save the unspent state to restore
                 old_coin = result[prevout];
                 // Update the expected result of prevouthash to know these coins
                 // are spent
                 result[prevout].Clear();
 
                 utxoset.erase(prevout);
 
                 // The test is designed to ensure spending a duplicate coinbase
                 // will work properly if that ever happens and not resurrect the
                 // previously overwritten coinbase
                 if (duplicate_coins.count(prevout)) {
                     spent_a_duplicate_coinbase = true;
                 }
             }
             // Update the expected result to know about the new output coins
             assert(tx.vout.size() == 1);
             const COutPoint outpoint(tx.GetId(), 0);
             result[outpoint] =
                 Coin(tx.vout[0], height, CTransaction(tx).IsCoinBase());
 
             // Call UpdateCoins on the top cache
             CTxUndo undo;
             UpdateCoins(*(stack.back()), CTransaction(tx), undo, height);
 
             // Update the utxo set for future spends
             utxoset.insert(outpoint);
 
             // Track this tx and undo info to use later
             utxoData.emplace(outpoint,
                              std::make_tuple(CTransaction(tx), undo, old_coin));
         }
 
         // 1/20 times undo a previous transaction
         else if (utxoset.size()) {
             auto utxod = FindRandomFrom(utxoset);
 
             CTransaction &tx = std::get<0>(utxod->second);
             CTxUndo &undo = std::get<1>(utxod->second);
             Coin &orig_coin = std::get<2>(utxod->second);
 
             // Update the expected result
             // Remove new outputs
             result[utxod->first].Clear();
             // If not coinbase restore prevout
             if (!tx.IsCoinBase()) {
                 result[tx.vin[0].prevout] = orig_coin;
             }
 
             // Disconnect the tx from the current UTXO
             // See code in DisconnectBlock
             // remove outputs
             stack.back()->SpendCoin(utxod->first);
 
             // restore inputs
             if (!tx.IsCoinBase()) {
                 const COutPoint &out = tx.vin[0].prevout;
                 UndoCoinSpend(undo.vprevout[0], *(stack.back()), out);
             }
 
             // Store as a candidate for reconnection
             disconnected_coins.insert(utxod->first);
 
             // Update the utxoset
             utxoset.erase(utxod->first);
             if (!tx.IsCoinBase()) {
                 utxoset.insert(tx.vin[0].prevout);
             }
         }
 
         // Once every 1000 iterations and at the end, verify the full cache.
         if (InsecureRandRange(1000) == 1 ||
             i == NUM_SIMULATION_ITERATIONS - 1) {
             for (const auto &entry : result) {
                 bool have = stack.back()->HaveCoin(entry.first);
                 const Coin &coin = stack.back()->AccessCoin(entry.first);
                 BOOST_CHECK(have == !coin.IsSpent());
                 BOOST_CHECK(coin == entry.second);
             }
         }
 
         // One every 10 iterations, remove a random entry from the cache
         if (utxoset.size() > 1 && InsecureRandRange(30)) {
             stack[insecure_rand() % stack.size()]->Uncache(
                 FindRandomFrom(utxoset)->first);
         }
         if (disconnected_coins.size() > 1 && InsecureRandRange(30)) {
             stack[insecure_rand() % stack.size()]->Uncache(
                 FindRandomFrom(disconnected_coins)->first);
         }
         if (duplicate_coins.size() > 1 && InsecureRandRange(30)) {
             stack[insecure_rand() % stack.size()]->Uncache(
                 FindRandomFrom(duplicate_coins)->first);
         }
 
         if (InsecureRandRange(100) == 0) {
             // Every 100 iterations, flush an intermediate cache
             if (stack.size() > 1 && InsecureRandBool() == 0) {
                 unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
                 stack[flushIndex]->Flush();
             }
         }
         if (InsecureRandRange(100) == 0) {
             // Every 100 iterations, change the cache stack.
             if (stack.size() > 0 && InsecureRandBool() == 0) {
                 stack.back()->Flush();
                 delete stack.back();
                 stack.pop_back();
             }
             if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
                 CCoinsView *tip = &base;
                 if (stack.size() > 0) {
                     tip = stack.back();
                 }
                 stack.push_back(new CCoinsViewCacheTest(tip));
             }
         }
     }
 
     // Clean up the stack.
     while (stack.size() > 0) {
         delete stack.back();
         stack.pop_back();
     }
 
     // Verify coverage.
     BOOST_CHECK(spent_a_duplicate_coinbase);
 }
 
 BOOST_AUTO_TEST_CASE(coin_serialization) {
     // Good example
     CDataStream ss1(
         ParseHex("97f23c835800816115944e077fe7c803cfa57f29b36bf87c1d35"),
         SER_DISK, CLIENT_VERSION);
     Coin c1;
     ss1 >> c1;
     BOOST_CHECK_EQUAL(c1.IsCoinBase(), false);
     BOOST_CHECK_EQUAL(c1.GetHeight(), 203998U);
     BOOST_CHECK_EQUAL(c1.GetTxOut().nValue, int64_t(60000000000) * SATOSHI);
     BOOST_CHECK_EQUAL(HexStr(c1.GetTxOut().scriptPubKey),
                       HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex(
                           "816115944e077fe7c803cfa57f29b36bf87c1d35"))))));
 
     // Good example
     CDataStream ss2(
         ParseHex("8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4"),
         SER_DISK, CLIENT_VERSION);
     Coin c2;
     ss2 >> c2;
     BOOST_CHECK_EQUAL(c2.IsCoinBase(), true);
     BOOST_CHECK_EQUAL(c2.GetHeight(), 120891);
     BOOST_CHECK_EQUAL(c2.GetTxOut().nValue, 110397 * SATOSHI);
     BOOST_CHECK_EQUAL(HexStr(c2.GetTxOut().scriptPubKey),
                       HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex(
                           "8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))))));
 
     // Smallest possible example
     CDataStream ss3(ParseHex("000006"), SER_DISK, CLIENT_VERSION);
     Coin c3;
     ss3 >> c3;
     BOOST_CHECK_EQUAL(c3.IsCoinBase(), false);
     BOOST_CHECK_EQUAL(c3.GetHeight(), 0);
     BOOST_CHECK_EQUAL(c3.GetTxOut().nValue, Amount::zero());
     BOOST_CHECK_EQUAL(c3.GetTxOut().scriptPubKey.size(), 0);
 
     // scriptPubKey that ends beyond the end of the stream
     CDataStream ss4(ParseHex("000007"), SER_DISK, CLIENT_VERSION);
     try {
         Coin c4;
         ss4 >> c4;
         BOOST_CHECK_MESSAGE(false, "We should have thrown");
     } catch (const std::ios_base::failure &e) {
     }
 
     // Very large scriptPubKey (3*10^9 bytes) past the end of the stream
     CDataStream tmp(SER_DISK, CLIENT_VERSION);
     uint64_t x = 3000000000ULL;
     tmp << VARINT(x);
     BOOST_CHECK_EQUAL(HexStr(tmp.begin(), tmp.end()), "8a95c0bb00");
     CDataStream ss5(ParseHex("00008a95c0bb00"), SER_DISK, CLIENT_VERSION);
     try {
         Coin c5;
         ss5 >> c5;
         BOOST_CHECK_MESSAGE(false, "We should have thrown");
     } catch (const std::ios_base::failure &e) {
     }
 }
 
 static const COutPoint OUTPOINT;
 static const Amount PRUNED(-1 * SATOSHI);
 static const Amount ABSENT(-2 * SATOSHI);
 static const Amount FAIL(-3 * SATOSHI);
 static const Amount VALUE1(100 * SATOSHI);
 static const Amount VALUE2(200 * SATOSHI);
 static const Amount VALUE3(300 * SATOSHI);
 static const char DIRTY = CCoinsCacheEntry::DIRTY;
 static const char FRESH = CCoinsCacheEntry::FRESH;
 static const char NO_ENTRY = -1;
 
 static const auto FLAGS = {char(0), FRESH, DIRTY, char(DIRTY | FRESH)};
 static const auto CLEAN_FLAGS = {char(0), FRESH};
 static const auto ABSENT_FLAGS = {NO_ENTRY};
 
 static void SetCoinValue(const Amount value, Coin &coin) {
     assert(value != ABSENT);
     coin.Clear();
     assert(coin.IsSpent());
     if (value != PRUNED) {
         CTxOut out;
         out.nValue = value;
         coin = Coin(std::move(out), 1, false);
         assert(!coin.IsSpent());
     }
 }
 
 size_t InsertCoinMapEntry(CCoinsMap &map, const Amount value, char flags) {
     if (value == ABSENT) {
         assert(flags == NO_ENTRY);
         return 0;
     }
     assert(flags != NO_ENTRY);
     CCoinsCacheEntry entry;
     entry.flags = flags;
     SetCoinValue(value, entry.coin);
     auto inserted = map.emplace(OUTPOINT, std::move(entry));
     assert(inserted.second);
     return inserted.first->second.coin.DynamicMemoryUsage();
 }
 
 void GetCoinMapEntry(const CCoinsMap &map, Amount &value, char &flags) {
     auto it = map.find(OUTPOINT);
     if (it == map.end()) {
         value = ABSENT;
         flags = NO_ENTRY;
     } else {
         if (it->second.coin.IsSpent()) {
             value = PRUNED;
         } else {
             value = it->second.coin.GetTxOut().nValue;
         }
         flags = it->second.flags;
         assert(flags != NO_ENTRY);
     }
 }
 
 void WriteCoinViewEntry(CCoinsView &view, const Amount value, char flags) {
     CCoinsMap map;
     InsertCoinMapEntry(map, value, flags);
     view.BatchWrite(map, {});
 }
 
 class SingleEntryCacheTest {
 public:
     SingleEntryCacheTest(const Amount base_value, const Amount cache_value,
                          char cache_flags) {
         WriteCoinViewEntry(base, base_value,
                            base_value == ABSENT ? NO_ENTRY : DIRTY);
         cache.usage() +=
             InsertCoinMapEntry(cache.map(), cache_value, cache_flags);
     }
 
     CCoinsView root;
     CCoinsViewCacheTest base{&root};
     CCoinsViewCacheTest cache{&base};
 };
 
 void CheckAccessCoin(const Amount base_value, const Amount cache_value,
                      const Amount expected_value, char cache_flags,
                      char expected_flags) {
     SingleEntryCacheTest test(base_value, cache_value, cache_flags);
     test.cache.AccessCoin(OUTPOINT);
     test.cache.SelfTest();
 
     Amount result_value;
     char result_flags;
     GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 }
 
 BOOST_AUTO_TEST_CASE(coin_access) {
     /* Check AccessCoin behavior, requesting a coin from a cache view layered on
      * top of a base view, and checking the resulting entry in the cache after
      * the access.
      *
      *               Base    Cache   Result  Cache        Result
      *               Value   Value   Value   Flags        Flags
      */
     CheckAccessCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, 0, 0);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, FRESH, FRESH);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, 0, 0);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, FRESH, FRESH);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, DIRTY, DIRTY);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(PRUNED, ABSENT, PRUNED, NO_ENTRY, FRESH);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, 0, 0);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, FRESH, FRESH);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, 0, 0);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, FRESH, FRESH);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, DIRTY, DIRTY);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(VALUE1, ABSENT, VALUE1, NO_ENTRY, 0);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, 0, 0);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, FRESH, FRESH);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, 0, 0);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, FRESH, FRESH);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, DIRTY, DIRTY);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH);
 }
 
 void CheckSpendCoin(Amount base_value, Amount cache_value,
                     Amount expected_value, char cache_flags,
                     char expected_flags) {
     SingleEntryCacheTest test(base_value, cache_value, cache_flags);
     test.cache.SpendCoin(OUTPOINT);
     test.cache.SelfTest();
 
     Amount result_value;
     char result_flags;
     GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 };
 
 BOOST_AUTO_TEST_CASE(coin_spend) {
     /**
      * Check SpendCoin behavior, requesting a coin from a cache view layered on
      * top of a base view, spending, and then checking the resulting entry in
      * the cache after the modification.
      *
      *              Base    Cache   Result  Cache        Result
      *              Value   Value   Value   Flags        Flags
      */
     CheckSpendCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckSpendCoin(ABSENT, PRUNED, PRUNED, 0, DIRTY);
     CheckSpendCoin(ABSENT, PRUNED, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(ABSENT, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(ABSENT, PRUNED, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(ABSENT, VALUE2, PRUNED, 0, DIRTY);
     CheckSpendCoin(ABSENT, VALUE2, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(ABSENT, VALUE2, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(ABSENT, VALUE2, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckSpendCoin(PRUNED, PRUNED, PRUNED, 0, DIRTY);
     CheckSpendCoin(PRUNED, PRUNED, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(PRUNED, PRUNED, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, VALUE2, PRUNED, 0, DIRTY);
     CheckSpendCoin(PRUNED, VALUE2, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, VALUE2, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(PRUNED, VALUE2, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, ABSENT, PRUNED, NO_ENTRY, DIRTY);
     CheckSpendCoin(VALUE1, PRUNED, PRUNED, 0, DIRTY);
     CheckSpendCoin(VALUE1, PRUNED, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(VALUE1, PRUNED, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, VALUE2, PRUNED, 0, DIRTY);
     CheckSpendCoin(VALUE1, VALUE2, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, VALUE2, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(VALUE1, VALUE2, ABSENT, DIRTY | FRESH, NO_ENTRY);
 }
 
 void CheckAddCoinBase(Amount base_value, Amount cache_value,
                       Amount modify_value, Amount expected_value,
                       char cache_flags, char expected_flags, bool coinbase) {
     SingleEntryCacheTest test(base_value, cache_value, cache_flags);
 
     Amount result_value;
     char result_flags;
     try {
         CTxOut output;
         output.nValue = modify_value;
         test.cache.AddCoin(OUTPOINT, Coin(std::move(output), 1, coinbase),
                            coinbase);
         test.cache.SelfTest();
         GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     } catch (std::logic_error &e) {
         result_value = FAIL;
         result_flags = NO_ENTRY;
     }
 
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 }
 
 // Simple wrapper for CheckAddCoinBase function above that loops through
 // different possible base_values, making sure each one gives the same results.
 // This wrapper lets the coin_add test below be shorter and less repetitive,
 // while still verifying that the CoinsViewCache::AddCoin implementation ignores
 // base values.
 template <typename... Args> void CheckAddCoin(Args &&... args) {
     for (Amount base_value : {ABSENT, PRUNED, VALUE1}) {
         CheckAddCoinBase(base_value, std::forward<Args>(args)...);
     }
 }
 
 BOOST_AUTO_TEST_CASE(coin_add) {
     /**
      * Check AddCoin behavior, requesting a new coin from a cache view, writing
      * a modification to the coin, and then checking the resulting entry in the
      * cache after the modification. Verify behavior with the with the AddCoin
      * potential_overwrite argument set to false, and to true.
      *
      * Cache   Write   Result  Cache        Result       potential_overwrite
      * Value   Value   Value   Flags        Flags
      */
     CheckAddCoin(ABSENT, VALUE3, VALUE3, NO_ENTRY, DIRTY | FRESH, false);
     CheckAddCoin(ABSENT, VALUE3, VALUE3, NO_ENTRY, DIRTY, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, 0, DIRTY | FRESH, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, 0, DIRTY, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, FRESH, DIRTY | FRESH, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, FRESH, DIRTY | FRESH, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY, DIRTY, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY, DIRTY, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY | FRESH, DIRTY | FRESH, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY | FRESH, DIRTY | FRESH, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, 0, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, 0, DIRTY, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, FRESH, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, FRESH, DIRTY | FRESH, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, DIRTY, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, DIRTY, DIRTY, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, DIRTY | FRESH, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, DIRTY | FRESH, DIRTY | FRESH, true);
 }
 
 void CheckWriteCoin(Amount parent_value, Amount child_value,
                     Amount expected_value, char parent_flags, char child_flags,
                     char expected_flags) {
     SingleEntryCacheTest test(ABSENT, parent_value, parent_flags);
 
     Amount result_value;
     char result_flags;
     try {
         WriteCoinViewEntry(test.cache, child_value, child_flags);
         test.cache.SelfTest();
         GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     } catch (std::logic_error &e) {
         result_value = FAIL;
         result_flags = NO_ENTRY;
     }
 
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 }
 
 BOOST_AUTO_TEST_CASE(coin_write) {
     /* Check BatchWrite behavior, flushing one entry from a child cache to a
      * parent cache, and checking the resulting entry in the parent cache
      * after the write.
      *
      *              Parent  Child   Result  Parent       Child        Result
      *              Value   Value   Value   Flags        Flags        Flags
      */
     CheckWriteCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY, NO_ENTRY);
     CheckWriteCoin(ABSENT, PRUNED, PRUNED, NO_ENTRY, DIRTY, DIRTY);
     CheckWriteCoin(ABSENT, PRUNED, ABSENT, NO_ENTRY, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(ABSENT, VALUE2, VALUE2, NO_ENTRY, DIRTY, DIRTY);
     CheckWriteCoin(ABSENT, VALUE2, VALUE2, NO_ENTRY, DIRTY | FRESH,
                    DIRTY | FRESH);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, 0, NO_ENTRY, 0);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, FRESH, NO_ENTRY, FRESH);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, DIRTY, NO_ENTRY, DIRTY);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, DIRTY | FRESH, NO_ENTRY,
                    DIRTY | FRESH);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, 0, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, 0, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, FRESH, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, DIRTY | FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, DIRTY | FRESH, DIRTY | FRESH,
                    NO_ENTRY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, 0, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, 0, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, FRESH, DIRTY | FRESH, DIRTY | FRESH);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY | FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH,
                    DIRTY | FRESH);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, 0, NO_ENTRY, 0);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, FRESH, NO_ENTRY, FRESH);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, DIRTY, NO_ENTRY, DIRTY);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, DIRTY | FRESH, NO_ENTRY,
                    DIRTY | FRESH);
     CheckWriteCoin(VALUE1, PRUNED, PRUNED, 0, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, 0, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, ABSENT, FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, FRESH, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, PRUNED, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, DIRTY, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, ABSENT, DIRTY | FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, DIRTY | FRESH, DIRTY | FRESH,
                    NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, 0, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, 0, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, FRESH, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, DIRTY, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, DIRTY | FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, DIRTY | FRESH, DIRTY | FRESH,
                    NO_ENTRY);
 
     // The checks above omit cases where the child flags are not DIRTY, since
     // they would be too repetitive (the parent cache is never updated in these
     // cases). The loop below covers these cases and makes sure the parent cache
     // is always left unchanged.
     for (Amount parent_value : {ABSENT, PRUNED, VALUE1}) {
         for (Amount child_value : {ABSENT, PRUNED, VALUE2}) {
             for (char parent_flags :
                  parent_value == ABSENT ? ABSENT_FLAGS : FLAGS) {
                 for (char child_flags :
                      child_value == ABSENT ? ABSENT_FLAGS : CLEAN_FLAGS) {
                     CheckWriteCoin(parent_value, child_value, parent_value,
                                    parent_flags, child_flags, parent_flags);
                 }
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp
index 06872a4ce0..de20219140 100644
--- a/src/test/compress_tests.cpp
+++ b/src/test/compress_tests.cpp
@@ -1,71 +1,73 @@
 // 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 "compressor.h"
-#include "test/test_bitcoin.h"
-#include "util.h"
+#include <compressor.h>
 
-#include <cstdint>
+#include <util.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <cstdint>
+
 // amounts 0.00000001 .. 0.00100000
 #define NUM_MULTIPLES_UNIT 100000
 
 // amounts 0.01 .. 100.00
 #define NUM_MULTIPLES_CENT 10000
 
 // amounts 1 .. 10000
 #define NUM_MULTIPLES_1BCH 10000
 
 // amounts 50 .. 21000000
 #define NUM_MULTIPLES_50BCH 420000
 
 BOOST_FIXTURE_TEST_SUITE(compress_tests, BasicTestingSetup)
 
 static bool TestEncode(Amount in) {
     return in == CTxOutCompressor::DecompressAmount(
                      CTxOutCompressor::CompressAmount(in));
 }
 
 static bool TestDecode(uint64_t in) {
     return in == CTxOutCompressor::CompressAmount(
                      CTxOutCompressor::DecompressAmount(in));
 }
 
 static bool TestPair(Amount dec, uint64_t enc) {
     return CTxOutCompressor::CompressAmount(dec) == enc &&
            CTxOutCompressor::DecompressAmount(enc) == dec;
 }
 
 BOOST_AUTO_TEST_CASE(compress_amounts) {
     BOOST_CHECK(TestPair(Amount::zero(), 0x0));
     BOOST_CHECK(TestPair(SATOSHI, 0x1));
     BOOST_CHECK(TestPair(CENT, 0x7));
     BOOST_CHECK(TestPair(COIN, 0x9));
     BOOST_CHECK(TestPair(50 * COIN, 0x32));
     BOOST_CHECK(TestPair(21000000 * COIN, 0x1406f40));
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_UNIT; i++) {
         BOOST_CHECK(TestEncode(i * SATOSHI));
     }
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_CENT; i++) {
         BOOST_CHECK(TestEncode(i * CENT));
     }
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_1BCH; i++) {
         BOOST_CHECK(TestEncode(i * COIN));
     }
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_50BCH; i++) {
         BOOST_CHECK(TestEncode(i * 50 * COIN));
     }
 
     for (int64_t i = 0; i < 100000; i++) {
         BOOST_CHECK(TestDecode(i));
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/config_tests.cpp b/src/test/config_tests.cpp
index a80c0bc103..a635fc254c 100644
--- a/src/test/config_tests.cpp
+++ b/src/test/config_tests.cpp
@@ -1,60 +1,62 @@
 // 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 "chainparams.h"
-#include "config.h"
-#include "consensus/consensus.h"
-#include "test/test_bitcoin.h"
+#include <config.h>
+
+#include <chainparams.h>
+#include <consensus/consensus.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(config_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(max_block_size) {
     GlobalConfig config;
 
     // Too small.
     BOOST_CHECK(!config.SetMaxBlockSize(0));
     BOOST_CHECK(!config.SetMaxBlockSize(12345));
     BOOST_CHECK(!config.SetMaxBlockSize(LEGACY_MAX_BLOCK_SIZE - 1));
     BOOST_CHECK(!config.SetMaxBlockSize(LEGACY_MAX_BLOCK_SIZE));
 
     // LEGACY_MAX_BLOCK_SIZE + 1
     BOOST_CHECK(config.SetMaxBlockSize(LEGACY_MAX_BLOCK_SIZE + 1));
     BOOST_CHECK_EQUAL(config.GetMaxBlockSize(), LEGACY_MAX_BLOCK_SIZE + 1);
 
     // 2MB
     BOOST_CHECK(config.SetMaxBlockSize(2 * ONE_MEGABYTE));
     BOOST_CHECK_EQUAL(config.GetMaxBlockSize(), 2 * ONE_MEGABYTE);
 
     // 8MB
     BOOST_CHECK(config.SetMaxBlockSize(8 * ONE_MEGABYTE));
     BOOST_CHECK_EQUAL(config.GetMaxBlockSize(), 8 * ONE_MEGABYTE);
 
     // Invalid size keep config.
     BOOST_CHECK(!config.SetMaxBlockSize(54321));
     BOOST_CHECK_EQUAL(config.GetMaxBlockSize(), 8 * ONE_MEGABYTE);
 
     // Setting it back down
     BOOST_CHECK(config.SetMaxBlockSize(7 * ONE_MEGABYTE));
     BOOST_CHECK_EQUAL(config.GetMaxBlockSize(), 7 * ONE_MEGABYTE);
     BOOST_CHECK(config.SetMaxBlockSize(ONE_MEGABYTE + 1));
     BOOST_CHECK_EQUAL(config.GetMaxBlockSize(), ONE_MEGABYTE + 1);
 }
 
 BOOST_AUTO_TEST_CASE(chain_params) {
     GlobalConfig config;
 
     // Global config is consistent with params.
     SelectParams(CBaseChainParams::MAIN);
     BOOST_CHECK_EQUAL(&Params(), &config.GetChainParams());
 
     SelectParams(CBaseChainParams::TESTNET);
     BOOST_CHECK_EQUAL(&Params(), &config.GetChainParams());
 
     SelectParams(CBaseChainParams::REGTEST);
     BOOST_CHECK_EQUAL(&Params(), &config.GetChainParams());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/core_io_tests.cpp b/src/test/core_io_tests.cpp
index 492a717dd6..5b0a5f4db8 100644
--- a/src/test/core_io_tests.cpp
+++ b/src/test/core_io_tests.cpp
@@ -1,158 +1,159 @@
 // 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 "core_io.h"
-#include "test/test_bitcoin.h"
+#include <core_io.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <string>
 
 BOOST_FIXTURE_TEST_SUITE(core_io_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(parse_hex_test) {
     std::string s = "0x";
     BOOST_CHECK_THROW(ParseScript(s), std::runtime_error);
 
     for (int numZeroes = 1; numZeroes <= 32; numZeroes++) {
         s += "0";
         if (numZeroes % 2 == 0) {
             BOOST_CHECK_NO_THROW(ParseScript(s));
         } else {
             BOOST_CHECK_THROW(ParseScript(s), std::runtime_error);
         }
     }
 }
 
 static void PrintLE(std::ostringstream &testString, size_t bytes,
                     size_t pushLength) {
     testString << "0x";
     while (bytes != 0) {
         testString << std::setfill('0') << std::setw(2) << std::hex
                    << pushLength % 256;
         pushLength /= 256;
         bytes--;
     }
 }
 
 static std::string TestPushOpcode(size_t pushWidth, size_t pushLength,
                                   size_t actualLength) {
     std::ostringstream testString;
 
     switch (pushWidth) {
         case 1:
             testString << "PUSHDATA1 ";
             break;
         case 2:
             testString << "PUSHDATA2 ";
             break;
         case 4:
             testString << "PUSHDATA4 ";
             break;
         default:
             assert(false);
     }
     PrintLE(testString, pushWidth, pushLength);
     testString << " 0x";
 
     for (size_t i = 0; i < actualLength; i++) {
         testString << "01";
     }
 
     return testString.str();
 }
 
 BOOST_AUTO_TEST_CASE(printle_tests) {
     // Ensure the test generator is doing what we think it is.
     std::ostringstream testString;
     PrintLE(testString, 04, 0x8001);
     BOOST_CHECK_EQUAL(testString.str(), "0x01800000");
 }
 
 BOOST_AUTO_TEST_CASE(testpushopcode_tests) {
     BOOST_CHECK_EQUAL(TestPushOpcode(1, 2, 2), "PUSHDATA1 0x02 0x0101");
     BOOST_CHECK_EQUAL(TestPushOpcode(2, 2, 2), "PUSHDATA2 0x0200 0x0101");
     BOOST_CHECK_EQUAL(TestPushOpcode(4, 2, 2), "PUSHDATA4 0x02000000 0x0101");
 }
 
 BOOST_AUTO_TEST_CASE(parse_push_test) {
     BOOST_CHECK_NO_THROW(ParseScript("0x01 0x01"));
     BOOST_CHECK_NO_THROW(ParseScript("0x01 XOR"));
     BOOST_CHECK_NO_THROW(ParseScript("0x01 1"));
     BOOST_CHECK_NO_THROW(ParseScript("0x01 ''"));
     BOOST_CHECK_NO_THROW(ParseScript("0x02 0x0101"));
     BOOST_CHECK_NO_THROW(ParseScript("0x02 42"));
     BOOST_CHECK_NO_THROW(ParseScript("0x02 'a'"));
 
     BOOST_CHECK_THROW(ParseScript("0x01 0x0101"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x01 42"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x02 0x01"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x02 XOR"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x02 1"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x02 ''"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x02 0x010101"), std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("0x02 'ab'"), std::runtime_error);
 
     // Note sizes are LE encoded.  Also, some of these values are not
     // minimally encoded intentionally -- nor are they being required to be
     // minimally encoded.
     BOOST_CHECK_NO_THROW(ParseScript("PUSHDATA4 0x02000000 0x0101"));
     BOOST_CHECK_THROW(ParseScript("PUSHDATA4 0x03000000 0x0101"),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("PUSHDATA4 0x02000000 0x010101"),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("PUSHDATA4 0x020000 0x0101"),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("PUSHDATA4 0x0200000000 0x0101"),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(ParseScript("PUSHDATA2 0x0200 0x0101"));
     BOOST_CHECK_THROW(ParseScript("PUSHDATA2 0x0300 0x0101"),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("PUSHDATA2 0x030000 0x0101"),
                       std::runtime_error);
     BOOST_CHECK_NO_THROW(ParseScript("PUSHDATA1 0x02 0x0101"));
     BOOST_CHECK_THROW(ParseScript("PUSHDATA1 0x02 0x010101"),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript("PUSHDATA1 0x0200 0x010101"),
                       std::runtime_error);
 
     // Ensure pushdata handling is not using 1's complement
     BOOST_CHECK_NO_THROW(ParseScript(TestPushOpcode(1, 0xC8, 0xC8)));
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(1, 0xC8, 0xC9)),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(ParseScript(TestPushOpcode(2, 0x8000, 0x8000)));
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(2, 0x8000, 0x8001)),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(2, 0x8001, 0x8000)),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(2, 0x80, 0x81)),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(2, 0x80, 0x7F)),
                       std::runtime_error);
 
     // Can't build something too long.
     BOOST_CHECK_NO_THROW(ParseScript(TestPushOpcode(4, 0x8000, 0x8000)));
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(4, 0x8000, 0x8001)),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(4, 0x8001, 0x8000)),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(4, 0x80, 0x81)),
                       std::runtime_error);
     BOOST_CHECK_THROW(ParseScript(TestPushOpcode(4, 0x80, 0x7F)),
                       std::runtime_error);
 }
 
 void TestFormatRoundTrip(const std::string &script) {
     BOOST_CHECK_EQUAL(script, FormatScript(ParseScript(script)));
 }
 
 BOOST_AUTO_TEST_CASE(format_script_test) {
     TestFormatRoundTrip("0 1 5 CHECKDATASIG CHECKSIG XOR NOP5 NOP10 "
                         "CHECKDATASIGVERIFY DEPTH RETURN VERIFY SPLIT INVERT "
                         "EQUAL HASH256 GREATERTHANOREQUAL RSHIFT");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
index 18856d974c..008c4c80fb 100644
--- a/src/test/crypto_tests.cpp
+++ b/src/test/crypto_tests.cpp
@@ -1,648 +1,651 @@
 // Copyright (c) 2014-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 "crypto/aes.h"
-#include "crypto/chacha20.h"
-#include "crypto/hmac_sha256.h"
-#include "crypto/hmac_sha512.h"
-#include "crypto/ripemd160.h"
-#include "crypto/sha1.h"
-#include "crypto/sha256.h"
-#include "crypto/sha512.h"
-#include "random.h"
-#include "test/test_bitcoin.h"
-#include "utilstrencodings.h"
+#include <crypto/aes.h>
+#include <crypto/chacha20.h>
+#include <crypto/hmac_sha256.h>
+#include <crypto/hmac_sha512.h>
+#include <crypto/ripemd160.h>
+#include <crypto/sha1.h>
+#include <crypto/sha256.h>
+#include <crypto/sha512.h>
 
-#include <vector>
+#include <random.h>
+#include <utilstrencodings.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
+
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 
+#include <vector>
+
 BOOST_FIXTURE_TEST_SUITE(crypto_tests, BasicTestingSetup)
 
 template <typename Hasher, typename In, typename Out>
 void TestVector(const Hasher &h, const In &in, const Out &out) {
     Out hash;
     BOOST_CHECK(out.size() == h.OUTPUT_SIZE);
     hash.resize(out.size());
     {
         // Test that writing the whole input string at once works.
         Hasher(h).Write((uint8_t *)&in[0], in.size()).Finalize(&hash[0]);
         BOOST_CHECK(hash == out);
     }
     for (int i = 0; i < 32; i++) {
         // Test that writing the string broken up in random pieces works.
         Hasher hasher(h);
         size_t pos = 0;
         while (pos < in.size()) {
             size_t len = InsecureRandRange((in.size() - pos + 1) / 2 + 1);
             hasher.Write((uint8_t *)&in[pos], len);
             pos += len;
             if (pos > 0 && pos + 2 * out.size() > in.size() &&
                 pos < in.size()) {
                 // Test that writing the rest at once to a copy of a hasher
                 // works.
                 Hasher(hasher)
                     .Write((uint8_t *)&in[pos], in.size() - pos)
                     .Finalize(&hash[0]);
                 BOOST_CHECK(hash == out);
             }
         }
         hasher.Finalize(&hash[0]);
         BOOST_CHECK(hash == out);
     }
 }
 
 void TestSHA1(const std::string &in, const std::string &hexout) {
     TestVector(CSHA1(), in, ParseHex(hexout));
 }
 void TestSHA256(const std::string &in, const std::string &hexout) {
     TestVector(CSHA256(), in, ParseHex(hexout));
 }
 void TestSHA512(const std::string &in, const std::string &hexout) {
     TestVector(CSHA512(), in, ParseHex(hexout));
 }
 void TestRIPEMD160(const std::string &in, const std::string &hexout) {
     TestVector(CRIPEMD160(), in, ParseHex(hexout));
 }
 
 void TestHMACSHA256(const std::string &hexkey, const std::string &hexin,
                     const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     TestVector(CHMAC_SHA256(&key[0], key.size()), ParseHex(hexin),
                ParseHex(hexout));
 }
 
 void TestHMACSHA512(const std::string &hexkey, const std::string &hexin,
                     const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     TestVector(CHMAC_SHA512(&key[0], key.size()), ParseHex(hexin),
                ParseHex(hexout));
 }
 
 void TestAES128(const std::string &hexkey, const std::string &hexin,
                 const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     std::vector<uint8_t> in = ParseHex(hexin);
     std::vector<uint8_t> correctout = ParseHex(hexout);
     std::vector<uint8_t> buf, buf2;
 
     assert(key.size() == 16);
     assert(in.size() == 16);
     assert(correctout.size() == 16);
     AES128Encrypt enc(&key[0]);
     buf.resize(correctout.size());
     buf2.resize(correctout.size());
     enc.Encrypt(&buf[0], &in[0]);
     BOOST_CHECK_EQUAL(HexStr(buf), HexStr(correctout));
     AES128Decrypt dec(&key[0]);
     dec.Decrypt(&buf2[0], &buf[0]);
     BOOST_CHECK_EQUAL(HexStr(buf2), HexStr(in));
 }
 
 void TestAES256(const std::string &hexkey, const std::string &hexin,
                 const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     std::vector<uint8_t> in = ParseHex(hexin);
     std::vector<uint8_t> correctout = ParseHex(hexout);
     std::vector<uint8_t> buf;
 
     assert(key.size() == 32);
     assert(in.size() == 16);
     assert(correctout.size() == 16);
     AES256Encrypt enc(&key[0]);
     buf.resize(correctout.size());
     enc.Encrypt(&buf[0], &in[0]);
     BOOST_CHECK(buf == correctout);
     AES256Decrypt dec(&key[0]);
     dec.Decrypt(&buf[0], &buf[0]);
     BOOST_CHECK(buf == in);
 }
 
 void TestAES128CBC(const std::string &hexkey, const std::string &hexiv,
                    bool pad, const std::string &hexin,
                    const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     std::vector<uint8_t> iv = ParseHex(hexiv);
     std::vector<uint8_t> in = ParseHex(hexin);
     std::vector<uint8_t> correctout = ParseHex(hexout);
     std::vector<uint8_t> realout(in.size() + AES_BLOCKSIZE);
 
     // Encrypt the plaintext and verify that it equals the cipher
     AES128CBCEncrypt enc(&key[0], &iv[0], pad);
     int size = enc.Encrypt(&in[0], in.size(), &realout[0]);
     realout.resize(size);
     BOOST_CHECK(realout.size() == correctout.size());
     BOOST_CHECK_MESSAGE(realout == correctout,
                         HexStr(realout) + std::string(" != ") + hexout);
 
     // Decrypt the cipher and verify that it equals the plaintext
     std::vector<uint8_t> decrypted(correctout.size());
     AES128CBCDecrypt dec(&key[0], &iv[0], pad);
     size = dec.Decrypt(&correctout[0], correctout.size(), &decrypted[0]);
     decrypted.resize(size);
     BOOST_CHECK(decrypted.size() == in.size());
     BOOST_CHECK_MESSAGE(decrypted == in,
                         HexStr(decrypted) + std::string(" != ") + hexin);
 
     // Encrypt and re-decrypt substrings of the plaintext and verify that they
     // equal each-other
     for (std::vector<uint8_t>::iterator i(in.begin()); i != in.end(); ++i) {
         std::vector<uint8_t> sub(i, in.end());
         std::vector<uint8_t> subout(sub.size() + AES_BLOCKSIZE);
         int _size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
         if (_size != 0) {
             subout.resize(_size);
             std::vector<uint8_t> subdecrypted(subout.size());
             _size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
             subdecrypted.resize(_size);
             BOOST_CHECK(decrypted.size() == in.size());
             BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) +
                                                          std::string(" != ") +
                                                          HexStr(sub));
         }
     }
 }
 
 void TestAES256CBC(const std::string &hexkey, const std::string &hexiv,
                    bool pad, const std::string &hexin,
                    const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     std::vector<uint8_t> iv = ParseHex(hexiv);
     std::vector<uint8_t> in = ParseHex(hexin);
     std::vector<uint8_t> correctout = ParseHex(hexout);
     std::vector<uint8_t> realout(in.size() + AES_BLOCKSIZE);
 
     // Encrypt the plaintext and verify that it equals the cipher
     AES256CBCEncrypt enc(&key[0], &iv[0], pad);
     int size = enc.Encrypt(&in[0], in.size(), &realout[0]);
     realout.resize(size);
     BOOST_CHECK(realout.size() == correctout.size());
     BOOST_CHECK_MESSAGE(realout == correctout,
                         HexStr(realout) + std::string(" != ") + hexout);
 
     // Decrypt the cipher and verify that it equals the plaintext
     std::vector<uint8_t> decrypted(correctout.size());
     AES256CBCDecrypt dec(&key[0], &iv[0], pad);
     size = dec.Decrypt(&correctout[0], correctout.size(), &decrypted[0]);
     decrypted.resize(size);
     BOOST_CHECK(decrypted.size() == in.size());
     BOOST_CHECK_MESSAGE(decrypted == in,
                         HexStr(decrypted) + std::string(" != ") + hexin);
 
     // Encrypt and re-decrypt substrings of the plaintext and verify that they
     // equal each-other
     for (std::vector<uint8_t>::iterator i(in.begin()); i != in.end(); ++i) {
         std::vector<uint8_t> sub(i, in.end());
         std::vector<uint8_t> subout(sub.size() + AES_BLOCKSIZE);
         int _size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
         if (_size != 0) {
             subout.resize(_size);
             std::vector<uint8_t> subdecrypted(subout.size());
             _size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
             subdecrypted.resize(_size);
             BOOST_CHECK(decrypted.size() == in.size());
             BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) +
                                                          std::string(" != ") +
                                                          HexStr(sub));
         }
     }
 }
 
 void TestChaCha20(const std::string &hexkey, uint64_t nonce, uint64_t seek,
                   const std::string &hexout) {
     std::vector<uint8_t> key = ParseHex(hexkey);
     ChaCha20 rng(key.data(), key.size());
     rng.SetIV(nonce);
     rng.Seek(seek);
     std::vector<uint8_t> out = ParseHex(hexout);
     std::vector<uint8_t> outres;
     outres.resize(out.size());
     rng.Output(outres.data(), outres.size());
     BOOST_CHECK(out == outres);
 }
 
 std::string LongTestString(void) {
     std::string ret;
     for (int i = 0; i < 200000; i++) {
         ret += uint8_t(i);
         ret += uint8_t(i >> 4);
         ret += uint8_t(i >> 8);
         ret += uint8_t(i >> 12);
         ret += uint8_t(i >> 16);
     }
     return ret;
 }
 
 const std::string test1 = LongTestString();
 
 BOOST_AUTO_TEST_CASE(ripemd160_testvectors) {
     TestRIPEMD160("", "9c1185a5c5e9fc54612808977ee8f548b2258d31");
     TestRIPEMD160("abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc");
     TestRIPEMD160("message digest", "5d0689ef49d2fae572b881b123a85ffa21595f36");
     TestRIPEMD160("secure hash algorithm",
                   "20397528223b6a5f4cbc2808aba0464e645544f9");
     TestRIPEMD160("RIPEMD160 is considered to be safe",
                   "a7d78608c7af8a8e728778e81576870734122b66");
     TestRIPEMD160("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
                   "12a053384a9c0c88e405a06c27dcf49ada62eb2b");
     TestRIPEMD160(
         "For this sample, this 63-byte string will be used as input data",
         "de90dbfee14b63fb5abf27c2ad4a82aaa5f27a11");
     TestRIPEMD160(
         "This is exactly 64 bytes long, not counting the terminating byte",
         "eda31d51d3a623b81e19eb02e24ff65d27d67b37");
     TestRIPEMD160(std::string(1000000, 'a'),
                   "52783243c1697bdbe16d37f97f68f08325dc1528");
     TestRIPEMD160(test1, "464243587bd146ea835cdf57bdae582f25ec45f1");
 }
 
 BOOST_AUTO_TEST_CASE(sha1_testvectors) {
     TestSHA1("", "da39a3ee5e6b4b0d3255bfef95601890afd80709");
     TestSHA1("abc", "a9993e364706816aba3e25717850c26c9cd0d89d");
     TestSHA1("message digest", "c12252ceda8be8994d5fa0290a47231c1d16aae3");
     TestSHA1("secure hash algorithm",
              "d4d6d2f0ebe317513bbd8d967d89bac5819c2f60");
     TestSHA1("SHA1 is considered to be safe",
              "f2b6650569ad3a8720348dd6ea6c497dee3a842a");
     TestSHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
              "84983e441c3bd26ebaae4aa1f95129e5e54670f1");
     TestSHA1("For this sample, this 63-byte string will be used as input data",
              "4f0ea5cd0585a23d028abdc1a6684e5a8094dc49");
     TestSHA1("This is exactly 64 bytes long, not counting the terminating byte",
              "fb679f23e7d1ce053313e66e127ab1b444397057");
     TestSHA1(std::string(1000000, 'a'),
              "34aa973cd4c4daa4f61eeb2bdbad27316534016f");
     TestSHA1(test1, "b7755760681cbfd971451668f32af5774f4656b5");
 }
 
 BOOST_AUTO_TEST_CASE(sha256_testvectors) {
     TestSHA256(
         "", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
     TestSHA256(
         "abc",
         "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
     TestSHA256(
         "message digest",
         "f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650");
     TestSHA256(
         "secure hash algorithm",
         "f30ceb2bb2829e79e4ca9753d35a8ecc00262d164cc077080295381cbd643f0d");
     TestSHA256(
         "SHA256 is considered to be safe",
         "6819d915c73f4d1e77e4e1b52d1fa0f9cf9beaead3939f15874bd988e2a23630");
     TestSHA256(
         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
         "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");
     TestSHA256(
         "For this sample, this 63-byte string will be used as input data",
         "f08a78cbbaee082b052ae0708f32fa1e50c5c421aa772ba5dbb406a2ea6be342");
     TestSHA256(
         "This is exactly 64 bytes long, not counting the terminating byte",
         "ab64eff7e88e2e46165e29f2bce41826bd4c7b3552f6b382a9e7d3af47c245f8");
     TestSHA256(
         "As Bitcoin relies on 80 byte header hashes, we want to have an "
         "example for that.",
         "7406e8de7d6e4fffc573daef05aefb8806e7790f55eab5576f31349743cca743");
     TestSHA256(
         std::string(1000000, 'a'),
         "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
     TestSHA256(
         test1,
         "a316d55510b49662420f49d145d42fb83f31ef8dc016aa4e32df049991a91e26");
 }
 
 BOOST_AUTO_TEST_CASE(sha512_testvectors) {
     TestSHA512(
         "", "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce"
             "47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
     TestSHA512(
         "abc",
         "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
         "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
     TestSHA512(
         "message digest",
         "107dbf389d9e9f71a3a95f6c055b9251bc5268c2be16d6c13492ea45b0199f33"
         "09e16455ab1e96118e8a905d5597b72038ddb372a89826046de66687bb420e7c");
     TestSHA512(
         "secure hash algorithm",
         "7746d91f3de30c68cec0dd693120a7e8b04d8073cb699bdce1a3f64127bca7a3"
         "d5db502e814bb63c063a7a5043b2df87c61133395f4ad1edca7fcf4b30c3236e");
     TestSHA512(
         "SHA512 is considered to be safe",
         "099e6468d889e1c79092a89ae925a9499b5408e01b66cb5b0a3bd0dfa51a9964"
         "6b4a3901caab1318189f74cd8cf2e941829012f2449df52067d3dd5b978456c2");
     TestSHA512(
         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
         "204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c335"
         "96fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445");
     TestSHA512(
         "For this sample, this 63-byte string will be used as input data",
         "b3de4afbc516d2478fe9b518d063bda6c8dd65fc38402dd81d1eb7364e72fb6e"
         "6663cf6d2771c8f5a6da09601712fb3d2a36c6ffea3e28b0818b05b0a8660766");
     TestSHA512(
         "This is exactly 64 bytes long, not counting the terminating byte",
         "70aefeaa0e7ac4f8fe17532d7185a289bee3b428d950c14fa8b713ca09814a38"
         "7d245870e007a80ad97c369d193e41701aa07f3221d15f0e65a1ff970cedf030");
     TestSHA512(
         "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmno"
         "ijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
         "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018"
         "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909");
     TestSHA512(
         std::string(1000000, 'a'),
         "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb"
         "de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b");
     TestSHA512(
         test1,
         "40cac46c147e6131c5193dd5f34e9d8bb4951395f27b08c558c65ff4ba2de594"
         "37de8c3ef5459d76a52cedc02dc499a3c9ed9dedbfb3281afd9653b8a112fafc");
 }
 
 BOOST_AUTO_TEST_CASE(hmac_sha256_testvectors) {
     // test cases 1, 2, 3, 4, 6 and 7 of RFC 4231
     TestHMACSHA256(
         "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", "4869205468657265",
         "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
     TestHMACSHA256(
         "4a656665", "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
         "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843");
     TestHMACSHA256(
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
         "dddddddddddddddddddddddddddddddddddd",
         "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe");
     TestHMACSHA256(
         "0102030405060708090a0b0c0d0e0f10111213141516171819",
         "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"
         "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
         "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b");
     TestHMACSHA256(
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaa",
         "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a"
         "65204b6579202d2048617368204b6579204669727374",
         "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54");
     TestHMACSHA256(
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaa",
         "5468697320697320612074657374207573696e672061206c6172676572207468"
         "616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074"
         "68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565"
         "647320746f20626520686173686564206265666f7265206265696e6720757365"
         "642062792074686520484d414320616c676f726974686d2e",
         "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2");
 }
 
 BOOST_AUTO_TEST_CASE(hmac_sha512_testvectors) {
     // test cases 1, 2, 3, 4, 6 and 7 of RFC 4231
     TestHMACSHA512(
         "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", "4869205468657265",
         "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cde"
         "daa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854");
     TestHMACSHA512(
         "4a656665", "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
         "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea250554"
         "9758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737");
     TestHMACSHA512(
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
         "dddddddddddddddddddddddddddddddddddd",
         "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39"
         "bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb");
     TestHMACSHA512(
         "0102030405060708090a0b0c0d0e0f10111213141516171819",
         "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"
         "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
         "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3db"
         "a91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd");
     TestHMACSHA512(
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaa",
         "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a"
         "65204b6579202d2048617368204b6579204669727374",
         "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f352"
         "6b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598");
     TestHMACSHA512(
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         "aaaaaa",
         "5468697320697320612074657374207573696e672061206c6172676572207468"
         "616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074"
         "68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565"
         "647320746f20626520686173686564206265666f7265206265696e6720757365"
         "642062792074686520484d414320616c676f726974686d2e",
         "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944"
         "b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58");
 }
 
 BOOST_AUTO_TEST_CASE(aes_testvectors) {
     // AES test vectors from FIPS 197.
     TestAES128("000102030405060708090a0b0c0d0e0f",
                "00112233445566778899aabbccddeeff",
                "69c4e0d86a7b0430d8cdb78070b4c55a");
     TestAES256(
         "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
         "00112233445566778899aabbccddeeff", "8ea2b7ca516745bfeafc49904b496089");
 
     // AES-ECB test vectors from NIST sp800-38a.
     TestAES128("2b7e151628aed2a6abf7158809cf4f3c",
                "6bc1bee22e409f96e93d7e117393172a",
                "3ad77bb40d7a3660a89ecaf32466ef97");
     TestAES128("2b7e151628aed2a6abf7158809cf4f3c",
                "ae2d8a571e03ac9c9eb76fac45af8e51",
                "f5d3d58503b9699de785895a96fdbaaf");
     TestAES128("2b7e151628aed2a6abf7158809cf4f3c",
                "30c81c46a35ce411e5fbc1191a0a52ef",
                "43b1cd7f598ece23881b00e3ed030688");
     TestAES128("2b7e151628aed2a6abf7158809cf4f3c",
                "f69f2445df4f9b17ad2b417be66c3710",
                "7b0c785e27e8ad3f8223207104725dd4");
     TestAES256(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "6bc1bee22e409f96e93d7e117393172a", "f3eed1bdb5d2a03c064b5a7e3db181f8");
     TestAES256(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "ae2d8a571e03ac9c9eb76fac45af8e51", "591ccb10d410ed26dc5ba74a31362870");
     TestAES256(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "30c81c46a35ce411e5fbc1191a0a52ef", "b6ed21b99ca6f4f9f153e7b1beafed1d");
     TestAES256(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "f69f2445df4f9b17ad2b417be66c3710", "23304b7a39f9f3ff067d8d8f9e24ecc7");
 }
 
 BOOST_AUTO_TEST_CASE(aes_cbc_testvectors) {
 
     // NIST AES CBC 128-bit encryption test-vectors
     TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c",
                   "000102030405060708090A0B0C0D0E0F", false,
                   "6bc1bee22e409f96e93d7e117393172a",
                   "7649abac8119b246cee98e9b12e9197d");
     TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c",
                   "7649ABAC8119B246CEE98E9B12E9197D", false,
                   "ae2d8a571e03ac9c9eb76fac45af8e51",
                   "5086cb9b507219ee95db113a917678b2");
     TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c",
                   "5086cb9b507219ee95db113a917678b2", false,
                   "30c81c46a35ce411e5fbc1191a0a52ef",
                   "73bed6b8e3c1743b7116e69e22229516");
     TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c",
                   "73bed6b8e3c1743b7116e69e22229516", false,
                   "f69f2445df4f9b17ad2b417be66c3710",
                   "3ff1caa1681fac09120eca307586e1a7");
 
     // The same vectors with padding enabled
     TestAES128CBC(
         "2b7e151628aed2a6abf7158809cf4f3c", "000102030405060708090A0B0C0D0E0F",
         true, "6bc1bee22e409f96e93d7e117393172a",
         "7649abac8119b246cee98e9b12e9197d8964e0b149c10b7b682e6e39aaeb731c");
     TestAES128CBC(
         "2b7e151628aed2a6abf7158809cf4f3c", "7649ABAC8119B246CEE98E9B12E9197D",
         true, "ae2d8a571e03ac9c9eb76fac45af8e51",
         "5086cb9b507219ee95db113a917678b255e21d7100b988ffec32feeafaf23538");
     TestAES128CBC(
         "2b7e151628aed2a6abf7158809cf4f3c", "5086cb9b507219ee95db113a917678b2",
         true, "30c81c46a35ce411e5fbc1191a0a52ef",
         "73bed6b8e3c1743b7116e69e22229516f6eccda327bf8e5ec43718b0039adceb");
     TestAES128CBC(
         "2b7e151628aed2a6abf7158809cf4f3c", "73bed6b8e3c1743b7116e69e22229516",
         true, "f69f2445df4f9b17ad2b417be66c3710",
         "3ff1caa1681fac09120eca307586e1a78cb82807230e1321d3fae00d18cc2012");
 
     // NIST AES CBC 256-bit encryption test-vectors
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "000102030405060708090A0B0C0D0E0F", false,
         "6bc1bee22e409f96e93d7e117393172a", "f58c4c04d6e5f1ba779eabfb5f7bfbd6");
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "F58C4C04D6E5F1BA779EABFB5F7BFBD6", false,
         "ae2d8a571e03ac9c9eb76fac45af8e51", "9cfc4e967edb808d679f777bc6702c7d");
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "9CFC4E967EDB808D679F777BC6702C7D", false,
         "30c81c46a35ce411e5fbc1191a0a52ef", "39f23369a9d9bacfa530e26304231461");
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "39F23369A9D9BACFA530E26304231461", false,
         "f69f2445df4f9b17ad2b417be66c3710", "b2eb05e2c39be9fcda6c19078c6a9d1b");
 
     // The same vectors with padding enabled
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "000102030405060708090A0B0C0D0E0F", true,
         "6bc1bee22e409f96e93d7e117393172a",
         "f58c4c04d6e5f1ba779eabfb5f7bfbd6485a5c81519cf378fa36d42b8547edc0");
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "F58C4C04D6E5F1BA779EABFB5F7BFBD6", true,
         "ae2d8a571e03ac9c9eb76fac45af8e51",
         "9cfc4e967edb808d679f777bc6702c7d3a3aa5e0213db1a9901f9036cf5102d2");
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "9CFC4E967EDB808D679F777BC6702C7D", true,
         "30c81c46a35ce411e5fbc1191a0a52ef",
         "39f23369a9d9bacfa530e263042314612f8da707643c90a6f732b3de1d3f5cee");
     TestAES256CBC(
         "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
         "39F23369A9D9BACFA530E26304231461", true,
         "f69f2445df4f9b17ad2b417be66c3710",
         "b2eb05e2c39be9fcda6c19078c6a9d1b3f461796d6b0d6b2e0c2a72b4d80e644");
 }
 
 BOOST_AUTO_TEST_CASE(chacha20_testvector) {
     // Test vector from RFC 7539
     TestChaCha20(
         "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
         0x4a000000UL, 1,
         "224f51f3401bd9e12fde276fb8631ded8c131f823d2c06e27e4fcaec9ef3cf788a3b0a"
         "a372600a92b57974cded2b9334794cba40c63e34cdea212c4cf07d41b769a6749f3f63"
         "0f4122cafe28ec4dc47e26d4346d70b98c73f3e9c53ac40c5945398b6eda1a832c89c1"
         "67eacd901d7e2bf363");
 
     // Test vectors from
     // https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7
     TestChaCha20(
         "0000000000000000000000000000000000000000000000000000000000000000", 0,
         0,
         "76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da4"
         "1597c5157488d7724e03fb8d84a376a43b8f41518a11cc387b669b2ee6586");
     TestChaCha20(
         "0000000000000000000000000000000000000000000000000000000000000001", 0,
         0,
         "4540f05a9f1fb296d7736e7b208e3c96eb4fe1834688d2604f450952ed432d41bbe"
         "2a0b6ea7566d2a5d1e7e20d42af2c53d792b1c43fea817e9ad275ae546963");
     TestChaCha20(
         "0000000000000000000000000000000000000000000000000000000000000000",
         0x0100000000000000ULL, 0,
         "de9cba7bf3d69ef5e786dc63973f653a0b49e015adbff7134fcb7df137821031e85a05"
         "0278a7084527214f73efc7fa5b5277062eb7a0433e445f41e3");
     TestChaCha20(
         "0000000000000000000000000000000000000000000000000000000000000000", 1,
         0,
         "ef3fdfd6c61578fbf5cf35bd3dd33b8009631634d21e42ac33960bd138e50d32111"
         "e4caf237ee53ca8ad6426194a88545ddc497a0b466e7d6bbdb0041b2f586b");
     TestChaCha20(
         "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
         0x0706050403020100ULL, 0,
         "f798a189f195e66982105ffb640bb7757f579da31602fc93ec01ac56f85ac3c134a454"
         "7b733b46413042c9440049176905d3be59ea1c53f15916155c2be8241a38008b9a26bc"
         "35941e2444177c8ade6689de95264986d95889fb60e84629c9bd9a5acb1cc118be563e"
         "b9b3a4a472f82e09a7e778492b562ef7130e88dfe031c79db9d4f7c7a899151b9a4750"
         "32b63fc385245fe054e3dd5a97a5f576fe064025d3ce042c566ab2c507b138db853e3d"
         "6959660996546cc9c4a6eafdc777c040d70eaf46f76dad3979e5c5360c3317166a1c89"
         "4c94a371876a94df7628fe4eaaf2ccb27d5aaae0ad7ad0f9d4b6ad3b54098746d4524d"
         "38407a6deb3ab78fab78c9");
 }
 
 BOOST_AUTO_TEST_CASE(countbits_tests) {
     FastRandomContext ctx;
     for (int i = 0; i <= 64; ++i) {
         if (i == 0) {
             // Check handling of zero.
             BOOST_CHECK_EQUAL(CountBits(0), 0);
         } else if (i < 10) {
             for (uint64_t j = 1 << (i - 1); (j >> i) == 0; ++j) {
                 // Exhaustively test up to 10 bits
                 BOOST_CHECK_EQUAL(CountBits(j), i);
             }
         } else {
             for (int k = 0; k < 1000; k++) {
                 // Randomly test 1000 samples of each length above 10 bits.
                 uint64_t j = uint64_t(1) << (i - 1) | ctx.randbits(i - 1);
                 BOOST_CHECK_EQUAL(CountBits(j), i);
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(sha256d64) {
     for (int i = 0; i <= 32; ++i) {
         uint8_t in[64 * 32];
         uint8_t out1[32 * 32], out2[32 * 32];
         for (int j = 0; j < 64 * i; ++j) {
             in[j] = InsecureRandBits(8);
         }
         for (int j = 0; j < i; ++j) {
             CHash256().Write(in + 64 * j, 64).Finalize(out1 + 32 * j);
         }
         SHA256D64(out2, in, i);
         BOOST_CHECK(memcmp(out1, out2, 32 * i) == 0);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/cuckoocache_tests.cpp b/src/test/cuckoocache_tests.cpp
index 8ef075ee8d..b45dc26c52 100644
--- a/src/test/cuckoocache_tests.cpp
+++ b/src/test/cuckoocache_tests.cpp
@@ -1,397 +1,398 @@
 // 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 "cuckoocache.h"
-#include "random.h"
-#include "script/sigcache.h"
-#include "test/test_bitcoin.h"
+#include <cuckoocache.h>
 
-#include <boost/thread/shared_mutex.hpp>
+#include <random.h>
+#include <script/sigcache.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
+#include <boost/thread/shared_mutex.hpp>
 
 /** Test Suite for CuckooCache
  *
  *  1) All tests should have a deterministic result (using insecure rand
  *  with deterministic seeds)
  *  2) Some test methods are templated to allow for easier testing
  *  against new versions / comparing
  *  3) Results should be treated as a regression test, i.e., did the behavior
  *  change significantly from what was expected. This can be OK, depending on
  *  the nature of the change, but requires updating the tests to reflect the new
  *  expected behavior. For example improving the hit rate may cause some tests
  *  using BOOST_CHECK_CLOSE to fail.
  */
 FastRandomContext local_rand_ctx(true);
 
 BOOST_AUTO_TEST_SUITE(cuckoocache_tests);
 
 /**
  * insecure_GetRandHash fills in a uint256 from local_rand_ctx
  */
 void insecure_GetRandHash(uint256 &t) {
     uint32_t *ptr = (uint32_t *)t.begin();
     for (uint8_t j = 0; j < 8; ++j) {
         *(ptr++) = local_rand_ctx.rand32();
     }
 }
 
 /**
  * Test that no values not inserted into the cache are read out of it.
  *
  * There are no repeats in the first 200000 insecure_GetRandHash calls
  */
 BOOST_AUTO_TEST_CASE(test_cuckoocache_no_fakes) {
     local_rand_ctx = FastRandomContext(true);
     CuckooCache::cache<uint256, SignatureCacheHasher> cc{};
     cc.setup_bytes(32 << 20);
     uint256 v;
     for (int x = 0; x < 100000; ++x) {
         insecure_GetRandHash(v);
         cc.insert(v);
     }
     for (int x = 0; x < 100000; ++x) {
         insecure_GetRandHash(v);
         BOOST_CHECK(!cc.contains(v, false));
     }
 };
 
 /**
  * This helper returns the hit rate when megabytes*load worth of entries are
  * inserted into a megabytes sized cache
  */
 template <typename Cache> double test_cache(size_t megabytes, double load) {
     local_rand_ctx = FastRandomContext(true);
     std::vector<uint256> hashes;
     Cache set{};
     size_t bytes = megabytes * (1 << 20);
     set.setup_bytes(bytes);
     uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
     hashes.resize(n_insert);
     for (uint32_t i = 0; i < n_insert; ++i) {
         uint32_t *ptr = (uint32_t *)hashes[i].begin();
         for (uint8_t j = 0; j < 8; ++j) {
             *(ptr++) = local_rand_ctx.rand32();
         }
     }
     /**
      * We make a copy of the hashes because future optimizations of the
      * cuckoocache may overwrite the inserted element, so the test is "future
      * proofed".
      */
     std::vector<uint256> hashes_insert_copy = hashes;
     /** Do the insert */
     for (uint256 &h : hashes_insert_copy) {
         set.insert(h);
     }
     /** Count the hits */
     uint32_t count = 0;
     for (uint256 &h : hashes) {
         count += set.contains(h, false);
     }
     double hit_rate = double(count) / double(n_insert);
     return hit_rate;
 }
 
 /** The normalized hit rate for a given load.
  *
  * The semantics are a little confusing, so please see the below
  * explanation.
  *
  * Examples:
  *
  * 1) at load 0.5, we expect a perfect hit rate, so we multiply by
  * 1.0
  * 2) at load 2.0, we expect to see half the entries, so a perfect hit rate
  * would be 0.5. Therefore, if we see a hit rate of 0.4, 0.4*2.0 = 0.8 is the
  * normalized hit rate.
  *
  * This is basically the right semantics, but has a bit of a glitch depending on
  * how you measure around load 1.0 as after load 1.0 your normalized hit rate
  * becomes effectively perfect, ignoring freshness.
  */
 double normalize_hit_rate(double hits, double load) {
     return hits * std::max(load, 1.0);
 }
 
 /** Check the hit rate on loads ranging from 0.1 to 2.0 */
 BOOST_AUTO_TEST_CASE(cuckoocache_hit_rate_ok) {
     /**
      * Arbitrarily selected Hit Rate threshold that happens to work for this
      * test as a lower bound on performance.
      */
     double HitRateThresh = 0.98;
     size_t megabytes = 32;
     for (double load = 0.1; load < 2; load *= 2) {
         double hits =
             test_cache<CuckooCache::cache<uint256, SignatureCacheHasher>>(
                 megabytes, load);
         BOOST_CHECK(normalize_hit_rate(hits, load) > HitRateThresh);
     }
 }
 
 /** This helper checks that erased elements are preferentially inserted onto and
  * that the hit rate of "fresher" keys is reasonable*/
 template <typename Cache> void test_cache_erase(size_t megabytes) {
     double load = 1;
     local_rand_ctx = FastRandomContext(true);
     std::vector<uint256> hashes;
     Cache set{};
     size_t bytes = megabytes * (1 << 20);
     set.setup_bytes(bytes);
     uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
     hashes.resize(n_insert);
     for (uint32_t i = 0; i < n_insert; ++i) {
         uint32_t *ptr = (uint32_t *)hashes[i].begin();
         for (uint8_t j = 0; j < 8; ++j) {
             *(ptr++) = local_rand_ctx.rand32();
         }
     }
     /** We make a copy of the hashes because future optimizations of the
      * cuckoocache may overwrite the inserted element, so the test is
      * "future proofed".
      */
     std::vector<uint256> hashes_insert_copy = hashes;
 
     /** Insert the first half */
     for (uint32_t i = 0; i < (n_insert / 2); ++i) {
         set.insert(hashes_insert_copy[i]);
     }
     /** Erase the first quarter */
     for (uint32_t i = 0; i < (n_insert / 4); ++i) {
         set.contains(hashes[i], true);
     }
     /** Insert the second half */
     for (uint32_t i = (n_insert / 2); i < n_insert; ++i) {
         set.insert(hashes_insert_copy[i]);
     }
 
     /** elements that we marked erased but that are still there */
     size_t count_erased_but_contained = 0;
     /** elements that we did not erase but are older */
     size_t count_stale = 0;
     /** elements that were most recently inserted */
     size_t count_fresh = 0;
 
     for (uint32_t i = 0; i < (n_insert / 4); ++i) {
         count_erased_but_contained += set.contains(hashes[i], false);
     }
     for (uint32_t i = (n_insert / 4); i < (n_insert / 2); ++i) {
         count_stale += set.contains(hashes[i], false);
     }
     for (uint32_t i = (n_insert / 2); i < n_insert; ++i) {
         count_fresh += set.contains(hashes[i], false);
     }
 
     double hit_rate_erased_but_contained =
         double(count_erased_but_contained) / (double(n_insert) / 4.0);
     double hit_rate_stale = double(count_stale) / (double(n_insert) / 4.0);
     double hit_rate_fresh = double(count_fresh) / (double(n_insert) / 2.0);
 
     // Check that our hit_rate_fresh is perfect
     BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0);
     // Check that we have a more than 2x better hit rate on stale elements than
     // erased elements.
     BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
 }
 
 BOOST_AUTO_TEST_CASE(cuckoocache_erase_ok) {
     size_t megabytes = 32;
     test_cache_erase<CuckooCache::cache<uint256, SignatureCacheHasher>>(
         megabytes);
 }
 
 template <typename Cache> void test_cache_erase_parallel(size_t megabytes) {
     double load = 1;
     local_rand_ctx = FastRandomContext(true);
     std::vector<uint256> hashes;
     Cache set{};
     size_t bytes = megabytes * (1 << 20);
     set.setup_bytes(bytes);
     uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
     hashes.resize(n_insert);
     for (uint32_t i = 0; i < n_insert; ++i) {
         uint32_t *ptr = (uint32_t *)hashes[i].begin();
         for (uint8_t j = 0; j < 8; ++j) {
             *(ptr++) = local_rand_ctx.rand32();
         }
     }
     /** We make a copy of the hashes because future optimizations of the
      * cuckoocache may overwrite the inserted element, so the test is
      * "future proofed".
      */
     std::vector<uint256> hashes_insert_copy = hashes;
     boost::shared_mutex mtx;
 
     {
         /** Grab lock to make sure we release inserts */
         boost::unique_lock<boost::shared_mutex> l(mtx);
         /** Insert the first half */
         for (uint32_t i = 0; i < (n_insert / 2); ++i) {
             set.insert(hashes_insert_copy[i]);
         }
     }
 
     /** Spin up 3 threads to run contains with erase.
      */
     std::vector<std::thread> threads;
     /** Erase the first quarter */
     for (uint32_t x = 0; x < 3; ++x)
         /** Each thread is emplaced with x copy-by-value */
         threads.emplace_back([&, x] {
             boost::shared_lock<boost::shared_mutex> l(mtx);
             size_t ntodo = (n_insert / 4) / 3;
             size_t start = ntodo * x;
             size_t end = ntodo * (x + 1);
             for (uint32_t i = start; i < end; ++i) {
                 set.contains(hashes[i], true);
             }
         });
 
     /** Wait for all threads to finish */
     for (std::thread &t : threads) {
         t.join();
     }
     /** Grab lock to make sure we observe erases */
     boost::unique_lock<boost::shared_mutex> l(mtx);
     /** Insert the second half */
     for (uint32_t i = (n_insert / 2); i < n_insert; ++i) {
         set.insert(hashes_insert_copy[i]);
     }
 
     /** elements that we marked erased but that are still there */
     size_t count_erased_but_contained = 0;
     /** elements that we did not erase but are older */
     size_t count_stale = 0;
     /** elements that were most recently inserted */
     size_t count_fresh = 0;
 
     for (uint32_t i = 0; i < (n_insert / 4); ++i) {
         count_erased_but_contained += set.contains(hashes[i], false);
     }
     for (uint32_t i = (n_insert / 4); i < (n_insert / 2); ++i) {
         count_stale += set.contains(hashes[i], false);
     }
     for (uint32_t i = (n_insert / 2); i < n_insert; ++i) {
         count_fresh += set.contains(hashes[i], false);
     }
 
     double hit_rate_erased_but_contained =
         double(count_erased_but_contained) / (double(n_insert) / 4.0);
     double hit_rate_stale = double(count_stale) / (double(n_insert) / 4.0);
     double hit_rate_fresh = double(count_fresh) / (double(n_insert) / 2.0);
 
     // Check that our hit_rate_fresh is perfect
     BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0);
     // Check that we have a more than 2x better hit rate on stale elements than
     // erased elements.
     BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
 }
 
 BOOST_AUTO_TEST_CASE(cuckoocache_erase_parallel_ok) {
     size_t megabytes = 32;
     test_cache_erase_parallel<
         CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes);
 }
 
 template <typename Cache> void test_cache_generations() {
     // This test checks that for a simulation of network activity, the fresh hit
     // rate is never below 99%, and the number of times that it is worse than
     // 99.9% are less than 1% of the time.
     double min_hit_rate = 0.99;
     double tight_hit_rate = 0.999;
     double max_rate_less_than_tight_hit_rate = 0.01;
     // A cache that meets this specification is therefore shown to have a hit
     // rate of at least tight_hit_rate * (1 - max_rate_less_than_tight_hit_rate)
     // +
     // min_hit_rate*max_rate_less_than_tight_hit_rate = 0.999*99%+0.99*1% ==
     // 99.89%
     // hit rate with low variance.
 
     // We use deterministic values, but this test has also passed on many
     // iterations with non-deterministic values, so it isn't "overfit" to the
     // specific entropy in FastRandomContext(true) and implementation of the
     // cache.
     local_rand_ctx = FastRandomContext(true);
 
     // block_activity models a chunk of network activity. n_insert elements are
     // adde to the cache. The first and last n/4 are stored for removal later
     // and the middle n/2 are not stored. This models a network which uses half
     // the signatures of recently (since the last block) added transactions
     // immediately and never uses the other half.
     struct block_activity {
         std::vector<uint256> reads;
         block_activity(uint32_t n_insert, Cache &c) : reads() {
             std::vector<uint256> inserts;
             inserts.resize(n_insert);
             reads.reserve(n_insert / 2);
             for (uint32_t i = 0; i < n_insert; ++i) {
                 uint32_t *ptr = (uint32_t *)inserts[i].begin();
                 for (uint8_t j = 0; j < 8; ++j) {
                     *(ptr++) = local_rand_ctx.rand32();
                 }
             }
             for (uint32_t i = 0; i < n_insert / 4; ++i) {
                 reads.push_back(inserts[i]);
             }
             for (uint32_t i = n_insert - (n_insert / 4); i < n_insert; ++i) {
                 reads.push_back(inserts[i]);
             }
             for (auto h : inserts) {
                 c.insert(h);
             }
         }
     };
 
     const uint32_t BLOCK_SIZE = 10000;
     // We expect window size 60 to perform reasonably given that each epoch
     // stores 45% of the cache size (~472k).
     const uint32_t WINDOW_SIZE = 60;
     const uint32_t POP_AMOUNT = (BLOCK_SIZE / WINDOW_SIZE) / 2;
     const double load = 10;
     const size_t megabytes = 32;
     const size_t bytes = megabytes * (1 << 20);
     const uint32_t n_insert =
         static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
 
     std::vector<block_activity> hashes;
     Cache set{};
     set.setup_bytes(bytes);
     hashes.reserve(n_insert / BLOCK_SIZE);
     std::deque<block_activity> last_few;
     uint32_t out_of_tight_tolerance = 0;
     uint32_t total = n_insert / BLOCK_SIZE;
     // we use the deque last_few to model a sliding window of blocks. at each
     // step, each of the last WINDOW_SIZE block_activities checks the cache for
     // POP_AMOUNT of the hashes that they inserted, and marks these erased.
     for (uint32_t i = 0; i < total; ++i) {
         if (last_few.size() == WINDOW_SIZE) last_few.pop_front();
         last_few.emplace_back(BLOCK_SIZE, set);
         uint32_t count = 0;
         for (auto &act : last_few) {
             for (uint32_t k = 0; k < POP_AMOUNT; ++k) {
                 count += set.contains(act.reads.back(), true);
                 act.reads.pop_back();
             }
         }
         // We use last_few.size() rather than WINDOW_SIZE for the correct
         // behavior on the first WINDOW_SIZE iterations where the deque is not
         // full yet.
         double hit = double(count) / (last_few.size() * POP_AMOUNT);
         // Loose Check that hit rate is above min_hit_rate
         BOOST_CHECK(hit > min_hit_rate);
         // Tighter check, count number of times we are less than tight_hit_rate
         // (and implicityly, greater than min_hit_rate)
         out_of_tight_tolerance += hit < tight_hit_rate;
     }
     // Check that being out of tolerance happens less than
     // max_rate_less_than_tight_hit_rate of the time
     BOOST_CHECK(double(out_of_tight_tolerance) / double(total) <
                 max_rate_less_than_tight_hit_rate);
 }
 BOOST_AUTO_TEST_CASE(cuckoocache_generations) {
     test_cache_generations<CuckooCache::cache<uint256, SignatureCacheHasher>>();
 }
 
 BOOST_AUTO_TEST_SUITE_END();
diff --git a/src/test/dbwrapper_tests.cpp b/src/test/dbwrapper_tests.cpp
index b408de08d6..f849fbf63b 100644
--- a/src/test/dbwrapper_tests.cpp
+++ b/src/test/dbwrapper_tests.cpp
@@ -1,311 +1,313 @@
 // 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 "dbwrapper.h"
-#include "random.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
+#include <dbwrapper.h>
+
+#include <random.h>
+#include <uint256.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 // Test if a string consists entirely of null characters
 bool is_null_key(const std::vector<uint8_t> &key) {
     bool isnull = true;
 
     for (unsigned int i = 0; i < key.size(); i++)
         isnull &= (key[i] == '\x00');
 
     return isnull;
 }
 
 BOOST_FIXTURE_TEST_SUITE(dbwrapper_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(dbwrapper) {
     // Perform tests both obfuscated and non-obfuscated.
     for (bool obfuscate : {false, true}) {
         fs::path ph = fs::temp_directory_path() / fs::unique_path();
         CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
         char key = 'k';
         uint256 in = InsecureRand256();
         uint256 res;
 
         // Ensure that we're doing real obfuscation when obfuscate=true
         BOOST_CHECK(obfuscate !=
                     is_null_key(dbwrapper_private::GetObfuscateKey(dbw)));
 
         BOOST_CHECK(dbw.Write(key, in));
         BOOST_CHECK(dbw.Read(key, res));
         BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
     }
 }
 
 // Test batch operations
 BOOST_AUTO_TEST_CASE(dbwrapper_batch) {
     // Perform tests both obfuscated and non-obfuscated.
     for (bool obfuscate : {false, true}) {
         fs::path ph = fs::temp_directory_path() / fs::unique_path();
         CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
 
         char key = 'i';
         uint256 in = InsecureRand256();
         char key2 = 'j';
         uint256 in2 = InsecureRand256();
         char key3 = 'k';
         uint256 in3 = InsecureRand256();
 
         uint256 res;
         CDBBatch batch(dbw);
 
         batch.Write(key, in);
         batch.Write(key2, in2);
         batch.Write(key3, in3);
 
         // Remove key3 before it's even been written
         batch.Erase(key3);
 
         dbw.WriteBatch(batch);
 
         BOOST_CHECK(dbw.Read(key, res));
         BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
         BOOST_CHECK(dbw.Read(key2, res));
         BOOST_CHECK_EQUAL(res.ToString(), in2.ToString());
 
         // key3 should've never been written
         BOOST_CHECK(dbw.Read(key3, res) == false);
     }
 }
 
 BOOST_AUTO_TEST_CASE(dbwrapper_iterator) {
     // Perform tests both obfuscated and non-obfuscated.
     for (bool obfuscate : {false, true}) {
         fs::path ph = fs::temp_directory_path() / fs::unique_path();
         CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
 
         // The two keys are intentionally chosen for ordering
         char key = 'j';
         uint256 in = InsecureRand256();
         BOOST_CHECK(dbw.Write(key, in));
         char key2 = 'k';
         uint256 in2 = InsecureRand256();
         BOOST_CHECK(dbw.Write(key2, in2));
 
         std::unique_ptr<CDBIterator> it(
             const_cast<CDBWrapper &>(dbw).NewIterator());
 
         // Be sure to seek past the obfuscation key (if it exists)
         it->Seek(key);
 
         char key_res;
         uint256 val_res;
 
         it->GetKey(key_res);
         it->GetValue(val_res);
         BOOST_CHECK_EQUAL(key_res, key);
         BOOST_CHECK_EQUAL(val_res.ToString(), in.ToString());
 
         it->Next();
 
         it->GetKey(key_res);
         it->GetValue(val_res);
         BOOST_CHECK_EQUAL(key_res, key2);
         BOOST_CHECK_EQUAL(val_res.ToString(), in2.ToString());
 
         it->Next();
         BOOST_CHECK_EQUAL(it->Valid(), false);
     }
 }
 
 // Test that we do not obfuscation if there is existing data.
 BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate) {
     // We're going to share this fs::path between two wrappers
     fs::path ph = fs::temp_directory_path() / fs::unique_path();
     create_directories(ph);
 
     // Set up a non-obfuscated wrapper to write some initial data.
     std::unique_ptr<CDBWrapper> dbw =
         std::make_unique<CDBWrapper>(ph, (1 << 10), false, false, false);
     char key = 'k';
     uint256 in = InsecureRand256();
     uint256 res;
 
     BOOST_CHECK(dbw->Write(key, in));
     BOOST_CHECK(dbw->Read(key, res));
     BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
 
     // Call the destructor to free leveldb LOCK
     dbw.reset();
 
     // Now, set up another wrapper that wants to obfuscate the same directory
     CDBWrapper odbw(ph, (1 << 10), false, false, true);
 
     // Check that the key/val we wrote with unobfuscated wrapper exists and
     // is readable.
     uint256 res2;
     BOOST_CHECK(odbw.Read(key, res2));
     BOOST_CHECK_EQUAL(res2.ToString(), in.ToString());
 
     // There should be existing data
     BOOST_CHECK(!odbw.IsEmpty());
     // The key should be an empty string
     BOOST_CHECK(is_null_key(dbwrapper_private::GetObfuscateKey(odbw)));
 
     uint256 in2 = InsecureRand256();
     uint256 res3;
 
     // Check that we can write successfully
     BOOST_CHECK(odbw.Write(key, in2));
     BOOST_CHECK(odbw.Read(key, res3));
     BOOST_CHECK_EQUAL(res3.ToString(), in2.ToString());
 }
 
 // Ensure that we start obfuscating during a reindex.
 BOOST_AUTO_TEST_CASE(existing_data_reindex) {
     // We're going to share this fs::path between two wrappers
     fs::path ph = fs::temp_directory_path() / fs::unique_path();
     create_directories(ph);
 
     // Set up a non-obfuscated wrapper to write some initial data.
     std::unique_ptr<CDBWrapper> dbw =
         std::make_unique<CDBWrapper>(ph, (1 << 10), false, false, false);
     char key = 'k';
     uint256 in = InsecureRand256();
     uint256 res;
 
     BOOST_CHECK(dbw->Write(key, in));
     BOOST_CHECK(dbw->Read(key, res));
     BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
 
     // Call the destructor to free leveldb LOCK
     dbw.reset();
 
     // Simulate a -reindex by wiping the existing data store
     CDBWrapper odbw(ph, (1 << 10), false, true, true);
 
     // Check that the key/val we wrote with unobfuscated wrapper doesn't exist
     uint256 res2;
     BOOST_CHECK(!odbw.Read(key, res2));
     BOOST_CHECK(!is_null_key(dbwrapper_private::GetObfuscateKey(odbw)));
 
     uint256 in2 = InsecureRand256();
     uint256 res3;
 
     // Check that we can write successfully
     BOOST_CHECK(odbw.Write(key, in2));
     BOOST_CHECK(odbw.Read(key, res3));
     BOOST_CHECK_EQUAL(res3.ToString(), in2.ToString());
 }
 
 BOOST_AUTO_TEST_CASE(iterator_ordering) {
     fs::path ph = fs::temp_directory_path() / fs::unique_path();
     CDBWrapper dbw(ph, (1 << 20), true, false, false);
     for (int x = 0x00; x < 256; ++x) {
         uint8_t key = x;
         uint32_t value = x * x;
         BOOST_CHECK(dbw.Write(key, value));
     }
 
     std::unique_ptr<CDBIterator> it(
         const_cast<CDBWrapper &>(dbw).NewIterator());
     for (int seek_start : {0x00, 0x80}) {
         it->Seek((uint8_t)seek_start);
         for (int x = seek_start; x < 256; ++x) {
             uint8_t key;
             uint32_t value;
             BOOST_CHECK(it->Valid());
             // Avoid spurious errors about invalid iterator's  key and value in
             // case of failure
             if (!it->Valid()) break;
             BOOST_CHECK(it->GetKey(key));
             BOOST_CHECK(it->GetValue(value));
             BOOST_CHECK_EQUAL(key, x);
             BOOST_CHECK_EQUAL(value, x * x);
             it->Next();
         }
         BOOST_CHECK(!it->Valid());
     }
 }
 
 struct StringContentsSerializer {
     // Used to make two serialized objects the same while letting them have a
     // different lengths. This is a terrible idea.
     std::string str;
     StringContentsSerializer() {}
     explicit StringContentsSerializer(const std::string &inp) : str(inp) {}
 
     StringContentsSerializer &operator+=(const std::string &s) {
         str += s;
         return *this;
     }
     StringContentsSerializer &operator+=(const StringContentsSerializer &s) {
         return *this += s.str;
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         if (ser_action.ForRead()) {
             str.clear();
             char c = 0;
             while (true) {
                 try {
                     READWRITE(c);
                     str.push_back(c);
                 } catch (const std::ios_base::failure &e) {
                     break;
                 }
             }
         } else {
             for (size_t i = 0; i < str.size(); i++)
                 READWRITE(str[i]);
         }
     }
 };
 
 BOOST_AUTO_TEST_CASE(iterator_string_ordering) {
     char buf[10];
 
     fs::path ph = fs::temp_directory_path() / fs::unique_path();
     CDBWrapper dbw(ph, (1 << 20), true, false, false);
     for (int x = 0x00; x < 10; ++x) {
         for (int y = 0; y < 10; y++) {
             snprintf(buf, sizeof(buf), "%d", x);
             StringContentsSerializer key(buf);
             for (int z = 0; z < y; z++)
                 key += key;
             uint32_t value = x * x;
             BOOST_CHECK(dbw.Write(key, value));
         }
     }
 
     std::unique_ptr<CDBIterator> it(
         const_cast<CDBWrapper &>(dbw).NewIterator());
     for (int seek_start : {0, 5}) {
         snprintf(buf, sizeof(buf), "%d", seek_start);
         StringContentsSerializer seek_key(buf);
         it->Seek(seek_key);
         for (int x = seek_start; x < 10; ++x) {
             for (int y = 0; y < 10; y++) {
                 snprintf(buf, sizeof(buf), "%d", x);
                 std::string exp_key(buf);
                 for (int z = 0; z < y; z++)
                     exp_key += exp_key;
                 StringContentsSerializer key;
                 uint32_t value;
                 BOOST_CHECK(it->Valid());
                 // Avoid spurious errors about invalid iterator's key and value
                 // in case of failure
                 if (!it->Valid()) break;
                 BOOST_CHECK(it->GetKey(key));
                 BOOST_CHECK(it->GetValue(value));
                 BOOST_CHECK_EQUAL(key.str, exp_key);
                 BOOST_CHECK_EQUAL(value, x * x);
                 it->Next();
             }
         }
         BOOST_CHECK(!it->Valid());
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/dstencode_tests.cpp b/src/test/dstencode_tests.cpp
index 769cf1b8f7..5d153b8deb 100644
--- a/src/test/dstencode_tests.cpp
+++ b/src/test/dstencode_tests.cpp
@@ -1,69 +1,71 @@
 // 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 "chainparams.h"
-#include "config.h"
-#include "dstencode.h"
-#include "test/test_bitcoin.h"
+#include <dstencode.h>
+
+#include <chainparams.h>
+#include <config.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 namespace {
 
 class DummyCashAddrConfig : public DummyConfig {
 public:
     DummyCashAddrConfig()
         : DummyConfig(CBaseChainParams::MAIN), useCashAddr(false) {}
     void SetCashAddrEncoding(bool b) override { useCashAddr = b; }
     bool UseCashAddrEncoding() const override { return useCashAddr; }
 
 private:
     bool useCashAddr;
 };
 
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(dstencode_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(test_addresses) {
     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};
 
     const CTxDestination dstKey = CKeyID(uint160(hash));
     const CTxDestination dstScript = CScriptID(uint160(hash));
 
     std::string cashaddr_pubkey =
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a";
     std::string cashaddr_script =
         "bitcoincash:ppm2qsznhks23z7629mms6s4cwef74vcwvn0h829pq";
     std::string base58_pubkey = "1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu";
     std::string base58_script = "3CWFddi6m4ndiGyKqzYvsFYagqDLPVMTzC";
 
     DummyCashAddrConfig config;
 
     // Check encoding
     config.SetCashAddrEncoding(true);
     BOOST_CHECK_EQUAL(cashaddr_pubkey, EncodeDestination(dstKey, config));
     BOOST_CHECK_EQUAL(cashaddr_script, EncodeDestination(dstScript, config));
     config.SetCashAddrEncoding(false);
     BOOST_CHECK_EQUAL(base58_pubkey, EncodeDestination(dstKey, config));
     BOOST_CHECK_EQUAL(base58_script, EncodeDestination(dstScript, config));
 
     // Check decoding
     const CChainParams &params = config.GetChainParams();
     BOOST_CHECK(dstKey == DecodeDestination(cashaddr_pubkey, params));
     BOOST_CHECK(dstScript == DecodeDestination(cashaddr_script, params));
     BOOST_CHECK(dstKey == DecodeDestination(base58_pubkey, params));
     BOOST_CHECK(dstScript == DecodeDestination(base58_script, params));
 
     // Validation
     BOOST_CHECK(IsValidDestinationString(cashaddr_pubkey, params));
     BOOST_CHECK(IsValidDestinationString(cashaddr_script, params));
     BOOST_CHECK(IsValidDestinationString(base58_pubkey, params));
     BOOST_CHECK(IsValidDestinationString(base58_script, params));
     BOOST_CHECK(!IsValidDestinationString("notvalid", params));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/excessiveblock_tests.cpp b/src/test/excessiveblock_tests.cpp
index 9c9cf41736..2ac1d5f804 100644
--- a/src/test/excessiveblock_tests.cpp
+++ b/src/test/excessiveblock_tests.cpp
@@ -1,62 +1,64 @@
 // 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 "consensus/consensus.h"
-#include "rpc/server.h"
-#include "test/test_bitcoin.h"
+#include <consensus/consensus.h>
+#include <rpc/server.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/test/unit_test.hpp>
+
 #include <limits>
 #include <string>
 
 extern UniValue CallRPC(std::string strMethod);
 
 BOOST_FIXTURE_TEST_SUITE(excessiveblock_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(excessiveblock_rpc) {
     BOOST_CHECK_NO_THROW(CallRPC("getexcessiveblock"));
 
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock not_uint"),
                       boost::bad_lexical_cast);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1000000 not_uint"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1000000 1"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock -1"), boost::bad_lexical_cast);
 
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 0"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1000"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC(std::string("setexcessiveblock ") +
                               std::to_string(ONE_MEGABYTE - 1)),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC(std::string("setexcessiveblock ") +
                               std::to_string(ONE_MEGABYTE)),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
                                  std::to_string(ONE_MEGABYTE + 1)));
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
                                  std::to_string(ONE_MEGABYTE + 10)));
 
     // Default can be higher than 1MB in future - test it too
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
                                  std::to_string(DEFAULT_MAX_BLOCK_SIZE)));
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
                                  std::to_string(DEFAULT_MAX_BLOCK_SIZE * 8)));
 
     BOOST_CHECK_NO_THROW(
         CallRPC(std::string("setexcessiveblock ") +
                 std::to_string(std::numeric_limits<uint64_t>::max())));
 
     BOOST_CHECK_THROW(
         CallRPC(std::string("setexcessiveblock ") +
                 std::to_string(std::numeric_limits<uint64_t>::max() + 1)),
         std::runtime_error);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/feerate_tests.cpp b/src/test/feerate_tests.cpp
index fd04127b8b..4f89344344 100644
--- a/src/test/feerate_tests.cpp
+++ b/src/test/feerate_tests.cpp
@@ -1,82 +1,83 @@
 // 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(feerate_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(GetFeeTest) {
     CFeeRate feeRate;
 
     feeRate = CFeeRate(Amount::zero());
     // Must always return 0
     BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero());
     BOOST_CHECK_EQUAL(feeRate.GetFee(1e5), Amount::zero());
 
     feeRate = CFeeRate(1000 * SATOSHI);
     // Must always just return the arg
     BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero());
     BOOST_CHECK_EQUAL(feeRate.GetFee(1), SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(121), 121 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(999), 999 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(1000), 1000 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(9000), 9000 * SATOSHI);
 
     feeRate = CFeeRate(-1000 * SATOSHI);
     // Must always just return -1 * arg
     BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero());
     BOOST_CHECK_EQUAL(feeRate.GetFee(1), -SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(121), -121 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(999), -999 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(1000), -1000 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(9000), -9000 * SATOSHI);
 
     feeRate = CFeeRate(123 * SATOSHI);
     // Truncates the result, if not integer
     BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero());
     // Special case: returns 1 instead of 0
     BOOST_CHECK_EQUAL(feeRate.GetFee(8), SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(9), SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(121), 14 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(122), 15 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(999), 122 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(1000), 123 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(9000), 1107 * SATOSHI);
 
     feeRate = CFeeRate(-123 * SATOSHI);
     // Truncates the result, if not integer
     BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero());
     // Special case: returns -1 instead of 0
     BOOST_CHECK_EQUAL(feeRate.GetFee(8), -SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFee(9), -SATOSHI);
 
     // Check ceiling results
     feeRate = CFeeRate(18 * SATOSHI);
     // Truncates the result, if not integer
     BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(0), Amount::zero());
     BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(100), 2 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(200), 4 * SATOSHI);
     BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(1000), 18 * SATOSHI);
 
     // Check full constructor
     // default value
     BOOST_CHECK(CFeeRate(-SATOSHI, 1000) == CFeeRate(-SATOSHI));
     BOOST_CHECK(CFeeRate(Amount::zero(), 1000) == CFeeRate(Amount::zero()));
     BOOST_CHECK(CFeeRate(SATOSHI, 1000) == CFeeRate(SATOSHI));
     // lost precision (can only resolve satoshis per kB)
     BOOST_CHECK(CFeeRate(SATOSHI, 1001) == CFeeRate(Amount::zero()));
     BOOST_CHECK(CFeeRate(2 * SATOSHI, 1001) == CFeeRate(SATOSHI));
     // some more integer checks
     BOOST_CHECK(CFeeRate(26 * SATOSHI, 789) == CFeeRate(32 * SATOSHI));
     BOOST_CHECK(CFeeRate(27 * SATOSHI, 789) == CFeeRate(34 * SATOSHI));
     // Maximum size in bytes, should not crash
     CFeeRate(MAX_MONEY, std::numeric_limits<size_t>::max() >> 1).GetFeePerK();
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/finalization_tests.cpp b/src/test/finalization_tests.cpp
index b24d341ae4..9c8ea9119f 100644
--- a/src/test/finalization_tests.cpp
+++ b/src/test/finalization_tests.cpp
@@ -1,93 +1,94 @@
 // 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 "chainparams.h"
-#include "config.h"
-#include "test/test_bitcoin.h"
-#include "validation.h"
+#include <chainparams.h>
+#include <config.h>
+#include <validation.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(finalization_tests, TestChain100Setup)
 
 BOOST_AUTO_TEST_CASE(finalizationDelay) {
     CScript p2pk_scriptPubKey =
         CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     CBlock block;
 
     {
         LOCK(cs_main);
         // We should have no finalized block because the 100 blocks generated by
         // the test setup are too close to "now";
         BOOST_CHECK_MESSAGE(GetFinalizedBlock() == nullptr,
                             "No block finalized (tip at height "
                                 << chainActive.Tip()->nHeight << ")");
     }
 
     // Create maxreorgdepth blocks. Auto-finalization will not occur because
     // the delay is not expired
     int64_t mockedTime = GetTime();
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         // These blocks are too recent.
         BOOST_CHECK_MESSAGE(GetFinalizedBlock() == nullptr,
                             "No block finalized (tip at height "
                                 << chainActive.Tip()->nHeight << ")");
     }
 
     // Make the finalization time to expire
     mockedTime += DEFAULT_MIN_FINALIZATION_DELAY + 1;
     SetMockTime(mockedTime);
 
     // Next maxreorgdepth blocks should cause auto-finalization
     CBlockIndex *blockToFinalize = chainActive.Tip()->GetAncestor(
         chainActive.Tip()->nHeight - DEFAULT_MAX_REORG_DEPTH);
 
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
         blockToFinalize = chainActive.Next(blockToFinalize);
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         BOOST_CHECK_MESSAGE(GetFinalizedBlock() == blockToFinalize,
                             "Block finalized at height "
                                 << blockToFinalize->nHeight
                                 << " (tip at height "
                                 << chainActive.Tip()->nHeight << ")");
     }
 
     // Next blocks won't cause auto-finalization because the delay is not
     // expired
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         // These blocks are finalized.
         BOOST_CHECK_MESSAGE(GetFinalizedBlock() == blockToFinalize,
                             "Finalized block remains unchanged at height "
                                 << blockToFinalize->nHeight
                                 << " (tip at height "
                                 << chainActive.Tip()->nHeight << ")");
     }
 
     // Make the finalization time to expire
     mockedTime += DEFAULT_MIN_FINALIZATION_DELAY + 1;
     SetMockTime(mockedTime);
 
     blockToFinalize = chainActive.Tip()->GetAncestor(
         chainActive.Tip()->nHeight - DEFAULT_MAX_REORG_DEPTH);
 
     // Create some more blocks.
     // Finalization should start moving again.
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
         blockToFinalize = chainActive.Next(blockToFinalize);
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         BOOST_CHECK_MESSAGE(GetFinalizedBlock() == blockToFinalize,
                             "Block finalized at height "
                                 << blockToFinalize->nHeight
                                 << " (tip at height "
                                 << chainActive.Tip()->nHeight << ")");
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/getarg_tests.cpp b/src/test/getarg_tests.cpp
index 530fde7756..8b290aa5c5 100644
--- a/src/test/getarg_tests.cpp
+++ b/src/test/getarg_tests.cpp
@@ -1,160 +1,161 @@
 // 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 "util.h"
+#include <util.h>
 
-#include <string>
-#include <vector>
+#include <test/test_bitcoin.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <string>
+#include <vector>
+
 BOOST_FIXTURE_TEST_SUITE(getarg_tests, BasicTestingSetup)
 
 static void ResetArgs(const std::string &strArg) {
     std::vector<std::string> vecArg;
     if (strArg.size())
         boost::split(vecArg, strArg, boost::is_space(),
                      boost::token_compress_on);
 
     // Insert dummy executable name:
     vecArg.insert(vecArg.begin(), "testbitcoin");
 
     // Convert to char*:
     std::vector<const char *> vecChar;
     for (std::string &s : vecArg) {
         vecChar.push_back(s.c_str());
     }
 
     gArgs.ParseParameters(vecChar.size(), &vecChar[0]);
 }
 
 BOOST_AUTO_TEST_CASE(boolarg) {
     ResetArgs("-foo");
     BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
 
     BOOST_CHECK(!gArgs.GetBoolArg("-fo", false));
     BOOST_CHECK(gArgs.GetBoolArg("-fo", true));
 
     BOOST_CHECK(!gArgs.GetBoolArg("-fooo", false));
     BOOST_CHECK(gArgs.GetBoolArg("-fooo", true));
 
     ResetArgs("-foo=0");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
 
     ResetArgs("-foo=1");
     BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
 
     // New 0.6 feature: auto-map -nosomething to !-something:
     ResetArgs("-nofoo");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
 
     ResetArgs("-nofoo=1");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
 
     // -nofoo should win
     ResetArgs("-foo -nofoo");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
 
     // -nofoo should win
     ResetArgs("-foo=1 -nofoo=1");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
 
     // -nofoo=0 should win
     ResetArgs("-foo=0 -nofoo=0");
     BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
 
     // New 0.6 feature: treat -- same as -:
     ResetArgs("--foo=1");
     BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
 
     ResetArgs("--nofoo=1");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
 }
 
 BOOST_AUTO_TEST_CASE(stringarg) {
     ResetArgs("");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "eleven");
 
     ResetArgs("-foo -bar");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "");
 
     ResetArgs("-foo=");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "");
 
     ResetArgs("-foo=11");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "11");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "11");
 
     ResetArgs("-foo=eleven");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "eleven");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "eleven");
 }
 
 BOOST_AUTO_TEST_CASE(intarg) {
     ResetArgs("");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 11), 11);
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 0), 0);
 
     ResetArgs("-foo -bar");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 11), 0);
     BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 11), 0);
 
     ResetArgs("-foo=11 -bar=12");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 0), 11);
     BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 11), 12);
 
     ResetArgs("-foo=NaN -bar=NotANumber");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 1), 0);
     BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 11), 0);
 }
 
 BOOST_AUTO_TEST_CASE(doubledash) {
     ResetArgs("--foo");
     BOOST_CHECK_EQUAL(gArgs.GetBoolArg("-foo", false), true);
 
     ResetArgs("--foo=verbose --bar=1");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "verbose");
     BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 0), 1);
 }
 
 BOOST_AUTO_TEST_CASE(boolargno) {
     ResetArgs("-nofoo");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
 
     ResetArgs("-nofoo=1");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
 
     ResetArgs("-nofoo=0");
     BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
     BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
 
     // --nofoo should win
     ResetArgs("-foo --nofoo");
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
     BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
 
     // foo always wins:
     ResetArgs("-nofoo -foo");
     BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
     BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/hash_tests.cpp b/src/test/hash_tests.cpp
index 2d83bc833e..55552974f9 100644
--- a/src/test/hash_tests.cpp
+++ b/src/test/hash_tests.cpp
@@ -1,202 +1,204 @@
 // Copyright (c) 2013-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 "hash.h"
-#include "test/test_bitcoin.h"
-#include "utilstrencodings.h"
+#include <hash.h>
 
-#include <vector>
+#include <utilstrencodings.h>
+
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <vector>
+
 BOOST_FIXTURE_TEST_SUITE(hash_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(murmurhash3) {
 
 #define T(expected, seed, data)                                                \
     BOOST_CHECK_EQUAL(MurmurHash3(seed, ParseHex(data)), expected)
 
     // Test MurmurHash3 with various inputs. Of course this is retested in the
     // bloom filter tests - they would fail if MurmurHash3() had any problems -
     // but is useful for those trying to implement Bitcoin libraries as a
     // source of test data for their MurmurHash3() primitive during
     // development.
     //
     // The magic number 0xFBA4C795 comes from CBloomFilter::Hash()
 
     T(0x00000000, 0x00000000, "");
     T(0x6a396f08, 0xFBA4C795, "");
     T(0x81f16f39, 0xffffffff, "");
 
     T(0x514e28b7, 0x00000000, "00");
     T(0xea3f0b17, 0xFBA4C795, "00");
     T(0xfd6cf10d, 0x00000000, "ff");
 
     T(0x16c6b7ab, 0x00000000, "0011");
     T(0x8eb51c3d, 0x00000000, "001122");
     T(0xb4471bf8, 0x00000000, "00112233");
     T(0xe2301fa8, 0x00000000, "0011223344");
     T(0xfc2e4a15, 0x00000000, "001122334455");
     T(0xb074502c, 0x00000000, "00112233445566");
     T(0x8034d2a0, 0x00000000, "0011223344556677");
     T(0xb4698def, 0x00000000, "001122334455667788");
 
 #undef T
 }
 
 /**
  * SipHash-2-4 output with
  * k = 00 01 02 ...
  * and
  * in = (empty string)
  * in = 00 (1 byte)
  * in = 00 01 (2 bytes)
  * in = 00 01 02 (3 bytes)
  * ...
  * in = 00 01 02 ... 3e (63 bytes)
  *
  * from: https://131002.net/siphash/siphash24.c
  */
 uint64_t siphash_4_2_testvec[] = {
     0x726fdb47dd0e0e31, 0x74f839c593dc67fd, 0x0d6c8009d9a94f5a,
     0x85676696d7fb7e2d, 0xcf2794e0277187b7, 0x18765564cd99a68d,
     0xcbc9466e58fee3ce, 0xab0200f58b01d137, 0x93f5f5799a932462,
     0x9e0082df0ba9e4b0, 0x7a5dbbc594ddb9f3, 0xf4b32f46226bada7,
     0x751e8fbc860ee5fb, 0x14ea5627c0843d90, 0xf723ca908e7af2ee,
     0xa129ca6149be45e5, 0x3f2acc7f57c29bdb, 0x699ae9f52cbe4794,
     0x4bc1b3f0968dd39c, 0xbb6dc91da77961bd, 0xbed65cf21aa2ee98,
     0xd0f2cbb02e3b67c7, 0x93536795e3a33e88, 0xa80c038ccd5ccec8,
     0xb8ad50c6f649af94, 0xbce192de8a85b8ea, 0x17d835b85bbb15f3,
     0x2f2e6163076bcfad, 0xde4daaaca71dc9a5, 0xa6a2506687956571,
     0xad87a3535c49ef28, 0x32d892fad841c342, 0x7127512f72f27cce,
     0xa7f32346f95978e3, 0x12e0b01abb051238, 0x15e034d40fa197ae,
     0x314dffbe0815a3b4, 0x027990f029623981, 0xcadcd4e59ef40c4d,
     0x9abfd8766a33735c, 0x0e3ea96b5304a7d0, 0xad0c42d6fc585992,
     0x187306c89bc215a9, 0xd4a60abcf3792b95, 0xf935451de4f21df2,
     0xa9538f0419755787, 0xdb9acddff56ca510, 0xd06c98cd5c0975eb,
     0xe612a3cb9ecba951, 0xc766e62cfcadaf96, 0xee64435a9752fe72,
     0xa192d576b245165a, 0x0a8787bf8ecb74b2, 0x81b3e73d20b49b6f,
     0x7fa8220ba3b2ecea, 0x245731c13ca42499, 0xb78dbfaf3a8d83bd,
     0xea1ad565322a1a0b, 0x60e61c23a3795013, 0x6606d7e446282b93,
     0x6ca4ecb15c5f91e1, 0x9f626da15c9625f3, 0xe51b38608ef25f57,
     0x958a324ceb064572};
 
 BOOST_AUTO_TEST_CASE(siphash) {
     CSipHasher hasher(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x726fdb47dd0e0e31ull);
     static const uint8_t t0[1] = {0};
     hasher.Write(t0, 1);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x74f839c593dc67fdull);
     static const uint8_t t1[7] = {1, 2, 3, 4, 5, 6, 7};
     hasher.Write(t1, 7);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x93f5f5799a932462ull);
     hasher.Write(0x0F0E0D0C0B0A0908ULL);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x3f2acc7f57c29bdbull);
     static const uint8_t t2[2] = {16, 17};
     hasher.Write(t2, 2);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x4bc1b3f0968dd39cull);
     static const uint8_t t3[9] = {18, 19, 20, 21, 22, 23, 24, 25, 26};
     hasher.Write(t3, 9);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x2f2e6163076bcfadull);
     static const uint8_t t4[5] = {27, 28, 29, 30, 31};
     hasher.Write(t4, 5);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x7127512f72f27cceull);
     hasher.Write(0x2726252423222120ULL);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0x0e3ea96b5304a7d0ull);
     hasher.Write(0x2F2E2D2C2B2A2928ULL);
     BOOST_CHECK_EQUAL(hasher.Finalize(), 0xe612a3cb9ecba951ull);
 
     BOOST_CHECK_EQUAL(
         SipHashUint256(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL,
                        uint256S("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09"
                                 "080706050403020100")),
         0x7127512f72f27cceull);
 
     // Check test vectors from spec, one byte at a time
     CSipHasher hasher2(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL);
     for (uint8_t x = 0; x < ARRAYLEN(siphash_4_2_testvec); ++x) {
         BOOST_CHECK_EQUAL(hasher2.Finalize(), siphash_4_2_testvec[x]);
         hasher2.Write(&x, 1);
     }
     // Check test vectors from spec, eight bytes at a time
     CSipHasher hasher3(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL);
     for (uint8_t x = 0; x < ARRAYLEN(siphash_4_2_testvec); x += 8) {
         BOOST_CHECK_EQUAL(hasher3.Finalize(), siphash_4_2_testvec[x]);
         hasher3.Write(uint64_t(x) | (uint64_t(x + 1) << 8) |
                       (uint64_t(x + 2) << 16) | (uint64_t(x + 3) << 24) |
                       (uint64_t(x + 4) << 32) | (uint64_t(x + 5) << 40) |
                       (uint64_t(x + 6) << 48) | (uint64_t(x + 7) << 56));
     }
 
     CHashWriter ss(SER_DISK, CLIENT_VERSION);
     CMutableTransaction tx;
     // Note these tests were originally written with tx.nVersion=1
     // and the test would be affected by default tx version bumps if not fixed.
     tx.nVersion = 1;
     ss << tx;
     BOOST_CHECK_EQUAL(SipHashUint256(1, 2, ss.GetHash()),
                       0x79751e980c2a0a35ULL);
 
     // Check consistency between CSipHasher and SipHashUint256[Extra].
     FastRandomContext ctx;
     for (int i = 0; i < 16; ++i) {
         uint64_t k1 = ctx.rand64();
         uint64_t k2 = ctx.rand64();
         uint256 x = InsecureRand256();
         uint32_t n = ctx.rand32();
         uint8_t nb[4];
         WriteLE32(nb, n);
         CSipHasher sip256(k1, k2);
         sip256.Write(x.begin(), 32);
         CSipHasher sip288 = sip256;
         sip288.Write(nb, 4);
         BOOST_CHECK_EQUAL(SipHashUint256(k1, k2, x), sip256.Finalize());
         BOOST_CHECK_EQUAL(SipHashUint256Extra(k1, k2, x, n), sip288.Finalize());
     }
 }
 
 namespace {
 class CDummyObject {
     uint32_t value;
 
 public:
     CDummyObject() : value(0) {}
 
     uint32_t GetValue() { return value; }
 
     template <typename Stream> void Serialize(Stream &s) const {
         int nVersionDummy = 0;
         ::Serialize(s, VARINT(nVersionDummy));
         ::Serialize(s, VARINT(value));
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         int nVersionDummy;
         ::Unserialize(s, VARINT(nVersionDummy));
         ::Unserialize(s, VARINT(value));
     }
 };
 } // namespace
 
 BOOST_AUTO_TEST_CASE(hashverifier_tests) {
     std::vector<uint8_t> data = ParseHex("4223");
     CDataStream ss(data, SER_DISK, CLIENT_VERSION);
 
     CHashVerifier<CDataStream> verifier(&ss);
 
     CDummyObject dummy;
     verifier >> dummy;
     uint256 checksum = verifier.GetHash();
     BOOST_CHECK_EQUAL(dummy.GetValue(), 0x23);
 
     CHashWriter h0(SER_DISK, CLIENT_VERSION);
     h0 << CDataStream(data, SER_DISK, CLIENT_VERSION);
     BOOST_CHECK(h0.GetHash() == checksum);
 
     CHashWriter h1(SER_DISK, CLIENT_VERSION);
     h1 << dummy;
     BOOST_CHECK(h1.GetHash() != checksum);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/inv_tests.cpp b/src/test/inv_tests.cpp
index 467addcfb3..1fa79950a4 100644
--- a/src/test/inv_tests.cpp
+++ b/src/test/inv_tests.cpp
@@ -1,42 +1,42 @@
 // Copyright (c) 2017 Amaury SÉCHET
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "protocol.h"
+#include <protocol.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(inv_tests)
 
 static void CheckType(int type, int expected, bool IsTx, bool IsBlock) {
     CInv inv(type, uint256());
     BOOST_CHECK_EQUAL(inv.GetKind(), expected);
     BOOST_CHECK_EQUAL(inv.IsTx(), IsTx);
     BOOST_CHECK_EQUAL(inv.IsSomeBlock(), IsBlock);
 }
 
 /* Validate various inv facilities. */
 BOOST_AUTO_TEST_CASE(validate_kind) {
     CheckType(GetDataMsg::UNDEFINED, GetDataMsg::UNDEFINED, false, false);
     CheckType(GetDataMsg::MSG_TX, GetDataMsg::MSG_TX, true, false);
     CheckType(GetDataMsg::MSG_BLOCK, GetDataMsg::MSG_BLOCK, false, true);
     CheckType(GetDataMsg::MSG_FILTERED_BLOCK, GetDataMsg::MSG_FILTERED_BLOCK,
               false, true);
     CheckType(GetDataMsg::MSG_CMPCT_BLOCK, GetDataMsg::MSG_CMPCT_BLOCK, false,
               true);
 }
 
 static void CheckCommand(int type, std::string expected) {
     CInv inv(type, uint256());
     BOOST_CHECK_EQUAL(inv.GetCommand(), expected);
 }
 
 /* Validate various inv facilities. */
 BOOST_AUTO_TEST_CASE(validate_cmd) {
     CheckCommand(GetDataMsg::MSG_TX, "tx");
     CheckCommand(GetDataMsg::MSG_BLOCK, "block");
     CheckCommand(GetDataMsg::MSG_FILTERED_BLOCK, "merkleblock");
     CheckCommand(GetDataMsg::MSG_CMPCT_BLOCK, "cmpctblock");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/jsonutil.cpp b/src/test/jsonutil.cpp
index f36c3f87bd..7f957a2075 100644
--- a/src/test/jsonutil.cpp
+++ b/src/test/jsonutil.cpp
@@ -1,17 +1,17 @@
 // 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/jsonutil.h"
+#include <test/jsonutil.h>
 
 #include <boost/test/unit_test.hpp>
 
 UniValue read_json(const std::string &jsondata) {
     UniValue v;
 
     if (!v.read(jsondata) || !v.isArray()) {
         BOOST_ERROR("Parse error.");
         return UniValue(UniValue::VARR);
     }
     return v.get_array();
 }
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index 0beab10699..3aeb7811f5 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -1,300 +1,301 @@
 // 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 "key.h"
+#include <key.h>
 
-#include "base58.h"
-#include "dstencode.h"
-#include "script/script.h"
-#include "test/test_bitcoin.h"
-#include "uint256.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <base58.h>
+#include <dstencode.h>
+#include <script/script.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
 
-#include <string>
-#include <vector>
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <string>
+#include <vector>
+
 static const std::string strSecret1 =
     "5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj";
 static const std::string strSecret2 =
     "5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3";
 static const std::string strSecret1C =
     "Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw";
 static const std::string strSecret2C =
     "L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g";
 static const std::string addr1 = "1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ";
 static const std::string addr2 = "1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ";
 static const std::string addr1C = "1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs";
 static const std::string addr2C = "1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs";
 
 static const std::string strAddressBad = "1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF";
 
 // get r value produced by ECDSA signing algorithm
 // (assumes ECDSA r is encoded in the canonical manner)
 std::vector<uint8_t> get_r_ECDSA(std::vector<uint8_t> sigECDSA) {
     std::vector<uint8_t> ret(32, 0);
 
     assert(sigECDSA[2] == 2);
     int rlen = sigECDSA[3];
     assert(rlen <= 33);
     assert(sigECDSA[4 + rlen] == 2);
     if (rlen == 33) {
         assert(sigECDSA[4] == 0);
         std::copy(sigECDSA.begin() + 5, sigECDSA.begin() + 37, ret.begin());
     } else {
         std::copy(sigECDSA.begin() + 4, sigECDSA.begin() + 36,
                   ret.begin() + (32 - rlen));
     }
     return ret;
 }
 
 BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(internal_test) {
     // test get_r_ECDSA (defined above) to make sure it's working properly
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045022100c6ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("c6ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045022046ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("46ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045021f4b5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("004b5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045021e5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("00005f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
 }
 
 BOOST_AUTO_TEST_CASE(key_test1) {
     CBitcoinSecret bsecret1, bsecret2, bsecret1C, bsecret2C, baddress1;
     BOOST_CHECK(bsecret1.SetString(strSecret1));
     BOOST_CHECK(bsecret2.SetString(strSecret2));
     BOOST_CHECK(bsecret1C.SetString(strSecret1C));
     BOOST_CHECK(bsecret2C.SetString(strSecret2C));
     BOOST_CHECK(!baddress1.SetString(strAddressBad));
 
     CKey key1 = bsecret1.GetKey();
     BOOST_CHECK(key1.IsCompressed() == false);
     CKey key2 = bsecret2.GetKey();
     BOOST_CHECK(key2.IsCompressed() == false);
     CKey key1C = bsecret1C.GetKey();
     BOOST_CHECK(key1C.IsCompressed() == true);
     CKey key2C = bsecret2C.GetKey();
     BOOST_CHECK(key2C.IsCompressed() == true);
 
     CPubKey pubkey1 = key1.GetPubKey();
     CPubKey pubkey2 = key2.GetPubKey();
     CPubKey pubkey1C = key1C.GetPubKey();
     CPubKey pubkey2C = key2C.GetPubKey();
 
     BOOST_CHECK(key1.VerifyPubKey(pubkey1));
     BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
     BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
     BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
 
     BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
     BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
     BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
     BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
 
     BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
     BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
     BOOST_CHECK(key2.VerifyPubKey(pubkey2));
     BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
 
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
     BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
 
     const CChainParams &chainParams = Params();
     BOOST_CHECK(DecodeDestination(addr1, chainParams) ==
                 CTxDestination(pubkey1.GetID()));
     BOOST_CHECK(DecodeDestination(addr2, chainParams) ==
                 CTxDestination(pubkey2.GetID()));
     BOOST_CHECK(DecodeDestination(addr1C, chainParams) ==
                 CTxDestination(pubkey1C.GetID()));
     BOOST_CHECK(DecodeDestination(addr2C, chainParams) ==
                 CTxDestination(pubkey2C.GetID()));
 
     for (int n = 0; n < 16; n++) {
         std::string strMsg = strprintf("Very secret message %i: 11", n);
         uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
 
         // normal ECDSA signatures
 
         std::vector<uint8_t> sign1, sign2, sign1C, sign2C;
 
         BOOST_CHECK(key1.SignECDSA(hashMsg, sign1));
         BOOST_CHECK(key2.SignECDSA(hashMsg, sign2));
         BOOST_CHECK(key1C.SignECDSA(hashMsg, sign1C));
         BOOST_CHECK(key2C.SignECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(pubkey1.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(!pubkey1.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(pubkey1.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(!pubkey1.VerifyECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(!pubkey2.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(pubkey2.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(!pubkey2.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(pubkey2.VerifyECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(pubkey1C.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(!pubkey1C.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(pubkey1C.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(!pubkey1C.VerifyECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(!pubkey2C.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(pubkey2C.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(!pubkey2C.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(pubkey2C.VerifyECDSA(hashMsg, sign2C));
 
         // compact ECDSA signatures (with key recovery)
 
         std::vector<uint8_t> csign1, csign2, csign1C, csign2C;
 
         BOOST_CHECK(key1.SignCompact(hashMsg, csign1));
         BOOST_CHECK(key2.SignCompact(hashMsg, csign2));
         BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
         BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
 
         CPubKey rkey1, rkey2, rkey1C, rkey2C;
 
         BOOST_CHECK(rkey1.RecoverCompact(hashMsg, csign1));
         BOOST_CHECK(rkey2.RecoverCompact(hashMsg, csign2));
         BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
         BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
 
         BOOST_CHECK(rkey1 == pubkey1);
         BOOST_CHECK(rkey2 == pubkey2);
         BOOST_CHECK(rkey1C == pubkey1C);
         BOOST_CHECK(rkey2C == pubkey2C);
 
         // Schnorr signatures
 
         std::vector<uint8_t> ssign1, ssign2, ssign1C, ssign2C;
 
         BOOST_CHECK(key1.SignSchnorr(hashMsg, ssign1));
         BOOST_CHECK(key2.SignSchnorr(hashMsg, ssign2));
         BOOST_CHECK(key1C.SignSchnorr(hashMsg, ssign1C));
         BOOST_CHECK(key2C.SignSchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(pubkey1.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(!pubkey1.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(pubkey1.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(!pubkey1.VerifySchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(!pubkey2.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(pubkey2.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(!pubkey2.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(pubkey2.VerifySchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(pubkey1C.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(!pubkey1C.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(pubkey1C.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(!pubkey1C.VerifySchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(!pubkey2C.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(pubkey2C.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(!pubkey2C.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(pubkey2C.VerifySchnorr(hashMsg, ssign2C));
 
         // check deterministicity of ECDSA & Schnorr
         BOOST_CHECK(sign1 == sign1C);
         BOOST_CHECK(sign2 == sign2C);
         BOOST_CHECK(ssign1 == ssign1C);
         BOOST_CHECK(ssign2 == ssign2C);
 
         // Extract r value from ECDSA and Schnorr. Make sure they are
         // distinct (nonce reuse would be dangerous and can leak private key).
         std::vector<uint8_t> rE1 = get_r_ECDSA(sign1);
         BOOST_CHECK(ssign1.size() == 64);
         std::vector<uint8_t> rS1(ssign1.begin(), ssign1.begin() + 32);
         BOOST_CHECK(rE1.size() == 32);
         BOOST_CHECK(rS1.size() == 32);
         BOOST_CHECK(rE1 != rS1);
 
         std::vector<uint8_t> rE2 = get_r_ECDSA(sign2);
         BOOST_CHECK(ssign2.size() == 64);
         std::vector<uint8_t> rS2(ssign2.begin(), ssign2.begin() + 32);
         BOOST_CHECK(rE2.size() == 32);
         BOOST_CHECK(rS2.size() == 32);
         BOOST_CHECK(rE2 != rS2);
     }
 
     // test deterministic signing expected values
 
     std::vector<uint8_t> detsig, detsigc;
     std::string strMsg = "Very deterministic message";
     uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
     // ECDSA
     BOOST_CHECK(key1.SignECDSA(hashMsg, detsig));
     BOOST_CHECK(key1C.SignECDSA(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("3045022100c6ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                          "c82e56a6cc37f9b50463111c9f9229b8f3b3"));
     BOOST_CHECK(key2.SignECDSA(hashMsg, detsig));
     BOOST_CHECK(key2C.SignECDSA(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("304502210094dc5a77b8d5db6b42b66c29d7033cd873fac7a1272"
                          "4a90373726f60bb9f852a02204eb4c98b9a2f5c017f9417ba7c43"
                          "279c20c84bb058dc05b3beeb9333016b15bb"));
     // Compact
     BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
     BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
     BOOST_CHECK(detsig ==
                 ParseHex("1b8c56f224d51415e6ce329144aa1e1c1563e297a005f450df015"
                          "14f3d047681760277e79d57502df27b8feebb001a588aa3a8c2bc"
                          "f5b2367273c15f840638cfc8"));
     BOOST_CHECK(detsigc ==
                 ParseHex("1f8c56f224d51415e6ce329144aa1e1c1563e297a005f450df015"
                          "14f3d047681760277e79d57502df27b8feebb001a588aa3a8c2bc"
                          "f5b2367273c15f840638cfc8"));
     BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
     BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
     BOOST_CHECK(detsig ==
                 ParseHex("1c9ffc56b38fbfc0e3eb2c42dff99d2375982449f35019c1b3d56"
                          "ca62bef187c5103e483a0ad481eaacc224fef4ee2995027300d5f"
                          "2457f7a20c43547aeddbae6e"));
     BOOST_CHECK(detsigc ==
                 ParseHex("209ffc56b38fbfc0e3eb2c42dff99d2375982449f35019c1b3d56"
                          "ca62bef187c5103e483a0ad481eaacc224fef4ee2995027300d5f"
                          "2457f7a20c43547aeddbae6e"));
     // Schnorr
     BOOST_CHECK(key1.SignSchnorr(hashMsg, detsig));
     BOOST_CHECK(key1C.SignSchnorr(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("2c56731ac2f7a7e7f11518fc7722a166b02438924ca9d8b4d1113"
                          "47b81d0717571846de67ad3d913a8fdf9d8f3f73161a4c48ae81c"
                          "b183b214765feb86e255ce"));
     BOOST_CHECK(key2.SignSchnorr(hashMsg, detsig));
     BOOST_CHECK(key2C.SignSchnorr(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("e7167ae0afbba6019b4c7fcfe6de79165d555e8295bd72da1b8aa"
                          "1a5b54305880517cace1bcb0cb515e2eeaffd49f1e4dd49fd7282"
                          "6b4b1573c84da49a38405d"));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/lcg_tests.cpp b/src/test/lcg_tests.cpp
index 5851b74371..bc8aa2d43b 100644
--- a/src/test/lcg_tests.cpp
+++ b/src/test/lcg_tests.cpp
@@ -1,47 +1,47 @@
 // 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 "test/lcg.h"
+#include <test/lcg.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_CASE(lcg_tests) {
     {
         MMIXLinearCongruentialGenerator lcg;
         // We want that the first iteration is 0 which is a helpful special
         // case.
         BOOST_CHECK_EQUAL(lcg.next(), 0x00000000);
         for (int i = 0; i < 99; i++) {
             lcg.next();
         }
         // Make sure the LCG is producing expected value after many iterations.
         // This ensures mul and add overflows are acting as expected on this
         // architecture.
         BOOST_CHECK_EQUAL(lcg.next(), 0xf306b780);
     }
     {
         MMIXLinearCongruentialGenerator lcg(42);
         // We this also should make first iteration as 0.
         BOOST_CHECK_EQUAL(lcg.next(), 0x00000000);
         for (int i = 0; i < 99; i++) {
             lcg.next();
         }
         // Make sure the LCG is producing expected value after many iterations.
         // This ensures mul and add overflows are acting as expected on this
         // architecture.
         BOOST_CHECK_EQUAL(lcg.next(), 0x3b96faf3);
     }
     {
         // just some big seed
         MMIXLinearCongruentialGenerator lcg(0xdeadbeef00000000);
         BOOST_CHECK_EQUAL(lcg.next(), 0xdeadbeef);
         for (int i = 0; i < 99; i++) {
             lcg.next();
         }
         // Make sure the LCG is producing expected value after many iterations.
         // This ensures mul and add overflows are acting as expected on this
         // architecture.
         BOOST_CHECK_EQUAL(lcg.next(), 0x6b00b1df);
     }
 }
diff --git a/src/test/limitedmap_tests.cpp b/src/test/limitedmap_tests.cpp
index 8233de0948..b167650cd9 100644
--- a/src/test/limitedmap_tests.cpp
+++ b/src/test/limitedmap_tests.cpp
@@ -1,100 +1,100 @@
 // 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 "limitedmap.h"
+#include <limitedmap.h>
 
-#include "test/test_bitcoin.h"
+#include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(limitedmap_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(limitedmap_test) {
     // create a limitedmap capped at 10 items
     limitedmap<int, int> map(10);
 
     // check that the max size is 10
     BOOST_CHECK(map.max_size() == 10);
 
     // check that it's empty
     BOOST_CHECK(map.size() == 0);
 
     // insert (-1, -1)
     map.insert(std::pair<int, int>(-1, -1));
 
     // make sure that the size is updated
     BOOST_CHECK(map.size() == 1);
 
     // make sure that the new item is in the map
     BOOST_CHECK(map.count(-1) == 1);
 
     // insert 10 new items
     for (int i = 0; i < 10; i++) {
         map.insert(std::pair<int, int>(i, i + 1));
     }
 
     // make sure that the map now contains 10 items...
     BOOST_CHECK(map.size() == 10);
 
     // ...and that the first item has been discarded
     BOOST_CHECK(map.count(-1) == 0);
 
     // iterate over the map, both with an index and an iterator
     limitedmap<int, int>::const_iterator it = map.begin();
     for (int i = 0; i < 10; i++) {
         // make sure the item is present
         BOOST_CHECK(map.count(i) == 1);
 
         // use the iterator to check for the expected key and value
         BOOST_CHECK(it->first == i);
         BOOST_CHECK(it->second == i + 1);
 
         // use find to check for the value
         BOOST_CHECK(map.find(i)->second == i + 1);
 
         // update and recheck
         map.update(it, i + 2);
         BOOST_CHECK(map.find(i)->second == i + 2);
 
         it++;
     }
 
     // check that we've exhausted the iterator
     BOOST_CHECK(it == map.end());
 
     // resize the map to 5 items
     map.max_size(5);
 
     // check that the max size and size are now 5
     BOOST_CHECK(map.max_size() == 5);
     BOOST_CHECK(map.size() == 5);
 
     // check that items less than 5 have been discarded
     // and items greater than 5 are retained
     for (int i = 0; i < 10; i++) {
         if (i < 5) {
             BOOST_CHECK(map.count(i) == 0);
         } else {
             BOOST_CHECK(map.count(i) == 1);
         }
     }
 
     // erase some items not in the map
     for (int i = 100; i < 1000; i += 100) {
         map.erase(i);
     }
 
     // check that the size is unaffected
     BOOST_CHECK(map.size() == 5);
 
     // erase the remaining elements
     for (int i = 5; i < 10; i++) {
         map.erase(i);
     }
 
     // check that the map is now empty
     BOOST_CHECK(map.empty());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/main_tests.cpp b/src/test/main_tests.cpp
index 77ec71ccde..478b22a832 100644
--- a/src/test/main_tests.cpp
+++ b/src/test/main_tests.cpp
@@ -1,60 +1,60 @@
 // Copyright (c) 2014-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 "chainparams.h"
-#include "net.h"
-#include "validation.h"
+#include <chainparams.h>
+#include <net.h>
+#include <validation.h>
 
-#include "test/test_bitcoin.h"
+#include <test/test_bitcoin.h>
 
 #include <boost/signals2/signal.hpp>
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(main_tests, TestingSetup)
 
 static void TestBlockSubsidyHalvings(const Consensus::Params &consensusParams) {
     int maxHalvings = 64;
     Amount nInitialSubsidy = 50 * COIN;
 
     Amount nPreviousSubsidy = 2 * nInitialSubsidy; // for height == 0
     BOOST_CHECK_EQUAL(nPreviousSubsidy, 2 * nInitialSubsidy);
     for (int nHalvings = 0; nHalvings < maxHalvings; nHalvings++) {
         int nHeight = nHalvings * consensusParams.nSubsidyHalvingInterval;
         Amount nSubsidy = GetBlockSubsidy(nHeight, consensusParams);
         BOOST_CHECK(nSubsidy <= nInitialSubsidy);
         BOOST_CHECK_EQUAL(nSubsidy, nPreviousSubsidy / 2);
         nPreviousSubsidy = nSubsidy;
     }
     BOOST_CHECK_EQUAL(
         GetBlockSubsidy(maxHalvings * consensusParams.nSubsidyHalvingInterval,
                         consensusParams),
         Amount::zero());
 }
 
 static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval) {
     Consensus::Params consensusParams;
     consensusParams.nSubsidyHalvingInterval = nSubsidyHalvingInterval;
     TestBlockSubsidyHalvings(consensusParams);
 }
 
 BOOST_AUTO_TEST_CASE(block_subsidy_test) {
     const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
     TestBlockSubsidyHalvings(chainParams->GetConsensus()); // As in main
     TestBlockSubsidyHalvings(150);                         // As in regtest
     TestBlockSubsidyHalvings(1000); // Just another interval
 }
 
 BOOST_AUTO_TEST_CASE(subsidy_limit_test) {
     const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
     Amount nSum = Amount::zero();
     for (int nHeight = 0; nHeight < 14000000; nHeight += 1000) {
         Amount nSubsidy = GetBlockSubsidy(nHeight, chainParams->GetConsensus());
         BOOST_CHECK(nSubsidy <= 50 * COIN);
         nSum += 1000 * nSubsidy;
         BOOST_CHECK(MoneyRange(nSum));
     }
     BOOST_CHECK_EQUAL(nSum, int64_t(2099999997690000LL) * SATOSHI);
 }
 
 BOOST_AUTO_TEST_SUITE_END()