Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Fix tests using election_scheduler::flush() (#3961)

Browse source 
* Fix tests using election_scheduler::flush

* Fix more tests using `election_scheduler::flush`

* Remove flush calls

* One more flush removed
This commit is contained in:
Piotr Wójcik 2022-09-28 02:17:04 +02:00 • committed by GitHub
commit 9dde6c897a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 47 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

14
nano/core_test/active_transactions.cpp
View file

@ -406,7 +406,7 @@ TEST (active_transactions, DISABLED_inactive_votes_cache_multiple_votes)
ASSERT_TIMELY (5s, node.inactive_vote_cache.find (send1->hash ())->voters.size () == 2);
ASSERT_EQ (1, node.inactive_vote_cache.cache_size ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (send1->qualified_root ()));
auto election = node.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (3, election->votes ().size ()); // 2 votes and 1 default not_an_acount
@ -623,7 +623,7 @@ TEST (active_transactions, dropped_cleanup)
ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
node.block_confirm (nano::dev::genesis);
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (nano::dev::genesis->qualified_root ()));
auto election = node.active.election (nano::dev::genesis->qualified_root ());
ASSERT_NE (nullptr, election);
@ -647,7 +647,7 @@ TEST (active_transactions, dropped_cleanup)
// Repeat test for a confirmed election
ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
node.block_confirm (nano::dev::genesis);
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (nano::dev::genesis->qualified_root ()));
election = node.active.election (nano::dev::genesis->qualified_root ());
ASSERT_NE (nullptr, election);
election->force_confirm ();
@ -1018,8 +1018,7 @@ TEST (active_transactions, DISABLED_confirm_new)
.build_shared ();
node1.process_active (send);
node1.block_processor.flush ();
node1.scheduler.flush ();
ASSERT_EQ (1, node1.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
auto & node2 = *system.add_node ();
// Add key to node2
system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv);
@ -1059,8 +1058,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
auto vote_fork (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector<nano::block_hash>{ fork->hash () }));
ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
node.scheduler.flush ();
ASSERT_EQ (1, node.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node.active.size ());
// Vote for conflicting block, but the block does not yet exist in the ledger
node.active.vote (vote_fork);
@ -1136,7 +1134,7 @@ TEST (active_transactions, activate_account_chain)
ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (send->qualified_root ()));
auto election1 = node.active.election (send->qualified_root ());
ASSERT_EQ (1, node.active.size ());
ASSERT_EQ (1, election1->blocks ().count (send->hash ()));

1
nano/core_test/bootstrap.cpp
View file

@ -1955,7 +1955,6 @@ TEST (bulk, offline_send)
ASSERT_NE (nullptr, send1);
ASSERT_NE (std::numeric_limits<nano::uint256_t>::max (), node1->balance (nano::dev::genesis_key.pub));
node1->block_processor.flush ();
node1->scheduler.flush ();
// Wait to finish election background tasks
ASSERT_TIMELY (10s, node1->active.empty ());
ASSERT_TIMELY (10s, node1->block_confirmed (send1->hash ()));

2
nano/core_test/conflicts.cpp
View file

@ -26,7 +26,7 @@ TEST (conflicts, start_stop)
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
ASSERT_EQ (0, node1.active.size ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election1 = node1.active.election (send1->qualified_root ());
ASSERT_EQ (1, node1.active.size ());
ASSERT_NE (nullptr, election1);

6
nano/core_test/election.cpp
View file

@ -11,7 +11,7 @@ TEST (election, construction)
nano::test::system system (1);
auto & node = *system.nodes[0];
node.block_confirm (nano::dev::genesis);
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (nano::dev::genesis->qualified_root ()));
auto election = node.active.election (nano::dev::genesis->qualified_root ());
election->transition_active ();
}
@ -142,7 +142,7 @@ TEST (election, quorum_minimum_confirm_success)
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (1, election->blocks ().size ());
@ -175,7 +175,7 @@ TEST (election, quorum_minimum_confirm_fail)
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (1, election->blocks ().size ());

5
nano/core_test/election_scheduler.cpp
View file

@ -28,7 +28,7 @@ TEST (election_scheduler, activate_one_timely)
.build_shared ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
system.nodes[0]->scheduler.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
ASSERT_TIMELY (1s, system.nodes[0]->active.election (send1->qualified_root ()));
ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ()));
}
TEST (election_scheduler, activate_one_flush)
@ -46,8 +46,7 @@ TEST (election_scheduler, activate_one_flush)
.build_shared ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
system.nodes[0]->scheduler.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
system.nodes[0]->scheduler.flush ();
ASSERT_NE (nullptr, system.nodes[0]->active.election (send1->qualified_root ()));
ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ()));
}
/**

10
nano/core_test/ledger.cpp
View file

@ -915,7 +915,7 @@ TEST (votes, check_signature)
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code);
}
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election1 = node1.active.election (send1->qualified_root ());
ASSERT_EQ (1, election1->votes ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector<nano::block_hash>{ send1->hash () }));
@ -944,7 +944,7 @@ TEST (votes, add_one)
auto transaction (node1.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code);
node1.block_confirm (send1);
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election1 = node1.active.election (send1->qualified_root ());
ASSERT_EQ (1, election1->votes ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector<nano::block_hash>{ send1->hash () }));
@ -986,7 +986,7 @@ TEST (votes, add_existing)
node1.work_generate_blocking (*send1);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election1 = node1.active.election (send1->qualified_root ());
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector<nano::block_hash>{ send1->hash () }));
ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
@ -1045,7 +1045,7 @@ TEST (votes, add_old)
auto transaction (node1.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code);
node1.block_confirm (send1);
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election1 = node1.active.election (send1->qualified_root ());
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector<nano::block_hash>{ send1->hash () }));
auto channel (std::make_shared<nano::transport::inproc::channel> (node1, node1));
@ -1151,7 +1151,7 @@ TEST (votes, add_cooldown)
auto transaction (node1.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code);
node1.block_confirm (send1);
node1.scheduler.flush ();
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
auto election1 = node1.active.election (send1->qualified_root ());
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector<nano::block_hash>{ send1->hash () }));
auto channel (std::make_shared<nano::transport::inproc::channel> (node1, node1));

74
nano/core_test/node.cpp
View file

@ -602,8 +602,7 @@ TEST (node, fork_publish)
node1.work_generate_blocking (*send2);
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.flush ();
ASSERT_EQ (1, node1.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
auto election (node1.active.election (send1->qualified_root ()));
ASSERT_NE (nullptr, election);
// Wait until the genesis rep activated & makes vote
@ -683,12 +682,10 @@ TEST (node, fork_keep)
.build_shared ();
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.flush ();
node2.process_active (send1);
node2.block_processor.flush ();
node2.scheduler.flush ();
ASSERT_EQ (1, node1.active.size ());
ASSERT_EQ (1, node2.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node2.active.size ());
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node1.process_active (send2);
node1.block_processor.flush ();
@ -740,13 +737,10 @@ TEST (node, fork_flip)
node1.network.inbound (publish1, ignored_channel);
node1.block_processor.flush ();
node1.scheduler.flush ();
node2.network.inbound (publish2, ignored_channel);
node2.block_processor.flush ();
node2.scheduler.flush ();
ASSERT_EQ (1, node1.active.size ());
ASSERT_EQ (1, node2.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node2.active.size ());
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node1.network.inbound (publish2, ignored_channel);
node1.block_processor.flush ();
@ -810,11 +804,9 @@ TEST (node, fork_multi_flip)
node2.network.inbound (publish2, channel2);
node2.network.inbound (publish3, channel2);
node1.block_processor.flush ();
node1.scheduler.flush ();
node2.block_processor.flush ();
node2.scheduler.flush ();
ASSERT_EQ (1, node1.active.size ());
ASSERT_EQ (1, node2.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node2.active.size ());
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node1.network.inbound (publish2, channel1);
@ -822,6 +814,7 @@ TEST (node, fork_multi_flip)
node1.block_processor.flush ();
node2.network.inbound (publish1, channel2);
node2.block_processor.flush ();
ASSERT_TIMELY (5s, node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ())));
auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ())));
ASSERT_NE (nullptr, election1);
ASSERT_EQ (1, election1->votes ().size ());
@ -1424,7 +1417,7 @@ TEST (node, rep_self_vote)
auto & active = node0->active;
auto & scheduler = node0->scheduler;
scheduler.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ());
scheduler.flush ();
ASSERT_TIMELY (5s, active.election (block0->qualified_root ()));
auto election1 = active.election (block0->qualified_root ());
ASSERT_NE (nullptr, election1);
// Wait until representatives are activated & make vote
@ -2117,8 +2110,7 @@ TEST (node, online_reps_election)
.build_shared ();
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.flush ();
ASSERT_EQ (1, node1.active.size ());
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
// Process vote for ongoing election
auto vote = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), 0, std::vector<nano::block_hash>{ send1->hash () });
ASSERT_EQ (0, node1.online_reps.online ());
@ -3612,10 +3604,9 @@ TEST (node, rollback_vote_self)
ASSERT_EQ (weight, node.weight (key.pub));
node.process_active (send2);
node.block_processor.flush ();
node.scheduler.flush ();
node.process_active (fork);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (send2->qualified_root ()));
election = node.active.election (send2->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (2, election->blocks ().size ());
@ -4167,7 +4158,7 @@ TEST (node, deferred_dependent_elections)
node.process_local (send1);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_TIMELY (5s, node.active.election (send1->qualified_root ()));
auto election_send1 = node.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election_send1);
@ -4175,20 +4166,18 @@ TEST (node, deferred_dependent_elections)
node.process_local (open);
node.process_local (send2);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_TRUE (node.block (open->hash ()));
ASSERT_TRUE (node.block (send2->hash ()));
ASSERT_FALSE (node.active.active (open->qualified_root ()));
ASSERT_FALSE (node.active.active (send2->qualified_root ()));
ASSERT_TIMELY (2s, node2.block (open->hash ()));
ASSERT_TIMELY (2s, node2.block (send2->hash ()));
ASSERT_TIMELY (5s, node.block (open->hash ()));
ASSERT_TIMELY (5s, node.block (send2->hash ()));
ASSERT_NEVER (1s, node.active.active (open->qualified_root ()));
ASSERT_NEVER (1s, node.active.active (send2->qualified_root ()));
ASSERT_TIMELY (5s, node2.block (open->hash ()));
ASSERT_TIMELY (5s, node2.block (send2->hash ()));
// Re-processing older blocks with updated work also does not start an election
node.work_generate_blocking (*open, nano::dev::network_params.work.difficulty (*open) + 1);
node.process_local (open);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_FALSE (node.active.active (open->qualified_root ()));
ASSERT_NEVER (1s, node.active.active (open->qualified_root ()));
// It is however possible to manually start an election from elsewhere
node.block_confirm (open);
@ -4201,8 +4190,7 @@ TEST (node, deferred_dependent_elections)
ASSERT_FALSE (node.active.active (open->qualified_root ()));
node.process_local (open);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_FALSE (node.active.active (open->qualified_root ()));
ASSERT_NEVER (1s, node.active.active (open->qualified_root ()));
// Drop both elections
node.active.erase (*open);
@ -4212,8 +4200,9 @@ TEST (node, deferred_dependent_elections)
// Confirming send1 will automatically start elections for the dependents
election_send1->force_confirm ();
ASSERT_TIMELY (2s, node.block_confirmed (send1->hash ()));
ASSERT_TIMELY (2s, node.active.active (open->qualified_root ()) && node.active.active (send2->qualified_root ()));
ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ()));
ASSERT_TIMELY (5s, node.active.active (open->qualified_root ()));
ASSERT_TIMELY (5s, node.active.active (send2->qualified_root ()));
auto election_open = node.active.election (open->qualified_root ());
ASSERT_NE (nullptr, election_open);
auto election_send2 = node.active.election (send2->qualified_root ());
@ -4223,29 +4212,26 @@ TEST (node, deferred_dependent_elections)
ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
ASSERT_FALSE (node.active.active (receive->qualified_root ()));
election_open->force_confirm ();
ASSERT_TIMELY (2s, node.block_confirmed (open->hash ()));
ASSERT_TIMELY (5s, node.block_confirmed (open->hash ()));
ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *receive));
std::this_thread::sleep_for (500ms);
ASSERT_FALSE (node.active.active (receive->qualified_root ()));
ASSERT_NEVER (1s, node.active.active (receive->qualified_root ()));
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), receive->hash ()));
ASSERT_FALSE (node.block (receive->hash ()));
node.process_local (receive);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_TRUE (node.block (receive->hash ()));
ASSERT_FALSE (node.active.active (receive->qualified_root ()));
ASSERT_TIMELY (5s, node.block (receive->hash ()));
ASSERT_NEVER (1s, node.active.active (receive->qualified_root ()));
// Processing a fork will also not start an election
ASSERT_EQ (nano::process_result::fork, node.process (*fork).code);
node.process_local (fork);
node.block_processor.flush ();
node.scheduler.flush ();
ASSERT_FALSE (node.active.active (receive->qualified_root ()));
ASSERT_NEVER (1s, node.active.active (receive->qualified_root ()));
// Confirming the other dependency allows starting an election from a fork
election_send2->force_confirm ();
ASSERT_TIMELY (2s, node.block_confirmed (send2->hash ()));
ASSERT_TIMELY (2s, node.active.active (receive->qualified_root ()));
ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ()));
ASSERT_TIMELY (5s, node.active.active (receive->qualified_root ()));
}
}