Differential D2045 Diff 6002 src/test/avalanche_tests.cpp

Changeset View

Standalone View

src/test/avalanche_tests.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines	BOOST_AUTO_TEST_CASE(vote_record) {

// The next vote will finalize the decision.		// The next vote will finalize the decision.
REGISTER_VOTE_AND_CHECK(vr, true, false, true,		REGISTER_VOTE_AND_CHECK(vr, true, false, true,
AVALANCHE_FINALIZATION_SCORE);		AVALANCHE_FINALIZATION_SCORE);
}		}

BOOST_AUTO_TEST_CASE(block_register) {		BOOST_AUTO_TEST_CASE(block_register) {
AvalancheProcessor p;		AvalancheProcessor p;
		std::vector<const CBlockIndex *> accepted, rejected;

CBlock block = CreateAndProcessBlock({}, CScript());		CBlock block = CreateAndProcessBlock({}, CScript());
const uint256 blockHash = block.GetHash();		const uint256 blockHash = block.GetHash();
const CBlockIndex *pindex = mapBlockIndex[blockHash];		const CBlockIndex *pindex = mapBlockIndex[blockHash];

// Querying for random block returns false.		// Querying for random block returns false.
BOOST_CHECK(!p.isAccepted(pindex));		BOOST_CHECK(!p.isAccepted(pindex));
BOOST_CHECK(!p.hasFinalized(pindex));

// Add a new block. Check it is added to the polls.		// Add a new block. Check it is added to the polls.
BOOST_CHECK(p.addBlockToReconcile(pindex));		BOOST_CHECK(p.addBlockToReconcile(pindex));
auto invs = AvalancheTest::getInvsForNextPoll(p);		auto invs = AvalancheTest::getInvsForNextPoll(p);
BOOST_CHECK_EQUAL(invs.size(), 1);		BOOST_CHECK_EQUAL(invs.size(), 1);
BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
BOOST_CHECK(invs[0].hash == blockHash);		BOOST_CHECK(invs[0].hash == blockHash);

// Newly added blocks are also considered rejected.		// Newly added blocks are also considered rejected.
BOOST_CHECK(!p.isAccepted(pindex));		BOOST_CHECK(!p.isAccepted(pindex));
BOOST_CHECK(!p.hasFinalized(pindex));

// Let's vote for this block a few times.		// Let's vote for this block a few times.
AvalancheResponse resp{0, {AvalancheVote(0, blockHash)}};		AvalancheResponse resp{0, {AvalancheVote(0, blockHash)}};
for (int i = 0; i < 5; i++) {		for (int i = 0; i < 5; i++) {
p.registerVotes(resp);		p.registerVotes(resp, accepted, rejected);
BOOST_CHECK(!p.isAccepted(pindex));		BOOST_CHECK(!p.isAccepted(pindex));
BOOST_CHECK(!p.hasFinalized(pindex));		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
}		}

// Now it is accepted, but we can vote for it numerous times.		// Now it is accepted, but we can vote for it numerous times.
for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {		for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {
p.registerVotes(resp);		p.registerVotes(resp, accepted, rejected);
BOOST_CHECK(p.isAccepted(pindex));		BOOST_CHECK(p.isAccepted(pindex));
BOOST_CHECK(!p.hasFinalized(pindex));		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
}		}

// As long as it is not finalized, we poll.		// As long as it is not finalized, we poll.
invs = AvalancheTest::getInvsForNextPoll(p);		invs = AvalancheTest::getInvsForNextPoll(p);
BOOST_CHECK_EQUAL(invs.size(), 1);		BOOST_CHECK_EQUAL(invs.size(), 1);
BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
BOOST_CHECK(invs[0].hash == blockHash);		BOOST_CHECK(invs[0].hash == blockHash);

// Now finalize the decision.		// Now finalize the decision.
resp = {0, {AvalancheVote(1, blockHash)}};		p.registerVotes(resp, accepted, rejected);
p.registerVotes(resp);		BOOST_CHECK_EQUAL(accepted.size(), 1);
BOOST_CHECK(p.isAccepted(pindex));		BOOST_CHECK_EQUAL(rejected.size(), 0);
BOOST_CHECK(p.hasFinalized(pindex));		BOOST_CHECK(accepted[0] == pindex);
		accepted = {};

		// Once the decision is finalized, there is no poll for it.
		invs = AvalancheTest::getInvsForNextPoll(p);
		BOOST_CHECK_EQUAL(invs.size(), 0);

// Once the decision is finalized, there is no poll for it.		// Once the decision is finalized, there is no poll for it.
invs = AvalancheTest::getInvsForNextPoll(p);		invs = AvalancheTest::getInvsForNextPoll(p);
BOOST_CHECK_EQUAL(invs.size(), 0);		BOOST_CHECK_EQUAL(invs.size(), 0);

// Now let's undo this and finalize rejection.		// Now let's undo this and finalize rejection.
for (int i = 0; i < 5; i++) {		BOOST_CHECK(p.addBlockToReconcile(pindex));
p.registerVotes(resp);		invs = AvalancheTest::getInvsForNextPoll(p);
BOOST_CHECK(p.isAccepted(pindex));		BOOST_CHECK_EQUAL(invs.size(), 1);
BOOST_CHECK(p.hasFinalized(pindex));		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
		BOOST_CHECK(invs[0].hash == blockHash);

		// Only 3 here as we don't need to flip state.
		resp = {0, {AvalancheVote(1, blockHash)}};
		for (int i = 0; i < 3; i++) {
		p.registerVotes(resp, accepted, rejected);
		BOOST_CHECK(!p.isAccepted(pindex));
		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
}		}

// Now it is rejected, but we can vote for it numerous times.		// Now it is rejected, but we can vote for it numerous times.
for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {		for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {
p.registerVotes(resp);		p.registerVotes(resp, accepted, rejected);
BOOST_CHECK(!p.isAccepted(pindex));		BOOST_CHECK(!p.isAccepted(pindex));
BOOST_CHECK(!p.hasFinalized(pindex));		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
}		}

// As long as it is not finalized, we poll.		// As long as it is not finalized, we poll.
invs = AvalancheTest::getInvsForNextPoll(p);		invs = AvalancheTest::getInvsForNextPoll(p);
BOOST_CHECK_EQUAL(invs.size(), 1);		BOOST_CHECK_EQUAL(invs.size(), 1);
BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
BOOST_CHECK(invs[0].hash == blockHash);		BOOST_CHECK(invs[0].hash == blockHash);

// Now finalize the decision.		// Now finalize the decision.
p.registerVotes(resp);		p.registerVotes(resp, accepted, rejected);
BOOST_CHECK(!p.isAccepted(pindex));		BOOST_CHECK(!p.isAccepted(pindex));
BOOST_CHECK(p.hasFinalized(pindex));		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 1);
		BOOST_CHECK(rejected[0] == pindex);
		rejected = {};

		// Once the decision is finalized, there is no poll for it.
		invs = AvalancheTest::getInvsForNextPoll(p);
		BOOST_CHECK_EQUAL(invs.size(), 0);

// Once the decision is finalized, there is no poll for it.		// Once the decision is finalized, there is no poll for it.
invs = AvalancheTest::getInvsForNextPoll(p);		invs = AvalancheTest::getInvsForNextPoll(p);
BOOST_CHECK_EQUAL(invs.size(), 0);		BOOST_CHECK_EQUAL(invs.size(), 0);

// Adding the block twice does nothing.		// Adding the block twice does nothing.
		BOOST_CHECK(p.addBlockToReconcile(pindex));
BOOST_CHECK(!p.addBlockToReconcile(pindex));		BOOST_CHECK(!p.addBlockToReconcile(pindex));
BOOST_CHECK(!p.isAccepted(pindex));		BOOST_CHECK(!p.isAccepted(pindex));
BOOST_CHECK(p.hasFinalized(pindex));		}

		BOOST_AUTO_TEST_CASE(multi_block_register) {
		AvalancheProcessor p;
		CBlockIndex indexA, indexB;

		std::vector<const CBlockIndex *> accepted, rejected;

		// Make sure the block has a hash.
		CBlock blockA = CreateAndProcessBlock({}, CScript());
		const uint256 blockHashA = blockA.GetHash();
		const CBlockIndex *pindexA = mapBlockIndex[blockHashA];

		CBlock blockB = CreateAndProcessBlock({}, CScript());
		const uint256 blockHashB = blockB.GetHash();
		const CBlockIndex *pindexB = mapBlockIndex[blockHashB];

		// Querying for random block returns false.
		BOOST_CHECK(!p.isAccepted(pindexA));
		BOOST_CHECK(!p.isAccepted(pindexB));

		// Start voting on block A.
		BOOST_CHECK(p.addBlockToReconcile(pindexA));
		auto invs = AvalancheTest::getInvsForNextPoll(p);
		BOOST_CHECK_EQUAL(invs.size(), 1);
		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
		BOOST_CHECK(invs[0].hash == blockHashA);

		AvalancheResponse resp{
		0, {AvalancheVote(0, blockHashA), AvalancheVote(0, blockHashB)}};
		p.registerVotes(resp, accepted, rejected);
		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 0);

		// Start voing on block B after one vote.
		BOOST_CHECK(p.addBlockToReconcile(pindexB));
		invs = AvalancheTest::getInvsForNextPoll(p);
		BOOST_CHECK_EQUAL(invs.size(), 2);
		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
		BOOST_CHECK(invs[0].hash == blockHashA);
		BOOST_CHECK_EQUAL(invs[1].type, MSG_BLOCK);
		BOOST_CHECK(invs[1].hash == blockHashB);

		// Now it is rejected, but we can vote for it numerous times.
		for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE + 4; i++) {
		p.registerVotes(resp, accepted, rejected);
		BOOST_CHECK_EQUAL(accepted.size(), 0);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
		}

		// Next vote will finalize block A.
		p.registerVotes(resp, accepted, rejected);
		BOOST_CHECK_EQUAL(accepted.size(), 1);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
		BOOST_CHECK(accepted[0] == pindexA);
		accepted = {};

		// We do not vote on A anymore.
		invs = AvalancheTest::getInvsForNextPoll(p);
		BOOST_CHECK_EQUAL(invs.size(), 1);
		BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
		BOOST_CHECK(invs[0].hash == blockHashB);

		// Next vote will finalize block B.
		p.registerVotes(resp, accepted, rejected);
		BOOST_CHECK_EQUAL(accepted.size(), 1);
		BOOST_CHECK_EQUAL(rejected.size(), 0);
		BOOST_CHECK(accepted[0] == pindexB);
		accepted = {};

		// There is nothing left to vote on.
		invs = AvalancheTest::getInvsForNextPoll(p);
		BOOST_CHECK_EQUAL(invs.size(), 0);
}		}

BOOST_AUTO_TEST_CASE(event_loop) {		BOOST_AUTO_TEST_CASE(event_loop) {
AvalancheProcessor p;		AvalancheProcessor p;
CScheduler s;		CScheduler s;

// Starting the event loop.		// Starting the event loop.
BOOST_CHECK(p.startEventLoop(s));		BOOST_CHECK(p.startEventLoop(s));
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines