diff --git a/src/test/checkqueue_tests.cpp b/src/test/checkqueue_tests.cpp
index 830fd55fd..274fc367c 100644
--- a/src/test/checkqueue_tests.cpp
+++ b/src/test/checkqueue_tests.cpp
@@ -1,423 +1,420 @@
 // Copyright (c) 2012-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <atomic>
 #include <checkqueue.h>
 #include <condition_variable>
 #include <mutex>
 #include <test/test_bitcoin.h>
 #include <thread>
 #include <vector>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 #include <random.h>
 #include <unordered_set>
 
 // BasicTestingSetup not sufficient because nScriptCheckThreads is not set
 // otherwise.
 BOOST_FIXTURE_TEST_SUITE(checkqueue_tests, TestingSetup)
 
 static const unsigned int QUEUE_BATCH_SIZE = 128;
 
 struct FakeCheck {
     bool operator()() { return true; }
     void swap(FakeCheck &x){};
 };
 
 struct FakeCheckCheckCompletion {
     static std::atomic<size_t> n_calls;
     bool operator()() {
         n_calls.fetch_add(1, std::memory_order_relaxed);
         return true;
     }
     void swap(FakeCheckCheckCompletion &x){};
 };
 
 struct FailingCheck {
     bool fails;
     FailingCheck(bool _fails) : fails(_fails){};
     FailingCheck() : fails(true){};
     bool operator()() { return !fails; }
     void swap(FailingCheck &x) { std::swap(fails, x.fails); };
 };
 
 struct UniqueCheck {
     static std::mutex m;
     static std::unordered_multiset<size_t> results;
     size_t check_id;
     UniqueCheck(size_t check_id_in) : check_id(check_id_in){};
     UniqueCheck() : check_id(0){};
     bool operator()() {
         std::lock_guard<std::mutex> l(m);
         results.insert(check_id);
         return true;
     }
     void swap(UniqueCheck &x) { std::swap(x.check_id, check_id); };
 };
 
 struct MemoryCheck {
     static std::atomic<size_t> fake_allocated_memory;
     bool b{false};
     bool operator()() { return true; }
     MemoryCheck(){};
     MemoryCheck(const MemoryCheck &x) {
         // We have to do this to make sure that destructor calls are paired
         //
         // Really, copy constructor should be deletable, but CCheckQueue breaks
         // if it is deleted because of internal push_back.
         fake_allocated_memory.fetch_add(b, std::memory_order_relaxed);
     };
     MemoryCheck(bool b_) : b(b_) {
         fake_allocated_memory.fetch_add(b, std::memory_order_relaxed);
     };
     ~MemoryCheck() {
         fake_allocated_memory.fetch_sub(b, std::memory_order_relaxed);
     };
     void swap(MemoryCheck &x) { std::swap(b, x.b); };
 };
 
 struct FrozenCleanupCheck {
     static std::atomic<uint64_t> nFrozen;
     static std::condition_variable cv;
     static std::mutex m;
     // Freezing can't be the default initialized behavior given how the queue
     // swaps in default initialized Checks.
     bool should_freeze{false};
     bool operator()() { return true; }
     FrozenCleanupCheck() {}
     ~FrozenCleanupCheck() {
         if (should_freeze) {
             std::unique_lock<std::mutex> l(m);
             nFrozen.store(1, std::memory_order_relaxed);
             cv.notify_one();
             cv.wait(
                 l, [] { return nFrozen.load(std::memory_order_relaxed) == 0; });
         }
     }
     void swap(FrozenCleanupCheck &x) {
         std::swap(should_freeze, x.should_freeze);
     };
 };
 
 // Static Allocations
 std::mutex FrozenCleanupCheck::m{};
 std::atomic<uint64_t> FrozenCleanupCheck::nFrozen{0};
 std::condition_variable FrozenCleanupCheck::cv{};
 std::mutex UniqueCheck::m;
 std::unordered_multiset<size_t> UniqueCheck::results;
 std::atomic<size_t> FakeCheckCheckCompletion::n_calls{0};
 std::atomic<size_t> MemoryCheck::fake_allocated_memory{0};
 
 // Queue Typedefs
 typedef CCheckQueue<FakeCheckCheckCompletion> Correct_Queue;
 typedef CCheckQueue<FakeCheck> Standard_Queue;
 typedef CCheckQueue<FailingCheck> Failing_Queue;
 typedef CCheckQueue<UniqueCheck> Unique_Queue;
 typedef CCheckQueue<MemoryCheck> Memory_Queue;
 typedef CCheckQueue<FrozenCleanupCheck> FrozenCleanup_Queue;
 
 /** This test case checks that the CCheckQueue works properly
  * with each specified size_t Checks pushed.
  */
 static void Correct_Queue_range(std::vector<size_t> range) {
     auto small_queue =
         std::unique_ptr<Correct_Queue>(new Correct_Queue{QUEUE_BATCH_SIZE});
     boost::thread_group tg;
     for (auto x = 0; x < nScriptCheckThreads; ++x) {
         tg.create_thread([&] { small_queue->Thread(); });
     }
     // Make vChecks here to save on malloc (this test can be slow...)
     std::vector<FakeCheckCheckCompletion> vChecks;
     for (const size_t i : range) {
         size_t total = i;
         FakeCheckCheckCompletion::n_calls = 0;
         CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get());
         while (total) {
             vChecks.resize(std::min(total, (size_t)InsecureRandRange(10)));
             total -= vChecks.size();
             control.Add(vChecks);
         }
         BOOST_REQUIRE(control.Wait());
         if (FakeCheckCheckCompletion::n_calls != i) {
             BOOST_REQUIRE_EQUAL(FakeCheckCheckCompletion::n_calls, i);
-            BOOST_TEST_MESSAGE("Failure on trial "
-                               << i << " expected, got "
-                               << FakeCheckCheckCompletion::n_calls);
         }
     }
     tg.interrupt_all();
     tg.join_all();
 }
 
 /** Test that 0 checks is correct
  */
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Zero) {
     std::vector<size_t> range;
     range.push_back((size_t)0);
     Correct_Queue_range(range);
 }
 /** Test that 1 check is correct
  */
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_One) {
     std::vector<size_t> range;
     range.push_back((size_t)1);
     Correct_Queue_range(range);
 }
 /** Test that MAX check is correct
  */
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Max) {
     std::vector<size_t> range;
     range.push_back(100000);
     Correct_Queue_range(range);
 }
 /** Test that random numbers of checks are correct
  */
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Random) {
     std::vector<size_t> range;
     range.reserve(100000 / 1000);
     for (size_t i = 2; i < 100000;
          i += std::max((size_t)1, (size_t)InsecureRandRange(std::min(
                                       (size_t)1000, ((size_t)100000) - i))))
         range.push_back(i);
     Correct_Queue_range(range);
 }
 
 /** Test that failing checks are caught */
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure) {
     auto fail_queue =
         std::unique_ptr<Failing_Queue>(new Failing_Queue{QUEUE_BATCH_SIZE});
 
     boost::thread_group tg;
     for (auto x = 0; x < nScriptCheckThreads; ++x) {
         tg.create_thread([&] { fail_queue->Thread(); });
     }
 
     for (size_t i = 0; i < 1001; ++i) {
         CCheckQueueControl<FailingCheck> control(fail_queue.get());
         size_t remaining = i;
         while (remaining) {
             size_t r = InsecureRandRange(10);
 
             std::vector<FailingCheck> vChecks;
             vChecks.reserve(r);
             for (size_t k = 0; k < r && remaining; k++, remaining--)
                 vChecks.emplace_back(remaining == 1);
             control.Add(vChecks);
         }
         bool success = control.Wait();
         if (i > 0) {
             BOOST_REQUIRE(!success);
         } else if (i == 0) {
             BOOST_REQUIRE(success);
         }
     }
     tg.interrupt_all();
     tg.join_all();
 }
 // Test that a block validation which fails does not interfere with
 // future blocks, ie, the bad state is cleared.
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure) {
     auto fail_queue =
         std::unique_ptr<Failing_Queue>(new Failing_Queue{QUEUE_BATCH_SIZE});
     boost::thread_group tg;
     for (auto x = 0; x < nScriptCheckThreads; ++x) {
         tg.create_thread([&] { fail_queue->Thread(); });
     }
 
     for (auto times = 0; times < 10; ++times) {
         for (const bool end_fails : {true, false}) {
             CCheckQueueControl<FailingCheck> control(fail_queue.get());
             {
                 std::vector<FailingCheck> vChecks;
                 vChecks.resize(100, false);
                 vChecks[99] = end_fails;
                 control.Add(vChecks);
             }
             bool r = control.Wait();
             BOOST_REQUIRE(r != end_fails);
         }
     }
     tg.interrupt_all();
     tg.join_all();
 }
 
 // Test that unique checks are actually all called individually, rather than
 // just one check being called repeatedly. Test that checks are not called
 // more than once as well
 BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck) {
     auto queue =
         std::unique_ptr<Unique_Queue>(new Unique_Queue{QUEUE_BATCH_SIZE});
     boost::thread_group tg;
     for (auto x = 0; x < nScriptCheckThreads; ++x) {
         tg.create_thread([&] { queue->Thread(); });
     }
 
     size_t COUNT = 100000;
     size_t total = COUNT;
     {
         CCheckQueueControl<UniqueCheck> control(queue.get());
         while (total) {
             size_t r = InsecureRandRange(10);
             std::vector<UniqueCheck> vChecks;
             for (size_t k = 0; k < r && total; k++)
                 vChecks.emplace_back(--total);
             control.Add(vChecks);
         }
     }
     bool r = true;
     BOOST_REQUIRE_EQUAL(UniqueCheck::results.size(), COUNT);
     for (size_t i = 0; i < COUNT; ++i)
         r = r && UniqueCheck::results.count(i) == 1;
     BOOST_REQUIRE(r);
     tg.interrupt_all();
     tg.join_all();
 }
 
 // Test that blocks which might allocate lots of memory free their memory
 // aggressively.
 //
 // This test attempts to catch a pathological case where by lazily freeing
 // checks might mean leaving a check un-swapped out, and decreasing by 1 each
 // time could leave the data hanging across a sequence of blocks.
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory) {
     auto queue =
         std::unique_ptr<Memory_Queue>(new Memory_Queue{QUEUE_BATCH_SIZE});
     boost::thread_group tg;
     for (auto x = 0; x < nScriptCheckThreads; ++x) {
         tg.create_thread([&] { queue->Thread(); });
     }
     for (size_t i = 0; i < 1000; ++i) {
         size_t total = i;
         {
             CCheckQueueControl<MemoryCheck> control(queue.get());
             while (total) {
                 size_t r = InsecureRandRange(10);
                 std::vector<MemoryCheck> vChecks;
                 for (size_t k = 0; k < r && total; k++) {
                     total--;
                     // Each iteration leaves data at the front, back, and middle
                     // to catch any sort of deallocation failure
                     vChecks.emplace_back(total == 0 || total == i ||
                                          total == i / 2);
                 }
                 control.Add(vChecks);
             }
         }
         BOOST_REQUIRE_EQUAL(MemoryCheck::fake_allocated_memory, 0U);
     }
     tg.interrupt_all();
     tg.join_all();
 }
 
 // Test that a new verification cannot occur until all checks
 // have been destructed
 BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup) {
     auto queue = std::unique_ptr<FrozenCleanup_Queue>(
         new FrozenCleanup_Queue{QUEUE_BATCH_SIZE});
     boost::thread_group tg;
     bool fails = false;
     for (auto x = 0; x < nScriptCheckThreads; ++x) {
         tg.create_thread([&] { queue->Thread(); });
     }
     std::thread t0([&]() {
         CCheckQueueControl<FrozenCleanupCheck> control(queue.get());
         std::vector<FrozenCleanupCheck> vChecks(1);
         // Freezing can't be the default initialized behavior given how the
         // queue
         // swaps in default initialized Checks (otherwise freezing destructor
         // would get called twice).
         vChecks[0].should_freeze = true;
         control.Add(vChecks);
         control.Wait(); // Hangs here
     });
     {
         std::unique_lock<std::mutex> l(FrozenCleanupCheck::m);
         // Wait until the queue has finished all jobs and frozen
         FrozenCleanupCheck::cv.wait(
             l, []() { return FrozenCleanupCheck::nFrozen == 1; });
     }
     // Try to get control of the queue a bunch of times
     for (auto x = 0; x < 100 && !fails; ++x) {
         fails = queue->ControlMutex.try_lock();
     }
     {
         // Unfreeze (we need lock n case of spurious wakeup)
         std::unique_lock<std::mutex> l(FrozenCleanupCheck::m);
         FrozenCleanupCheck::nFrozen = 0;
     }
     // Awaken frozen destructor
     FrozenCleanupCheck::cv.notify_one();
     // Wait for control to finish
     t0.join();
     tg.interrupt_all();
     tg.join_all();
     BOOST_REQUIRE(!fails);
 }
 
 /** Test that CCheckQueueControl is threadsafe */
 BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks) {
     auto queue =
         std::unique_ptr<Standard_Queue>(new Standard_Queue{QUEUE_BATCH_SIZE});
     {
         boost::thread_group tg;
         std::atomic<int> nThreads{0};
         std::atomic<int> fails{0};
         for (size_t i = 0; i < 3; ++i) {
             tg.create_thread([&] {
                 CCheckQueueControl<FakeCheck> control(queue.get());
                 // While sleeping, no other thread should execute to this point
                 auto observed = ++nThreads;
                 MilliSleep(10);
                 fails += observed != nThreads;
             });
         }
         tg.join_all();
         BOOST_REQUIRE_EQUAL(fails, 0);
     }
     {
         boost::thread_group tg;
         std::mutex m;
         std::condition_variable cv;
         bool has_lock{false};
         bool has_tried{false};
         bool done{false};
         bool done_ack{false};
         {
             std::unique_lock<std::mutex> l(m);
             tg.create_thread([&] {
                 CCheckQueueControl<FakeCheck> control(queue.get());
                 std::unique_lock<std::mutex> ll(m);
                 has_lock = true;
                 cv.notify_one();
                 cv.wait(ll, [&] { return has_tried; });
                 done = true;
                 cv.notify_one();
                 // Wait until the done is acknowledged
                 //
                 cv.wait(ll, [&] { return done_ack; });
             });
             // Wait for thread to get the lock
             cv.wait(l, [&]() { return has_lock; });
             bool fails = false;
             for (auto x = 0; x < 100 && !fails; ++x) {
                 fails = queue->ControlMutex.try_lock();
             }
             has_tried = true;
             cv.notify_one();
             cv.wait(l, [&]() { return done; });
             // Acknowledge the done
             done_ack = true;
             cv.notify_one();
             BOOST_REQUIRE(!fails);
         }
         tg.join_all();
     }
 }
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/rcu_tests.cpp b/src/test/rcu_tests.cpp
index 5dd835a67..95032320f 100644
--- a/src/test/rcu_tests.cpp
+++ b/src/test/rcu_tests.cpp
@@ -1,389 +1,392 @@
 // 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 <rcu.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <chrono>
 
 struct RCUTest {
     static uint64_t getRevision() { return RCUInfos::revision.load(); }
 
     static uint64_t hasSyncedTo(uint64_t syncRev) {
         return RCUInfos::infos.hasSyncedTo(syncRev);
     }
 
     static std::map<uint64_t, std::function<void()>> &getCleanups() {
         return RCUInfos::infos.cleanups;
     }
 };
 
 BOOST_FIXTURE_TEST_SUITE(rcu_tests, BasicTestingSetup)
 
 enum RCUTestStep {
     Init,
     Locked,
     LockAck,
     RCULocked,
     Synchronizing,
     Synchronized,
 };
 
 #define WAIT_FOR_STEP(step)                                                    \
     do {                                                                       \
         cond.notify_all();                                                     \
     } while (!cond.wait_for(lock, std::chrono::milliseconds(1),                \
                             [&] { return otherstep == step; }))
 
 void synchronize(std::atomic<RCUTestStep> &step,
                  const std::atomic<RCUTestStep> &otherstep, Mutex &cs,
                  std::condition_variable &cond,
                  std::atomic<uint64_t> &syncRev) {
     assert(step == RCUTestStep::Init);
 
     {
         WAIT_LOCK(cs, lock);
         step = RCUTestStep::Locked;
 
         // Wait for our lock to be acknowledged.
         WAIT_FOR_STEP(RCUTestStep::LockAck);
 
         RCULock rculock;
 
         // Update step.
         step = RCUTestStep::RCULocked;
 
         // Wait for master.
         WAIT_FOR_STEP(RCUTestStep::RCULocked);
     }
 
     // Update step.
     syncRev = RCUTest::getRevision() + 1;
     step = RCUTestStep::Synchronizing;
 
     assert(!RCUTest::hasSyncedTo(syncRev));
 
     // We wait for readers.
     RCULock::synchronize();
 
     // Update step.
     step = RCUTestStep::Synchronized;
 }
 
 void lockAndWaitForSynchronize(std::atomic<RCUTestStep> &step,
                                const std::atomic<RCUTestStep> &otherstep,
                                Mutex &cs, std::condition_variable &cond,
                                std::atomic<uint64_t> &syncRev) {
     assert(step == RCUTestStep::Init);
     WAIT_LOCK(cs, lock);
 
     // Wait for th eother thread to be locked.
     WAIT_FOR_STEP(RCUTestStep::Locked);
     step = RCUTestStep::LockAck;
 
     // Wait for the synchronizing tread to take its RCU lock.
     WAIT_FOR_STEP(RCUTestStep::RCULocked);
     assert(!RCUTest::hasSyncedTo(syncRev));
 
     {
         RCULock rculock;
 
         // Update master step.
         step = RCUTestStep::RCULocked;
 
         while (RCUTest::getRevision() < syncRev) {
             WAIT_FOR_STEP(RCUTestStep::Synchronizing);
         }
 
         assert(RCUTest::getRevision() >= syncRev);
         assert(otherstep.load() == RCUTestStep::Synchronizing);
     }
 
     assert(RCUTest::hasSyncedTo(syncRev) >= syncRev);
     WAIT_FOR_STEP(RCUTestStep::Synchronized);
 }
 
 static const int COUNT = 128;
 
 BOOST_AUTO_TEST_CASE(synchronize_test) {
     Mutex cs;
     std::condition_variable cond;
     std::atomic<RCUTestStep> parentstep;
     std::atomic<RCUTestStep> childstep;
     std::atomic<uint64_t> syncRev;
 
     for (int i = 0; i < COUNT; i++) {
         parentstep = RCUTestStep::Init;
         childstep = RCUTestStep::Init;
         syncRev = RCUTest::getRevision() + 1;
 
         std::thread tlock([&] {
             lockAndWaitForSynchronize(parentstep, childstep, cs, cond, syncRev);
         });
 
         std::thread tsync(
             [&] { synchronize(childstep, parentstep, cs, cond, syncRev); });
 
         tlock.join();
         tsync.join();
     }
+
+    // Needed to suppress "Test case [...] did not check any assertions"
+    BOOST_CHECK(true);
 }
 
 BOOST_AUTO_TEST_CASE(cleanup_test) {
     RCULock::synchronize();
     BOOST_CHECK(RCUTest::getCleanups().empty());
 
     bool isClean1 = false;
     RCULock::registerCleanup([&] { isClean1 = true; });
 
     BOOST_CHECK(!isClean1);
     BOOST_CHECK_EQUAL(RCUTest::getCleanups().size(), 1);
     BOOST_CHECK_EQUAL(RCUTest::getRevision(),
                       RCUTest::getCleanups().begin()->first);
 
     // Synchronize runs the cleanups.
     RCULock::synchronize();
     BOOST_CHECK(RCUTest::getCleanups().empty());
     BOOST_CHECK(isClean1);
 
     // Check multiple callbacks.
     isClean1 = false;
     bool isClean2 = false;
     bool isClean3 = false;
     RCULock::registerCleanup([&] { isClean1 = true; });
     RCULock::registerCleanup([&] { isClean2 = true; });
     RCULock::registerCleanup([&] { isClean3 = true; });
 
     BOOST_CHECK_EQUAL(RCUTest::getCleanups().size(), 3);
     RCULock::synchronize();
     BOOST_CHECK(RCUTest::getCleanups().empty());
     BOOST_CHECK(isClean1);
     BOOST_CHECK(isClean2);
     BOOST_CHECK(isClean3);
 
     // Check callbacks adding each others.
     isClean1 = false;
     isClean2 = false;
     isClean3 = false;
 
     RCULock::registerCleanup([&] {
         isClean1 = true;
         RCULock::registerCleanup([&] {
             isClean2 = true;
             RCULock::registerCleanup([&] { isClean3 = true; });
         });
     });
 
     BOOST_CHECK_EQUAL(RCUTest::getCleanups().size(), 1);
     RCULock::synchronize();
     BOOST_CHECK(RCUTest::getCleanups().empty());
     BOOST_CHECK(isClean1);
     BOOST_CHECK(isClean2);
     BOOST_CHECK(isClean3);
 }
 
 class RCURefTestItem {
     IMPLEMENT_RCU_REFCOUNT(uint32_t);
     const std::function<void()> cleanupfun;
 
 public:
     explicit RCURefTestItem(const std::function<void()> &fun)
         : cleanupfun(fun) {}
     ~RCURefTestItem() { cleanupfun(); }
 
     uint32_t getRefCount() const { return refcount.load(); }
 };
 
 BOOST_AUTO_TEST_CASE(rcuptr_test) {
     // Make sure it works for null.
     {
         RCURefTestItem *ptr = nullptr;
         RCUPtr<RCURefTestItem>::copy(ptr);
         RCUPtr<RCURefTestItem>::acquire(ptr);
     }
 
     // Check the destruction mechanism.
     bool isDestroyed = false;
 
     {
         auto rcuptr = RCUPtr<RCURefTestItem>::make([&] { isDestroyed = true; });
         BOOST_CHECK_EQUAL(rcuptr->getRefCount(), 0);
     }
 
     // rcuptr waits for synchronization to destroy.
     BOOST_CHECK(!isDestroyed);
     RCULock::synchronize();
     BOOST_CHECK(isDestroyed);
 
     // Check that copy behaves properly.
     isDestroyed = false;
     RCUPtr<RCURefTestItem> gptr;
 
     {
         auto rcuptr = RCUPtr<RCURefTestItem>::make([&] { isDestroyed = true; });
         BOOST_CHECK_EQUAL(rcuptr->getRefCount(), 0);
 
         gptr = rcuptr;
         BOOST_CHECK_EQUAL(rcuptr->getRefCount(), 1);
         BOOST_CHECK_EQUAL(gptr->getRefCount(), 1);
 
         auto rcuptrcopy = rcuptr;
         BOOST_CHECK_EQUAL(rcuptrcopy->getRefCount(), 2);
         BOOST_CHECK_EQUAL(rcuptr->getRefCount(), 2);
         BOOST_CHECK_EQUAL(gptr->getRefCount(), 2);
     }
 
     BOOST_CHECK_EQUAL(gptr->getRefCount(), 0);
     RCULock::synchronize();
     BOOST_CHECK(!isDestroyed);
 
     gptr = RCUPtr<RCURefTestItem>();
     BOOST_CHECK(!isDestroyed);
     RCULock::synchronize();
     BOOST_CHECK(isDestroyed);
 }
 
 BOOST_AUTO_TEST_CASE(rcuptr_operator_test) {
     auto gptr = RCUPtr<RCURefTestItem>();
     auto ptr = new RCURefTestItem([] {});
     auto oldPtr = ptr;
 
     auto altptr = RCUPtr<RCURefTestItem>::make([] {});
 
     // Check various operators.
     BOOST_CHECK_EQUAL(gptr.get(), NULLPTR(RCURefTestItem));
     BOOST_CHECK_EQUAL(gptr, NULLPTR(RCURefTestItem));
     BOOST_CHECK(!gptr);
 
     auto copyptr = gptr;
     BOOST_CHECK(gptr == nullptr);
     BOOST_CHECK(gptr != oldPtr);
     BOOST_CHECK(gptr == copyptr);
     BOOST_CHECK(gptr != altptr);
 
     gptr = RCUPtr<RCURefTestItem>::acquire(ptr);
     BOOST_CHECK_EQUAL(ptr, NULLPTR(RCURefTestItem));
 
     BOOST_CHECK_EQUAL(gptr.get(), oldPtr);
     BOOST_CHECK_EQUAL(&*gptr, oldPtr);
     BOOST_CHECK_EQUAL(gptr, oldPtr);
     BOOST_CHECK(gptr);
 
     copyptr = gptr;
     BOOST_CHECK(gptr != nullptr);
     BOOST_CHECK(gptr == oldPtr);
     BOOST_CHECK(gptr == copyptr);
     BOOST_CHECK(gptr != altptr);
 }
 
 BOOST_AUTO_TEST_CASE(const_rcuptr_test) {
     bool isDestroyed = false;
     auto ptr = RCUPtr<const RCURefTestItem>::make([&] { isDestroyed = true; });
 
     // Now let's destroy it.
     ptr = RCUPtr<const RCURefTestItem>();
     BOOST_CHECK(!isDestroyed);
     RCULock::synchronize();
     BOOST_CHECK(isDestroyed);
 }
 
 class RCURefMoveTestItem {
     const std::function<void()> cleanupfun;
 
 public:
     explicit RCURefMoveTestItem(const std::function<void()> &fun)
         : cleanupfun(fun) {}
     ~RCURefMoveTestItem() { cleanupfun(); }
 
     void acquire() {
         throw std::runtime_error("RCUPtr incremented the refcount");
     }
     void release() {
         RCULock::registerCleanup([this] { delete this; });
     }
 };
 
 BOOST_AUTO_TEST_CASE(move_rcuptr_test) {
     bool isDestroyed = false;
 
     // Check tat copy is failing.
     auto rcuptr1 =
         RCUPtr<RCURefMoveTestItem>::make([&] { isDestroyed = true; });
     BOOST_CHECK_THROW(rcuptr1->acquire(), std::runtime_error);
     BOOST_CHECK_THROW(auto rcuptrcopy = rcuptr1;, std::runtime_error);
 
     // Try to move.
     auto rcuptr2 = std::move(rcuptr1);
     RCULock::synchronize();
     BOOST_CHECK(!isDestroyed);
 
     // Move to a local and check proper destruction.
     { auto rcuptr3 = std::move(rcuptr2); }
 
     BOOST_CHECK(!isDestroyed);
     RCULock::synchronize();
     BOOST_CHECK(isDestroyed);
 
     // Let's try to swap.
     isDestroyed = false;
     rcuptr1 = RCUPtr<RCURefMoveTestItem>::make([&] { isDestroyed = true; });
     std::swap(rcuptr1, rcuptr2);
 
     RCULock::synchronize();
     BOOST_CHECK(!isDestroyed);
 
     // Chain moves to make sure there are no double free.
     {
         auto rcuptr3 = std::move(rcuptr2);
         auto rcuptr4 = std::move(rcuptr3);
         std::swap(rcuptr1, rcuptr4);
     }
 
     RCULock::synchronize();
     BOOST_CHECK(!isDestroyed);
 
     // Check we can return from a function.
     {
         auto r = ([&] {
             auto moved = std::move(rcuptr1);
             return moved;
         })();
 
         RCULock::synchronize();
         BOOST_CHECK(!isDestroyed);
     }
 
     BOOST_CHECK(!isDestroyed);
     RCULock::synchronize();
     BOOST_CHECK(isDestroyed);
 
     // Acquire/release workflow.
     isDestroyed = false;
     auto ptr = new RCURefMoveTestItem([&] { isDestroyed = true; });
     auto ptrCopy = ptr;
     BOOST_CHECK_THROW(RCUPtr<RCURefMoveTestItem>::copy(ptr),
                       std::runtime_error);
 
     rcuptr1 = RCUPtr<RCURefMoveTestItem>::acquire(ptr);
     BOOST_CHECK_EQUAL(rcuptr1, ptrCopy);
     BOOST_CHECK_EQUAL(ptr, NULLPTR(RCURefMoveTestItem));
 
     ptr = rcuptr1.release();
     BOOST_CHECK_EQUAL(rcuptr1, NULLPTR(RCURefMoveTestItem));
     BOOST_CHECK_EQUAL(ptr, ptrCopy);
 
     RCULock::synchronize();
     BOOST_CHECK(!isDestroyed);
 
     RCUPtr<RCURefMoveTestItem>::acquire(ptr);
     BOOST_CHECK_EQUAL(ptr, NULLPTR(RCURefMoveTestItem));
     BOOST_CHECK(!isDestroyed);
     RCULock::synchronize();
     BOOST_CHECK(isDestroyed);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
index baf00c69f..66f2e97bd 100644
--- a/src/test/streams_tests.cpp
+++ b/src/test/streams_tests.cpp
@@ -1,220 +1,220 @@
 // 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 <streams.h>
 
 #include <support/allocators/zeroafterfree.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/assign/std/vector.hpp> // for 'operator+=()'
 #include <boost/test/unit_test.hpp>
 
 using namespace boost::assign; // bring 'operator+=()' into scope
 
 BOOST_FIXTURE_TEST_SUITE(streams_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(streams_vector_writer) {
     uint8_t a(1);
     uint8_t b(2);
     uint8_t bytes[] = {3, 4, 5, 6};
     std::vector<uint8_t> vch;
 
     // Each test runs twice. Serializing a second time at the same starting
     // point should yield the same results, even if the first test grew the
     // vector.
 
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{1, 2}}));
     vch.clear();
 
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2}}));
     vch.clear();
 
     vch.resize(5, 0);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2, 0}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2, 0}}));
     vch.clear();
 
     vch.resize(4, 0);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 1, 2}}));
     vch.clear();
 
     vch.resize(4, 0);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 0, 1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 0, 1, 2}}));
     vch.clear();
 
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, bytes);
     BOOST_CHECK((vch == std::vector<uint8_t>{{3, 4, 5, 6}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, bytes);
     BOOST_CHECK((vch == std::vector<uint8_t>{{3, 4, 5, 6}}));
     vch.clear();
 
     vch.resize(4, 8);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, bytes, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{8, 8, 1, 3, 4, 5, 6, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, bytes, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{8, 8, 1, 3, 4, 5, 6, 2}}));
     vch.clear();
 }
 
 BOOST_AUTO_TEST_CASE(streams_vector_reader) {
     std::vector<uint8_t> vch = {1, 255, 3, 4, 5, 6};
 
     VectorReader reader(SER_NETWORK, INIT_PROTO_VERSION, vch, 0);
     BOOST_CHECK_EQUAL(reader.size(), 6);
     BOOST_CHECK(!reader.empty());
 
     // Read a single byte as an uint8_t.
     uint8_t a;
     reader >> a;
     BOOST_CHECK_EQUAL(a, 1);
     BOOST_CHECK_EQUAL(reader.size(), 5);
     BOOST_CHECK(!reader.empty());
 
     // Read a single byte as a (signed) int8_t.
     int8_t b;
     reader >> b;
     BOOST_CHECK_EQUAL(b, -1);
     BOOST_CHECK_EQUAL(reader.size(), 4);
     BOOST_CHECK(!reader.empty());
 
     // Read a 4 bytes as an unsigned uint32_t.
     uint32_t c;
     reader >> c;
     // 100992003 = 3,4,5,6 in little-endian base-256
     BOOST_CHECK_EQUAL(c, 100992003);
     BOOST_CHECK_EQUAL(reader.size(), 0);
     BOOST_CHECK(reader.empty());
 
     // Reading after end of byte vector throws an error.
     int32_t d;
     BOOST_CHECK_THROW(reader >> d, std::ios_base::failure);
 
     // Read a 4 bytes as a (signed) int32_t from the beginning of the buffer.
     VectorReader new_reader(SER_NETWORK, INIT_PROTO_VERSION, vch, 0);
     new_reader >> d;
     // 67370753 = 1,255,3,4 in little-endian base-256
     BOOST_CHECK_EQUAL(d, 67370753);
     BOOST_CHECK_EQUAL(new_reader.size(), 2);
     BOOST_CHECK(!new_reader.empty());
 
     // Reading after end of byte vector throws an error even if the reader is
     // not totally empty.
     BOOST_CHECK_THROW(new_reader >> d, std::ios_base::failure);
 }
 
 BOOST_AUTO_TEST_CASE(bitstream_reader_writer) {
     CDataStream data(SER_NETWORK, INIT_PROTO_VERSION);
 
     BitStreamWriter<CDataStream> bit_writer(data);
     bit_writer.Write(0, 1);
     bit_writer.Write(2, 2);
     bit_writer.Write(6, 3);
     bit_writer.Write(11, 4);
     bit_writer.Write(1, 5);
     bit_writer.Write(32, 6);
     bit_writer.Write(7, 7);
     bit_writer.Write(30497, 16);
     bit_writer.Flush();
 
     CDataStream data_copy(data);
     uint32_t serialized_int1;
     data >> serialized_int1;
     // NOTE: Serialized as LE
     BOOST_CHECK_EQUAL(serialized_int1, (uint32_t)0x7700C35A);
     uint16_t serialized_int2;
     data >> serialized_int2;
     // NOTE: Serialized as LE
     BOOST_CHECK_EQUAL(serialized_int2, (uint16_t)0x1072);
 
     BitStreamReader<CDataStream> bit_reader(data_copy);
     BOOST_CHECK_EQUAL(bit_reader.Read(1), 0);
     BOOST_CHECK_EQUAL(bit_reader.Read(2), 2);
     BOOST_CHECK_EQUAL(bit_reader.Read(3), 6);
     BOOST_CHECK_EQUAL(bit_reader.Read(4), 11);
     BOOST_CHECK_EQUAL(bit_reader.Read(5), 1);
     BOOST_CHECK_EQUAL(bit_reader.Read(6), 32);
     BOOST_CHECK_EQUAL(bit_reader.Read(7), 7);
     BOOST_CHECK_EQUAL(bit_reader.Read(16), 30497);
     BOOST_CHECK_THROW(bit_reader.Read(8), std::ios_base::failure);
 }
 
 BOOST_AUTO_TEST_CASE(streams_serializedata_xor) {
     std::vector<char> in;
     std::vector<char> expected_xor;
     std::vector<uint8_t> key;
     CDataStream ds(in, 0, 0);
 
     // Degenerate case
 
     key += '\x00', '\x00';
     ds.Xor(key);
     BOOST_CHECK_EQUAL(std::string(expected_xor.begin(), expected_xor.end()),
                       std::string(ds.begin(), ds.end()));
 
     in += '\x0f', '\xf0';
     expected_xor += '\xf0', '\x0f';
 
     // Single character key
 
     ds.clear();
     ds.insert(ds.begin(), in.begin(), in.end());
     key.clear();
 
     key += '\xff';
     ds.Xor(key);
     BOOST_CHECK_EQUAL(std::string(expected_xor.begin(), expected_xor.end()),
                       std::string(ds.begin(), ds.end()));
 
     // Multi character key
 
     in.clear();
     expected_xor.clear();
     in += '\xf0', '\x0f';
     expected_xor += '\x0f', '\x00';
 
     ds.clear();
     ds.insert(ds.begin(), in.begin(), in.end());
 
     key.clear();
     key += '\xff', '\x0f';
 
     ds.Xor(key);
     BOOST_CHECK_EQUAL(std::string(expected_xor.begin(), expected_xor.end()),
                       std::string(ds.begin(), ds.end()));
 }
 
 BOOST_AUTO_TEST_CASE(streams_empty_vector) {
     std::vector<char> in;
     CDataStream ds(in, 0, 0);
 
     // read 0 bytes used to cause a segfault on some older systems.
-    ds.read(nullptr, 0);
+    BOOST_CHECK_NO_THROW(ds.read(nullptr, 0));
 
     // Same goes for writing 0 bytes from a vector ...
     const std::vector<char> vdata{'f', 'o', 'o', 'b', 'a', 'r'};
-    ds.insert(ds.begin(), vdata.begin(), vdata.begin());
-    ds.insert(ds.begin(), vdata.begin(), vdata.end());
+    BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), vdata.begin(), vdata.begin()));
+    BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), vdata.begin(), vdata.end()));
 
     // ... or an array.
     const char adata[6] = {'f', 'o', 'o', 'b', 'a', 'r'};
-    ds.insert(ds.begin(), &adata[0], &adata[0]);
-    ds.insert(ds.begin(), &adata[0], &adata[6]);
+    BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), &adata[0], &adata[0]));
+    BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), &adata[0], &adata[6]));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/test_bitcoin.cpp b/src/test/test_bitcoin.cpp
index 40d045501..fd34c7f4b 100644
--- a/src/test/test_bitcoin.cpp
+++ b/src/test/test_bitcoin.cpp
@@ -1,319 +1,323 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/test_bitcoin.h>
 
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <crypto/sha256.h>
 #include <fs.h>
 #include <key.h>
 #include <logging.h>
 #include <miner.h>
 #include <net_processing.h>
 #include <noui.h>
 #include <pow.h>
 #include <pubkey.h>
 #include <random.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <script/script_error.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <streams.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <validation.h>
 
 #include <memory>
 
 const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
 
 FastRandomContext g_insecure_rand_ctx;
 
 std::ostream &operator<<(std::ostream &os, const uint256 &num) {
     os << num.ToString();
     return os;
 }
 
 std::ostream &operator<<(std::ostream &os, const ScriptError &err) {
     os << ScriptErrorString(err);
     return os;
 }
 
 BasicTestingSetup::BasicTestingSetup(const std::string &chainName)
     : m_path_root(fs::temp_directory_path() / "test_bitcoin" /
                   strprintf("%lu_%i", static_cast<unsigned long>(GetTime()),
                             int(InsecureRandRange(1 << 30)))) {
     SHA256AutoDetect();
     ECC_Start();
     SetupEnvironment();
     SetupNetworking();
     InitSignatureCache();
     InitScriptExecutionCache();
 
     fCheckBlockIndex = true;
     SelectParams(chainName);
-    noui_connect();
+    static bool noui_connected = false;
+    if (!noui_connected) {
+        noui_connect();
+        noui_connected = true;
+    }
 }
 
 BasicTestingSetup::~BasicTestingSetup() {
     fs::remove_all(m_path_root);
     ECC_Stop();
 }
 
 fs::path BasicTestingSetup::SetDataDir(const std::string &name) {
     fs::path ret = m_path_root / name;
     fs::create_directories(ret);
     gArgs.ForceSetArg("-datadir", ret.string());
     return ret;
 }
 
 TestingSetup::TestingSetup(const std::string &chainName)
     : BasicTestingSetup(chainName) {
     SetDataDir("tempdir");
     const Config &config = GetConfig();
     const CChainParams &chainparams = config.GetChainParams();
 
     // Ideally we'd move all the RPC tests to the functional testing framework
     // instead of unit tests, but for now we need these here.
     RPCServer rpcServer;
     RegisterAllRPCCommands(config, rpcServer, tableRPC);
 
     /**
      * RPC does not come out of the warmup state on its own. Normally, this is
      * handled in bitcoind's init path, but unit tests do not trigger this
      * codepath, so we call it explicitly as part of setup.
      */
     std::string rpcWarmupStatus;
     if (RPCIsInWarmup(&rpcWarmupStatus)) {
         SetRPCWarmupFinished();
     }
 
     ClearDatadirCache();
 
     // We have to run a scheduler thread to prevent ActivateBestChain
     // from blocking due to queue overrun.
     threadGroup.create_thread(std::bind(&CScheduler::serviceQueue, &scheduler));
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
 
     g_mempool.setSanityCheck(1.0);
     pblocktree.reset(new CBlockTreeDB(1 << 20, true));
     pcoinsdbview.reset(new CCoinsViewDB(1 << 23, true));
     pcoinsTip.reset(new CCoinsViewCache(pcoinsdbview.get()));
     if (!LoadGenesisBlock(chainparams)) {
         throw std::runtime_error("LoadGenesisBlock failed.");
     }
     {
         CValidationState state;
         if (!ActivateBestChain(config, state)) {
             throw std::runtime_error(strprintf("ActivateBestChain failed. (%s)",
                                                FormatStateMessage(state)));
         }
     }
     nScriptCheckThreads = 3;
     for (int i = 0; i < nScriptCheckThreads - 1; i++) {
         threadGroup.create_thread(&ThreadScriptCheck);
     }
 
     g_banman =
         std::make_unique<BanMan>(GetDataDir() / "banlist.dat", chainparams,
                                  nullptr, DEFAULT_MISBEHAVING_BANTIME);
     // Deterministic randomness for tests.
     g_connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
 }
 
 TestingSetup::~TestingSetup() {
     threadGroup.interrupt_all();
     threadGroup.join_all();
     GetMainSignals().FlushBackgroundCallbacks();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     g_connman.reset();
     g_banman.reset();
     UnloadBlockIndex();
     pcoinsTip.reset();
     pcoinsdbview.reset();
     pblocktree.reset();
 }
 
 TestChain100Setup::TestChain100Setup()
     : TestingSetup(CBaseChainParams::REGTEST) {
     // Generate a 100-block chain:
     coinbaseKey.MakeNewKey(true);
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
                                      << OP_CHECKSIG;
     for (int i = 0; i < COINBASE_MATURITY; i++) {
         std::vector<CMutableTransaction> noTxns;
         CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
         m_coinbase_txns.push_back(b.vtx[0]);
     }
 }
 
 //
 // Create a new block with just given transactions, coinbase paying to
 // scriptPubKey, and try to add it to the current chain.
 //
 CBlock TestChain100Setup::CreateAndProcessBlock(
     const std::vector<CMutableTransaction> &txns, const CScript &scriptPubKey) {
     const Config &config = GetConfig();
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, g_mempool).CreateNewBlock(scriptPubKey);
     CBlock &block = pblocktemplate->block;
 
     // Replace mempool-selected txns with just coinbase plus passed-in txns:
     block.vtx.resize(1);
     for (const CMutableTransaction &tx : txns) {
         block.vtx.push_back(MakeTransactionRef(tx));
     }
 
     // Order transactions by canonical order
     std::sort(std::begin(block.vtx) + 1, std::end(block.vtx),
               [](const std::shared_ptr<const CTransaction> &txa,
                  const std::shared_ptr<const CTransaction> &txb) -> bool {
                   return txa->GetId() < txb->GetId();
               });
 
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     {
         LOCK(cs_main);
         unsigned int extraNonce = 0;
         IncrementExtraNonce(&block, chainActive.Tip(), config.GetMaxBlockSize(),
                             extraNonce);
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
     while (!CheckProofOfWork(block.GetHash(), block.nBits, params)) {
         ++block.nNonce;
     }
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
     ProcessNewBlock(config, shared_pblock, true, nullptr);
 
     CBlock result = block;
     return result;
 }
 
 TestChain100Setup::~TestChain100Setup() {}
 
 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction &tx) {
     return FromTx(MakeTransactionRef(tx));
 }
 
 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransactionRef &tx) {
     return CTxMemPoolEntry(tx, nFee, nTime, nHeight, spendsCoinbase,
                            nSigOpCount, LockPoints());
 }
 
 /**
  * @returns a real block
  * (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af) with 9
  * txs.
  */
 CBlock getBlock13b8a() {
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000090f0a9f110702f808219ebea1173056042a714bad51b916cb680000000"
             "0000005275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558"
             "da2fdb261b4d4c86041b1ab1bf9309010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff07044c86041b0146ffff"
             "ffff0100f2052a01000000434104e18f7afbe4721580e81e8414fc8c24d7cfacf2"
             "54bb5c7b949450c3e997c2dc1242487a8169507b631eb3771f2b425483fb13102c"
             "4eb5d858eef260fe70fbfae0ac00000000010000000196608ccbafa16abada9027"
             "80da4dc35dafd7af05fa0da08cf833575f8cf9e836000000004a493046022100da"
             "b24889213caf43ae6adc41cf1c9396c08240c199f5225acf45416330fd7dbd0221"
             "00fe37900e0644bf574493a07fc5edba06dbc07c311b947520c2d514bc5725dcb4"
             "01ffffffff0100f2052a010000001976a914f15d1921f52e4007b146dfa60f369e"
             "d2fc393ce288ac000000000100000001fb766c1288458c2bafcfec81e48b24d98e"
             "c706de6b8af7c4e3c29419bfacb56d000000008c493046022100f268ba165ce0ad"
             "2e6d93f089cfcd3785de5c963bb5ea6b8c1b23f1ce3e517b9f022100da7c0f21ad"
             "c6c401887f2bfd1922f11d76159cbc597fbd756a23dcbb00f4d7290141042b4e86"
             "25a96127826915a5b109852636ad0da753c9e1d5606a50480cd0c40f1f8b8d8982"
             "35e571fe9357d9ec842bc4bba1827daaf4de06d71844d0057707966affffffff02"
             "80969800000000001976a9146963907531db72d0ed1a0cfb471ccb63923446f388"
             "ac80d6e34c000000001976a914f0688ba1c0d1ce182c7af6741e02658c7d4dfcd3"
             "88ac000000000100000002c40297f730dd7b5a99567eb8d27b78758f607507c522"
             "92d02d4031895b52f2ff010000008b483045022100f7edfd4b0aac404e5bab4fd3"
             "889e0c6c41aa8d0e6fa122316f68eddd0a65013902205b09cc8b2d56e1cd1f7f2f"
             "afd60a129ed94504c4ac7bdc67b56fe67512658b3e014104732012cb962afa90d3"
             "1b25d8fb0e32c94e513ab7a17805c14ca4c3423e18b4fb5d0e676841733cb83aba"
             "f975845c9f6f2a8097b7d04f4908b18368d6fc2d68ecffffffffca5065ff9617cb"
             "cba45eb23726df6498a9b9cafed4f54cbab9d227b0035ddefb000000008a473044"
             "022068010362a13c7f9919fa832b2dee4e788f61f6f5d344a7c2a0da6ae7406056"
             "58022006d1af525b9a14a35c003b78b72bd59738cd676f845d1ff3fc25049e0100"
             "3614014104732012cb962afa90d31b25d8fb0e32c94e513ab7a17805c14ca4c342"
             "3e18b4fb5d0e676841733cb83abaf975845c9f6f2a8097b7d04f4908b18368d6fc"
             "2d68ecffffffff01001ec4110200000043410469ab4181eceb28985b9b4e895c13"
             "fa5e68d85761b7eee311db5addef76fa8621865134a221bd01f28ec9999ee3e021"
             "e60766e9d1f3458c115fb28650605f11c9ac000000000100000001cdaf2f758e91"
             "c514655e2dc50633d1e4c84989f8aa90a0dbc883f0d23ed5c2fa010000008b4830"
             "4502207ab51be6f12a1962ba0aaaf24a20e0b69b27a94fac5adf45aa7d2d18ffd9"
             "236102210086ae728b370e5329eead9accd880d0cb070aea0c96255fae6c4f1ddc"
             "ce1fd56e014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
             "4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
             "ebbb12dcd4ffffffff02404b4c00000000001976a9142b6ba7c9d796b75eef7942"
             "fc9288edd37c32f5c388ac002d3101000000001976a9141befba0cdc1ad5652937"
             "1864d9f6cb042faa06b588ac000000000100000001b4a47603e71b61bc3326efd9"
             "0111bf02d2f549b067f4c4a8fa183b57a0f800cb010000008a4730440220177c37"
             "f9a505c3f1a1f0ce2da777c339bd8339ffa02c7cb41f0a5804f473c9230220585b"
             "25a2ee80eb59292e52b987dad92acb0c64eced92ed9ee105ad153cdb12d0014104"
             "43bd44f683467e549dae7d20d1d79cbdb6df985c6e9c029c8d0c6cb46cc1a4d3cf"
             "7923c5021b27f7a0b562ada113bc85d5fda5a1b41e87fe6e8802817cf69996ffff"
             "ffff0280651406000000001976a9145505614859643ab7b547cd7f1f5e7e2a1232"
             "2d3788ac00aa0271000000001976a914ea4720a7a52fc166c55ff2298e07baf70a"
             "e67e1b88ac00000000010000000586c62cd602d219bb60edb14a3e204de0705176"
             "f9022fe49a538054fb14abb49e010000008c493046022100f2bc2aba2534becbdf"
             "062eb993853a42bbbc282083d0daf9b4b585bd401aa8c9022100b1d7fd7ee0b956"
             "00db8535bbf331b19eed8d961f7a8e54159c53675d5f69df8c014104462e76fd40"
             "67b3a0aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c6"
             "9b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff03ad0e"
             "58ccdac3df9dc28a218bcf6f1997b0a93306faaa4b3a28ae83447b217901000000"
             "8b483045022100be12b2937179da88599e27bb31c3525097a07cdb52422d165b3c"
             "a2f2020ffcf702200971b51f853a53d644ebae9ec8f3512e442b1bcb6c315a5b49"
             "1d119d10624c83014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33"
             "d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312e"
             "f1c0e8ebbb12dcd4ffffffff2acfcab629bbc8685792603762c921580030ba144a"
             "f553d271716a95089e107b010000008b483045022100fa579a840ac258871365dd"
             "48cd7552f96c8eea69bd00d84f05b283a0dab311e102207e3c0ee9234814cfbb1b"
             "659b83671618f45abc1326b9edcc77d552a4f2a805c0014104462e76fd4067b3a0"
             "aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc3"
             "1895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffffdcdc6023bbc9"
             "944a658ddc588e61eacb737ddf0a3cd24f113b5a8634c517fcd2000000008b4830"
             "450221008d6df731df5d32267954bd7d2dda2302b74c6c2a6aa5c0ca64ecbabc1a"
             "f03c75022010e55c571d65da7701ae2da1956c442df81bbf076cdbac25133f99d9"
             "8a9ed34c014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
             "4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
             "ebbb12dcd4ffffffffe15557cd5ce258f479dfd6dc6514edf6d7ed5b21fcfa4a03"
             "8fd69f06b83ac76e010000008b483045022023b3e0ab071eb11de2eb1cc3a67261"
             "b866f86bf6867d4558165f7c8c8aca2d86022100dc6e1f53a91de3efe8f6351285"
             "0811f26284b62f850c70ca73ed5de8771fb451014104462e76fd4067b3a0aa4207"
             "0082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0"
             "c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff01404b4c0000000000"
             "1976a9142b6ba7c9d796b75eef7942fc9288edd37c32f5c388ac00000000010000"
             "000166d7577163c932b4f9690ca6a80b6e4eb001f0a2fa9023df5595602aae96ed"
             "8d000000008a4730440220262b42546302dfb654a229cefc86432b89628ff259dc"
             "87edd1154535b16a67e102207b4634c020a97c3e7bbd0d4d19da6aa2269ad9dded"
             "4026e896b213d73ca4b63f014104979b82d02226b3a4597523845754d44f13639e"
             "3bf2df5e82c6aab2bdc79687368b01b1ab8b19875ae3c90d661a3d0a33161dab29"
             "934edeb36aa01976be3baf8affffffff02404b4c00000000001976a9144854e695"
             "a02af0aeacb823ccbc272134561e0a1688ac40420f00000000001976a914abee93"
             "376d6b37b5c2940655a6fcaf1c8e74237988ac0000000001000000014e3f8ef2e9"
             "1349a9059cb4f01e54ab2597c1387161d3da89919f7ea6acdbb371010000008c49"
             "304602210081f3183471a5ca22307c0800226f3ef9c353069e0773ac76bb580654"
             "d56aa523022100d4c56465bdc069060846f4fbf2f6b20520b2a80b08b168b31e66"
             "ddb9c694e240014104976c79848e18251612f8940875b2b08d06e6dc73b9840e88"
             "60c066b7e87432c477e9a59a453e71e6d76d5fe34058b800a098fc1740ce3012e8"
             "fc8a00c96af966ffffffff02c0e1e400000000001976a9144134e75a6fcb604203"
             "4aab5e18570cf1f844f54788ac404b4c00000000001976a9142b6ba7c9d796b75e"
             "ef7942fc9288edd37c32f5c388ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
     return block;
 }
diff --git a/src/test/torcontrol_tests.cpp b/src/test/torcontrol_tests.cpp
index be5009ce3..a48412f71 100644
--- a/src/test/torcontrol_tests.cpp
+++ b/src/test/torcontrol_tests.cpp
@@ -1,201 +1,198 @@
 // Copyright (c) 2017 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
 #include <torcontrol.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <map>
 #include <string>
 #include <utility>
 
 std::pair<std::string, std::string> SplitTorReplyLine(const std::string &s);
 std::map<std::string, std::string> ParseTorReplyMapping(const std::string &s);
 
 BOOST_FIXTURE_TEST_SUITE(torcontrol_tests, BasicTestingSetup)
 
 static void CheckSplitTorReplyLine(std::string input, std::string command,
                                    std::string args) {
-    BOOST_TEST_MESSAGE(std::string("CheckSplitTorReplyLine(") + input + ")");
     auto ret = SplitTorReplyLine(input);
     BOOST_CHECK_EQUAL(ret.first, command);
     BOOST_CHECK_EQUAL(ret.second, args);
 }
 
 BOOST_AUTO_TEST_CASE(util_SplitTorReplyLine) {
     // Data we should receive during normal usage
     CheckSplitTorReplyLine("PROTOCOLINFO PIVERSION", "PROTOCOLINFO",
                            "PIVERSION");
     CheckSplitTorReplyLine("AUTH METHODS=COOKIE,SAFECOOKIE "
                            "COOKIEFILE=\"/home/x/.tor/control_auth_cookie\"",
                            "AUTH",
                            "METHODS=COOKIE,SAFECOOKIE "
                            "COOKIEFILE=\"/home/x/.tor/control_auth_cookie\"");
     CheckSplitTorReplyLine("AUTH METHODS=NULL", "AUTH", "METHODS=NULL");
     CheckSplitTorReplyLine("AUTH METHODS=HASHEDPASSWORD", "AUTH",
                            "METHODS=HASHEDPASSWORD");
     CheckSplitTorReplyLine("VERSION Tor=\"0.2.9.8 (git-a0df013ea241b026)\"",
                            "VERSION", "Tor=\"0.2.9.8 (git-a0df013ea241b026)\"");
     CheckSplitTorReplyLine("AUTHCHALLENGE SERVERHASH=aaaa SERVERNONCE=bbbb",
                            "AUTHCHALLENGE", "SERVERHASH=aaaa SERVERNONCE=bbbb");
 
     // Other valid inputs
     CheckSplitTorReplyLine("COMMAND", "COMMAND", "");
     CheckSplitTorReplyLine("COMMAND SOME  ARGS", "COMMAND", "SOME  ARGS");
 
     // These inputs are valid because PROTOCOLINFO accepts an OtherLine that is
     // just an OptArguments, which enables multiple spaces to be present
     // between the command and arguments.
     CheckSplitTorReplyLine("COMMAND  ARGS", "COMMAND", " ARGS");
     CheckSplitTorReplyLine("COMMAND   EVEN+more  ARGS", "COMMAND",
                            "  EVEN+more  ARGS");
 }
 
 static void
 CheckParseTorReplyMapping(std::string input,
                           std::map<std::string, std::string> expected) {
-    BOOST_TEST_MESSAGE(std::string("CheckParseTorReplyMapping(") + input + ")");
     auto ret = ParseTorReplyMapping(input);
     BOOST_CHECK_EQUAL(ret.size(), expected.size());
     auto r_it = ret.begin();
     auto e_it = expected.begin();
     while (r_it != ret.end() && e_it != expected.end()) {
         BOOST_CHECK_EQUAL(r_it->first, e_it->first);
         BOOST_CHECK_EQUAL(r_it->second, e_it->second);
         r_it++;
         e_it++;
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseTorReplyMapping) {
     // Data we should receive during normal usage
     CheckParseTorReplyMapping(
         "METHODS=COOKIE,SAFECOOKIE "
         "COOKIEFILE=\"/home/x/.tor/control_auth_cookie\"",
         {
             {"METHODS", "COOKIE,SAFECOOKIE"},
             {"COOKIEFILE", "/home/x/.tor/control_auth_cookie"},
         });
     CheckParseTorReplyMapping("METHODS=NULL", {
                                                   {"METHODS", "NULL"},
                                               });
     CheckParseTorReplyMapping("METHODS=HASHEDPASSWORD",
                               {
                                   {"METHODS", "HASHEDPASSWORD"},
                               });
     CheckParseTorReplyMapping("Tor=\"0.2.9.8 (git-a0df013ea241b026)\"",
                               {
                                   {"Tor", "0.2.9.8 (git-a0df013ea241b026)"},
                               });
     CheckParseTorReplyMapping("SERVERHASH=aaaa SERVERNONCE=bbbb",
                               {
                                   {"SERVERHASH", "aaaa"},
                                   {"SERVERNONCE", "bbbb"},
                               });
     CheckParseTorReplyMapping("ServiceID=exampleonion1234",
                               {
                                   {"ServiceID", "exampleonion1234"},
                               });
     CheckParseTorReplyMapping("PrivateKey=RSA1024:BLOB",
                               {
                                   {"PrivateKey", "RSA1024:BLOB"},
                               });
     CheckParseTorReplyMapping("ClientAuth=bob:BLOB",
                               {
                                   {"ClientAuth", "bob:BLOB"},
                               });
 
     // Other valid inputs
     CheckParseTorReplyMapping("Foo=Bar=Baz Spam=Eggs", {
                                                            {"Foo", "Bar=Baz"},
                                                            {"Spam", "Eggs"},
                                                        });
     CheckParseTorReplyMapping("Foo=\"Bar=Baz\"", {
                                                      {"Foo", "Bar=Baz"},
                                                  });
     CheckParseTorReplyMapping("Foo=\"Bar Baz\"", {
                                                      {"Foo", "Bar Baz"},
                                                  });
 
     // Escapes
     CheckParseTorReplyMapping("Foo=\"Bar\\ Baz\"", {
                                                        {"Foo", "Bar Baz"},
                                                    });
     CheckParseTorReplyMapping("Foo=\"Bar\\Baz\"", {
                                                       {"Foo", "BarBaz"},
                                                   });
     CheckParseTorReplyMapping("Foo=\"Bar\\@Baz\"", {
                                                        {"Foo", "Bar@Baz"},
                                                    });
     CheckParseTorReplyMapping("Foo=\"Bar\\\"Baz\" Spam=\"\\\"Eggs\\\"\"",
                               {
                                   {"Foo", "Bar\"Baz"},
                                   {"Spam", "\"Eggs\""},
                               });
     CheckParseTorReplyMapping("Foo=\"Bar\\\\Baz\"", {
                                                         {"Foo", "Bar\\Baz"},
                                                     });
 
     // C escapes
     CheckParseTorReplyMapping(
         "Foo=\"Bar\\nBaz\\t\" Spam=\"\\rEggs\" "
         "Octals=\"\\1a\\11\\17\\18\\81\\377\\378\\400\\2222\" Final=Check",
         {
             {"Foo", "Bar\nBaz\t"},
             {"Spam", "\rEggs"},
             {"Octals", "\1a\11\17\1"
                        "881\377\37"
                        "8\40"
                        "0\222"
                        "2"},
             {"Final", "Check"},
         });
     CheckParseTorReplyMapping("Valid=Mapping Escaped=\"Escape\\\\\"",
                               {
                                   {"Valid", "Mapping"},
                                   {"Escaped", "Escape\\"},
                               });
     CheckParseTorReplyMapping("Valid=Mapping Bare=\"Escape\\\"", {});
     CheckParseTorReplyMapping("OneOctal=\"OneEnd\\1\" TwoOctal=\"TwoEnd\\11\"",
                               {
                                   {"OneOctal", "OneEnd\1"},
                                   {"TwoOctal", "TwoEnd\11"},
                               });
 
     // Special handling for null case
     // (needed because string comparison reads the null as end-of-string)
-    BOOST_TEST_MESSAGE(std::string("CheckParseTorReplyMapping(Null=\"\\0\")"));
     auto ret = ParseTorReplyMapping("Null=\"\\0\"");
     BOOST_CHECK_EQUAL(ret.size(), 1U);
     auto r_it = ret.begin();
     BOOST_CHECK_EQUAL(r_it->first, "Null");
     BOOST_CHECK_EQUAL(r_it->second.size(), 1U);
     BOOST_CHECK_EQUAL(r_it->second[0], '\0');
 
     // A more complex valid grammar. PROTOCOLINFO accepts a VersionLine that
     // takes a key=value pair followed by an OptArguments, making this valid.
     // Because an OptArguments contains no semantic data, there is no point in
     // parsing it.
     CheckParseTorReplyMapping("SOME=args,here MORE optional=arguments  here",
                               {
                                   {"SOME", "args,here"},
                               });
 
     // Inputs that are effectively invalid under the target grammar.
     // PROTOCOLINFO accepts an OtherLine that is just an OptArguments, which
     // would make these inputs valid. However,
     // - This parser is never used in that situation, because the
     //   SplitTorReplyLine parser enables OtherLine to be skipped.
     // - Even if these were valid, an OptArguments contains no semantic data,
     //   so there is no point in parsing it.
     CheckParseTorReplyMapping("ARGS", {});
     CheckParseTorReplyMapping("MORE ARGS", {});
     CheckParseTorReplyMapping("MORE  ARGS", {});
     CheckParseTorReplyMapping("EVEN more=ARGS", {});
     CheckParseTorReplyMapping("EVEN+more ARGS", {});
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 588106429..a8665935d 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -1,1484 +1,1488 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/system.h>
 
 #include <clientversion.h>
 #include <primitives/transaction.h>
 #include <sync.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cstdint>
 #ifndef WIN32
 #include <csignal>
 #include <sys/types.h>
 #include <sys/wait.h>
 #endif
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(util_criticalsection) {
     CCriticalSection cs;
 
     do {
         LOCK(cs);
         break;
 
         BOOST_ERROR("break was swallowed!");
     } while (0);
 
     do {
         TRY_LOCK(cs, lockTest);
-        if (lockTest) break;
+        if (lockTest) {
+            // Needed to suppress "Test case [...] did not check any assertions"
+            BOOST_CHECK(true);
+            break;
+        }
 
         BOOST_ERROR("break was swallowed!");
     } while (0);
 }
 
 static const uint8_t ParseHex_expected[65] = {
     0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67,
     0xf1, 0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0,
     0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde, 0xb6,
     0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04,
     0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b,
     0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d, 0x5f};
 BOOST_AUTO_TEST_CASE(util_ParseHex) {
     std::vector<uint8_t> result;
     std::vector<uint8_t> expected(
         ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
     // Basic test vector
     result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0"
                       "ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d"
                       "578a4c702b6bf11d5f");
     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
                                   expected.begin(), expected.end());
 
     // Spaces between bytes must be supported
     result = ParseHex("12 34 56 78");
     BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 &&
                 result[2] == 0x56 && result[3] == 0x78);
 
     // Leading space must be supported (used in BerkeleyEnvironment::Salvage)
     result = ParseHex(" 89 34 56 78");
     BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 &&
                 result[2] == 0x56 && result[3] == 0x78);
 
     // Stop parsing at invalid value
     result = ParseHex("1234 invalid 1234");
     BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
 }
 
 BOOST_AUTO_TEST_CASE(util_HexStr) {
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected,
                              ParseHex_expected + sizeof(ParseHex_expected)),
                       "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0"
                       "ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d"
                       "578a4c702b6bf11d5f");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected, ParseHex_expected + 5, true),
                       "04 67 8a fd b0");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected + sizeof(ParseHex_expected),
                              ParseHex_expected + sizeof(ParseHex_expected)),
                       "");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected + sizeof(ParseHex_expected),
                              ParseHex_expected + sizeof(ParseHex_expected),
                              true),
                       "");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected, ParseHex_expected), "");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected, ParseHex_expected, true), "");
 
     std::vector<uint8_t> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_vec, true), "04 67 8a fd b0");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_vec.rbegin(), ParseHex_vec.rend()),
                       "b0fd8a6704");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_vec.rbegin(), ParseHex_vec.rend(), true),
                       "b0 fd 8a 67 04");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected), true),
         "");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 1),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "04");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 1),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected), true),
         "04");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 5),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "b0fd8a6704");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 5),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected), true),
         "b0 fd 8a 67 04");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 65),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "5f1df16b2b704c8a578d0bbaf74d385cde12c11ee50455f3c438ef4c3fbcf649b6de61"
         "1feae06279a60939e028a8d65c10b73071a6f16719274855feb0fd8a6704");
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatISO8601DateTime) {
     BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777),
                       "2011-09-30T23:36:17Z");
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatISO8601Date) {
     BOOST_CHECK_EQUAL(FormatISO8601Date(1317425777), "2011-09-30");
 }
 
 struct TestArgsManager : public ArgsManager {
     TestArgsManager() { m_network_only_args.clear(); }
     std::map<std::string, std::vector<std::string>> &GetOverrideArgs() {
         return m_override_args;
     }
     std::map<std::string, std::vector<std::string>> &GetConfigArgs() {
         return m_config_args;
     }
     void ReadConfigString(const std::string str_config) {
         std::istringstream streamConfig(str_config);
         {
             LOCK(cs_args);
             m_config_args.clear();
         }
         std::string error;
         ReadConfigStream(streamConfig, error);
     }
     void SetNetworkOnlyArg(const std::string arg) {
         LOCK(cs_args);
         m_network_only_args.insert(arg);
     }
     void SetupArgs(int argv, const char *args[]) {
         for (int i = 0; i < argv; ++i) {
             AddArg(args[i], "", false, OptionsCategory::OPTIONS);
         }
     }
 };
 
 BOOST_AUTO_TEST_CASE(util_ParseParameters) {
     TestArgsManager testArgs;
     const char *avail_args[] = {"-a", "-b", "-ccc", "-d"};
     const char *argv_test[] = {"-ignored",      "-a", "-b",  "-ccc=argument",
                                "-ccc=multiple", "f",  "-d=e"};
 
     std::string error;
     testArgs.SetupArgs(4, avail_args);
     BOOST_CHECK(testArgs.ParseParameters(0, (char **)argv_test, error));
     BOOST_CHECK(testArgs.GetOverrideArgs().empty() &&
                 testArgs.GetConfigArgs().empty());
 
     BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     BOOST_CHECK(testArgs.GetOverrideArgs().empty() &&
                 testArgs.GetConfigArgs().empty());
 
     BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
     // expectation: -ignored is ignored (program name argument),
     // -a, -b and -ccc end up in map, -d ignored because it is after
     // a non-option argument (non-GNU option parsing)
     BOOST_CHECK(testArgs.GetOverrideArgs().size() == 3 &&
                 testArgs.GetConfigArgs().empty());
     BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") &&
                 testArgs.IsArgSet("-ccc") && !testArgs.IsArgSet("f") &&
                 !testArgs.IsArgSet("-d"));
     BOOST_CHECK(testArgs.GetOverrideArgs().count("-a") &&
                 testArgs.GetOverrideArgs().count("-b") &&
                 testArgs.GetOverrideArgs().count("-ccc") &&
                 !testArgs.GetOverrideArgs().count("f") &&
                 !testArgs.GetOverrideArgs().count("-d"));
 
     BOOST_CHECK(testArgs.GetOverrideArgs()["-a"].size() == 1);
     BOOST_CHECK(testArgs.GetOverrideArgs()["-a"].front() == "");
     BOOST_CHECK(testArgs.GetOverrideArgs()["-ccc"].size() == 2);
     BOOST_CHECK(testArgs.GetOverrideArgs()["-ccc"].front() == "argument");
     BOOST_CHECK(testArgs.GetOverrideArgs()["-ccc"].back() == "multiple");
     BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseKeyValue) {
     {
         std::string key = "badarg";
         std::string value;
         BOOST_CHECK(!ParseKeyValue(key, value));
     }
     {
         std::string key = "badarg=v";
         std::string value;
         BOOST_CHECK(!ParseKeyValue(key, value));
     }
     {
         std::string key = "-a";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-a");
         BOOST_CHECK_EQUAL(value, "");
     }
     {
         std::string key = "-a=1";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-a");
         BOOST_CHECK_EQUAL(value, "1");
     }
     {
         std::string key = "--b";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-b");
         BOOST_CHECK_EQUAL(value, "");
     }
     {
         std::string key = "--b=abc";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-b");
         BOOST_CHECK_EQUAL(value, "abc");
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_GetBoolArg) {
     TestArgsManager testArgs;
     const char *avail_args[] = {"-a", "-b", "-c", "-d", "-e", "-f"};
     const char *argv_test[] = {"ignored", "-a",       "-nob",   "-c=0",
                                "-d=1",    "-e=false", "-f=true"};
     std::string error;
     testArgs.SetupArgs(6, avail_args);
     BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
 
     // Each letter should be set.
     for (const char opt : "abcdef") {
         BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt);
     }
 
     // Nothing else should be in the map
     BOOST_CHECK(testArgs.GetOverrideArgs().size() == 6 &&
                 testArgs.GetConfigArgs().empty());
 
     // The -no prefix should get stripped on the way in.
     BOOST_CHECK(!testArgs.IsArgSet("-nob"));
 
     // The -b option is flagged as negated, and nothing else is
     BOOST_CHECK(testArgs.IsArgNegated("-b"));
     BOOST_CHECK(!testArgs.IsArgNegated("-a"));
 
     // Check expected values.
     BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true);
     BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true);
     BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false);
 }
 
 BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases) {
     // Test some awful edge cases that hopefully no user will ever exercise.
     TestArgsManager testArgs;
 
     // Params test
     const char *avail_args[] = {"-foo", "-bar"};
     const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
     testArgs.SetupArgs(2, avail_args);
     std::string error;
     BOOST_CHECK(testArgs.ParseParameters(4, (char **)argv_test, error));
 
     // This was passed twice, second one overrides the negative setting.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "");
 
     // A double negative is a positive, and not marked as negated.
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
 
     // Config test
     const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
     BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     testArgs.ReadConfigString(conf_test);
 
     // This was passed twice, second one overrides the negative setting,
     // and the value.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1");
 
     // A double negative is a positive, and does not count as negated.
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
 
     // Combined test
     const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
     const char *combo_test_conf = "foo=1\nnobar=1\n";
     BOOST_CHECK(testArgs.ParseParameters(3, (char **)combo_test_args, error));
     testArgs.ReadConfigString(combo_test_conf);
 
     // Command line overrides, but doesn't erase old setting
     BOOST_CHECK(testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0");
     BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0);
 
     // Command line overrides, but doesn't erase old setting
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "");
     BOOST_CHECK(testArgs.GetArgs("-bar").size() == 1 &&
                 testArgs.GetArgs("-bar").front() == "");
 }
 
 BOOST_AUTO_TEST_CASE(util_ReadConfigStream) {
     const char *str_config = "a=\n"
                              "b=1\n"
                              "ccc=argument\n"
                              "ccc=multiple\n"
                              "d=e\n"
                              "nofff=1\n"
                              "noggg=0\n"
                              "h=1\n"
                              "noh=1\n"
                              "noi=1\n"
                              "i=1\n"
                              "sec1.ccc=extend1\n"
                              "\n"
                              "[sec1]\n"
                              "ccc=extend2\n"
                              "d=eee\n"
                              "h=1\n"
                              "[sec2]\n"
                              "ccc=extend3\n"
                              "iii=2\n";
 
     TestArgsManager test_args;
     const char *avail_args[] = {"-a",   "-b",   "-ccc", "-d", "-e",
                                 "-fff", "-ggg", "-h",   "-i", "-iii"};
     test_args.SetupArgs(10, avail_args);
 
     test_args.ReadConfigString(str_config);
     // expectation: a, b, ccc, d, fff, ggg, h, i end up in map
     // so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii
 
     BOOST_CHECK(test_args.GetOverrideArgs().empty());
     BOOST_CHECK(test_args.GetConfigArgs().size() == 13);
 
     BOOST_CHECK(test_args.GetConfigArgs().count("-a") &&
                 test_args.GetConfigArgs().count("-b") &&
                 test_args.GetConfigArgs().count("-ccc") &&
                 test_args.GetConfigArgs().count("-d") &&
                 test_args.GetConfigArgs().count("-fff") &&
                 test_args.GetConfigArgs().count("-ggg") &&
                 test_args.GetConfigArgs().count("-h") &&
                 test_args.GetConfigArgs().count("-i"));
     BOOST_CHECK(test_args.GetConfigArgs().count("-sec1.ccc") &&
                 test_args.GetConfigArgs().count("-sec1.h") &&
                 test_args.GetConfigArgs().count("-sec2.ccc") &&
                 test_args.GetConfigArgs().count("-sec2.iii"));
 
     BOOST_CHECK(test_args.IsArgSet("-a") && test_args.IsArgSet("-b") &&
                 test_args.IsArgSet("-ccc") && test_args.IsArgSet("-d") &&
                 test_args.IsArgSet("-fff") && test_args.IsArgSet("-ggg") &&
                 test_args.IsArgSet("-h") && test_args.IsArgSet("-i") &&
                 !test_args.IsArgSet("-zzz") && !test_args.IsArgSet("-iii"));
 
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-ccc", "xxx") == "argument" &&
                 test_args.GetArg("-d", "xxx") == "e" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-h", "xxx") == "0" &&
                 test_args.GetArg("-i", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-iii", "xxx") == "xxx");
 
     for (const bool def : {false, true}) {
         BOOST_CHECK(test_args.GetBoolArg("-a", def) &&
                     test_args.GetBoolArg("-b", def) &&
                     !test_args.GetBoolArg("-ccc", def) &&
                     !test_args.GetBoolArg("-d", def) &&
                     !test_args.GetBoolArg("-fff", def) &&
                     test_args.GetBoolArg("-ggg", def) &&
                     !test_args.GetBoolArg("-h", def) &&
                     test_args.GetBoolArg("-i", def) &&
                     test_args.GetBoolArg("-zzz", def) == def &&
                     test_args.GetBoolArg("-iii", def) == def);
     }
 
     BOOST_CHECK(test_args.GetArgs("-a").size() == 1 &&
                 test_args.GetArgs("-a").front() == "");
     BOOST_CHECK(test_args.GetArgs("-b").size() == 1 &&
                 test_args.GetArgs("-b").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2 &&
                 test_args.GetArgs("-ccc").front() == "argument" &&
                 test_args.GetArgs("-ccc").back() == "multiple");
     BOOST_CHECK(test_args.GetArgs("-fff").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-ggg").size() == 1 &&
                 test_args.GetArgs("-ggg").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-h").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-noh").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-i").size() == 1 &&
                 test_args.GetArgs("-i").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-noi").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0);
 
     BOOST_CHECK(!test_args.IsArgNegated("-a"));
     BOOST_CHECK(!test_args.IsArgNegated("-b"));
     BOOST_CHECK(!test_args.IsArgNegated("-ccc"));
     BOOST_CHECK(!test_args.IsArgNegated("-d"));
     BOOST_CHECK(test_args.IsArgNegated("-fff"));
     BOOST_CHECK(!test_args.IsArgNegated("-ggg"));
     // last setting takes precedence
     BOOST_CHECK(test_args.IsArgNegated("-h"));
     // last setting takes precedence
     BOOST_CHECK(!test_args.IsArgNegated("-i"));
     BOOST_CHECK(!test_args.IsArgNegated("-zzz"));
 
     // Test sections work
     test_args.SelectConfigNetwork("sec1");
 
     // same as original
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-iii", "xxx") == "xxx");
     // d is overridden
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
     // section-specific setting
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
     // section takes priority for multiple values
     BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1");
     // check multiple values works
     const std::vector<std::string> sec1_ccc_expected = {"extend1", "extend2",
                                                         "argument", "multiple"};
     const auto &sec1_ccc_res = test_args.GetArgs("-ccc");
     BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(),
                                   sec1_ccc_expected.begin(),
                                   sec1_ccc_expected.end());
 
     test_args.SelectConfigNetwork("sec2");
 
     // same as original
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-d", "xxx") == "e" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-h", "xxx") == "0");
     // section-specific setting
     BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2");
     // section takes priority for multiple values
     BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3");
     // check multiple values works
     const std::vector<std::string> sec2_ccc_expected = {"extend3", "argument",
                                                         "multiple"};
     const auto &sec2_ccc_res = test_args.GetArgs("-ccc");
     BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(),
                                   sec2_ccc_expected.begin(),
                                   sec2_ccc_expected.end());
 
     // Test section only options
 
     test_args.SetNetworkOnlyArg("-d");
     test_args.SetNetworkOnlyArg("-ccc");
     test_args.SetNetworkOnlyArg("-h");
 
     test_args.SelectConfigNetwork(CBaseChainParams::MAIN);
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
 
     test_args.SelectConfigNetwork("sec1");
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
     BOOST_CHECK(test_args.GetArgs("-d").size() == 1);
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
 
     test_args.SelectConfigNetwork("sec2");
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx");
     BOOST_CHECK(test_args.GetArgs("-d").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
 }
 
 BOOST_AUTO_TEST_CASE(util_GetArg) {
     TestArgsManager testArgs;
     testArgs.GetOverrideArgs().clear();
     testArgs.GetOverrideArgs()["strtest1"] = {"string..."};
     // strtest2 undefined on purpose
     testArgs.GetOverrideArgs()["inttest1"] = {"12345"};
     testArgs.GetOverrideArgs()["inttest2"] = {"81985529216486895"};
     // inttest3 undefined on purpose
     testArgs.GetOverrideArgs()["booltest1"] = {""};
     // booltest2 undefined on purpose
     testArgs.GetOverrideArgs()["booltest3"] = {"0"};
     testArgs.GetOverrideArgs()["booltest4"] = {"1"};
 
     // priorities
     testArgs.GetOverrideArgs()["pritest1"] = {"a", "b"};
     testArgs.GetConfigArgs()["pritest2"] = {"a", "b"};
     testArgs.GetOverrideArgs()["pritest3"] = {"a"};
     testArgs.GetConfigArgs()["pritest3"] = {"b"};
     testArgs.GetOverrideArgs()["pritest4"] = {"a", "b"};
     testArgs.GetConfigArgs()["pritest4"] = {"c", "d"};
 
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArg("inttest1", -1), 12345);
     BOOST_CHECK_EQUAL(testArgs.GetArg("inttest2", -1), 81985529216486895LL);
     BOOST_CHECK_EQUAL(testArgs.GetArg("inttest3", -1), -1);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
 
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");
 }
 
 BOOST_AUTO_TEST_CASE(util_ClearArg) {
     TestArgsManager testArgs;
 
     // Clear single string arg
     testArgs.GetOverrideArgs()["strtest1"] = {"string..."};
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     testArgs.ClearArg("strtest1");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
 
     // Clear boolean arg
     testArgs.GetOverrideArgs()["booltest1"] = {"1"};
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     testArgs.ClearArg("booltest1");
     BOOST_CHECK_EQUAL(testArgs.GetArg("booltest1", false), false);
 
     // Clear config args only
     testArgs.GetConfigArgs()["strtest2"].push_back("string...");
     testArgs.GetConfigArgs()["strtest2"].push_back("...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 2);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").back(), "...gnirts");
     testArgs.ClearArg("strtest2");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 0);
 
     // Clear both cli args and config args
     testArgs.GetOverrideArgs()["strtest3"].push_back("cli string...");
     testArgs.GetOverrideArgs()["strtest3"].push_back("...gnirts ilc");
     testArgs.GetConfigArgs()["strtest3"].push_back("string...");
     testArgs.GetConfigArgs()["strtest3"].push_back("...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest3", "default"), "...gnirts ilc");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest3").size(), 4);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest3").front(), "cli string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest3").back(), "...gnirts");
     testArgs.ClearArg("strtest3");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest3", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest3").size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(util_SetArg) {
     TestArgsManager testArgs;
 
     // SoftSetArg
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "string..."), true);
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest1").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest1").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "...gnirts"), false);
     testArgs.ClearArg("strtest1");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "...gnirts"), true);
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "...gnirts");
 
     // SoftSetBoolArg
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), false);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", true), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", false), false);
     testArgs.ClearArg("booltest1");
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", true), true);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", true), false);
 
     // ForceSetArg
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     testArgs.ForceSetArg("strtest2", "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     testArgs.ForceSetArg("strtest2", "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
 
     // ForceSetMultiArg
     testArgs.ForceSetMultiArg("strtest2", "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 2);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").back(), "string...");
     testArgs.ClearArg("strtest2");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 0);
     testArgs.ForceSetMultiArg("strtest2", "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     testArgs.ForceSetMultiArg("strtest2", "one more thing...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"),
                       "one more thing...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 2);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").back(), "one more thing...");
     // If there are multi args, ForceSetArg should erase them
     testArgs.ForceSetArg("strtest2", "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
 }
 
 BOOST_AUTO_TEST_CASE(util_GetChainName) {
     TestArgsManager test_args;
     const char *avail_args[] = {"-testnet", "-regtest"};
     test_args.SetupArgs(2, avail_args);
 
     const char *argv_testnet[] = {"cmd", "-testnet"};
     const char *argv_regtest[] = {"cmd", "-regtest"};
     const char *argv_test_no_reg[] = {"cmd", "-testnet", "-noregtest"};
     const char *argv_both[] = {"cmd", "-testnet", "-regtest"};
 
     // equivalent to "-testnet"
     // regtest in testnet section is ignored
     const char *testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";
     std::string error;
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     // check setting the network to test (and thus making
     // [test] regtest=1 potentially relevant) doesn't break things
     test_args.SelectConfigNetwork("test");
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatMoney) {
     BOOST_CHECK_EQUAL(FormatMoney(Amount::zero()), "0.00");
     BOOST_CHECK_EQUAL(FormatMoney(123456789 * (COIN / 10000)), "12345.6789");
     BOOST_CHECK_EQUAL(FormatMoney(-1 * COIN), "-1.00");
 
     BOOST_CHECK_EQUAL(FormatMoney(100000000 * COIN), "100000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10000000 * COIN), "10000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(1000000 * COIN), "1000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(100000 * COIN), "100000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10000 * COIN), "10000.00");
     BOOST_CHECK_EQUAL(FormatMoney(1000 * COIN), "1000.00");
     BOOST_CHECK_EQUAL(FormatMoney(100 * COIN), "100.00");
     BOOST_CHECK_EQUAL(FormatMoney(10 * COIN), "10.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN), "1.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10), "0.10");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100), "0.01");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000), "0.001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000), "0.0001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000), "0.00001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000000), "0.000001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000000), "0.0000001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000000), "0.00000001");
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseMoney) {
     Amount ret = Amount::zero();
     BOOST_CHECK(ParseMoney("0.0", ret));
     BOOST_CHECK_EQUAL(ret, Amount::zero());
 
     BOOST_CHECK(ParseMoney("12345.6789", ret));
     BOOST_CHECK_EQUAL(ret, 123456789 * (COIN / 10000));
 
     BOOST_CHECK(ParseMoney("100000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 100000000 * COIN);
     BOOST_CHECK(ParseMoney("10000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 10000000 * COIN);
     BOOST_CHECK(ParseMoney("1000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 1000000 * COIN);
     BOOST_CHECK(ParseMoney("100000.00", ret));
     BOOST_CHECK_EQUAL(ret, 100000 * COIN);
     BOOST_CHECK(ParseMoney("10000.00", ret));
     BOOST_CHECK_EQUAL(ret, 10000 * COIN);
     BOOST_CHECK(ParseMoney("1000.00", ret));
     BOOST_CHECK_EQUAL(ret, 1000 * COIN);
     BOOST_CHECK(ParseMoney("100.00", ret));
     BOOST_CHECK_EQUAL(ret, 100 * COIN);
     BOOST_CHECK(ParseMoney("10.00", ret));
     BOOST_CHECK_EQUAL(ret, 10 * COIN);
     BOOST_CHECK(ParseMoney("1.00", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("1", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("0.1", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 10);
     BOOST_CHECK(ParseMoney("0.01", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100);
     BOOST_CHECK(ParseMoney("0.001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 1000);
     BOOST_CHECK(ParseMoney("0.0001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 10000);
     BOOST_CHECK(ParseMoney("0.00001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000);
     BOOST_CHECK(ParseMoney("0.000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 1000000);
     BOOST_CHECK(ParseMoney("0.0000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 10000000);
     BOOST_CHECK(ParseMoney("0.00000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000000);
 
     // Attempted 63 bit overflow should fail
     BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
 
     // Parsing negative amounts must fail
     BOOST_CHECK(!ParseMoney("-1", ret));
 }
 
 BOOST_AUTO_TEST_CASE(util_IsHex) {
     BOOST_CHECK(IsHex("00"));
     BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     BOOST_CHECK(IsHex("ff"));
     BOOST_CHECK(IsHex("FF"));
 
     BOOST_CHECK(!IsHex(""));
     BOOST_CHECK(!IsHex("0"));
     BOOST_CHECK(!IsHex("a"));
     BOOST_CHECK(!IsHex("eleven"));
     BOOST_CHECK(!IsHex("00xx00"));
     BOOST_CHECK(!IsHex("0x0000"));
 }
 
 BOOST_AUTO_TEST_CASE(util_IsHexNumber) {
     BOOST_CHECK(IsHexNumber("0x0"));
     BOOST_CHECK(IsHexNumber("0"));
     BOOST_CHECK(IsHexNumber("0x10"));
     BOOST_CHECK(IsHexNumber("10"));
     BOOST_CHECK(IsHexNumber("0xff"));
     BOOST_CHECK(IsHexNumber("ff"));
     BOOST_CHECK(IsHexNumber("0xFfa"));
     BOOST_CHECK(IsHexNumber("Ffa"));
     BOOST_CHECK(IsHexNumber("0x00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     BOOST_CHECK(IsHexNumber("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
 
     BOOST_CHECK(!IsHexNumber(""));      // empty string not allowed
     BOOST_CHECK(!IsHexNumber("0x"));    // empty string after prefix not allowed
     BOOST_CHECK(!IsHexNumber("0x0 "));  // no spaces at end,
     BOOST_CHECK(!IsHexNumber(" 0x0"));  // or beginning,
     BOOST_CHECK(!IsHexNumber("0x 0"));  // or middle,
     BOOST_CHECK(!IsHexNumber(" "));     // etc.
     BOOST_CHECK(!IsHexNumber("0x0ga")); // invalid character
     BOOST_CHECK(!IsHexNumber("x0"));    // broken prefix
     BOOST_CHECK(!IsHexNumber("0x0x00")); // two prefixes not allowed
 }
 
 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand) {
     SeedInsecureRand(true);
     for (int mod = 2; mod < 11; mod++) {
         int mask = 1;
         // Really rough binomial confidence approximation.
         int err =
             30 * 10000. / mod * sqrt((1. / mod * (1 - 1. / mod)) / 10000.);
         // mask is 2^ceil(log2(mod))-1
         while (mask < mod - 1) {
             mask = (mask << 1) + 1;
         }
 
         int count = 0;
         // How often does it get a zero from the uniform range [0,mod)?
         for (int i = 0; i < 10000; i++) {
             uint32_t rval;
             do {
                 rval = InsecureRand32() & mask;
             } while (rval >= uint32_t(mod));
             count += rval == 0;
         }
         BOOST_CHECK(count <= 10000 / mod + err);
         BOOST_CHECK(count >= 10000 / mod - err);
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_TimingResistantEqual) {
     BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
     BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
     BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
     BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
     BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
 }
 
 /* Test strprintf formatting directives.
  * Put a string before and after to ensure sanity of element sizes on stack. */
 #define B "check_prefix"
 #define E "check_postfix"
 BOOST_AUTO_TEST_CASE(strprintf_numbers) {
     int64_t s64t = -9223372036854775807LL;   /* signed 64 bit test value */
     uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
     BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B
                 " -9223372036854775807 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B
                 " 18446744073709551615 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B " ffffffffffffffff " E);
 
     size_t st = 12345678;    /* unsigned size_t test value */
     ssize_t sst = -12345678; /* signed size_t test value */
     BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B " -12345678 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B " 12345678 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B " bc614e " E);
 
     ptrdiff_t pt = 87654321;   /* positive ptrdiff_t test value */
     ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
     BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B " -87654321 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B " 87654321 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B " 5397fb1 " E);
 }
 #undef B
 #undef E
 
 /* Check for mingw/wine issue #3494
  * Remove this test before time.ctime(0xffffffff) == 'Sun Feb  7 07:28:15 2106'
  */
 BOOST_AUTO_TEST_CASE(gettime) {
     BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
 }
 
 BOOST_AUTO_TEST_CASE(test_IsDigit) {
     BOOST_CHECK_EQUAL(IsDigit('0'), true);
     BOOST_CHECK_EQUAL(IsDigit('1'), true);
     BOOST_CHECK_EQUAL(IsDigit('8'), true);
     BOOST_CHECK_EQUAL(IsDigit('9'), true);
 
     BOOST_CHECK_EQUAL(IsDigit('0' - 1), false);
     BOOST_CHECK_EQUAL(IsDigit('9' + 1), false);
     BOOST_CHECK_EQUAL(IsDigit(0), false);
     BOOST_CHECK_EQUAL(IsDigit(1), false);
     BOOST_CHECK_EQUAL(IsDigit(8), false);
     BOOST_CHECK_EQUAL(IsDigit(9), false);
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseInt32) {
     int32_t n;
     // Valid values
     BOOST_CHECK(ParseInt32("1234", nullptr));
     BOOST_CHECK(ParseInt32("0", &n) && n == 0);
     BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
     BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
     // (-2147483647 - 1) equals INT_MIN
     BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1));
     BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
     // Invalid values
     BOOST_CHECK(!ParseInt32("", &n));
     BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseInt32("1 ", &n));
     BOOST_CHECK(!ParseInt32("1a", &n));
     BOOST_CHECK(!ParseInt32("aap", &n));
     BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
     BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseInt32(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
     BOOST_CHECK(!ParseInt32("2147483648", nullptr));
     BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseInt64) {
     int64_t n;
     // Valid values
     BOOST_CHECK(ParseInt64("1234", nullptr));
     BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
     BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
     BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
     BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
     BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
     BOOST_CHECK(ParseInt64("9223372036854775807", &n) &&
                 n == (int64_t)9223372036854775807);
     BOOST_CHECK(ParseInt64("-9223372036854775808", &n) &&
                 n == (int64_t)-9223372036854775807 - 1);
     BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
     // Invalid values
     BOOST_CHECK(!ParseInt64("", &n));
     BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseInt64("1 ", &n));
     BOOST_CHECK(!ParseInt64("1a", &n));
     BOOST_CHECK(!ParseInt64("aap", &n));
     BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseInt64(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
     BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
     BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt32) {
     uint32_t n;
     // Valid values
     BOOST_CHECK(ParseUInt32("1234", nullptr));
     BOOST_CHECK(ParseUInt32("0", &n) && n == 0);
     BOOST_CHECK(ParseUInt32("1234", &n) && n == 1234);
     BOOST_CHECK(ParseUInt32("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseUInt32("2147483647", &n) && n == 2147483647);
     BOOST_CHECK(ParseUInt32("2147483648", &n) && n == (uint32_t)2147483648);
     BOOST_CHECK(ParseUInt32("4294967295", &n) && n == (uint32_t)4294967295);
     // Invalid values
     BOOST_CHECK(!ParseUInt32("", &n));
     BOOST_CHECK(!ParseUInt32(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt32(" -1", &n));
     BOOST_CHECK(!ParseUInt32("1 ", &n));
     BOOST_CHECK(!ParseUInt32("1a", &n));
     BOOST_CHECK(!ParseUInt32("aap", &n));
     BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
     BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseUInt32(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt32("-2147483648", &n));
     BOOST_CHECK(!ParseUInt32("4294967296", &n));
     BOOST_CHECK(!ParseUInt32("-1234", &n));
     BOOST_CHECK(!ParseUInt32("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseUInt32("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt64) {
     uint64_t n;
     // Valid values
     BOOST_CHECK(ParseUInt64("1234", nullptr));
     BOOST_CHECK(ParseUInt64("0", &n) && n == 0LL);
     BOOST_CHECK(ParseUInt64("1234", &n) && n == 1234LL);
     BOOST_CHECK(ParseUInt64("01234", &n) && n == 1234LL); // no octal
     BOOST_CHECK(ParseUInt64("2147483647", &n) && n == 2147483647LL);
     BOOST_CHECK(ParseUInt64("9223372036854775807", &n) &&
                 n == 9223372036854775807ULL);
     BOOST_CHECK(ParseUInt64("9223372036854775808", &n) &&
                 n == 9223372036854775808ULL);
     BOOST_CHECK(ParseUInt64("18446744073709551615", &n) &&
                 n == 18446744073709551615ULL);
     // Invalid values
     BOOST_CHECK(!ParseUInt64("", &n));
     BOOST_CHECK(!ParseUInt64(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt64(" -1", &n));
     BOOST_CHECK(!ParseUInt64("1 ", &n));
     BOOST_CHECK(!ParseUInt64("1a", &n));
     BOOST_CHECK(!ParseUInt64("aap", &n));
     BOOST_CHECK(!ParseUInt64("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseUInt64(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt64("-9223372036854775809", nullptr));
     BOOST_CHECK(!ParseUInt64("18446744073709551616", nullptr));
     BOOST_CHECK(!ParseUInt64("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseUInt64("-2147483648", &n));
     BOOST_CHECK(!ParseUInt64("-9223372036854775808", &n));
     BOOST_CHECK(!ParseUInt64("-1234", &n));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseDouble) {
     double n;
     // Valid values
     BOOST_CHECK(ParseDouble("1234", nullptr));
     BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
     BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
     BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
     BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
     BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
     BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
     BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
     BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
     // Invalid values
     BOOST_CHECK(!ParseDouble("", &n));
     BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseDouble("1 ", &n));
     BOOST_CHECK(!ParseDouble("1a", &n));
     BOOST_CHECK(!ParseDouble("aap", &n));
     BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseDouble(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseDouble("-1e10000", nullptr));
     BOOST_CHECK(!ParseDouble("1e10000", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatParagraph) {
     BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
     BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
     BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), " test");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
     BOOST_CHECK_EQUAL(FormatParagraph("testerde test", 4, 0), "testerde\ntest");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n    test");
 
     // Make sure we don't indent a fully-new line following a too-long line
     // ending
     BOOST_CHECK_EQUAL(FormatParagraph("test test\nabc", 4, 4),
                       "test\n    test\nabc");
 
     BOOST_CHECK_EQUAL(
         FormatParagraph("This_is_a_very_long_test_string_without_any_spaces_so_"
                         "it_should_just_get_returned_as_is_despite_the_length "
                         "until it gets here",
                         79),
         "This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_"
         "get_returned_as_is_despite_the_length\nuntil it gets here");
 
     // Test wrap length is exact
     BOOST_CHECK_EQUAL(
         FormatParagraph("a b c d e f g h i j k l m n o p q r s t u v w x y z 1 "
                         "2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p",
                         79),
         "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 "
         "a b c de\nf g h i j k l m n o p");
     BOOST_CHECK_EQUAL(
         FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y "
                         "z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p",
                         79),
         "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 "
         "8 9 a b c de\nf g h i j k l m n o p");
     // Indent should be included in length of lines
     BOOST_CHECK_EQUAL(
         FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y "
                         "z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p q "
                         "r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg h "
                         "i j k",
                         79, 4),
         "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 "
         "8 9 a b c de\n    f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 "
         "5 6 7 8 9 a b c d e fg\n    h i j k");
 
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string. This is a second "
                         "sentence in the very long test string.",
                         79),
         "This is a very long test string. This is a second sentence in the "
         "very long\ntest string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string.\nThis is a second "
                         "sentence in the very long test string. This is a "
                         "third sentence in the very long test string.",
                         79),
         "This is a very long test string.\nThis is a second sentence in the "
         "very long test string. This is a third\nsentence in the very long "
         "test string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string.\n\nThis is a second "
                         "sentence in the very long test string. This is a "
                         "third sentence in the very long test string.",
                         79),
         "This is a very long test string.\n\nThis is a second sentence in the "
         "very long test string. This is a third\nsentence in the very long "
         "test string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph(
             "Testing that normal newlines do not get indented.\nLike here.",
             79),
         "Testing that normal newlines do not get indented.\nLike here.");
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatSubVersion) {
     std::vector<std::string> comments;
     comments.push_back(std::string("comment1"));
     std::vector<std::string> comments2;
     comments2.push_back(std::string("comment1"));
     // Semicolon is discouraged but not forbidden by BIP-0014
     comments2.push_back(SanitizeString(
         std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"),
         SAFE_CHARS_UA_COMMENT));
     BOOST_CHECK_EQUAL(
         FormatSubVersion("Test", 99900, std::vector<std::string>()),
         std::string("/Test:0.9.99/"));
     BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),
                       std::string("/Test:0.9.99(comment1)/"));
     BOOST_CHECK_EQUAL(
         FormatSubVersion("Test", 99900, comments2),
         std::string("/Test:0.9.99(comment1; Comment2; .,_?@-; )/"));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseFixedPoint) {
     int64_t amount = 0;
     BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 0LL);
     BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000LL);
     BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 0LL);
     BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -10000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 110000000LL);
     BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 110000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1100000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 11000000LL);
     BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000000LL);
     BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -100000000000LL);
     BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1LL);
     BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1LL);
     BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -1LL);
     BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
     BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
     BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
 
     BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
 }
 
 static void TestOtherThread(fs::path dirname, std::string lockname,
                             bool *result) {
     *result = LockDirectory(dirname, lockname);
 }
 
 #ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
 static constexpr char LockCommand = 'L';
 static constexpr char UnlockCommand = 'U';
 static constexpr char ExitCommand = 'X';
 
 static void TestOtherProcess(fs::path dirname, std::string lockname, int fd) {
     char ch;
     while (true) {
         // Wait for command
         int rv = read(fd, &ch, 1);
         assert(rv == 1);
         switch (ch) {
             case LockCommand:
                 ch = LockDirectory(dirname, lockname);
                 rv = write(fd, &ch, 1);
                 assert(rv == 1);
                 break;
             case UnlockCommand:
                 ReleaseDirectoryLocks();
                 ch = true; // Always succeeds
                 rv = write(fd, &ch, 1);
                 assert(rv == 1);
                 break;
             case ExitCommand:
                 close(fd);
                 exit(0);
             default:
                 assert(0);
         }
     }
 }
 #endif
 
 BOOST_AUTO_TEST_CASE(test_LockDirectory) {
     fs::path dirname = SetDataDir("test_LockDirectory") / fs::unique_path();
     const std::string lockname = ".lock";
 #ifndef WIN32
     // Revert SIGCHLD to default, otherwise boost.test will catch and fail on
     // it: there is BOOST_TEST_IGNORE_SIGCHLD but that only works when defined
     // at build-time of the boost library
     void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
 
     // Fork another process for testing before creating the lock, so that we
     // won't fork while holding the lock (which might be undefined, and is not
     // relevant as test case as that is avoided with -daemonize).
     int fd[2];
     BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
     pid_t pid = fork();
     if (!pid) {
         BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
         TestOtherProcess(dirname, lockname, fd[0]);
     }
     BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
 #endif
     // Lock on non-existent directory should fail
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), false);
 
     fs::create_directories(dirname);
 
     // Probing lock on new directory should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Persistent lock on new directory should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
 
     // Another lock on the directory from the same thread should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
 
     // Another lock on the directory from a different thread within the same
     // process should succeed
     bool threadresult;
     std::thread thr(TestOtherThread, dirname, lockname, &threadresult);
     thr.join();
     BOOST_CHECK_EQUAL(threadresult, true);
 #ifndef WIN32
     // Try to acquire lock in child process while we're holding it, this should
     // fail.
     char ch;
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, false);
 
     // Give up our lock
     ReleaseDirectoryLocks();
     // Probing lock from our side now should succeed, but not hold on to the
     // lock.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Try to acquire the lock in the child process, this should be successful.
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, true);
 
     // When we try to probe the lock now, it should fail.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), false);
 
     // Unlock the lock in the child process
     BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, true);
 
     // When we try to probe the lock now, it should succeed.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Re-lock the lock in the child process, then wait for it to exit, check
     // successful return. After that, we check that exiting the process
     // has released the lock as we would expect by probing it.
     int processstatus;
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
     BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
     BOOST_CHECK_EQUAL(processstatus, 0);
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Restore SIGCHLD
     signal(SIGCHLD, old_handler);
     BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
 #endif
     // Clean up
     ReleaseDirectoryLocks();
     fs::remove_all(dirname);
 }
 
 BOOST_AUTO_TEST_CASE(test_DirIsWritable) {
     // Should be able to write to the data dir.
     fs::path tmpdirname = SetDataDir("test_DirIsWritable");
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
 
     // Should not be able to write to a non-existent dir.
     tmpdirname = tmpdirname / fs::unique_path();
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), false);
 
     fs::create_directory(tmpdirname);
     // Should be able to write to it now.
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
     fs::remove(tmpdirname);
 }
 
 template <int F, int T>
 static void CheckConvertBits(const std::vector<uint8_t> &in,
                              const std::vector<uint8_t> &expected) {
     std::vector<uint8_t> outpad;
     bool ret = ConvertBits<F, T, true>(outpad, in.begin(), in.end());
     BOOST_CHECK(ret);
     BOOST_CHECK(outpad == expected);
 
     const bool dopad = (in.size() * F) % T;
     std::vector<uint8_t> outnopad;
     ret = ConvertBits<F, T, false>(outnopad, in.begin(), in.end());
     BOOST_CHECK(ret != dopad);
 
     if (dopad) {
         // We should have skipped the last digit.
         outnopad.push_back(expected.back());
     }
 
     BOOST_CHECK(outnopad == expected);
 
     // Check the other way around.
     std::vector<uint8_t> orignopad;
     ret = ConvertBits<T, F, false>(orignopad, expected.begin(), expected.end());
     BOOST_CHECK(ret == !((expected.size() * T) % F));
     BOOST_CHECK(orignopad == in);
 
     // Check with padding. We may get an extra 0 in that case.
     std::vector<uint8_t> origpad;
     ret = ConvertBits<T, F, true>(origpad, expected.begin(), expected.end());
     BOOST_CHECK(ret);
 
     if (dopad) {
         BOOST_CHECK_EQUAL(origpad.back(), 0);
         origpad.pop_back();
     }
 
     BOOST_CHECK(origpad == in);
 }
 
 BOOST_AUTO_TEST_CASE(test_ConvertBits) {
     CheckConvertBits<8, 5>({}, {});
     CheckConvertBits<8, 5>({0xff}, {0x1f, 0x1c});
     CheckConvertBits<8, 5>({0xff, 0xff}, {0x1f, 0x1f, 0x1f, 0x10});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff}, {0x1f, 0x1f, 0x1f, 0x1f, 0x1e});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x18});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
                            {0x00, 0x04, 0x11, 0x14, 0x0a, 0x19, 0x1c, 0x09,
                             0x15, 0x0f, 0x06, 0x1e, 0x1e});
 }
 
 BOOST_AUTO_TEST_CASE(test_ToLower) {
     BOOST_CHECK_EQUAL(ToLower('@'), '@');
     BOOST_CHECK_EQUAL(ToLower('A'), 'a');
     BOOST_CHECK_EQUAL(ToLower('Z'), 'z');
     BOOST_CHECK_EQUAL(ToLower('['), '[');
     BOOST_CHECK_EQUAL(ToLower(0), 0);
     BOOST_CHECK_EQUAL(ToLower(255), 255);
 
     std::string testVector;
     Downcase(testVector);
     BOOST_CHECK_EQUAL(testVector, "");
 
     testVector = "#HODL";
     Downcase(testVector);
     BOOST_CHECK_EQUAL(testVector, "#hodl");
 
     testVector = "\x00\xfe\xff";
     Downcase(testVector);
     BOOST_CHECK_EQUAL(testVector, "\x00\xfe\xff");
 }
 
 BOOST_AUTO_TEST_CASE(test_ToUpper) {
     BOOST_CHECK_EQUAL(ToUpper('`'), '`');
     BOOST_CHECK_EQUAL(ToUpper('a'), 'A');
     BOOST_CHECK_EQUAL(ToUpper('z'), 'Z');
     BOOST_CHECK_EQUAL(ToUpper('{'), '{');
     BOOST_CHECK_EQUAL(ToUpper(0), 0);
     BOOST_CHECK_EQUAL(ToUpper(255), 255);
 }
 
 BOOST_AUTO_TEST_CASE(test_Capitalize) {
     BOOST_CHECK_EQUAL(Capitalize(""), "");
     BOOST_CHECK_EQUAL(Capitalize("bitcoin"), "Bitcoin");
     BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index c1acb7ca2..4acc3303a 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -1,775 +1,774 @@
 // Copyright (c) 2017 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 <chainparams.h> // For Params
 #include <primitives/transaction.h>
 #include <random.h>
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
 #include <wallet/wallet.h>
 
 #include <test/test_bitcoin.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 #include <random>
 
 BOOST_FIXTURE_TEST_SUITE(coinselector_tests, WalletTestingSetup)
 
 // how many times to run all the tests to have a chance to catch errors that
 // only show up with particular random shuffles
 #define RUN_TESTS 100
 
 // some tests fail 1% of the time due to bad luck.
 // we repeat those tests this many times and only complain if all iterations of
 // the test fail
 #define RANDOM_REPEATS 5
 
 std::vector<std::unique_ptr<CWalletTx>> wtxn;
 
 typedef std::set<CInputCoin> CoinSet;
 
 static std::vector<COutput> vCoins;
 static Amount balance = Amount::zero();
 
 CoinEligibilityFilter filter_standard(1, 6, 0);
 CoinEligibilityFilter filter_confirmed(1, 1, 0);
 CoinEligibilityFilter filter_standard_extra(6, 6, 0);
 CoinSelectionParams coin_selection_params(false, 0, 0, CFeeRate(Amount::zero()),
                                           0);
 
 static void add_coin(const Amount nValue, int nInput,
                      std::vector<CInputCoin> &set) {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     set.emplace_back(MakeTransactionRef(tx), nInput);
 }
 
 static void add_coin(const Amount nValue, int nInput, CoinSet &set) {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     set.emplace(MakeTransactionRef(tx), nInput);
 }
 
 static void add_coin(CWallet &wallet, const Amount nValue, int nAge = 6 * 24,
                      bool fIsFromMe = false, int nInput = 0) {
     balance += nValue;
     static int nextLockTime = 0;
     CMutableTransaction tx;
     // so all transactions get different hashes
     tx.nLockTime = nextLockTime++;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     if (fIsFromMe) {
         // IsFromMe() returns (GetDebit() > 0), and GetDebit() is 0 if
         // vin.empty(), so stop vin being empty, and cache a non-zero Debit to
         // fake out IsFromMe()
         tx.vin.resize(1);
     }
     std::unique_ptr<CWalletTx> wtx(
         new CWalletTx(&wallet, MakeTransactionRef(std::move(tx))));
     if (fIsFromMe) {
         wtx->fDebitCached = true;
         wtx->nDebitCached = SATOSHI;
     }
     COutput output(wtx.get(), nInput, nAge, true /* spendable */,
                    true /* solvable */, true /* safe */);
     vCoins.push_back(output);
     wallet.AddToWallet(*wtx.get());
     wtxn.emplace_back(std::move(wtx));
 }
 
 static void empty_wallet() {
     vCoins.clear();
     wtxn.clear();
     balance = Amount::zero();
 }
 
 static bool equal_sets(CoinSet a, CoinSet b) {
     std::pair<CoinSet::iterator, CoinSet::iterator> ret =
         mismatch(a.begin(), a.end(), b.begin());
     return ret.first == a.end() && ret.second == b.end();
 }
 
 static Amount make_hard_case(int utxos, std::vector<CInputCoin> &utxo_pool) {
     utxo_pool.clear();
     Amount target = Amount::zero();
     for (int i = 0; i < utxos; ++i) {
         const Amount base = (int64_t(1) << (utxos + i)) * SATOSHI;
         target += base;
         add_coin(base, 2 * i, utxo_pool);
         add_coin(base + (int64_t(1) << (utxos - 1 - i)) * SATOSHI, 2 * i + 1,
                  utxo_pool);
     }
     return target;
 }
 
 inline std::vector<OutputGroup> &
 GroupCoins(const std::vector<CInputCoin> &coins) {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
     for (auto &coin : coins) {
         static_groups.emplace_back(coin, 0, true, 0, 0);
     }
     return static_groups;
 }
 
 inline std::vector<OutputGroup> &GroupCoins(const std::vector<COutput> &coins) {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
     for (auto &coin : coins) {
         // HACK: we can't figure out the is_me flag so we use the conditions
         // defined below; perhaps set safe to false for !fIsFromMe in add_coin()
         const bool is_me =
             coin.tx->fDebitCached && coin.tx->nDebitCached == SATOSHI;
         static_groups.emplace_back(coin.GetInputCoin(), coin.nDepth, is_me, 0,
                                    0);
     }
     return static_groups;
 }
 
 // Branch and bound coin selection tests
 BOOST_AUTO_TEST_CASE(bnb_search_test) {
     LOCK(m_wallet.cs_wallet);
 
     // Setup
     std::vector<CInputCoin> utxo_pool;
     CoinSet selection;
     CoinSet actual_selection;
     Amount value_ret = Amount::zero();
     Amount not_input_fees = Amount::zero();
 
     /////////////////////////
     // Known Outcome tests //
     /////////////////////////
-    BOOST_TEST_MESSAGE("Testing known outcomes");
 
     // Empty utxo pool
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, CENT / 2,
                                 selection, value_ret, not_input_fees));
     selection.clear();
 
     // Add utxos
     add_coin(1 * CENT, 1, utxo_pool);
     add_coin(2 * CENT, 2, utxo_pool);
     add_coin(3 * CENT, 3, utxo_pool);
     add_coin(4 * CENT, 4, utxo_pool);
 
     // Select 1 Cent
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 1 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 2 Cent
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 2 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 2 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 5 Cent
     add_coin(3 * CENT, 3, actual_selection);
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 5 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 5 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 11 Cent, not possible
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 11 * CENT, CENT / 2,
                                 selection, value_ret, not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Select 10 Cent
     add_coin(5 * CENT, 5, utxo_pool);
     add_coin(4 * CENT, 4, actual_selection);
     add_coin(3 * CENT, 3, actual_selection);
     add_coin(2 * CENT, 2, actual_selection);
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 10 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Negative effective value
     // Select 10 Cent but have 1 Cent not be possible because too small
     add_coin(5 * CENT, 5, actual_selection);
     add_coin(3 * CENT, 3, actual_selection);
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, 5000 * SATOSHI,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 10 * CENT);
     // FIXME: this test is redundant with the above, because 1 Cent is selected,
     // not "too small" BOOST_CHECK(equal_sets(selection, actual_selection));
 
     // Select 0.25 Cent, not possible
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), CENT / 4, CENT / 2,
                                 selection, value_ret, not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Iteration exhaustion test
     Amount target = make_hard_case(17, utxo_pool);
     // Should exhaust
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), target, Amount::zero(),
                                 selection, value_ret, not_input_fees));
     target = make_hard_case(14, utxo_pool);
     // Should not exhaust
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), target, Amount::zero(),
                                selection, value_ret, not_input_fees));
 
     // Test same value early bailout optimization
     utxo_pool.clear();
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(2 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(2 * CENT, 7, utxo_pool);
     for (int i = 0; i < 50000; ++i) {
         add_coin(5 * CENT, 7, utxo_pool);
     }
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 30 * CENT, 5000 * SATOSHI,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 30 * CENT);
     BOOST_CHECK(equal_sets(selection, actual_selection));
 
     ////////////////////
     // Behavior tests //
     ////////////////////
     // Select 1 Cent with pool of only greater than 5 Cent
     utxo_pool.clear();
     for (int i = 5; i <= 20; ++i) {
         add_coin(i * CENT, i, utxo_pool);
     }
     // Run 100 times, to make sure it is never finding a solution
     for (int i = 0; i < 100; ++i) {
         BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, 2 * CENT,
                                     selection, value_ret, not_input_fees));
     }
 
     // Make sure that effective value is working in SelectCoinsMinConf when BnB
     // is used
     CoinSelectionParams coin_selection_params_bnb(true, 0, 0,
                                                   CFeeRate(3000 * SATOSHI), 0);
     CoinSet setCoinsRet;
     Amount nValueRet;
     bool bnb_used;
     empty_wallet();
     add_coin(m_wallet, SATOSHI);
     // Make sure that it has a negative effective value. The next check should
     // assert if this somehow got through. Otherwise it will fail
     vCoins.at(0).nInputBytes = 40;
     BOOST_CHECK(!m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
 
     // Make sure that we aren't using BnB when there are preset inputs
     empty_wallet();
     add_coin(m_wallet, 5 * CENT);
     add_coin(m_wallet, 3 * CENT);
     add_coin(m_wallet, 2 * CENT);
     CCoinControl coin_control;
     coin_control.fAllowOtherInputs = true;
     coin_control.Select(COutPoint(vCoins.at(0).tx->GetId(), vCoins.at(0).i));
     BOOST_CHECK(m_wallet.SelectCoins(vCoins, 10 * CENT, setCoinsRet, nValueRet,
                                      coin_control, coin_selection_params_bnb,
                                      bnb_used));
     BOOST_CHECK(!bnb_used);
     BOOST_CHECK(!coin_selection_params_bnb.use_bnb);
 }
 
 BOOST_AUTO_TEST_CASE(knapsack_solver_test) {
     CWallet testWallet(Params(), WalletLocation(),
                        WalletDatabase::CreateDummy());
 
     CoinSet setCoinsRet, setCoinsRet2;
     Amount nValueRet;
     bool bnb_used;
 
     LOCK(testWallet.cs_wallet);
 
     // test multiple times to allow for differences in the shuffle order
     for (int i = 0; i < RUN_TESTS; i++) {
         empty_wallet();
 
         // with an empty wallet we can't even pay one cent
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // add a new 1 cent coin
         add_coin(testWallet, 1 * CENT, 4);
 
         // with a new 1 cent coin, we still can't find a mature 1 cent
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // but we can find a new 1 cent
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);
         // add a mature 2 cent coin
         add_coin(testWallet, 2 * CENT);
 
         // we can't make 3 cents of mature coins
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             3 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // we can make 3 cents of new coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             3 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 3 * CENT);
 
         // add a mature 5 cent coin,
         add_coin(testWallet, 5 * CENT);
         // a new 10 cent coin sent from one of our own addresses
         add_coin(testWallet, 10 * CENT, 3, true);
         // and a mature 20 cent coin
         add_coin(testWallet, 20 * CENT);
 
         // now we have new: 1+10=11 (of which 10 was self-sent), and mature:
         // 2+5+20=27.  total = 38
 
         // we can't make 38 cents only if we disallow new coins:
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             38 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we can't even make 37 cents if we don't allow new coins even if
         // they're from us
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             38 * CENT, filter_standard_extra, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // but we can make 37 cents if we accept new coins from ourself
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             37 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 37 * CENT);
         // and we can make 38 cents if we accept all new coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             38 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 38 * CENT);
 
         // try making 34 cents from 1,2,5,10,20 - we can't do it exactly
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             34 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // but 35 cents is closest
         BOOST_CHECK_EQUAL(nValueRet, 35 * CENT);
         // the best should be 20+10+5.  it's incredibly unlikely the 1 or 2 got
         // included (but possible)
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 7 cents, the smaller coins (1,2,5) are enough.  We
         // should see just 2+5
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             7 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 7 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // when we try making 8 cents, the smaller coins (1,2,5) are exactly
         // enough.
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             8 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(nValueRet == 8 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 9 cents, no subset of smaller coins is enough, and
         // we get the next bigger coin (10)
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             9 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 10 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now clear out the wallet and start again to test choosing between
         // subsets of smaller coins and the next biggest coin
         empty_wallet();
 
         add_coin(testWallet, 6 * CENT);
         add_coin(testWallet, 7 * CENT);
         add_coin(testWallet, 8 * CENT);
         add_coin(testWallet, 20 * CENT);
         // now we have 6+7+8+20+30 = 71 cents total
         add_coin(testWallet, 30 * CENT);
 
         // check that we have 71 and not 72
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             71 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             72 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // now try making 16 cents.  the best smaller coins can do is 6+7+8 =
         // 21; not as good at the next biggest coin, 20
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 20 in one coin
         BOOST_CHECK_EQUAL(nValueRet, 20 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now we have 5+6+7+8+20+30 = 75 cents total
         add_coin(testWallet, 5 * CENT);
 
         // now if we try making 16 cents again, the smaller coins can make 5+6+7
         // = 18 cents, better than the next biggest coin, 20
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 18 in 3 coins
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // now we have 5+6+7+8+18+20+30
         add_coin(testWallet, 18 * CENT);
 
         // and now if we try making 16 cents again, the smaller coins can make
         // 5+6+7 = 18 cents, the same as the next biggest coin, 18
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 18 in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);
         // because in the event of a tie, the biggest coin wins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now try making 11 cents.  we should get 5+6
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             11 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 11 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // check that the smallest bigger coin is used
         add_coin(testWallet, 1 * COIN);
         add_coin(testWallet, 2 * COIN);
         add_coin(testWallet, 3 * COIN);
         // now we have 5+6+7+8+18+20+30+100+200+300+400 = 1094 cents
         add_coin(testWallet, 4 * COIN);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             95 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 1 BCH in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 1 * COIN);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             195 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 2 BCH in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 2 * COIN);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // empty the wallet and start again, now with fractions of a cent, to
         // test small change avoidance
 
         empty_wallet();
         add_coin(testWallet, 1 * MIN_CHANGE / 10);
         add_coin(testWallet, 2 * MIN_CHANGE / 10);
         add_coin(testWallet, 3 * MIN_CHANGE / 10);
         add_coin(testWallet, 4 * MIN_CHANGE / 10);
         add_coin(testWallet, 5 * MIN_CHANGE / 10);
 
         // try making 1 * MIN_CHANGE from the 1.5 * MIN_CHANGE
         // we'll get change smaller than MIN_CHANGE whatever happens, so can
         // expect MIN_CHANGE exactly
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
 
         // but if we add a bigger coin, small change is avoided
         add_coin(testWallet, 1111 * MIN_CHANGE);
 
         // try making 1 from 0.1 + 0.2 + 0.3 + 0.4 + 0.5 + 1111 = 1112.5
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE);
 
         // if we add more small coins:
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 7 * MIN_CHANGE / 10);
 
         // and try again to make 1.0 * MIN_CHANGE
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE);
 
         // run the 'mtgox' test (see
         // http://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf)
         // they tried to consolidate 10 50k coins into one 500k coin, and ended
         // up with 50k in change
         empty_wallet();
         for (int j = 0; j < 20; j++) {
             add_coin(testWallet, 50000 * COIN);
         }
 
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             500000 * COIN, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 500000 * COIN);
         // in ten coins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 10U);
 
         // if there's not enough in the smaller coins to make at least 1 *
         // MIN_CHANGE change (0.5+0.6+0.7 < 1.0+1.0), we need to try finding an
         // exact subset anyway
 
         // sometimes it will fail, and so we use the next biggest coin:
         empty_wallet();
         add_coin(testWallet, 5 * MIN_CHANGE / 10);
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 7 * MIN_CHANGE / 10);
         add_coin(testWallet, 1111 * MIN_CHANGE);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we get the bigger coin
         BOOST_CHECK_EQUAL(nValueRet, 1111 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // but sometimes it's possible, and we use an exact subset (0.4 + 0.6 =
         // 1.0)
         empty_wallet();
         add_coin(testWallet, 4 * MIN_CHANGE / 10);
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 8 * MIN_CHANGE / 10);
         add_coin(testWallet, 1111 * MIN_CHANGE);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
         // in two coins 0.4+0.6
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // test avoiding small change
         empty_wallet();
         add_coin(testWallet, 5 * MIN_CHANGE / 100);
         add_coin(testWallet, 1 * MIN_CHANGE);
         add_coin(testWallet, 100 * MIN_CHANGE);
 
         // trying to make 100.01 from these three coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             10001 * MIN_CHANGE / 100, filter_confirmed, GroupCoins(vCoins),
             setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         // we should get all coins
         BOOST_CHECK_EQUAL(nValueRet, 10105 * MIN_CHANGE / 100);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // but if we try to make 99.9, we should take the bigger of the two
         // small coins to avoid small change
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             9990 * MIN_CHANGE / 100, filter_confirmed, GroupCoins(vCoins),
             setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 101 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
     }
 
     // test with many inputs
     for (Amount amt = 1500 * SATOSHI; amt < COIN; amt = 10 * amt) {
         empty_wallet();
         // Create 676 inputs (=  (old MAX_STANDARD_TX_SIZE == 100000)  / 148
         // bytes per input)
         for (uint16_t j = 0; j < 676; j++) {
             add_coin(testWallet, amt);
         }
 
         // We only create the wallet once to save time, but we still run the
         // coin selection RUN_TESTS times.
         for (int i = 0; i < RUN_TESTS; i++) {
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 2000 * SATOSHI, filter_confirmed, GroupCoins(vCoins),
                 setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
             if (amt - 2000 * SATOSHI < MIN_CHANGE) {
                 // needs more than one input:
                 uint16_t returnSize = std::ceil(
                     (2000.0 + (MIN_CHANGE / SATOSHI)) / (amt / SATOSHI));
                 Amount returnValue = returnSize * amt;
                 BOOST_CHECK_EQUAL(nValueRet, returnValue);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), returnSize);
             } else {
                 // one input is sufficient:
                 BOOST_CHECK_EQUAL(nValueRet, amt);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
             }
         }
     }
 
     // test randomness
     {
         empty_wallet();
         for (int i2 = 0; i2 < 100; i2++) {
             add_coin(testWallet, COIN);
         }
 
         // Again, we only create the wallet once to save time, but we still run
         // the coin selection RUN_TESTS times.
         for (int i = 0; i < RUN_TESTS; i++) {
             // picking 50 from 100 coins doesn't depend on the shuffle, but does
             // depend on randomness in the stochastic approximation code
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
                 nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2,
                 nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(!equal_sets(setCoinsRet, setCoinsRet2));
 
             int fails = 0;
             for (int j = 0; j < RANDOM_REPEATS; j++) {
                 // selecting 1 from 100 identical coins depends on the shuffle;
                 // this test will fail 1% of the time run the test
                 // RANDOM_REPEATS times and only complain if all of them fail
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
                     nValueRet, coin_selection_params, bnb_used));
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2,
                     nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2)) {
                     fails++;
                 }
             }
             BOOST_CHECK_NE(fails, RANDOM_REPEATS);
         }
 
         // add 75 cents in small change.  not enough to make 90 cents, then
         // try making 90 cents.  there are multiple competing "smallest
         // bigger" coins, one of which should be picked at random
         add_coin(testWallet, 5 * CENT);
         add_coin(testWallet, 10 * CENT);
         add_coin(testWallet, 15 * CENT);
         add_coin(testWallet, 20 * CENT);
         add_coin(testWallet, 25 * CENT);
 
         for (int i = 0; i < RUN_TESTS; i++) {
             int fails = 0;
             for (int j = 0; j < RANDOM_REPEATS; j++) {
                 // selecting 1 from 100 identical coins depends on the shuffle;
                 // this test will fail 1% of the time run the test
                 // RANDOM_REPEATS times and only complain if all of them fail
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     90 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
                     nValueRet, coin_selection_params, bnb_used));
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     90 * CENT, filter_standard, GroupCoins(vCoins),
                     setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2)) {
                     fails++;
                 }
             }
             BOOST_CHECK_NE(fails, RANDOM_REPEATS);
         }
     }
 
     empty_wallet();
 }
 
 BOOST_AUTO_TEST_CASE(ApproximateBestSubset) {
     CoinSet setCoinsRet;
     Amount nValueRet;
     bool bnb_used;
 
     LOCK(m_wallet.cs_wallet);
 
     empty_wallet();
 
     // Test vValue sort order
     for (int i = 0; i < 1000; i++) {
         add_coin(m_wallet, 1000 * COIN);
     }
     add_coin(m_wallet, 3 * COIN);
 
     BOOST_CHECK(m_wallet.SelectCoinsMinConf(
         1003 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
         nValueRet, coin_selection_params, bnb_used));
     BOOST_CHECK_EQUAL(nValueRet, 1003 * COIN);
     BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
     empty_wallet();
 }
 
 // Tests that with the ideal conditions, the coin selector will always be able
 // to find a solution that can pay the target value
 BOOST_AUTO_TEST_CASE(SelectCoins_test) {
     CWallet testWallet(Params(), WalletLocation(),
                        WalletDatabase::CreateDummy());
 
     // Random generator stuff
     std::default_random_engine generator;
     std::exponential_distribution<double> distribution(100);
     FastRandomContext rand;
 
     // Run this test 100 times
     for (int i = 0; i < 100; ++i) {
         empty_wallet();
 
         // Make a wallet with 1000 exponentially distributed random inputs
         for (int j = 0; j < 1000; ++j) {
             add_coin(testWallet,
                      int64_t(10000000 * distribution(generator)) * SATOSHI);
         }
 
         // Generate a random fee rate in the range of 100 - 400
         CFeeRate rate(int64_t(rand.randrange(300) + 100) * SATOSHI);
 
         // Generate a random target value between 1000 and wallet balance
         Amount target =
             int64_t(rand.randrange(balance / SATOSHI - 1000) + 1000) * SATOSHI;
 
         // Perform selection
         CoinSelectionParams coin_selection_params_knapsack(
             false, 34, 148, CFeeRate(Amount::zero()), 0);
         CoinSelectionParams coin_selection_params_bnb(
             true, 34, 148, CFeeRate(Amount::zero()), 0);
         CoinSet out_set;
         Amount out_value = Amount::zero();
         bool bnb_used = false;
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
                         target, filter_standard, GroupCoins(vCoins), out_set,
                         out_value, coin_selection_params_bnb, bnb_used) ||
                     testWallet.SelectCoinsMinConf(
                         target, filter_standard, GroupCoins(vCoins), out_set,
                         out_value, coin_selection_params_knapsack, bnb_used));
         BOOST_CHECK_GE(out_value, target);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()