bool one_block::verify_1(CryptoNote::Core& c, size_t ev_index, const std::vector<test_event_entry> &events)
{
DEFINE_TESTS_ERROR_CONTEXT("one_block::verify_1");
alice = boost::get<CryptoNote::AccountBase>(events[1]);
// check balances
//std::vector<const CryptoNote::Block*> chain;
//map_hash2tx_t mtx;
//CHECK_TEST_CONDITION(find_block_chain(events, chain, mtx, getBlockHash(boost::get<CryptoNote::BlockTemplate>(events[1]))));
//CHECK_TEST_CONDITION(get_block_reward(0) == get_balance(alice, events, chain, mtx));
// check height
std::vector<BlockTemplate> blocks;
auto rawBlocks = c.getBlocks(0, 10000);
blocks.resize(rawBlocks.size());
for (size_t i = 0; i < rawBlocks.size(); ++i) {
CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
}
CHECK_TEST_CONDITION(blocks.size() == 1);
//CHECK_TEST_CONDITION(outs.size() == blocks.size());
CHECK_TEST_CONDITION(c.getBlockchainTransactionCount() == 1);
//CHECK_TEST_CONDITION(blocks.back() == boost::get<CryptoNote::BlockTemplate>(events[0]));
return true;
}
//-----------------------------------------------------------------------------------------------------
bool gen_chain_switch_1::check_split_switched(CryptoNote::Core& c, size_t ev_index,
const std::vector<test_event_entry>& events) {
DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_switched");
std::vector<BlockTemplate> blocks;
auto rawBlocks = c.getBlocks(0, 10000);
blocks.resize(rawBlocks.size());
for (size_t i = 0; i < rawBlocks.size(); ++i) {
CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
}
CHECK_EQ(7 + 2 * m_currency->minedMoneyUnlockWindow(), blocks.size());
auto it = blocks.end();
--it;
--it;
--it;
CHECK_TEST_CONDITION(std::equal(blocks.begin(), it, m_chain_1.begin()));
CHECK_TEST_CONDITION(blocks.back() ==
boost::get<BlockTemplate>(events[25 + 2 * m_currency->minedMoneyUnlockWindow()])); // blk_7
auto alt_blocks = c.getAlternativeBlocks();
CHECK_EQ(2, c.getAlternativeBlockCount());
// Some blocks that were in main chain are in alt chain now
for (const auto& b : alt_blocks) {
CHECK_TEST_CONDITION(
!(m_chain_1.end() == std::find_if(m_chain_1.cbegin(), m_chain_1.cend(),
[&b](const CryptoNote::BlockTemplate& arg) -> bool { return b == arg; })));
}
std::vector<CryptoNote::BlockTemplate> chain;
map_hash2tx_t mtx;
bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
CHECK_TEST_CONDITION(r);
CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx));
CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_2, chain, mtx));
CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx));
CHECK_EQ(MK_COINS(16), get_balance(m_recipient_account_4, chain, mtx));
auto tx_pool = c.getPoolTransactions();
CHECK_EQ(1, tx_pool.size());
CHECK_TEST_CONDITION(!(tx_pool.front() == m_tx_pool.front()));
std::vector<size_t> tx_outs;
uint64_t transfered;
lookup_acc_outs(m_recipient_account_2.getAccountKeys(), tx_pool.front(), tx_outs, transfered);
CHECK_EQ(MK_COINS(7), transfered);
return true;
}
bool gen_ring_signature_big::check_balances_2(CryptoNote::Core& c, size_t ev_index,
const std::vector<test_event_entry>& events) {
DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_big::check_balances_2");
std::vector<BlockTemplate> blocks;
auto rawBlocks = c.getBlocks(0, 2 * static_cast<uint32_t>(m_test_size) + m_currency->minedMoneyUnlockWindow());
blocks.resize(rawBlocks.size());
for (size_t i = 0; i < rawBlocks.size(); ++i) {
CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
}
std::vector<CryptoNote::BlockTemplate> chain;
map_hash2tx_t mtx;
bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
CHECK_TEST_CONDITION(r);
CHECK_EQ(0, get_balance(m_bob_account, chain, mtx));
CHECK_EQ(m_tx_amount, get_balance(m_alice_account, chain, mtx));
for (size_t i = 2; i < 1 + m_test_size; ++i) {
const AccountBase& an_account = boost::get<AccountBase>(events[i]);
uint64_t balance = m_tx_amount + m_currency->minimumFee() * i;
CHECK_EQ(balance, get_balance(an_account, chain, mtx));
}
std::vector<size_t> tx_outs;
uint64_t transfered;
lookup_acc_outs(m_alice_account.getAccountKeys(), boost::get<Transaction>(events[events.size() - 3]),
getTransactionPublicKeyFromExtra(boost::get<Transaction>(events[events.size() - 3]).extra), tx_outs,
transfered);
CHECK_EQ(m_tx_amount, transfered);
return true;
}
//-----------------------------------------------------------------------------------------------------
bool gen_chain_switch_1::check_split_not_switched(CryptoNote::Core& c, size_t ev_index,
const std::vector<test_event_entry>& events) {
DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_not_switched");
m_recipient_account_1 = boost::get<AccountBase>(events[2]);
m_recipient_account_2 = boost::get<AccountBase>(events[3]);
m_recipient_account_3 = boost::get<AccountBase>(events[4]);
m_recipient_account_4 = boost::get<AccountBase>(events[5]);
std::vector<BlockTemplate> blocks;
auto rawBlocks = c.getBlocks(0, 10000);
blocks.resize(rawBlocks.size());
for (size_t i = 0; i < rawBlocks.size(); ++i) {
CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
}
CHECK_EQ(6 + 2 * m_currency->minedMoneyUnlockWindow(), blocks.size());
auto blk_4 = CryptoNote::fromBinaryArray<BlockTemplate>(
boost::get<RawBlock>(events[21 + 2 * m_currency->minedMoneyUnlockWindow()]).block);
CHECK_TEST_CONDITION(getBlockHash(blocks.back()) == getBlockHash(blk_4)); // blk_4
CHECK_EQ(2, c.getAlternativeBlockCount());
std::vector<CryptoNote::BlockTemplate> chain;
map_hash2tx_t mtx;
bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
CHECK_TEST_CONDITION(r);
CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx));
CHECK_EQ(MK_COINS(10), get_balance(m_recipient_account_2, chain, mtx));
CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx));
CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_4, chain, mtx));
auto tx_pool = c.getPoolTransactions();
CHECK_EQ(1, tx_pool.size());
std::vector<size_t> tx_outs;
uint64_t transfered;
lookup_acc_outs(m_recipient_account_4.getAccountKeys(), tx_pool.front(),
getTransactionPublicKeyFromExtra(tx_pool.front().extra), tx_outs, transfered);
CHECK_EQ(MK_COINS(13), transfered);
m_chain_1.swap(blocks);
m_tx_pool.swap(tx_pool);
return true;
}
bool gen_upgrade::checkBlockRewardIsZero(CryptoNote::Core& c, size_t evIndex, const std::vector<test_event_entry>& events) {
DEFINE_TESTS_ERROR_CONTEXT("gen_upgrade::checkBlockRewardIsZero");
BlockTemplate blk = boost::get<BlockTemplate>(events[evIndex - 1]);
uint64_t blockReward = getSummaryOutsAmount(blk.baseTransaction);
CHECK_EQ(blockReward, 0);
CHECK_EQ(m_coinsInCirculationAfterUpgrade - m_currency->minimumFee(), c.getTotalGeneratedAmount());
return true;
}
bool gen_upgrade::checkBlockTemplateVersion(CryptoNote::Core& c, uint8_t expectedMajorVersion, uint8_t expectedMinorVersion) {
DEFINE_TESTS_ERROR_CONTEXT("gen_upgrade::checkBlockTemplateVersion");
AccountBase account;
account.generate();
BlockTemplate b;
Difficulty difficulty;
uint32_t height;
CHECK_TEST_CONDITION(c.getBlockTemplate(b, account.getAccountKeys().address, BinaryArray(), difficulty, height));
CHECK_EQ(static_cast<int>(b.majorVersion), static_cast<int>(expectedMajorVersion));
CHECK_EQ(static_cast<int>(b.minorVersion), static_cast<int>(expectedMinorVersion));
return true;
}
bool gen_ring_signature_2::check_balances_2(CryptoNote::Core& c, size_t ev_index,
const std::vector<test_event_entry>& events) {
DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_2::check_balances_2");
std::vector<BlockTemplate> blocks;
auto rawBlocks = c.getBlocks(0, 100 + 2 * m_currency->minedMoneyUnlockWindow());
blocks.resize(rawBlocks.size());
for (size_t i = 0; i < rawBlocks.size(); ++i) {
CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
}
std::vector<CryptoNote::BlockTemplate> chain;
map_hash2tx_t mtx;
bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
CHECK_TEST_CONDITION(r);
CHECK_EQ(0, get_balance(m_bob_account, chain, mtx));
CHECK_EQ(MK_COINS(244) - m_currency->minimumFee(), get_balance(m_alice_account, chain, mtx));
return true;
}
bool gen_upgrade::rememberCoinsInCirculationAfterUpgrade(CryptoNote::Core& c, size_t /*evIndex*/, const std::vector<test_event_entry>& /*events*/) {
m_coinsInCirculationAfterUpgrade = c.getTotalGeneratedAmount();
return true;
}