Destroy Boost.Test with lazer beams

Author: rustaceanrob

src/addrman.h

@@ -69,7 +69,7 @@ struct AddressPosition {
     const int bucket;
     const int position;
 
-    bool operator==(AddressPosition other) {
+    bool operator==(AddressPosition other) const {
         return std::tie(tried, multiplicity, bucket, position) ==
                std::tie(other.tried, other.multiplicity, other.bucket, other.position);
     }

src/crypto/hmac_sha256.h

@@ -17,7 +17,7 @@ class CHMAC_SHA256
     CSHA256 inner;
 
 public:
-    static const size_t OUTPUT_SIZE = 32;
+    static constexpr size_t OUTPUT_SIZE = 32;
 
     CHMAC_SHA256(const unsigned char* key, size_t keylen);
     CHMAC_SHA256& Write(const unsigned char* data, size_t len)

src/crypto/hmac_sha512.h

@@ -17,7 +17,7 @@ class CHMAC_SHA512
     CSHA512 inner;
 
 public:
-    static const size_t OUTPUT_SIZE = 64;
+    static constexpr size_t OUTPUT_SIZE = 64;
 
     CHMAC_SHA512(const unsigned char* key, size_t keylen);
     CHMAC_SHA512& Write(const unsigned char* data, size_t len)

src/crypto/ripemd160.h

@@ -17,7 +17,7 @@ class CRIPEMD160
     uint64_t bytes{0};
 
 public:
-    static const size_t OUTPUT_SIZE = 20;
+    static constexpr size_t OUTPUT_SIZE = 20;
 
     CRIPEMD160();
     CRIPEMD160& Write(const unsigned char* data, size_t len);

src/crypto/sha1.h

@@ -17,7 +17,7 @@ class CSHA1
     uint64_t bytes{0};
 
 public:
-    static const size_t OUTPUT_SIZE = 20;
+    static constexpr size_t OUTPUT_SIZE = 20;
 
     CSHA1();
     CSHA1& Write(const unsigned char* data, size_t len);

src/crypto/sha256.h

@@ -18,7 +18,7 @@ class CSHA256
     uint64_t bytes{0};
 
 public:
-    static const size_t OUTPUT_SIZE = 32;
+    static constexpr size_t OUTPUT_SIZE = 32;
 
     CSHA256();
     CSHA256& Write(const unsigned char* data, size_t len);

src/ipc/libmultiprocess/src/mp/proxy.cpp

@@ -30,6 +30,7 @@
 #include <optional>
 #include <stdexcept>
 #include <string>
+#include <csignal>
 #include <sys/socket.h>
 #include <thread>
 #include <tuple>
@@ -203,6 +204,9 @@ EventLoop::EventLoop(const char* exe_name, LogOptions log_opts, void* context)
       m_log_opts(std::move(log_opts)),
       m_context(context)
 {
+    // Ignore SIGPIPE so writes to a closed pipe/socket return EPIPE instead of
+    // terminating the process when the remote end disconnects unexpectedly.
+    std::signal(SIGPIPE, SIG_IGN);
     int fds[2];
     KJ_SYSCALL(socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
     m_wait_fd = fds[0];

src/ipc/test/ipc_test.cpp

@@ -23,30 +23,32 @@
 #include <kj/test.h>
 #include <stdexcept>
 
-#include <boost/test/unit_test.hpp>
+#include <test/util/framework.hpp>
 
 static_assert(ipc::capnp::messages::MAX_MONEY == MAX_MONEY);
 static_assert(ipc::capnp::messages::MAX_DOUBLE == std::numeric_limits<double>::max());
 static_assert(ipc::capnp::messages::DEFAULT_BLOCK_RESERVED_WEIGHT == DEFAULT_BLOCK_RESERVED_WEIGHT);
 static_assert(ipc::capnp::messages::DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS == DEFAULT_COINBASE_OUTPUT_MAX_ADDITIONAL_SIGOPS);
 
 //! Remote init class.
+namespace {
 class TestInit : public interfaces::Init
 {
 public:
     std::atomic<bool> stop_called{false};
     std::unique_ptr<interfaces::Echo> makeEcho() override { return interfaces::MakeEcho(); }
     void stop() override { stop_called.store(true); }
 };
+} // namespace
 
 //! Generate a temporary path with temp_directory_path and mkstemp
 static std::string TempPath(std::string_view pattern)
 {
     std::string temp{fs::PathToString(fs::path{fs::temp_directory_path()} / fs::PathFromString(std::string{pattern}))};
     temp.push_back('\0');
     int fd{mkstemp(temp.data())};
-    BOOST_CHECK_GE(fd, 0);
-    BOOST_CHECK_EQUAL(close(fd), 0);
+    CHECK(fd >= 0);
+    CHECK(close(fd) == 0);
     temp.resize(temp.size() - 1);
     fs::remove(fs::PathFromString(temp));
     return temp;
@@ -85,17 +87,17 @@ void IpcPipeTest()
     std::unique_ptr<mp::ProxyClient<gen::FooInterface>> foo{foo_promise.get_future().get()};
 
     // Test: make sure arguments were sent and return value is received
-    BOOST_CHECK_EQUAL(foo->add(1, 2), 3);
+    CHECK(foo->add(1, 2) == 3);
 
     COutPoint txout1{Txid::FromUint256(uint256{100}), 200};
     COutPoint txout2{foo->passOutPoint(txout1)};
-    BOOST_CHECK(txout1 == txout2);
+    CHECK(txout1 == txout2);
 
     UniValue uni1{UniValue::VOBJ};
     uni1.pushKV("i", 1);
     uni1.pushKV("s", "two");
     UniValue uni2{foo->passUniValue(uni1)};
-    BOOST_CHECK_EQUAL(uni1.write(), uni2.write());
+    CHECK(uni1.write() == uni2.write());
 
     CMutableTransaction mtx;
     mtx.version = 2;
@@ -104,15 +106,15 @@ void IpcPipeTest()
     mtx.vout.emplace_back(COIN, CScript());
     CTransactionRef tx1{MakeTransactionRef(mtx)};
     CTransactionRef tx2{foo->passTransaction(tx1)};
-    BOOST_CHECK(*Assert(tx1) == *Assert(tx2));
+    CHECK(*Assert(tx1) == *Assert(tx2));
 
     std::vector<char> vec1{'H', 'e', 'l', 'l', 'o'};
     std::vector<char> vec2{foo->passVectorChar(vec1)};
-    BOOST_CHECK_EQUAL(std::string_view(vec1.begin(), vec1.end()), std::string_view(vec2.begin(), vec2.end()));
+    CHECK(std::string_view(vec1.begin(), vec1.end()) == std::string_view(vec2.begin(), vec2.end()));
 
     auto script1{CScript() << OP_11};
     auto script2{foo->passScript(script1)};
-    BOOST_CHECK_EQUAL(HexStr(script1), HexStr(script2));
+    CHECK(HexStr(script1) == HexStr(script2));
 
     // Test cleanup: disconnect and join thread
     foo.reset();
@@ -123,7 +125,7 @@ void IpcPipeTest()
 void IpcSocketPairTest()
 {
     int fds[2];
-    BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
+    CHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0);
     std::unique_ptr<interfaces::Init> init{std::make_unique<TestInit>()};
     std::unique_ptr<ipc::Protocol> protocol{ipc::capnp::MakeCapnpProtocol()};
     std::promise<void> promise;
@@ -133,10 +135,10 @@ void IpcSocketPairTest()
     promise.get_future().wait();
     std::unique_ptr<interfaces::Init> remote_init{protocol->connect(fds[1], "test-connect")};
     std::unique_ptr<interfaces::Echo> remote_echo{remote_init->makeEcho()};
-    BOOST_CHECK_EQUAL(remote_echo->echo("echo test"), "echo test");
+    CHECK(remote_echo->echo("echo test") == "echo test");
     remote_echo.reset();
     remote_init->stop();
-    BOOST_CHECK(static_cast<TestInit*>(init.get())->stop_called.load());
+    CHECK(static_cast<TestInit*>(init.get())->stop_called.load());
     remote_init.reset();
     thread.join();
 }
@@ -149,24 +151,24 @@ void IpcSocketTest(const fs::path& datadir)
     std::unique_ptr<ipc::Process> process{ipc::MakeProcess()};
 
     std::string invalid_bind{"invalid:"};
-    BOOST_CHECK_THROW(process->bind(datadir, "test_bitcoin", invalid_bind), std::invalid_argument);
-    BOOST_CHECK_THROW(process->connect(datadir, "test_bitcoin", invalid_bind), std::invalid_argument);
+    CHECK_THROWS_AS(process->bind(datadir, "test_bitcoin", invalid_bind), std::invalid_argument);
+    CHECK_THROWS_AS(process->connect(datadir, "test_bitcoin", invalid_bind), std::invalid_argument);
 
     auto bind_and_listen{[&](const std::string& bind_address) {
         std::string address{bind_address};
         int serve_fd = process->bind(datadir, "test_bitcoin", address);
-        BOOST_CHECK_GE(serve_fd, 0);
-        BOOST_CHECK_EQUAL(address, bind_address);
+        CHECK(serve_fd >= 0);
+        CHECK(address == bind_address);
         protocol->listen(serve_fd, "test-serve", *init);
     }};
 
     auto connect_and_test{[&](const std::string& connect_address) {
         std::string address{connect_address};
         int connect_fd{process->connect(datadir, "test_bitcoin", address)};
-        BOOST_CHECK_EQUAL(address, connect_address);
+        CHECK(address == connect_address);
         std::unique_ptr<interfaces::Init> remote_init{protocol->connect(connect_fd, "test-connect")};
         std::unique_ptr<interfaces::Echo> remote_echo{remote_init->makeEcho()};
-        BOOST_CHECK_EQUAL(remote_echo->echo("echo test"), "echo test");
+        CHECK(remote_echo->echo("echo test") == "echo test");
     }};
 
     // Need to specify explicit socket addresses outside the data directory, because the data

src/ipc/test/ipc_tests.cpp

@@ -7,29 +7,29 @@
 
 #include <test/util/common.h>
 #include <test/util/setup_common.h>
-#include <boost/test/unit_test.hpp>
+#include <test/util/framework.hpp>
 
-BOOST_FIXTURE_TEST_SUITE(ipc_tests, BasicTestingSetup)
-BOOST_AUTO_TEST_CASE(ipc_tests)
+TEST_SUITE_BEGIN("ipc_tests")
+FIXTURE_TEST_CASE("ipc_tests", BasicTestingSetup)
 {
     IpcPipeTest();
     IpcSocketPairTest();
     IpcSocketTest(m_args.GetDataDirNet());
 }
 
 // Test address parsing.
-BOOST_AUTO_TEST_CASE(parse_address_test)
+FIXTURE_TEST_CASE("parse_address_test", BasicTestingSetup)
 {
     std::unique_ptr<ipc::Process> process{ipc::MakeProcess()};
     fs::path datadir{"/var/empty/notexist"};
     auto check_notexist{[](const std::system_error& e) { return e.code() == std::errc::no_such_file_or_directory; }};
     auto check_address{[&](std::string address, std::string expect_address, std::string expect_error) {
         if (expect_error.empty()) {
-            BOOST_CHECK_EXCEPTION(process->connect(datadir, "test_bitcoin", address), std::system_error, check_notexist);
+            CHECK_EXCEPTION(process->connect(datadir, "test_bitcoin", address), std::system_error, check_notexist);
         } else {
-            BOOST_CHECK_EXCEPTION(process->connect(datadir, "test_bitcoin", address), std::invalid_argument, HasReason(expect_error));
+            CHECK_EXCEPTION(process->connect(datadir, "test_bitcoin", address), std::invalid_argument, HasReason(expect_error));
         }
-        BOOST_CHECK_EQUAL(address, expect_address);
+        CHECK(address == expect_address);
     }};
     check_address("unix", "unix:/var/empty/notexist/test_bitcoin.sock", "");
     check_address("unix:", "unix:/var/empty/notexist/test_bitcoin.sock", "");
@@ -40,4 +40,4 @@ BOOST_AUTO_TEST_CASE(parse_address_test)
     check_address("invalid", "invalid", "Unrecognized address 'invalid'");
 }
 
-BOOST_AUTO_TEST_SUITE_END()
+TEST_SUITE_END()

src/support/lockedpool.h

@@ -131,11 +131,11 @@ class LockedPool
      * allocation and deallocation overhead. Setting it too high allocates
      * more locked memory from the OS than strictly necessary.
      */
-    static const size_t ARENA_SIZE = 256*1024;
+    static constexpr size_t ARENA_SIZE = 256*1024;
     /** Chunk alignment. Another compromise. Setting this too high will waste
      * memory, setting it too low will facilitate fragmentation.
      */
-    static const size_t ARENA_ALIGN = 16;
+    static constexpr size_t ARENA_ALIGN = 16;
 
     /** Callback when allocation succeeds but locking fails.
      */