test: improve handwritten test doubles

Author: johnny9

test/mocks/callcounter.h

@@ -0,0 +1,28 @@
+// Copyright (c) 2026 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_QML_TEST_MOCKS_CALLCOUNTER_H
+#define BITCOIN_QML_TEST_MOCKS_CALLCOUNTER_H
+
+#include <atomic>
+#include <string_view>
+
+class CallCounter
+{
+public:
+    explicit CallCounter(std::string_view name) : m_name{name} {}
+
+    CallCounter(const CallCounter&) = delete;
+    CallCounter& operator=(const CallCounter&) = delete;
+
+    int operator++() { return m_calls.fetch_add(1) + 1; }
+    int load() const { return m_calls.load(); }
+    std::string_view Name() const { return m_name; }
+
+private:
+    std::atomic<int> m_calls{0};
+    const std::string_view m_name;
+};
+
+#endif // BITCOIN_QML_TEST_MOCKS_CALLCOUNTER_H

test/mocks/mocknode.h

@@ -5,11 +5,11 @@
 #ifndef BITCOIN_QML_TEST_MOCKS_MOCKNODE_H
 #define BITCOIN_QML_TEST_MOCKS_MOCKNODE_H
 
+#include <test/mocks/callcounter.h>
 #include <test/mocks/stubnode.h>
 
 #include <QtTest/qtestcase.h>
 
-#include <atomic>
 #include <functional>
 #include <mutex>
 #include <source_location>
@@ -39,9 +39,8 @@ class MockNode : public StubNode
         ~Verification()
         {
             if (!m_node) return;
-            const std::string failure{m_node->UnexpectedCallMessage()};
-            if (!failure.empty()) {
-                QTest::qFail(failure.c_str(), m_where.file_name(), static_cast<int>(m_where.line()));
+            for (const auto& failure : m_node->VerificationFailures(m_where)) {
+                QTest::qFail(failure.message.c_str(), failure.where.file_name(), static_cast<int>(failure.where.line()));
             }
         }
 
@@ -52,45 +51,24 @@ class MockNode : public StubNode
 
     explicit MockNode(bool strict = false) : m_strict{strict} {}
 
-    Verification VerifyOnExit(std::source_location where = std::source_location::current())
+    [[nodiscard]] Verification VerifyOnExit(std::source_location where = std::source_location::current())
     {
         return Verification{*this, where};
     }
 
-    std::string UnexpectedCallMessage() const
+    void ExpectExactly(const CallCounter& calls, int expected, std::source_location where = std::source_location::current())
     {
-        std::lock_guard<std::mutex> lock{m_unexpected_mutex};
-        std::ostringstream message;
-        if (!m_unexpected_calls.empty()) {
-            message << "Unexpected Node call(s):";
-            for (const std::string& call : m_unexpected_calls) message << "\n  " << call;
-        }
-        for (const CallExpectation& expectation : m_call_expectations) {
-            const int actual{expectation.calls->load() - expectation.baseline};
-            if (actual < expectation.minimum || (expectation.maximum && actual > *expectation.maximum)) {
-                if (message.tellp() > 0) message << '\n';
-                message << "Expected " << expectation.name << " calls to be ";
-                if (expectation.maximum && expectation.minimum == *expectation.maximum) {
-                    message << expectation.minimum;
-                } else if (expectation.maximum) {
-                    message << "between " << expectation.minimum << " and " << *expectation.maximum;
-                } else {
-                    message << "at least " << expectation.minimum;
-                }
-                message << ", actual " << actual;
-            }
-        }
-        return message.str();
+        m_call_expectations.push_back(CallExpectation{&calls, calls.load(), expected, expected, where});
     }
 
-    void ExpectCallCount(const std::atomic<int>& calls, int expected, const char* name)
+    void ExpectNoCalls(const CallCounter& calls, std::source_location where = std::source_location::current())
     {
-        m_call_expectations.push_back(CallExpectation{&calls, calls.load(), expected, expected, name});
+        ExpectExactly(calls, 0, where);
     }
 
-    void ExpectAtLeast(const std::atomic<int>& calls, int minimum, const char* name)
+    void ExpectAtLeast(const CallCounter& calls, int minimum, std::source_location where = std::source_location::current())
     {
-        m_call_expectations.push_back(CallExpectation{&calls, calls.load(), minimum, std::nullopt, name});
+        m_call_expectations.push_back(CallExpectation{&calls, calls.load(), minimum, std::nullopt, where});
     }
 
     void SetPersistentSetting(std::string name, common::SettingsValue value)
@@ -142,45 +120,45 @@ class MockNode : public StubNode
     std::function<std::unique_ptr<interfaces::Handler>(NotifyBlockTipFn)> handle_notify_block_tip_fn;
     std::function<std::unique_ptr<interfaces::Handler>(NotifyHeaderTipFn)> handle_notify_header_tip_fn;
 
-    std::atomic<int> get_warnings_calls{0};
-    std::atomic<int> app_init_main_calls{0};
-    std::atomic<int> app_shutdown_calls{0};
-    std::atomic<int> start_shutdown_calls{0};
-    std::atomic<int> shutdown_requested_calls{0};
-    std::atomic<int> get_persistent_setting_calls{0};
-    std::atomic<int> update_rw_setting_calls{0};
-    std::atomic<int> force_setting_calls{0};
-    std::atomic<int> map_port_calls{0};
-    std::atomic<int> get_node_count_calls{0};
-    std::atomic<int> get_nodes_stats_calls{0};
-    std::atomic<int> get_banned_calls{0};
-    std::atomic<int> ban_calls{0};
-    std::atomic<int> unban_calls{0};
-    std::atomic<int> disconnect_by_address_calls{0};
-    std::atomic<int> disconnect_by_id_calls{0};
-    std::atomic<int> list_external_signers_calls{0};
-    std::atomic<int> get_total_bytes_recv_calls{0};
-    std::atomic<int> get_total_bytes_sent_calls{0};
-    std::atomic<int> get_mempool_size_calls{0};
-    std::atomic<int> get_mempool_dynamic_usage_calls{0};
-    std::atomic<int> get_mempool_max_usage_calls{0};
-    std::atomic<int> get_header_tip_calls{0};
-    std::atomic<int> get_num_blocks_calls{0};
-    std::atomic<int> get_net_local_addresses_calls{0};
-    std::atomic<int> get_last_block_time_calls{0};
-    std::atomic<int> is_initial_block_download_calls{0};
-    std::atomic<int> get_network_active_calls{0};
-    std::atomic<int> get_dust_relay_fee_calls{0};
-    std::atomic<int> broadcast_transaction_calls{0};
-    std::atomic<int> wallet_loader_calls{0};
-    std::atomic<int> handle_message_box_calls{0};
-    std::atomic<int> handle_question_calls{0};
-    std::atomic<int> handle_notify_num_connections_changed_calls{0};
-    std::atomic<int> handle_notify_network_active_changed_calls{0};
-    std::atomic<int> handle_notify_alert_changed_calls{0};
-    std::atomic<int> handle_banned_list_changed_calls{0};
-    std::atomic<int> handle_notify_block_tip_calls{0};
-    std::atomic<int> handle_notify_header_tip_calls{0};
+    CallCounter get_warnings_calls{"getWarnings"};
+    CallCounter app_init_main_calls{"appInitMain"};
+    CallCounter app_shutdown_calls{"appShutdown"};
+    CallCounter start_shutdown_calls{"startShutdown"};
+    CallCounter shutdown_requested_calls{"shutdownRequested"};
+    CallCounter get_persistent_setting_calls{"getPersistentSetting"};
+    CallCounter update_rw_setting_calls{"updateRwSetting"};
+    CallCounter force_setting_calls{"forceSetting"};
+    CallCounter map_port_calls{"mapPort"};
+    CallCounter get_node_count_calls{"getNodeCount"};
+    CallCounter get_nodes_stats_calls{"getNodesStats"};
+    CallCounter get_banned_calls{"getBanned"};
+    CallCounter ban_calls{"ban"};
+    CallCounter unban_calls{"unban"};
+    CallCounter disconnect_by_address_calls{"disconnectByAddress"};
+    CallCounter disconnect_by_id_calls{"disconnectById"};
+    CallCounter list_external_signers_calls{"listExternalSigners"};
+    CallCounter get_total_bytes_recv_calls{"getTotalBytesRecv"};
+    CallCounter get_total_bytes_sent_calls{"getTotalBytesSent"};
+    CallCounter get_mempool_size_calls{"getMempoolSize"};
+    CallCounter get_mempool_dynamic_usage_calls{"getMempoolDynamicUsage"};
+    CallCounter get_mempool_max_usage_calls{"getMempoolMaxUsage"};
+    CallCounter get_header_tip_calls{"getHeaderTip"};
+    CallCounter get_num_blocks_calls{"getNumBlocks"};
+    CallCounter get_net_local_addresses_calls{"getNetLocalAddresses"};
+    CallCounter get_last_block_time_calls{"getLastBlockTime"};
+    CallCounter is_initial_block_download_calls{"isInitialBlockDownload"};
+    CallCounter get_network_active_calls{"getNetworkActive"};
+    CallCounter get_dust_relay_fee_calls{"getDustRelayFee"};
+    CallCounter broadcast_transaction_calls{"broadcastTransaction"};
+    CallCounter wallet_loader_calls{"walletLoader"};
+    CallCounter handle_message_box_calls{"handleMessageBox"};
+    CallCounter handle_question_calls{"handleQuestion"};
+    CallCounter handle_notify_num_connections_changed_calls{"handleNotifyNumConnectionsChanged"};
+    CallCounter handle_notify_network_active_changed_calls{"handleNotifyNetworkActiveChanged"};
+    CallCounter handle_notify_alert_changed_calls{"handleNotifyAlertChanged"};
+    CallCounter handle_banned_list_changed_calls{"handleBannedListChanged"};
+    CallCounter handle_notify_block_tip_calls{"handleNotifyBlockTip"};
+    CallCounter handle_notify_header_tip_calls{"handleNotifyHeaderTip"};
 
     std::vector<std::pair<std::string, common::SettingsValue>> update_rw_setting_arguments;
     std::vector<std::pair<std::string, common::SettingsValue>> force_setting_arguments;
@@ -233,7 +211,7 @@ class MockNode : public StubNode
         ++wallet_loader_calls;
         if (wallet_loader_fn) return wallet_loader_fn();
         UnexpectedCall("walletLoader");
-        return StubNode::walletLoader();
+        return FallbackWalletLoader();
     }
     std::unique_ptr<interfaces::Handler> handleMessageBox(MessageBoxFn fn) override { return Invoke(handle_message_box_calls, handle_message_box_fn, "handleMessageBox", std::unique_ptr<interfaces::Handler>{}, std::move(fn)); }
     std::unique_ptr<interfaces::Handler> handleQuestion(QuestionFn fn) override { return Invoke(handle_question_calls, handle_question_fn, "handleQuestion", std::unique_ptr<interfaces::Handler>{}, std::move(fn)); }
@@ -250,15 +228,52 @@ class MockNode : public StubNode
 private:
     struct CallExpectation
     {
-        const std::atomic<int>* calls;
+        const CallCounter* calls;
         int baseline;
         int minimum;
         std::optional<int> maximum;
-        std::string name;
+        std::source_location where;
     };
 
+    struct VerificationFailure
+    {
+        std::string message;
+        std::source_location where;
+    };
+
+    std::vector<VerificationFailure> VerificationFailures(std::source_location unexpected_where) const
+    {
+        std::vector<VerificationFailure> failures;
+        {
+            std::lock_guard<std::mutex> lock{m_unexpected_mutex};
+            if (!m_unexpected_calls.empty()) {
+                std::ostringstream message;
+                message << "Unexpected Node call(s):";
+                for (const std::string& call : m_unexpected_calls) message << "\n  " << call;
+                failures.push_back({message.str(), unexpected_where});
+            }
+        }
+        for (const CallExpectation& expectation : m_call_expectations) {
+            const int actual{expectation.calls->load() - expectation.baseline};
+            if (actual < expectation.minimum || (expectation.maximum && actual > *expectation.maximum)) {
+                std::ostringstream message;
+                message << "Expected " << expectation.calls->Name() << " calls to be ";
+                if (expectation.maximum && expectation.minimum == *expectation.maximum) {
+                    message << expectation.minimum;
+                } else if (expectation.maximum) {
+                    message << "between " << expectation.minimum << " and " << *expectation.maximum;
+                } else {
+                    message << "at least " << expectation.minimum;
+                }
+                message << ", actual " << actual;
+                failures.push_back({message.str(), expectation.where});
+            }
+        }
+        return failures;
+    }
+
     template <typename R, typename... FnArgs, typename... CallArgs>
-    R Invoke(std::atomic<int>& calls, const std::function<R(FnArgs...)>& fn, const char* name, R fallback, CallArgs&&... args)
+    R Invoke(CallCounter& calls, const std::function<R(FnArgs...)>& fn, const char* name, R fallback, CallArgs&&... args)
     {
         ++calls;
         if (fn) return fn(std::forward<CallArgs>(args)...);
@@ -267,7 +282,7 @@ class MockNode : public StubNode
     }
 
     template <typename... FnArgs, typename... CallArgs>
-    void InvokeVoid(std::atomic<int>& calls, const std::function<void(FnArgs...)>& fn, const char* name, CallArgs&&... args)
+    void InvokeVoid(CallCounter& calls, const std::function<void(FnArgs...)>& fn, const char* name, CallArgs&&... args)
     {
         ++calls;
         if (fn) {