Charon/blockchain
1
0
Fork 0
forked from lthn/blockchain
Code Pull requests Activity

coretests: adapted few tests to fit redesigned test environment (hardforks)

Browse source
This commit is contained in:
sowle 2023-06-05 18:19:39 +02:00
parent ddaf862170
commit 1ec3bac95d
No known key found for this signature in database
GPG key ID: C07A24B2D89D49FC
6 changed files with 65 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
tests/core_tests/alias_tests.cpp
View file

@ -96,9 +96,6 @@ gen_alias_tests::gen_alias_tests()
REGISTER_CALLBACK_METHOD(gen_alias_tests, check_height_not_changed);
REGISTER_CALLBACK_METHOD(gen_alias_tests, check_height_changed);
REGISTER_CALLBACK_METHOD(gen_alias_tests, check_too_many_aliases_registration);
m_hardforks.set_hardfork_height(1, 0);
m_hardforks.set_hardfork_height(2, 0);
}
bool gen_alias_tests::generate(std::vector<test_event_entry>& events) const
@ -107,7 +104,6 @@ bool gen_alias_tests::generate(std::vector<test_event_entry>& events) const
GENERATE_ACCOUNT(miner_account); // event index
m_accounts.push_back(miner_account);
MAKE_GENESIS_BLOCK(events, blk_0, preminer_account, test_core_time::get_time()); // 0
set_hard_fork_heights_to_generator(generator);
DO_CALLBACK(events, "configure_core"); // 1
MAKE_ACCOUNT(events, first_acc); // 2
MAKE_ACCOUNT(events, second_acc); // 3
@ -874,6 +870,7 @@ bool gen_alias_reg_with_locked_money::generate(std::vector<test_event_entry>& ev
GENERATE_ACCOUNT(alice);
MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, ts);
DO_CALLBACK(events, "configure_core");
currency::block& prev_block = blk_0;
@ -1155,6 +1152,7 @@ bool gen_alias_tx_no_outs::generate(std::vector<test_event_entry>& events) const
uint64_t ts = test_core_time::get_time();
GENERATE_ACCOUNT(miner_acc);
MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, ts);
DO_CALLBACK(events, "configure_core");
events.push_back(miner_acc);
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);

5
tests/core_tests/block_validation.cpp
View file

@ -1,4 +1,4 @@
// Copyright (c) 2014-2018 Zano Project
// Copyright (c) 2014-2023 Zano Project
// Copyright (c) 2014-2018 The Louisdor Project
// Copyright (c) 2012-2013 The Cryptonote developers
// Distributed under the MIT/X11 software license, see the accompanying
@ -46,7 +46,8 @@ namespace
#define BLOCK_VALIDATION_INIT_GENERATE() \
GENERATE_ACCOUNT(miner_account); \
MAKE_GENESIS_BLOCK(events, blk_0, miner_account, 1338224400);
MAKE_GENESIS_BLOCK(events, blk_0, miner_account, 1338224400); \
DO_CALLBACK(events, "configure_core");
//----------------------------------------------------------------------------------------------------------------------
// Tests

77
tests/core_tests/block_validation.h
View file

@ -1,4 +1,4 @@
// Copyright (c) 2014-2018 Zano Project
// Copyright (c) 2014-2023 Zano Project
// Copyright (c) 2014-2018 The Louisdor Project
// Copyright (c) 2012-2013 The Cryptonote developers
// Distributed under the MIT/X11 software license, see the accompanying
@ -8,16 +8,11 @@
#include "chaingen.h"
template<size_t invalid_block_idx = 0>
class gen_block_verification_base : public test_chain_unit_base
class gen_block_verification_base : public test_chain_unit_enchanced
{
public:
gen_block_verification_base()
{
m_hardforks.m_height_the_hardfork_n_active_after[1] = 1440;
m_hardforks.m_height_the_hardfork_n_active_after[2] = 1800;
m_hardforks.m_height_the_hardfork_n_active_after[3] = 1801;
m_hardforks.m_height_the_hardfork_n_active_after[4] = 50000000000;
REGISTER_CALLBACK("check_block_purged", gen_block_verification_base<invalid_block_idx>::check_block_purged);
}
@ -29,143 +24,131 @@ public:
return !bvc.m_verification_failed;
}
// currency::core_runtime_config get_runtime_info_for_core() const
// {
// currency::core_runtime_config res = test_chain_unit_base::get_runtime_info_for_core();
//
// }
bool check_block_purged(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
CHECK_TEST_CONDITION(invalid_block_idx < ev_index);
CHECK_EQ(0, c.get_pool_transactions_count());
CHECK_EQ(invalid_block_idx, c.get_current_blockchain_size());
size_t invalid_block_height = invalid_block_idx - 1; // it's bad idea to use invalid_block_idx for both event index and block height, consider redisign -- sowle
CHECK_EQ(invalid_block_height, c.get_current_blockchain_size());
return true;
}
//mutable currency::hard_forks_descriptor m_hardforks;
};
template<size_t expected_blockchain_height>
struct gen_block_accepted_base : public test_chain_unit_base
struct gen_block_accepted_base : public test_chain_unit_enchanced
{
gen_block_accepted_base()
{
m_hardforks.m_height_the_hardfork_n_active_after[1] = 1440;
m_hardforks.m_height_the_hardfork_n_active_after[2] = 1800;
m_hardforks.m_height_the_hardfork_n_active_after[3] = 1801;
m_hardforks.m_height_the_hardfork_n_active_after[4] = 50000000000;
REGISTER_CALLBACK("check_block_accepted", gen_block_accepted_base::check_block_accepted);
}
bool check_block_accepted(currency::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& /*events*/)
{
CHECK_EQ(0, c.get_pool_transactions_count());
CHECK_EQ(expected_blockchain_height, c.get_current_blockchain_size());
return true;
}
};
struct gen_block_big_major_version : public gen_block_verification_base<1>
struct gen_block_big_major_version : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_big_minor_version : public gen_block_accepted_base<2>
struct gen_block_big_minor_version : public gen_block_accepted_base<2 /* <- expected blockchain height */>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_ts_not_checked : public gen_block_accepted_base<BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW>
struct gen_block_ts_not_checked : public gen_block_accepted_base<BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW /* <- expected blockchain height */>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_ts_in_past : public gen_block_verification_base<BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW>
struct gen_block_ts_in_past : public gen_block_verification_base<BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW + 1 /* <- invalid_block_idx */>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_ts_in_future : public gen_block_verification_base<1>
struct gen_block_ts_in_future : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_invalid_prev_id : public gen_block_verification_base<1>
struct gen_block_invalid_prev_id : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
bool check_block_verification_context(const currency::block_verification_context& bvc, size_t event_idx, const currency::block& /*blk*/);
};
struct gen_block_invalid_nonce : public gen_block_verification_base<3>
struct gen_block_invalid_nonce : public gen_block_verification_base<4>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_no_miner_tx : public gen_block_verification_base<1>
struct gen_block_no_miner_tx : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_unlock_time_is_low : public gen_block_verification_base<1>
struct gen_block_unlock_time_is_low : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_unlock_time_is_high : public gen_block_verification_base<1>
struct gen_block_unlock_time_is_high : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_unlock_time_is_timestamp_in_past : public gen_block_verification_base<1>
struct gen_block_unlock_time_is_timestamp_in_past : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_unlock_time_is_timestamp_in_future : public gen_block_verification_base<1>
struct gen_block_unlock_time_is_timestamp_in_future : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_height_is_low : public gen_block_verification_base<1>
struct gen_block_height_is_low : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_height_is_high : public gen_block_verification_base<1>
struct gen_block_height_is_high : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_miner_tx_has_2_tx_gen_in : public gen_block_verification_base<1>
struct gen_block_miner_tx_has_2_tx_gen_in : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_miner_tx_has_2_in : public gen_block_verification_base<CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 1>
struct gen_block_miner_tx_has_2_in : public gen_block_verification_base<CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_miner_tx_with_txin_to_key : public gen_block_verification_base<CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 2>
struct gen_block_miner_tx_with_txin_to_key : public gen_block_verification_base<CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 3>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_miner_tx_out_is_small : public gen_block_verification_base<1>
struct gen_block_miner_tx_out_is_small : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_miner_tx_out_is_big : public gen_block_verification_base<1>
struct gen_block_miner_tx_out_is_big : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_miner_tx_has_no_out : public gen_block_verification_base<1>
struct gen_block_miner_tx_has_no_out : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
@ -175,17 +158,17 @@ struct gen_block_miner_tx_has_out_to_alice : public gen_block_accepted_base<2>
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_has_invalid_tx : public gen_block_verification_base<1>
struct gen_block_has_invalid_tx : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_is_too_big : public gen_block_verification_base<1>
struct gen_block_is_too_big : public gen_block_verification_base<2>
{
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_wrong_version_agains_hardfork : public gen_block_verification_base<1>
struct gen_block_wrong_version_agains_hardfork : public gen_block_verification_base<2>
{
public:
gen_block_wrong_version_agains_hardfork();
@ -193,8 +176,6 @@ public:
bool generate(std::vector<test_event_entry>& events) const;
};
struct gen_block_invalid_binary_format : public test_chain_unit_base
{
gen_block_invalid_binary_format();
@ -205,4 +186,4 @@ struct gen_block_invalid_binary_format : public test_chain_unit_base
private:
size_t m_corrupt_blocks_begin_idx;
};
};

58
tests/core_tests/chaingen_main.cpp
View file

@ -968,7 +968,7 @@ int main(int argc, char* argv[])
GENERATE_AND_PLAY(multisig_and_unlock_time);
GENERATE_AND_PLAY(multisig_and_coinbase);
GENERATE_AND_PLAY(multisig_with_same_id_in_pool);
GENERATE_AND_PLAY(multisig_and_checkpoints);
GENERATE_AND_PLAY_HF(multisig_and_checkpoints, "0"); // TODO: fix for HF 1-3 (checkpoint hash check)
GENERATE_AND_PLAY(multisig_and_checkpoints_bad_txs);
GENERATE_AND_PLAY(multisig_and_altchains);
GENERATE_AND_PLAY(multisig_out_make_and_spent_in_altchain);
@ -1028,7 +1028,7 @@ int main(int argc, char* argv[])
GENERATE_AND_PLAY(gen_checkpoints_pos_validation_on_altchain);
GENERATE_AND_PLAY(gen_checkpoints_and_invalid_tx_to_pool);
GENERATE_AND_PLAY(gen_checkpoints_set_after_switching_to_altchain);
GENERATE_AND_PLAY(gen_no_attchments_in_coinbase);
GENERATE_AND_PLAY_HF(gen_no_attchments_in_coinbase, "0");
GENERATE_AND_PLAY(gen_no_attchments_in_coinbase_gentime);
GENERATE_AND_PLAY(gen_alias_tests);
@ -1039,10 +1039,10 @@ int main(int argc, char* argv[])
GENERATE_AND_PLAY(gen_alias_update_after_addr_changed);
GENERATE_AND_PLAY(gen_alias_blocking_reg_by_invalid_tx);
GENERATE_AND_PLAY(gen_alias_blocking_update_by_invalid_tx);
GENERATE_AND_PLAY(gen_alias_reg_with_locked_money);
GENERATE_AND_PLAY_HF(gen_alias_reg_with_locked_money, "*");
GENERATE_AND_PLAY(gen_alias_too_small_reward);
GENERATE_AND_PLAY(gen_alias_too_much_reward);
GENERATE_AND_PLAY(gen_alias_tx_no_outs);
GENERATE_AND_PLAY_HF(gen_alias_tx_no_outs, "*");
GENERATE_AND_PLAY(gen_alias_switch_and_check_block_template);
GENERATE_AND_PLAY(gen_alias_too_many_regs_in_block_template);
GENERATE_AND_PLAY(gen_alias_update_for_free);
@ -1052,7 +1052,7 @@ int main(int argc, char* argv[])
GENERATE_AND_PLAY(gen_wallet_refreshing_on_chain_switch);
GENERATE_AND_PLAY(gen_wallet_refreshing_on_chain_switch_2);
GENERATE_AND_PLAY(gen_wallet_unconfirmed_tx_from_tx_pool);
GENERATE_AND_PLAY(gen_wallet_save_load_and_balance);
GENERATE_AND_PLAY_HF(gen_wallet_save_load_and_balance, "*");
GENERATE_AND_PLAY(gen_wallet_mine_pos_block);
GENERATE_AND_PLAY(gen_wallet_unconfirmed_outdated_tx);
GENERATE_AND_PLAY(gen_wallet_unlock_by_block_and_by_time);
@ -1139,30 +1139,30 @@ int main(int argc, char* argv[])
GENERATE_AND_PLAY(random_outs_and_burnt_coins);
// Block verification tests
GENERATE_AND_PLAY(gen_block_big_major_version);
GENERATE_AND_PLAY(gen_block_big_minor_version);
GENERATE_AND_PLAY(gen_block_ts_not_checked);
GENERATE_AND_PLAY(gen_block_ts_in_past);
GENERATE_AND_PLAY(gen_block_ts_in_future);
//GENERATE_AND_PLAY(gen_block_invalid_prev_id); disabled becouse impossible to generate text chain with wrong prev_id - pow hash not works without chaining
GENERATE_AND_PLAY(gen_block_invalid_nonce);
GENERATE_AND_PLAY(gen_block_no_miner_tx);
GENERATE_AND_PLAY(gen_block_unlock_time_is_low);
GENERATE_AND_PLAY(gen_block_unlock_time_is_high);
GENERATE_AND_PLAY(gen_block_unlock_time_is_timestamp_in_past);
GENERATE_AND_PLAY(gen_block_unlock_time_is_timestamp_in_future);
GENERATE_AND_PLAY(gen_block_height_is_low);
GENERATE_AND_PLAY(gen_block_height_is_high);
GENERATE_AND_PLAY(gen_block_miner_tx_has_2_tx_gen_in);
GENERATE_AND_PLAY(gen_block_miner_tx_has_2_in);
GENERATE_AND_PLAY(gen_block_miner_tx_with_txin_to_key);
GENERATE_AND_PLAY(gen_block_miner_tx_out_is_small);
GENERATE_AND_PLAY(gen_block_miner_tx_out_is_big);
GENERATE_AND_PLAY(gen_block_miner_tx_has_no_out);
GENERATE_AND_PLAY(gen_block_miner_tx_has_out_to_alice);
GENERATE_AND_PLAY(gen_block_has_invalid_tx);
GENERATE_AND_PLAY(gen_block_is_too_big);
GENERATE_AND_PLAY(gen_block_wrong_version_agains_hardfork);
GENERATE_AND_PLAY_HF(gen_block_big_major_version, "0,3");
GENERATE_AND_PLAY_HF(gen_block_big_minor_version, "0,3");
GENERATE_AND_PLAY_HF(gen_block_ts_not_checked, "0,3");
GENERATE_AND_PLAY_HF(gen_block_ts_in_past, "0,3");
GENERATE_AND_PLAY_HF(gen_block_ts_in_future, "0,3");
//GENERATE_AND_PLAY(gen_block_invalid_prev_id); disabled because impossible to generate text chain with wrong prev_id - pow hash not works without chaining
GENERATE_AND_PLAY_HF(gen_block_invalid_nonce, "0,3");
GENERATE_AND_PLAY_HF(gen_block_no_miner_tx, "0,3");
GENERATE_AND_PLAY_HF(gen_block_unlock_time_is_low, "0,3");
GENERATE_AND_PLAY_HF(gen_block_unlock_time_is_high, "0,3");
GENERATE_AND_PLAY_HF(gen_block_unlock_time_is_timestamp_in_past, "0,3");
GENERATE_AND_PLAY_HF(gen_block_unlock_time_is_timestamp_in_future, "0,3");
GENERATE_AND_PLAY_HF(gen_block_height_is_low, "0,3");
GENERATE_AND_PLAY_HF(gen_block_height_is_high, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_has_2_tx_gen_in, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_has_2_in, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_with_txin_to_key, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_out_is_small, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_out_is_big, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_has_no_out, "0,3");
GENERATE_AND_PLAY_HF(gen_block_miner_tx_has_out_to_alice, "0,3");
GENERATE_AND_PLAY_HF(gen_block_has_invalid_tx, "0,3");
GENERATE_AND_PLAY_HF(gen_block_is_too_big, "0,3");
GENERATE_AND_PLAY_HF(gen_block_wrong_version_agains_hardfork, "0,3");
//GENERATE_AND_PLAY(gen_block_invalid_binary_format); // Takes up to 3 hours, if CURRENCY_MINED_MONEY_UNLOCK_WINDOW == 500, up to 30 minutes, if CURRENCY_MINED_MONEY_UNLOCK_WINDOW == 10

6
tests/core_tests/checkpoints_tests.cpp
View file

@ -669,11 +669,6 @@ bool gen_checkpoints_pos_validation_on_altchain::init_runtime_config(currency::c
gen_no_attchments_in_coinbase::gen_no_attchments_in_coinbase()
{
m_hardforks.m_height_the_hardfork_n_active_after[1] = 1440;
m_hardforks.m_height_the_hardfork_n_active_after[2] = 1800;
m_hardforks.m_height_the_hardfork_n_active_after[3] = 1801;
m_hardforks.m_height_the_hardfork_n_active_after[4] = 50000000000;
generator.set_hardforks(m_hardforks);
// NOTE: This test is made deterministic to be able to correctly set up checkpoint.
random_state_test_restorer::reset_random(); // random generator's state was previously stored, will be restore on dtor (see also m_random_state_test_restorer)
@ -692,6 +687,7 @@ bool gen_no_attchments_in_coinbase::generate(std::vector<test_event_entry>& even
block blk_0 = AUTO_VAL_INIT(blk_0);
generator.construct_genesis_block(blk_0, m_miner_acc, ts);
events.push_back(blk_0);
DO_CALLBACK(events, "configure_core");
DO_CALLBACK(events, "check_not_being_in_cp_zone");
DO_CALLBACK(events, "init_config_set_cp");

5
tests/core_tests/multisig_wallet_tests.cpp
View file

@ -1632,10 +1632,6 @@ multisig_and_checkpoints::multisig_and_checkpoints()
{
// NOTE: This test is made deterministic to be able to correctly set up checkpoint.
random_state_test_restorer::reset_random(); // random generator's state was previously stored, will be restore on dtor (see also m_random_state_test_restorer)
m_hardforks.m_height_the_hardfork_n_active_after[1] = 1440;
m_hardforks.m_height_the_hardfork_n_active_after[2] = 1800;
m_hardforks.m_height_the_hardfork_n_active_after[3] = 1801;
m_hardforks.m_height_the_hardfork_n_active_after[4] = 50000000000;
REGISTER_CALLBACK_METHOD(multisig_and_checkpoints, set_cp);
}
@ -1681,6 +1677,7 @@ bool multisig_and_checkpoints::generate(std::vector<test_event_entry>& events) c
std::vector<tx_destination_entry> destinations;
MAKE_GENESIS_BLOCK(events, blk_0, preminer_acc, ts);
DO_CALLBACK(events, "configure_core");
// set checkpoint
DO_CALLBACK(events, "set_cp");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 2);