18 files changed, 465 insertions, 40 deletions
diff --git a/tests/core_tests/transaction_tests.cpp b/tests/core_tests/transaction_tests.cpp
index d0b55dcf4..d19bdd1f9 100644
--- a/tests/core_tests/transaction_tests.cpp
+++ b/tests/core_tests/transaction_tests.cpp
@@ -78,8 +78,6 @@ bool test_transaction_generation_and_ring_signature()
   tx_source_entry& src = sources.back();
   src.amount = 70368744177663;
   {
-    tx_output_entry oe;
-
     src.push_output(0, boost::get<txout_to_key>(tx_mine_1.vout[0].target).key, src.amount);
 
     src.push_output(1, boost::get<txout_to_key>(tx_mine_2.vout[0].target).key, src.amount);
diff --git a/tests/core_tests/tx_pool.cpp b/tests/core_tests/tx_pool.cpp
index 1e496f3da..166eb6075 100644
--- a/tests/core_tests/tx_pool.cpp
+++ b/tests/core_tests/tx_pool.cpp
@@ -165,9 +165,6 @@ bool txpool_double_spend_base::timestamp_change_pause(cryptonote::core& /*c*/, s
 
 bool txpool_double_spend_base::check_changed(cryptonote::core& c, const size_t ev_index, relay_test condition)
 {
-  const std::size_t public_hash_count = m_broadcasted_hashes.size();
-  const std::size_t all_hash_count = m_all_hashes.size();
-
   const std::size_t new_broadcasted_hash_count = m_broadcasted_hashes.size() + unsigned(condition == relay_test::broadcasted);
   const std::size_t new_all_hash_count = m_all_hashes.size() + unsigned(condition == relay_test::hidden) + unsigned(condition == relay_test::no_relay);
 
@@ -393,7 +390,7 @@ bool txpool_double_spend_base::check_changed(cryptonote::core& c, const size_t e
     }
   }
 
-  for (const std::pair<crypto::hash, uint64_t>& hash : m_all_hashes)
+  for (const std::pair<const crypto::hash, uint64_t>& hash : m_all_hashes)
   {
     cryptonote::blobdata tx_blob{};
     if (!c.get_pool_transaction(hash.first, tx_blob, cryptonote::relay_category::all))
@@ -411,7 +408,7 @@ bool txpool_double_spend_base::check_changed(cryptonote::core& c, const size_t e
     for (const crypto::hash& hash : m_no_relay_hashes)
       difference.erase(hash);
 
-    for (const std::pair<crypto::hash, uint64_t>& hash : difference)
+    for (const std::pair<const crypto::hash, uint64_t>& hash : difference)
     {
       if (c.pool_has_tx(hash.first))
       {
diff --git a/tests/functional_tests/CMakeLists.txt b/tests/functional_tests/CMakeLists.txt
index 462fd4b77..7a50e9855 100644
--- a/tests/functional_tests/CMakeLists.txt
+++ b/tests/functional_tests/CMakeLists.txt
@@ -69,11 +69,10 @@ if (REQUESTS_OUTPUT STREQUAL "OK")
   add_test(
     NAME    functional_tests_rpc
     COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/functional_tests_rpc.py" "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" all)
+  add_test(
+    NAME    check_missing_rpc_methods
+    COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/check_missing_rpc_methods.py" "${CMAKE_SOURCE_DIR}")
 else()
-  message(WARNING "functional_tests_rpc skipped, needs the 'requests' python module")
-  set(CTEST_CUSTOM_TESTS_IGNORE ${CTEST_CUSTOM_TESTS_IGNORE} functional_tests_rpc)
+  message(WARNING "functional_tests_rpc and check_missing_rpc_methods skipped, needs the 'requests' python module")
+  set(CTEST_CUSTOM_TESTS_IGNORE ${CTEST_CUSTOM_TESTS_IGNORE} functional_tests_rpc check_missing_rpc_methods)
 endif()
-
-add_test(
-  NAME    check_missing_rpc_methods
-  COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/check_missing_rpc_methods.py" "${CMAKE_SOURCE_DIR}")
diff --git a/tests/functional_tests/mining.py b/tests/functional_tests/mining.py
index 1eb6b0ba7..50bfd32a2 100755
--- a/tests/functional_tests/mining.py
+++ b/tests/functional_tests/mining.py
@@ -97,7 +97,7 @@ class MiningTest():
         # wait till we mined a few of them
         target_height = prev_height + 5
         height = prev_height
-        timeout = 60 # randomx is slow to init
+        timeout = 240 # randomx is slow to init
         while height < target_height:
             seen_height = height
             for _ in range(timeout):
diff --git a/tests/functional_tests/transactions_flow_test.cpp b/tests/functional_tests/transactions_flow_test.cpp
index cec6825f5..3f5f90d3b 100644
--- a/tests/functional_tests/transactions_flow_test.cpp
+++ b/tests/functional_tests/transactions_flow_test.cpp
@@ -41,7 +41,6 @@ using namespace cryptonote;
 namespace
 {
   uint64_t const TEST_FEE = 5000000000; // 5 * 10^9
-  uint64_t const TEST_DUST_THRESHOLD = 5000000000; // 5 * 10^9
 }
 
 std::string generate_random_wallet_name()
diff --git a/tests/net_load_tests/srv.cpp b/tests/net_load_tests/srv.cpp
index 84d97ebd4..fabe14f49 100644
--- a/tests/net_load_tests/srv.cpp
+++ b/tests/net_load_tests/srv.cpp
@@ -169,7 +169,7 @@ namespace
       LOG_PRINT_L0("Closing connections. Number of opened connections: " << m_tcp_server.get_config_object().get_connections_count());
 
       size_t count = 0;
-      bool r = m_tcp_server.get_config_object().foreach_connection([&](test_connection_context& ctx) {
+      m_tcp_server.get_config_object().foreach_connection([&](test_connection_context& ctx) {
         if (ctx.m_connection_id != cmd_conn_id)
         {
           ++count;
diff --git a/tests/performance_tests/performance_tests.h b/tests/performance_tests/performance_tests.h
index ae7aabe08..7bedfdd4e 100644
--- a/tests/performance_tests/performance_tests.h
+++ b/tests/performance_tests/performance_tests.h
@@ -215,7 +215,6 @@ void run_test(const std::string &filter, Params &params, const char* test_name)
     if (params.stats)
     {
       uint64_t mins = min / scale;
-      uint64_t maxs = max / scale;
       uint64_t meds = med / scale;
       uint64_t p95s = quantiles[9] / scale;
       uint64_t stddevs = stddev / scale;
diff --git a/tests/unit_tests/bulletproofs.cpp b/tests/unit_tests/bulletproofs.cpp
index 7c6e459f5..ee617938c 100644
--- a/tests/unit_tests/bulletproofs.cpp
+++ b/tests/unit_tests/bulletproofs.cpp
@@ -296,7 +296,6 @@ TEST(bulletproof, weight_pruned)
     ASSERT_TRUE(tx.version == 2);
     ASSERT_FALSE(tx.pruned);
     ASSERT_TRUE(rct::is_rct_bulletproof(tx.rct_signatures.type));
-    const uint64_t tx_size = bd.size();
     const uint64_t tx_weight = cryptonote::get_transaction_weight(tx);
     ASSERT_TRUE(parse_and_validate_tx_base_from_blob(bd, pruned_tx));
     ASSERT_TRUE(pruned_tx.version == 2);
diff --git a/tests/unit_tests/crypto.cpp b/tests/unit_tests/crypto.cpp
index 7ac87ca7c..b550b35b0 100644
--- a/tests/unit_tests/crypto.cpp
+++ b/tests/unit_tests/crypto.cpp
@@ -33,6 +33,7 @@
 #include <string>
 
 #include "cryptonote_basic/cryptonote_basic_impl.h"
+#include "cryptonote_basic/merge_mining.h"
 
 namespace
 {
@@ -99,3 +100,215 @@ TEST(Crypto, verify_32)
     }
   }
 }
+
+TEST(Crypto, tree_branch)
+{
+  crypto::hash inputs[6];
+  crypto::hash branch[8];
+  crypto::hash root, root2;
+  size_t depth;
+  uint32_t path, path2;
+
+  auto hasher = [](const crypto::hash &h0, const crypto::hash &h1) -> crypto::hash
+  {
+    char buffer[64];
+    memcpy(buffer, &h0, 32);
+    memcpy(buffer + 32, &h1, 32);
+    crypto::hash res;
+    cn_fast_hash(buffer, 64, res);
+    return res;
+  };
+
+  for (int n = 0; n < 6; ++n)
+  {
+    memset(&inputs[n], 0, 32);
+    inputs[n].data[0] = n + 1;
+  }
+
+  // empty
+  ASSERT_FALSE(crypto::tree_branch((const char(*)[32])inputs, 0, crypto::null_hash.data, (char(*)[32])branch, &depth, &path));
+
+  // one, matching
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 1, inputs[0].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_EQ(depth, 0);
+  ASSERT_EQ(path, 0);
+  ASSERT_TRUE(crypto::tree_path(1, 0, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 1, root.data);
+  ASSERT_EQ(root, inputs[0]);
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // one, not found
+  ASSERT_FALSE(crypto::tree_branch((const char(*)[32])inputs, 1, inputs[1].data, (char(*)[32])branch, &depth, &path));
+
+  // two, index 0
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 2, inputs[0].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_EQ(depth, 1);
+  ASSERT_EQ(path, 0);
+  ASSERT_TRUE(crypto::tree_path(2, 0, &path2));
+  ASSERT_EQ(path, path2);
+  ASSERT_EQ(branch[0], inputs[1]);
+  crypto::tree_hash((const char(*)[32])inputs, 2, root.data);
+  ASSERT_EQ(root, hasher(inputs[0], inputs[1]));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // two, index 1
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 2, inputs[1].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_EQ(depth, 1);
+  ASSERT_EQ(path, 1);
+  ASSERT_TRUE(crypto::tree_path(2, 1, &path2));
+  ASSERT_EQ(path, path2);
+  ASSERT_EQ(branch[0], inputs[0]);
+  crypto::tree_hash((const char(*)[32])inputs, 2, root.data);
+  ASSERT_EQ(root, hasher(inputs[0], inputs[1]));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // two, not found
+  ASSERT_FALSE(crypto::tree_branch((const char(*)[32])inputs, 2, inputs[2].data, (char(*)[32])branch, &depth, &path));
+
+  // a b c 0
+  //  x   y
+  //    z
+
+  // three, index 0
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 3, inputs[0].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 1);
+  ASSERT_LE(depth, 2);
+  ASSERT_TRUE(crypto::tree_path(3, 0, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 3, root.data);
+  ASSERT_EQ(root, hasher(inputs[0], hasher(inputs[1], inputs[2])));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // three, index 1
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 3, inputs[1].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 1);
+  ASSERT_LE(depth, 2);
+  ASSERT_TRUE(crypto::tree_path(3, 1, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 3, root.data);
+  ASSERT_EQ(root, hasher(inputs[0], hasher(inputs[1], inputs[2])));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // three, index 2
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 3, inputs[2].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 1);
+  ASSERT_LE(depth, 2);
+  ASSERT_TRUE(crypto::tree_path(3, 2, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 3, root.data);
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::tree_branch_hash(inputs[2].data, (const char(*)[32])branch, depth, path, root2.data));
+  ASSERT_EQ(root, root2);
+
+  // three, not found
+  ASSERT_FALSE(crypto::tree_branch((const char(*)[32])inputs, 3, inputs[3].data, (char(*)[32])branch, &depth, &path));
+
+  // a b c d e 0 0 0
+  //    x   y
+  //      z
+  //    w
+
+  // five, index 0
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 5, inputs[0].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 2);
+  ASSERT_LE(depth, 3);
+  ASSERT_TRUE(crypto::tree_path(5, 0, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 5, root.data);
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[5].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // five, index 1
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 5, inputs[1].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 2);
+  ASSERT_LE(depth, 3);
+  ASSERT_TRUE(crypto::tree_path(5, 1, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 5, root.data);
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[5].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // five, index 2
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 5, inputs[2].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 2);
+  ASSERT_LE(depth, 3);
+  ASSERT_TRUE(crypto::tree_path(5, 2, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 5, root.data);
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[5].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  // five, index 4
+  ASSERT_TRUE(crypto::tree_branch((const char(*)[32])inputs, 5, inputs[4].data, (char(*)[32])branch, &depth, &path));
+  ASSERT_GE(depth, 2);
+  ASSERT_LE(depth, 3);
+  ASSERT_TRUE(crypto::tree_path(5, 4, &path2));
+  ASSERT_EQ(path, path2);
+  crypto::tree_hash((const char(*)[32])inputs, 5, root.data);
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[0].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[1].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[2].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[3].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_TRUE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[5].data, root.data, (const char(*)[32])branch, depth, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(crypto::null_hash.data, root.data, (const char(*)[32])branch, depth, path));
+
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth - 1, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth + 1, path));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path ^ 1));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path ^ 2));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])branch, depth, path ^ 3));
+  ASSERT_FALSE(crypto::is_branch_in_tree(inputs[4].data, root.data, (const char(*)[32])(branch + 1), depth, path));
+
+  // five, not found
+  ASSERT_FALSE(crypto::tree_branch((const char(*)[32])inputs, 5, crypto::null_hash.data, (char(*)[32])branch, &depth, &path));
+
+  // depth encoding roundtrip
+  for (uint32_t n_chains = 1; n_chains <= 65; ++n_chains)
+  {
+    for (uint32_t nonce = 0; nonce < 1024; ++nonce)
+    {
+      const uint32_t depth = cryptonote::encode_mm_depth(n_chains, nonce);
+      uint32_t n_chains_2, nonce_2;
+      ASSERT_TRUE(cryptonote::decode_mm_depth(depth, n_chains_2, nonce_2));
+      ASSERT_EQ(n_chains, n_chains_2);
+      ASSERT_EQ(nonce, nonce_2);
+    }
+  }
+}
diff --git a/tests/unit_tests/epee_boosted_tcp_server.cpp b/tests/unit_tests/epee_boosted_tcp_server.cpp
index 71098f612..06e076a3a 100644
--- a/tests/unit_tests/epee_boosted_tcp_server.cpp
+++ b/tests/unit_tests/epee_boosted_tcp_server.cpp
@@ -37,6 +37,7 @@
 #include "include_base_utils.h"
 #include "string_tools.h"
 #include "net/abstract_tcp_server2.h"
+#include "net/levin_protocol_handler_async.h"
 
 namespace
 {
@@ -132,3 +133,223 @@ TEST(boosted_tcp_server, worker_threads_are_exception_resistant)
   ASSERT_TRUE(srv.timed_wait_server_stop(5 * 1000));
   ASSERT_TRUE(srv.deinit_server());
 }
+
+
+TEST(test_epee_connection, test_lifetime)
+{
+  struct context_t: epee::net_utils::connection_context_base {
+    static constexpr size_t get_max_bytes(int) noexcept { return -1; }
+    static constexpr int handshake_command() noexcept { return 1001; }
+    static constexpr bool handshake_complete() noexcept { return true; }
+  };
+
+  using functional_obj_t = std::function<void ()>;
+  struct command_handler_t: epee::levin::levin_commands_handler<context_t> {
+    size_t delay;
+    functional_obj_t on_connection_close_f;
+    command_handler_t(size_t delay = 0,
+      functional_obj_t on_connection_close_f = nullptr
+    ):
+      delay(delay),
+      on_connection_close_f(on_connection_close_f)
+    {}
+    virtual int invoke(int, const epee::span<const uint8_t>, epee::byte_slice&, context_t&) override { epee::misc_utils::sleep_no_w(delay); return {}; }
+    virtual int notify(int, const epee::span<const uint8_t>, context_t&) override { return {}; }
+    virtual void callback(context_t&) override {}
+    virtual void on_connection_new(context_t&) override {}
+    virtual void on_connection_close(context_t&) override {
+      if (on_connection_close_f)
+        on_connection_close_f();
+    }
+    virtual ~command_handler_t() override {}
+    static void destroy(epee::levin::levin_commands_handler<context_t>* ptr) { delete ptr; }
+  };
+
+  using handler_t = epee::levin::async_protocol_handler<context_t>;
+  using connection_t = epee::net_utils::connection<handler_t>;
+  using connection_ptr = boost::shared_ptr<connection_t>;
+  using shared_state_t = typename connection_t::shared_state;
+  using shared_state_ptr = std::shared_ptr<shared_state_t>;
+  using tag_t = boost::uuids::uuid;
+  using tags_t = std::vector<tag_t>;
+  using io_context_t = boost::asio::io_service;
+  using endpoint_t = boost::asio::ip::tcp::endpoint;
+  using work_t = boost::asio::io_service::work;
+  using work_ptr = std::shared_ptr<work_t>;
+  using workers_t = std::vector<std::thread>;
+  using server_t = epee::net_utils::boosted_tcp_server<handler_t>;
+  using lock_t = std::mutex;
+  using lock_guard_t = std::lock_guard<lock_t>;
+  using connection_weak_ptr = boost::weak_ptr<connection_t>;
+  struct shared_conn_t {
+    lock_t lock;
+    connection_weak_ptr conn;
+  };
+  using shared_conn_ptr = std::shared_ptr<shared_conn_t>;
+
+  io_context_t io_context;
+  work_ptr work(std::make_shared<work_t>(io_context));
+
+  workers_t workers;
+  while (workers.size() < 4) {
+    workers.emplace_back([&io_context]{
+      io_context.run();
+    });
+  }
+
+  endpoint_t endpoint(boost::asio::ip::address::from_string("127.0.0.1"), 5262);
+  server_t server(epee::net_utils::e_connection_type_P2P);
+  server.init_server(endpoint.port(),
+    endpoint.address().to_string(),
+    0,
+    "",
+    false,
+    true,
+    epee::net_utils::ssl_support_t::e_ssl_support_disabled
+  );
+  server.run_server(2, false);
+  server.get_config_shared()->set_handler(new command_handler_t, &command_handler_t::destroy);
+
+  io_context.post([&io_context, &work, &endpoint, &server]{
+    auto scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&work]{
+      work.reset();
+    });
+
+    shared_state_ptr shared_state(std::make_shared<shared_state_t>());
+    shared_state->set_handler(new command_handler_t, &command_handler_t::destroy);
+
+    auto create_connection = [&io_context, &endpoint, &shared_state] {
+        connection_ptr conn(new connection_t(io_context, shared_state, {}, {}));
+        conn->socket().connect(endpoint);
+        conn->start({}, {});
+        context_t context;
+        conn->get_context(context);
+        auto tag = context.m_connection_id;
+        return tag;
+    };
+
+    ASSERT_TRUE(shared_state->get_connections_count() == 0);
+    auto tag = create_connection();
+    ASSERT_TRUE(shared_state->get_connections_count() == 1);
+    bool success = shared_state->for_connection(tag, [shared_state](context_t& context){
+      shared_state->close(context.m_connection_id);
+      context.m_remote_address.get_zone();
+      return true;
+    });
+    ASSERT_TRUE(success);
+
+    ASSERT_TRUE(shared_state->get_connections_count() == 0);
+    constexpr auto N = 8;
+    tags_t tags(N);
+    for(auto &t: tags)
+      t = create_connection();
+    ASSERT_TRUE(shared_state->get_connections_count() == N);
+    size_t index = 0;
+    success = shared_state->foreach_connection([&index, shared_state, &tags, &create_connection](context_t& context){
+      if (!index)
+        for (const auto &t: tags)
+          shared_state->close(t);
+
+      shared_state->close(context.m_connection_id);
+      context.m_remote_address.get_zone();
+      ++index;
+
+      for(auto i = 0; i < N; ++i)
+        create_connection();
+      return true;
+    });
+    ASSERT_TRUE(success);
+    ASSERT_TRUE(index == N);
+    ASSERT_TRUE(shared_state->get_connections_count() == N * N);
+
+    index = 0;
+    success = shared_state->foreach_connection([&index, shared_state](context_t& context){
+      shared_state->close(context.m_connection_id);
+      context.m_remote_address.get_zone();
+      ++index;
+      return true;
+    });
+    ASSERT_TRUE(success);
+    ASSERT_TRUE(index == N * N);
+    ASSERT_TRUE(shared_state->get_connections_count() == 0);
+
+    while (shared_state->sock_count);
+    ASSERT_TRUE(shared_state->get_connections_count() == 0);
+    constexpr auto DELAY = 30;
+    constexpr auto TIMEOUT = 1;
+    server.get_config_shared()->set_handler(new command_handler_t(DELAY), &command_handler_t::destroy);
+    for (auto i = 0; i < N; ++i) {
+      tag = create_connection();
+      ASSERT_TRUE(shared_state->get_connections_count() == 1);
+      success = shared_state->invoke_async(1, {}, tag, [](int, const epee::span<const uint8_t>, context_t&){}, TIMEOUT);
+      ASSERT_TRUE(success);
+      while (shared_state->sock_count == 1) {
+        success = shared_state->foreach_connection([&shared_state, &tag](context_t&){
+          return shared_state->request_callback(tag);
+        });
+        ASSERT_TRUE(success);
+      }
+      shared_state->close(tag);
+      ASSERT_TRUE(shared_state->get_connections_count() == 0);
+    }
+
+    while (shared_state->sock_count);
+    constexpr auto ZERO_DELAY = 0;
+    size_t counter = 0;
+    shared_state->set_handler(new command_handler_t(ZERO_DELAY,
+        [&counter]{
+          ASSERT_TRUE(counter++ == 0);
+        }
+      ),
+      &command_handler_t::destroy
+    );
+    connection_ptr conn(new connection_t(io_context, shared_state, {}, {}));
+    conn->socket().connect(endpoint);
+    conn->start({}, {});
+    ASSERT_TRUE(shared_state->get_connections_count() == 1);
+    shared_state->del_out_connections(1);
+    ASSERT_TRUE(shared_state->get_connections_count() == 0);
+    conn.reset();
+
+    while (shared_state->sock_count);
+    shared_conn_ptr shared_conn(std::make_shared<shared_conn_t>());
+    shared_state->set_handler(new command_handler_t(ZERO_DELAY,
+        [shared_state, shared_conn]{
+          {
+            connection_ptr conn;
+            {
+              lock_guard_t guard(shared_conn->lock);
+              conn = std::move(shared_conn->conn.lock());
+            }
+            if (conn)
+              conn->cancel();
+          }
+          const auto success = shared_state->foreach_connection([](context_t&){
+            return true;
+          });
+          ASSERT_TRUE(success);
+        }
+      ),
+      &command_handler_t::destroy
+    );
+    for (auto i = 0; i < N; ++i) {
+      {
+        connection_ptr conn(new connection_t(io_context, shared_state, {}, {}));
+        conn->socket().connect(endpoint);
+        conn->start({}, {});
+        lock_guard_t guard(shared_conn->lock);
+        shared_conn->conn = conn;
+      }
+      ASSERT_TRUE(shared_state->get_connections_count() == 1);
+      shared_state->del_out_connections(1);
+      ASSERT_TRUE(shared_state->get_connections_count() == 0);
+    }
+  });
+
+  for (auto& w: workers) {
+    w.join();
+  }
+  server.send_stop_signal();
+  server.timed_wait_server_stop(5 * 1000);
+  server.deinit_server();
+}
diff --git a/tests/unit_tests/epee_serialization.cpp b/tests/unit_tests/epee_serialization.cpp
index cade16f0d..95a2b6ecd 100644
--- a/tests/unit_tests/epee_serialization.cpp
+++ b/tests/unit_tests/epee_serialization.cpp
@@ -30,6 +30,7 @@
 #include <gtest/gtest.h>
 
 #include "storages/portable_storage.h"
+#include "span.h"
 
 TEST(epee_binary, two_keys)
 {
diff --git a/tests/unit_tests/epee_utils.cpp b/tests/unit_tests/epee_utils.cpp
index 256f8c3c2..cbe3c61b1 100644
--- a/tests/unit_tests/epee_utils.cpp
+++ b/tests/unit_tests/epee_utils.cpp
@@ -1115,11 +1115,13 @@ TEST(ByteStream, ToByteSlice)
 
   epee::byte_stream stream;
 
+  stream.reserve(128*1024);
   stream.write(source);
   EXPECT_EQ(sizeof(source), stream.size());
+  EXPECT_EQ(128*1024, stream.capacity());
   EXPECT_TRUE(equal(source, byte_span{stream.data(), stream.size()}));
 
-  const epee::byte_slice slice{std::move(stream)};
+  const epee::byte_slice slice{std::move(stream), true};
   EXPECT_EQ(0u, stream.size());
   EXPECT_EQ(0u, stream.available());
   EXPECT_EQ(0u, stream.capacity());
diff --git a/tests/unit_tests/hardfork.cpp b/tests/unit_tests/hardfork.cpp
index 6d7e9a8aa..912651de4 100644
--- a/tests/unit_tests/hardfork.cpp
+++ b/tests/unit_tests/hardfork.cpp
@@ -432,7 +432,6 @@ TEST(voting, info)
 
   //                                             0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9
   static const uint8_t block_versions[]      = { 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4 };
-  static const uint8_t expected_versions[]   = { 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4 };
   static const uint8_t expected_thresholds[] = { 0, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 2, 2, 2, 2 };
 
   for (uint64_t h = 0; h < sizeof(block_versions) / sizeof(block_versions[0]); ++h) {
diff --git a/tests/unit_tests/net.cpp b/tests/unit_tests/net.cpp
index dffda5e4e..2836fd948 100644
--- a/tests/unit_tests/net.cpp
+++ b/tests/unit_tests/net.cpp
@@ -1351,7 +1351,7 @@ TEST(dandelionpp_map, dropped_connection)
         }
 
         EXPECT_EQ(3u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(3u, entry.second);
 
         for (const boost::uuids::uuid& connection : in_connections)
@@ -1409,7 +1409,7 @@ TEST(dandelionpp_map, dropped_connection)
         }
 
         EXPECT_EQ(3u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(3u, entry.second);
     }
     {
@@ -1472,7 +1472,7 @@ TEST(dandelionpp_map, dropped_connection_remapped)
         }
 
         EXPECT_EQ(3u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(3u, entry.second);
 
         for (const boost::uuids::uuid& connection : in_connections)
@@ -1511,7 +1511,7 @@ TEST(dandelionpp_map, dropped_connection_remapped)
         }
 
         EXPECT_EQ(2u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(5u, entry.second);
     }
     // select 3 of 3 connections but do not remap existing links
@@ -1532,7 +1532,7 @@ TEST(dandelionpp_map, dropped_connection_remapped)
         }
 
         EXPECT_EQ(2u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(5u, entry.second);
     }
     // map 8 new incoming connections across 3 outgoing links
@@ -1555,7 +1555,7 @@ TEST(dandelionpp_map, dropped_connection_remapped)
         }
 
         EXPECT_EQ(3u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(6u, entry.second);
     }
 }
@@ -1609,7 +1609,7 @@ TEST(dandelionpp_map, dropped_all_connections)
         }
 
         EXPECT_EQ(3u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(3u, entry.second);
 
         for (const boost::uuids::uuid& connection : in_connections)
@@ -1641,7 +1641,7 @@ TEST(dandelionpp_map, dropped_all_connections)
         }
 
         EXPECT_EQ(3u, used.size());
-        for (const std::pair<boost::uuids::uuid, std::size_t>& entry : used)
+        for (const std::pair<const boost::uuids::uuid, std::size_t>& entry : used)
             EXPECT_EQ(3u, entry.second);
     }
 }
diff --git a/tests/unit_tests/node_server.cpp b/tests/unit_tests/node_server.cpp
index 4d6f09e69..af297d01a 100644
--- a/tests/unit_tests/node_server.cpp
+++ b/tests/unit_tests/node_server.cpp
@@ -250,7 +250,6 @@ TEST(ban, subnet)
 
 TEST(ban, ignores_port)
 {
-  time_t seconds;
   test_core pr_core;
   cryptonote::t_cryptonote_protocol_handler<test_core> cprotocol(pr_core, NULL);
   Server server(cprotocol);
diff --git a/tests/unit_tests/output_selection.cpp b/tests/unit_tests/output_selection.cpp
index cff509451..20dc58e03 100644
--- a/tests/unit_tests/output_selection.cpp
+++ b/tests/unit_tests/output_selection.cpp
@@ -206,7 +206,7 @@ TEST(select_outputs, same_distribution)
   for (size_t i = 0; i < chain_picks.size(); ++i)
     chain_norm[i * 100 / chain_picks.size()] += chain_picks[i];
 
-  double max_dev = 0.0, avg_dev = 0.0;
+  double avg_dev = 0.0;
   for (size_t i = 0; i < 100; ++i)
   {
     const double diff = (double)output_norm[i] - (double)chain_norm[i];
diff --git a/tests/unit_tests/wipeable_string.cpp b/tests/unit_tests/wipeable_string.cpp
index 9911bd6f4..0e0bf8906 100644
--- a/tests/unit_tests/wipeable_string.cpp
+++ b/tests/unit_tests/wipeable_string.cpp
@@ -189,20 +189,20 @@ TEST(wipeable_string, parse_hexstr)
 {
   boost::optional<epee::wipeable_string> s;
 
-  ASSERT_EQ(boost::none, epee::wipeable_string("x").parse_hexstr());
-  ASSERT_EQ(boost::none, epee::wipeable_string("x0000000000000000").parse_hexstr());
-  ASSERT_EQ(boost::none, epee::wipeable_string("0000000000000000x").parse_hexstr());
-  ASSERT_EQ(boost::none, epee::wipeable_string("0").parse_hexstr());
-  ASSERT_EQ(boost::none, epee::wipeable_string("000").parse_hexstr());
+  ASSERT_TRUE(boost::none == epee::wipeable_string("x").parse_hexstr());
+  ASSERT_TRUE(boost::none == epee::wipeable_string("x0000000000000000").parse_hexstr());
+  ASSERT_TRUE(boost::none == epee::wipeable_string("0000000000000000x").parse_hexstr());
+  ASSERT_TRUE(boost::none == epee::wipeable_string("0").parse_hexstr());
+  ASSERT_TRUE(boost::none == epee::wipeable_string("000").parse_hexstr());
 
   ASSERT_TRUE((s = epee::wipeable_string("").parse_hexstr()) != boost::none);
-  ASSERT_EQ(*s, "");
+  ASSERT_TRUE(*s == "");
   ASSERT_TRUE((s = epee::wipeable_string("00").parse_hexstr()) != boost::none);
-  ASSERT_EQ(*s, epee::wipeable_string("", 1));
+  ASSERT_TRUE(*s == epee::wipeable_string("", 1));
   ASSERT_TRUE((s = epee::wipeable_string("41").parse_hexstr()) != boost::none);
-  ASSERT_EQ(*s, epee::wipeable_string("A"));
+  ASSERT_TRUE(*s == epee::wipeable_string("A"));
   ASSERT_TRUE((s = epee::wipeable_string("414243").parse_hexstr()) != boost::none);
-  ASSERT_EQ(*s, epee::wipeable_string("ABC"));
+  ASSERT_TRUE(*s == epee::wipeable_string("ABC"));
 }
 
 TEST(wipeable_string, to_hex)
diff --git a/tests/unit_tests/zmq_rpc.cpp b/tests/unit_tests/zmq_rpc.cpp
index 59759bed8..66a7f3ac1 100644
--- a/tests/unit_tests/zmq_rpc.cpp
+++ b/tests/unit_tests/zmq_rpc.cpp
@@ -202,7 +202,6 @@ namespace
     MASSERT(!expected.empty());
 
     std::size_t actual_height = 0;
-    crypto::hash actual_id{};
     crypto::hash actual_prev_id{};
     std::vector<crypto::hash> actual_ids{};
     GET_FROM_JSON_OBJECT(pub.second, actual_height, first_height);