diff --git a/nano/core_test/active_elections.cpp b/nano/core_test/active_elections.cpp index 9818755d..597a2a86 100644 --- a/nano/core_test/active_elections.cpp +++ b/nano/core_test/active_elections.cpp @@ -437,6 +437,7 @@ TEST (inactive_votes_cache, election_start) nano::test::system system; nano::node_config node_config = system.default_config (); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + node_config.priority_scheduler.enabled = false; node_config.optimistic_scheduler.enabled = false; auto & node = *system.add_node (node_config); nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 04b1cde9..98c61c52 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -291,7 +291,7 @@ TEST (bootstrap_processor, process_none) auto node0 = system.nodes[0]; auto node1 = system.make_disconnected_node (); - bool done = false; + std::atomic done = false; node0->observers.socket_connected.add ([&] (nano::transport::socket & socket) { done = true; }); @@ -1652,10 +1652,6 @@ TEST (bootstrap_processor, multiple_attempts) auto lazy_attempt (node2->bootstrap_initiator.current_lazy_attempt ()); auto legacy_attempt (node2->bootstrap_initiator.current_attempt ()); ASSERT_TIMELY (5s, lazy_attempt->started && legacy_attempt->started); - // Check that both bootstrap attempts are running & not finished - ASSERT_FALSE (lazy_attempt->stopped); - ASSERT_FALSE (legacy_attempt->stopped); - ASSERT_GE (node2->bootstrap_initiator.attempts.size (), 2); // Check processed blocks ASSERT_TIMELY (10s, node2->balance (key2.pub) != 0); // Check attempts finish diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index d84ac7da..a0bdefd3 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -411,7 +411,6 @@ TEST (receivable_processor, send_with_receive) nano::keypair key2; system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub)); - system.wallet (1)->insert_adhoc (key2.prv); nano::block_builder builder; auto block1 = builder .send () @@ -433,6 +432,7 @@ TEST (receivable_processor, send_with_receive) ASSERT_EQ (0, node1.balance (key2.pub)); ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node2.balance (key2.pub)); + system.wallet (1)->insert_adhoc (key2.prv); ASSERT_TIMELY (10s, node1.balance (key2.pub) == node1.config.receive_minimum.number () && node2.balance (key2.pub) == node1.config.receive_minimum.number ()); ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (node1.config.receive_minimum.number (), node1.balance (key2.pub)); @@ -644,9 +644,9 @@ TEST (network, peer_max_tcp_attempts) // Start TCP attempt node->network.merge_peer (node2->network.endpoint ()); } - ASSERT_EQ (0, node->network.size ()); + ASSERT_TIMELY_EQ (30s, node->network.size (), node->network_params.network.max_peers_per_ip); ASSERT_FALSE (node->network.tcp_channels.track_reachout (nano::endpoint (node->network.endpoint ().address (), system.get_available_port ()))); - ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::max_per_ip, nano::stat::dir::out)); + ASSERT_LE (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::max_per_ip, nano::stat::dir::out)); } #endif @@ -896,15 +896,16 @@ TEST (network, cleanup_purge) node1.network.cleanup (std::chrono::steady_clock::now ()); ASSERT_EQ (0, node1.network.size ()); - std::weak_ptr node_w = node1.shared (); - node1.network.tcp_channels.start_tcp (node2->network.endpoint ()); + node1.network.merge_peer (node2->network.endpoint ()); + + ASSERT_TIMELY_EQ (5s, node1.network.size (), 1); - ASSERT_TIMELY_EQ (3s, node1.network.size (), 1); node1.network.cleanup (test_start); ASSERT_EQ (1, node1.network.size ()); + ASSERT_EQ (0, node1.stats.count (nano::stat::type::tcp_channels_purge)); node1.network.cleanup (std::chrono::steady_clock::now ()); - ASSERT_TIMELY_EQ (5s, 0, node1.network.size ()); + ASSERT_EQ (1, node1.stats.count (nano::stat::type::tcp_channels_purge, nano::stat::detail::idle)); } TEST (network, loopback_channel) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 5ccf56c2..8614b66e 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -276,7 +276,6 @@ TEST (node, auto_bootstrap) node1->start (); system.nodes.push_back (node1); ASSERT_NE (nullptr, nano::test::establish_tcp (system, *node1, node0->network.endpoint ())); - ASSERT_TIMELY (10s, node1->bootstrap_initiator.in_progress ()); ASSERT_TIMELY_EQ (10s, node1->balance (key2.pub), node0->config.receive_minimum.number ()); ASSERT_TIMELY (10s, !node1->bootstrap_initiator.in_progress ()); ASSERT_TRUE (node1->block_or_pruned_exists (send1->hash ())); @@ -322,7 +321,6 @@ TEST (node, auto_bootstrap_age) node1->start (); system.nodes.push_back (node1); ASSERT_NE (nullptr, nano::test::establish_tcp (system, *node1, node0->network.endpoint ())); - ASSERT_TIMELY (10s, node1->bootstrap_initiator.in_progress ()); // 4 bootstraps with frontiers age ASSERT_TIMELY (10s, node0->stats.count (nano::stat::type::bootstrap, nano::stat::detail::initiate_legacy_age, nano::stat::dir::out) >= 3); // More attempts with frontiers age diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp index b55150d5..d51b7b4c 100644 --- a/nano/core_test/peer_container.cpp +++ b/nano/core_test/peer_container.cpp @@ -215,6 +215,10 @@ TEST (peer_container, list_fanout) TEST (peer_container, reachout) { nano::test::system system; + nano::node_config node_config = system.default_config (); + // Disable automatic reachout + node_config.network.cached_peer_reachout = 0s; + node_config.network.peer_reachout = 0s; nano::node_flags node_flags; auto & node1 = *system.add_node (node_flags); auto outer_node1 = nano::test::add_outer_node (system); @@ -222,6 +226,7 @@ TEST (peer_container, reachout) // Make sure having been contacted by them already indicates we shouldn't reach out ASSERT_FALSE (node1.network.track_reachout (outer_node1->network.endpoint ())); auto outer_node2 = nano::test::add_outer_node (system); + auto outer_node2_endpoint = outer_node2->network.endpoint (); ASSERT_TRUE (node1.network.track_reachout (outer_node2->network.endpoint ())); ASSERT_NE (nullptr, nano::test::establish_tcp (system, node1, outer_node2->network.endpoint ())); // Reaching out to them once should signal we shouldn't reach out again. @@ -230,9 +235,11 @@ TEST (peer_container, reachout) node1.network.cleanup (std::chrono::steady_clock::now () - std::chrono::seconds (10)); ASSERT_FALSE (node1.network.track_reachout (outer_node2->network.endpoint ())); // Make sure we purge old items + outer_node1->stop (); + outer_node2->stop (); node1.network.cleanup (std::chrono::steady_clock::now () + std::chrono::seconds (10)); ASSERT_TIMELY (5s, node1.network.empty ()); - ASSERT_TRUE (node1.network.track_reachout (outer_node2->network.endpoint ())); + ASSERT_TRUE (node1.network.track_reachout (outer_node2_endpoint)); } // This test is similar to network.filter_invalid_version_using with the difference that diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 316ea8f0..7bca7846 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -100,28 +100,28 @@ TEST (request_aggregator, one_update) .work (*node.work_generate_blocking (key1.pub)) .build (); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.ledger.tx_begin_write (), receive1)); - std::vector> request; - request.emplace_back (send2->hash (), send2->root ()); - auto client = std::make_shared (node); - std::shared_ptr dummy_channel = std::make_shared (node, client); - node.aggregator.request (request, dummy_channel); - request.clear (); - request.emplace_back (receive1->hash (), receive1->root ()); + + auto dummy_channel = nano::test::fake_channel (node); + + std::vector> request1{ { send2->hash (), send2->root () } }; + node.aggregator.request (request1, dummy_channel); + // Update the pool of requests with another hash - node.aggregator.request (request, dummy_channel); + std::vector> request2{ { receive1->hash (), receive1->root () } }; + node.aggregator.request (request2, dummy_channel); + // In the ledger but no vote generated yet ASSERT_TIMELY (3s, 0 < node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes)) ASSERT_TRUE (node.aggregator.empty ()); ASSERT_TIMELY_EQ (3s, 2, node.stats.count (nano::stat::type::aggregator, nano::stat::detail::aggregator_accepted)); - ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::aggregator, nano::stat::detail::aggregator_dropped)); - ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown)); ASSERT_TIMELY_EQ (3s, 2, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_hashes)); - size_t count = 0; - ASSERT_TIMELY_EQ (3s, 1, (count = node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes))); - ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_hashes)); - ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_votes)); - ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cannot_vote)); - ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); + ASSERT_EQ (0, node.stats.count (nano::stat::type::aggregator, nano::stat::detail::aggregator_dropped)); + ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown)); + + ASSERT_TIMELY (3s, 0 < node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes)); + ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_hashes)); + ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_votes)); + ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cannot_vote)); } TEST (request_aggregator, two) diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp index 42e8bf54..8880a836 100644 --- a/nano/core_test/socket.cpp +++ b/nano/core_test/socket.cpp @@ -11,6 +11,7 @@ #include +#include #include #include #include @@ -27,8 +28,6 @@ TEST (socket, max_connections) nano::inactive_node inactivenode (nano::unique_path (), node_flags); auto node = inactivenode.node; - nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 }; - auto server_port = system.get_available_port (); // successful incoming connections are stored in server_sockets to keep them alive (server side) @@ -135,8 +134,6 @@ TEST (socket, max_connections_per_ip) auto node = inactivenode.node; ASSERT_FALSE (node->flags.disable_max_peers_per_ip); - nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 }; - auto server_port = system.get_available_port (); const auto max_ip_connections = node->network_params.network.max_peers_per_ip; @@ -252,8 +249,6 @@ TEST (socket, max_connections_per_subnetwork) ASSERT_TRUE (node->flags.disable_max_peers_per_ip); ASSERT_FALSE (node->flags.disable_max_peers_per_subnetwork); - nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 }; - auto server_port = system.get_available_port (); boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; @@ -311,8 +306,6 @@ TEST (socket, disabled_max_peers_per_ip) ASSERT_TRUE (node->flags.disable_max_peers_per_ip); - nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 }; - auto server_port = system.get_available_port (); const auto max_ip_connections = node->network_params.network.max_peers_per_ip; @@ -370,9 +363,10 @@ TEST (socket, disconnection_of_silent_connections) auto node = system.add_node (config); // On a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test. - std::shared_ptr server_data_socket; - node->tcp_listener.connection_accepted.add ([&server_data_socket] (auto const & socket, auto const & server) { - server_data_socket = socket; + std::promise> server_data_socket_promise; + std::future> server_data_socket_future = server_data_socket_promise.get_future (); + node->tcp_listener.connection_accepted.add ([&server_data_socket_promise] (auto const & socket, auto const & server) { + server_data_socket_promise.set_value (socket); }); boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), node->tcp_listener.endpoint ().port () }; @@ -386,8 +380,10 @@ TEST (socket, disconnection_of_silent_connections) connected = true; }); ASSERT_TIMELY (4s, connected); + // Checking the connection was closed. - ASSERT_TIMELY (10s, server_data_socket != nullptr); + ASSERT_TIMELY (10s, server_data_socket_future.wait_for (0s) == std::future_status::ready); + auto server_data_socket = server_data_socket_future.get (); ASSERT_TIMELY (10s, server_data_socket->is_closed ()); // Just to ensure the disconnection wasn't due to the timer timeout. @@ -405,8 +401,6 @@ TEST (socket, drop_policy) nano::inactive_node inactivenode (nano::unique_path (), node_flags); auto node = inactivenode.node; - nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 }; - std::vector> connections; auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) { @@ -454,12 +448,10 @@ TEST (socket, drop_policy) // The stats are accumulated from before ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out)); ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out)); - - node->stop (); - runner.abort (); - runner.join (); } +// This is abusing the socket class, it's interfering with the normal node lifetimes and as a result deadlocks +// TEST (socket, DISABLED_concurrent_writes) TEST (socket, concurrent_writes) { nano::test::system system; @@ -471,10 +463,6 @@ TEST (socket, concurrent_writes) nano::inactive_node inactivenode (nano::unique_path (), node_flags); auto node = inactivenode.node; - // This gives more realistic execution than using system#poll, allowing writes to - // queue up and drain concurrently. - nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 }; - constexpr size_t max_connections = 4; constexpr size_t client_count = max_connections; constexpr size_t message_count = 4; @@ -567,10 +555,6 @@ TEST (socket, concurrent_writes) ASSERT_TIMELY_EQ (10s, completed_reads, total_message_count); - node->stop (); - runner.abort (); - runner.join (); - for (auto & t : client_threads) { t.join (); diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index aafeda27..b4070ca8 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -83,13 +83,7 @@ TEST (wallet, status_with_peer) }; // Because of the wallet "vulnerable" message, this won't be the message displayed. // However, it will still be part of the status set. - ASSERT_FALSE (wallet_has (nano_qt::status_types::synchronizing)); system.deadline_set (25s); - while (!wallet_has (nano_qt::status_types::synchronizing)) - { - test_application->processEvents (); - ASSERT_NO_ERROR (system.poll ()); - } system.nodes[0]->network.cleanup (std::chrono::steady_clock::now () + std::chrono::seconds (5)); while (wallet_has (nano_qt::status_types::synchronizing)) { diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 3093ca9a..7387f4ce 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -6453,7 +6453,8 @@ TEST (rpc, epoch_upgrade_multithreaded) } } -TEST (rpc, account_lazy_start) +// FIXME: This test is testing legacy bootstrap, the current behavior is different +TEST (rpc, DISABLED_account_lazy_start) { nano::test::system system{}; nano::node_flags node_flags{}; @@ -6650,7 +6651,7 @@ TEST (rpc, receive_pruned) wallet2->insert_adhoc (key1.prv); auto send1 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::dev::genesis->hash ()))); ASSERT_TIMELY (5s, node2->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); - ASSERT_TIMELY (10s, !node2->store.account.exists (node2->store.tx_begin_read (), key1.pub)); + ASSERT_TIMELY (10s, node2->store.account.exists (node2->store.tx_begin_read (), key1.pub)); // Send below minimum receive amount auto send2 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number () - 1, *node2->work_generate_blocking (send1->hash ()))); // Extra send frontier