sysio::testing::base_tester Class Reference

#include <tester.hpp>

Inheritance diagram for sysio::testing::base_tester:

Collaboration diagram for sysio::testing::base_tester:

Public Types
typedef string	action_result

Public Member Functions
virtual	~base_tester ()
void	init (const setup_policy policy=setup_policy::full, db_read_mode read_mode=db_read_mode::SPECULATIVE, std::optional< uint32_t > genesis_max_inline_action_size=std::optional< uint32_t >{}, std::optional< uint32_t > config_max_nonprivileged_inline_action_size=std::optional< uint32_t >{})
void	init (controller::config config, const snapshot_reader_ptr &snapshot)
void	init (controller::config config, const genesis_state &genesis)
void	init (controller::config config)
void	init (controller::config config, protocol_feature_set &&pfs, const snapshot_reader_ptr &snapshot)
void	init (controller::config config, protocol_feature_set &&pfs, const genesis_state &genesis)
void	init (controller::config config, protocol_feature_set &&pfs)
void	execute_setup_policy (const setup_policy policy)
void	close ()
template<typename Lambda >
void	open (protocol_feature_set &&pfs, std::optional< chain_id_type > expected_chain_id, Lambda lambda)
void	open (protocol_feature_set &&pfs, const snapshot_reader_ptr &snapshot)
void	open (protocol_feature_set &&pfs, const genesis_state &genesis)
void	open (protocol_feature_set &&pfs, std::optional< chain_id_type > expected_chain_id={})
void	open (const snapshot_reader_ptr &snapshot)
void	open (const genesis_state &genesis)
void	open (std::optional< chain_id_type > expected_chain_id={})
bool	is_same_chain (base_tester &other)
virtual signed_block_ptr	produce_block (fc::microseconds skip_time=fc::milliseconds(config::block_interval_ms))=0
virtual signed_block_ptr	produce_empty_block (fc::microseconds skip_time=fc::milliseconds(config::block_interval_ms))=0
virtual signed_block_ptr	finish_block ()=0
signed_block_ptr	produce_block (std::vector< transaction_trace_ptr > &traces)
void	produce_blocks (uint32_t n=1, bool empty=false)
void	produce_blocks_until_end_of_round ()
void	produce_blocks_for_n_rounds (const uint32_t num_of_rounds=1)
void	produce_min_num_of_blocks_to_spend_time_wo_inactive_prod (const fc::microseconds target_elapsed_time=fc::microseconds())
void	push_block (signed_block_ptr b)
vector< transaction_id_type >	get_scheduled_transactions () const
unapplied_transaction_queue &	get_unapplied_transaction_queue ()
transaction_trace_ptr	push_transaction (packed_transaction &trx, fc::time_point deadline=fc::time_point::maximum(), uint32_t billed_cpu_time_us=DEFAULT_BILLED_CPU_TIME_US)
transaction_trace_ptr	push_transaction (signed_transaction &trx, fc::time_point deadline=fc::time_point::maximum(), uint32_t billed_cpu_time_us=DEFAULT_BILLED_CPU_TIME_US, bool no_throw=false)
action_result	push_action (action &&cert_act, uint64_t authorizer)
transaction_trace_ptr	push_action (const account_name &code, const action_name &acttype, const account_name &actor, const variant_object &data, uint32_t expiration=DEFAULT_EXPIRATION_DELTA, uint32_t delay_sec=0)
transaction_trace_ptr	push_action (const account_name &code, const action_name &acttype, const vector< account_name > &actors, const variant_object &data, uint32_t expiration=DEFAULT_EXPIRATION_DELTA, uint32_t delay_sec=0)
transaction_trace_ptr	push_action (const account_name &code, const action_name &acttype, const vector< permission_level > &auths, const variant_object &data, uint32_t expiration=DEFAULT_EXPIRATION_DELTA, uint32_t delay_sec=0)
action	get_action (account_name code, action_name acttype, vector< permission_level > auths, const variant_object &data) const
void	set_transaction_headers (transaction &trx, uint32_t expiration=DEFAULT_EXPIRATION_DELTA, uint32_t delay_sec=0) const
vector< transaction_trace_ptr >	create_accounts (vector< account_name > names, bool multisig=false, bool include_code=true)
void	set_before_preactivate_bios_contract ()
void	set_before_producer_authority_bios_contract ()
void	set_bios_contract ()
vector< producer_authority >	get_producer_authorities (const vector< account_name > &producer_names) const
transaction_trace_ptr	set_producers (const vector< account_name > &producer_names)
transaction_trace_ptr	set_producer_schedule (const vector< producer_authority > &schedule)
transaction_trace_ptr	set_producers_legacy (const vector< account_name > &producer_names)
void	link_authority (account_name account, account_name code, permission_name req, action_name type={})
void	unlink_authority (account_name account, account_name code, action_name type={})
void	set_authority (account_name account, permission_name perm, authority auth, permission_name parent, const vector< permission_level > &auths, const vector< private_key_type > &keys)
void	set_authority (account_name account, permission_name perm, authority auth, permission_name parent=config::owner_name)
void	delete_authority (account_name account, permission_name perm, const vector< permission_level > &auths, const vector< private_key_type > &keys)
void	delete_authority (account_name account, permission_name perm)
transaction_trace_ptr	create_account (account_name name, account_name creator=config::system_account_name, bool multisig=false, bool include_code=true)
transaction_trace_ptr	push_reqauth (account_name from, const vector< permission_level > &auths, const vector< private_key_type > &keys)
transaction_trace_ptr	push_reqauth (account_name from, string role, bool multi_sig=false)
transaction_trace_ptr	push_dummy (account_name from, const string &v="blah", uint32_t billed_cpu_time_us=DEFAULT_BILLED_CPU_TIME_US)
transaction_trace_ptr	transfer (account_name from, account_name to, asset amount, string memo, account_name currency)
transaction_trace_ptr	transfer (account_name from, account_name to, string amount, string memo, account_name currency)
transaction_trace_ptr	issue (account_name to, string amount, account_name currency, string memo)
template<typename ObjectType >
const auto &	get (const chainbase::oid< ObjectType > &key)
template<typename ObjectType , typename IndexBy , typename... Args>
const auto &	get (Args &&... args)
template<typename ObjectType , typename IndexBy , typename... Args>
const auto *	find (Args &&... args)
void	set_code (account_name name, const char *wast, const private_key_type *signer=nullptr)
void	set_code (account_name name, const vector< uint8_t > wasm, const private_key_type *signer=nullptr)
void	set_abi (account_name name, const char *abi_json, const private_key_type *signer=nullptr)
bool	chain_has_transaction (const transaction_id_type &txid) const
const transaction_receipt &	get_transaction_receipt (const transaction_id_type &txid) const
asset	get_currency_balance (const account_name &contract, const symbol &asset_symbol, const account_name &account) const
vector< char >	get_row_by_account (name code, name scope, name table, const account_name &act) const
map< account_name, block_id_type >	get_last_produced_block_map () const
void	set_last_produced_block_map (const map< account_name, block_id_type > &lpb)
auto	get_resolver ()
void	sync_with (base_tester &other)
const table_id_object *	find_table (name code, name scope, name table)
template<typename Object >
bool	get_table_entry (Object &obj, account_name code, account_name scope, account_name table, uint64_t key, bool require=true)
const controller::config &	get_config () const
void	schedule_protocol_features_wo_preactivation (const vector< digest_type > feature_digests)
void	preactivate_protocol_features (const vector< digest_type > feature_digests)
void	preactivate_builtin_protocol_features (const std::vector< builtin_protocol_feature_t > &features)
void	preactivate_all_builtin_protocol_features ()

Static Public Member Functions
template<typename KeyType = fc::ecc::private_key_shim>
static auto	get_private_key (name keyname, string role="owner")
template<typename KeyType = fc::ecc::private_key_shim>
static auto	get_public_key (name keyname, string role="owner")
static vector< uint8_t >	to_uint8_vector (const string &s)
static vector< uint8_t >	to_uint8_vector (uint64_t x)
static uint64_t	to_uint64 (fc::variant x)
static string	to_string (fc::variant x)
static action_result	success ()
static action_result	error (const string &msg)
static action_result	wasm_assert_msg (const string &msg)
static action_result	wasm_assert_code (uint64_t error_code)
static genesis_state	default_genesis ()
static std::pair< controller::config, genesis_state >	default_config (const fc::temp_directory &tempdir, std::optional< uint32_t > genesis_max_inline_action_size=std::optional< uint32_t >{}, std::optional< uint32_t > config_max_nonprivileged_inline_action_size=std::optional< uint32_t >{})

Public Attributes
unique_ptr< controller >	control
std::map< chain::public_key_type, chain::private_key_type >	block_signing_private_keys
vector< digest_type >	protocol_features_to_be_activated_wo_preactivation

Static Public Attributes
static const uint32_t	DEFAULT_EXPIRATION_DELTA = 6
static const uint32_t	DEFAULT_BILLED_CPU_TIME_US = 2000
static const fc::microseconds	abi_serializer_max_time {1000*1000}

Protected Member Functions
signed_block_ptr	_produce_block (fc::microseconds skip_time, bool skip_pending_trxs)
signed_block_ptr	_produce_block (fc::microseconds skip_time, bool skip_pending_trxs, bool no_throw, std::vector< transaction_trace_ptr > &traces)
void	_start_block (fc::time_point block_time)
signed_block_ptr	_finish_block ()

Protected Attributes
fc::temp_directory	tempdir
controller::config	cfg
map< transaction_id_type, transaction_receipt >	chain_transactions
map< account_name, block_id_type >	last_produced_block
unapplied_transaction_queue	unapplied_transactions

Detailed Description

Definition at line 146 of file tester.hpp.

Member Typedef Documentation

action_result

string sysio::testing::base_tester::action_result

Definition at line 148 of file tester.hpp.

Constructor & Destructor Documentation

~base_tester()

virtual sysio::testing::base_tester::~base_tester ( )

inlinevirtual

Definition at line 155 of file tester.hpp.

{};

Member Function Documentation

_finish_block()

signed_block_ptr sysio::testing::base_tester::_finish_block ( )

protected

Definition at line 416 of file tester.cpp.

                                               {
      FC_ASSERT( control->is_building_block(), "must first start a block before it can be finished" );
 
      auto producer = control->head_block_state()->get_scheduled_producer( control->pending_block_time() );
      vector<private_key_type> signing_keys;
 
      auto default_active_key = get_public_key( producer.producer_name, "active");
      producer.for_each_key([&](const public_key_type& key){
         const auto& iter = block_signing_private_keys.find(key);
         if(iter != block_signing_private_keys.end()) {
            signing_keys.push_back(iter->second);
         } else if (key == default_active_key) {
            signing_keys.emplace_back( get_private_key( producer.producer_name, "active") );
         }
      });
 
      control->finalize_block( [&]( digest_type d ) {
         std::vector<signature_type> result;
         result.reserve(signing_keys.size());
         for (const auto& k: signing_keys)
             result.emplace_back(k.sign(d));
 
         return result;
      } );
 
      control->commit_block();
      last_produced_block[control->head_block_state()->header.producer] = control->head_block_state()->id;
 
      return control->head_block_state()->block;
   }

Here is the caller graph for this function:

_produce_block() [1/2]

signed_block_ptr sysio::testing::base_tester::_produce_block ( fc::microseconds skip_time, bool skip_pending_trxs )

protected

Definition at line 338 of file tester.cpp.

                                                                                                  {
      std::vector<transaction_trace_ptr> traces;
      return _produce_block( skip_time, skip_pending_trxs, false, traces );
   }

Here is the caller graph for this function:

_produce_block() [2/2]

signed_block_ptr sysio::testing::base_tester::_produce_block ( fc::microseconds skip_time, bool skip_pending_trxs, bool no_throw, std::vector< transaction_trace_ptr > & traces )

protected

Definition at line 343 of file tester.cpp.

                                                                                                           {
      auto head = control->head_block_state();
      auto head_time = control->head_block_time();
      auto next_time = head_time + skip_time;
 
      if( !control->is_building_block() || control->pending_block_time() != next_time ) {
         _start_block( next_time );
      }
 
      if( !skip_pending_trxs ) {
         for( auto itr = unapplied_transactions.begin(); itr != unapplied_transactions.end();  ) {
            auto trace = control->push_transaction( itr->trx_meta, fc::time_point::maximum(), fc::microseconds::maximum(), DEFAULT_BILLED_CPU_TIME_US, true, 0 );
            traces.emplace_back( trace );
            if(!no_throw && trace->except) {
               // this always throws an fc::exception, since the original exception is copied into an fc::exception
               trace->except->dynamic_rethrow_exception();
            }
            itr = unapplied_transactions.erase( itr );
         }
 
         vector<transaction_id_type> scheduled_trxs;
         while ((scheduled_trxs = get_scheduled_transactions()).size() > 0 ) {
            for( const auto& trx : scheduled_trxs ) {
               auto trace = control->push_scheduled_transaction( trx, fc::time_point::maximum(), fc::microseconds::maximum(), DEFAULT_BILLED_CPU_TIME_US, true );
               traces.emplace_back( trace );
               if( !no_throw && trace->except ) {
                  // this always throws an fc::exception, since the original exception is copied into an fc::exception
                  trace->except->dynamic_rethrow_exception();
               }
            }
         }
      }
 
      auto head_block = _finish_block();
 
      _start_block( next_time + fc::microseconds(config::block_interval_us));
      return head_block;
   }

Here is the call graph for this function:

_start_block()

void sysio::testing::base_tester::_start_block ( fc::time_point block_time )

protected

Definition at line 383 of file tester.cpp.

                                                         {
      auto head_block_number = control->head_block_num();
      auto producer = control->head_block_state()->get_scheduled_producer(block_time);
 
      auto last_produced_block_num = control->last_irreversible_block_num();
      auto itr = last_produced_block.find(producer.producer_name);
      if (itr != last_produced_block.end()) {
         last_produced_block_num = std::max(control->last_irreversible_block_num(), block_header::num_from_id(itr->second));
      }
 
      unapplied_transactions.add_aborted( control->abort_block() );
 
      vector<digest_type> feature_to_be_activated;
      // First add protocol features to be activated WITHOUT preactivation
      feature_to_be_activated.insert(
         feature_to_be_activated.end(),
         protocol_features_to_be_activated_wo_preactivation.begin(),
         protocol_features_to_be_activated_wo_preactivation.end()
      );
      // Then add protocol features to be activated WITH preactivation
      const auto preactivated_protocol_features = control->get_preactivated_protocol_features();
      feature_to_be_activated.insert(
         feature_to_be_activated.end(),
         preactivated_protocol_features.begin(),
         preactivated_protocol_features.end()
      );
 
      control->start_block( block_time, head_block_number - last_produced_block_num, feature_to_be_activated );
 
      // Clear the list, if start block finishes successfuly, the protocol features should be assumed to be activated
      protocol_features_to_be_activated_wo_preactivation.clear();
   }

Here is the call graph for this function:

chain_has_transaction()

bool sysio::testing::base_tester::chain_has_transaction

(

const transaction_id_type &

txid

)

const

Definition at line 953 of file tester.cpp.

                                                                                  {
      return chain_transactions.count(txid) != 0;
   }

close()

void sysio::testing::base_tester::close

(

)

Definition at line 255 of file tester.cpp.

                           {
      control.reset();
      chain_transactions.clear();
   }

create_account()

transaction_trace_ptr sysio::testing::base_tester::create_account	(	account_name	name,
		account_name	creator = config::system_account_name,
		bool	multisig = false,
		bool	include_code = true )

Definition at line 516 of file tester.cpp.

                                                                                                                             {
      signed_transaction trx;
      set_transaction_headers(trx);
 
      authority owner_auth;
      if( multisig ) {
         // multisig between account's owner key and creators active permission
         owner_auth = authority(2, {key_weight{get_public_key( a, "owner" ), 1}}, {permission_level_weight{{creator, config::active_name}, 1}});
      } else {
         owner_auth =  authority( get_public_key( a, "owner" ) );
      }
 
      authority active_auth( get_public_key( a, "active" ) );
 
      auto sort_permissions = []( authority& auth ) {
         std::sort( auth.accounts.begin(), auth.accounts.end(),
                    []( const permission_level_weight& lhs, const permission_level_weight& rhs ) {
                        return lhs.permission < rhs.permission;
                    }
                  );
      };
 
      if( include_code ) {
         FC_ASSERT( owner_auth.threshold <= std::numeric_limits<weight_type>::max(), "threshold is too high" );
         FC_ASSERT( active_auth.threshold <= std::numeric_limits<weight_type>::max(), "threshold is too high" );
         owner_auth.accounts.push_back( permission_level_weight{ {a, config::sysio_code_name},
                                                                 static_cast<weight_type>(owner_auth.threshold) } );
         sort_permissions(owner_auth);
         active_auth.accounts.push_back( permission_level_weight{ {a, config::sysio_code_name},
                                                                  static_cast<weight_type>(active_auth.threshold) } );
         sort_permissions(active_auth);
      }
 
      trx.actions.emplace_back( vector<permission_level>{{creator,config::active_name}},
                                newaccount{
                                   .creator  = creator,
                                   .name     = a,
                                   .owner    = owner_auth,
                                   .active   = active_auth,
                                });
 
      set_transaction_headers(trx);
      trx.sign( get_private_key( creator, "active" ), control->get_chain_id()  );
      return push_transaction( trx );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

create_accounts()

vector< transaction_trace_ptr > sysio::testing::base_tester::create_accounts ( vector< account_name > names, bool multisig = false, bool include_code = true )

inline

Definition at line 234 of file tester.hpp.

         {
            vector<transaction_trace_ptr> traces;
            traces.reserve(names.size());
            for( auto n : names ) traces.emplace_back( create_account( n, config::system_account_name, multisig, include_code ) );
            return traces;
         }

Here is the call graph for this function:

default_config()

static std::pair< controller::config, genesis_state > sysio::testing::base_tester::default_config ( const fc::temp_directory & tempdir, std::optional< uint32_t > genesis_max_inline_action_size = std::optional<uint32_t>{}, std::optional< uint32_t > config_max_nonprivileged_inline_action_size = std::optional<uint32_t>{} )

inlinestatic

Definition at line 396 of file tester.hpp.

                                                                                                                                                                                     {}, std::optional<uint32_t> config_max_nonprivileged_inline_action_size = std::optional<uint32_t>{}) {
            controller::config cfg;
            cfg.blocks_dir      = tempdir.path() / config::default_blocks_dir_name;
            cfg.state_dir  = tempdir.path() / config::default_state_dir_name;
            cfg.state_size = 1024*1024*16;
            cfg.state_guard_size = 0;
            cfg.contracts_console = true;
            cfg.eosvmoc_config.cache_size = 1024*1024*8;
 
            for(int i = 0; i < boost::unit_test::framework::master_test_suite().argc; ++i) {
               if(boost::unit_test::framework::master_test_suite().argv[i] == std::string("--sys-vm"))
                  cfg.wasm_runtime = chain::wasm_interface::vm_type::eos_vm;
               else if(boost::unit_test::framework::master_test_suite().argv[i] == std::string("--sys-vm-jit"))
                  cfg.wasm_runtime = chain::wasm_interface::vm_type::eos_vm_jit;
               else if(boost::unit_test::framework::master_test_suite().argv[i] == std::string("--sys-vm-oc"))
                  cfg.wasm_runtime = chain::wasm_interface::vm_type::eos_vm_oc;
            }
            auto gen = default_genesis();
            if (genesis_max_inline_action_size) {
               gen.initial_configuration.max_inline_action_size = *genesis_max_inline_action_size;
            }
            if (config_max_nonprivileged_inline_action_size) {
               cfg.max_nonprivileged_inline_action_size = *config_max_nonprivileged_inline_action_size;
            }
            return {cfg, gen};
         }

Here is the caller graph for this function:

default_genesis()

static genesis_state sysio::testing::base_tester::default_genesis ( )

inlinestatic

Definition at line 388 of file tester.hpp.

                                                {
            genesis_state genesis;
            genesis.initial_timestamp = fc::time_point::from_iso_string("2020-01-01T00:00:00.000");
            genesis.initial_key = get_public_key( config::system_account_name, "active" );
 
            return genesis;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

delete_authority() [1/2]

void sysio::testing::base_tester::delete_authority	(	account_name	account,
		permission_name	perm )

Definition at line 903 of file tester.cpp.

                                                              {
      delete_authority(account, perm, { permission_level{ account, config::owner_name } }, { get_private_key( account, "owner" ) });
   }

delete_authority() [2/2]

void sysio::testing::base_tester::delete_authority	(	account_name	account,
		permission_name	perm,
		const vector< permission_level > &	auths,
		const vector< private_key_type > &	keys )

Definition at line 886 of file tester.cpp.

                                                                           { try {
         signed_transaction trx;
         trx.actions.emplace_back( auths,
                                   deleteauth(account, perm) );
 
         set_transaction_headers(trx);
         for (const auto& key: keys) {
            trx.sign( key, control->get_chain_id()  );
         }
 
         push_transaction( trx );
      } FC_CAPTURE_AND_RETHROW( (account)(perm) ) }

Here is the call graph for this function:

error()

static action_result sysio::testing::base_tester::error ( const string & msg )

inlinestatic

Definition at line 333 of file tester.hpp.

{ return msg; }

execute_setup_policy()

void sysio::testing::base_tester::execute_setup_policy

(

const setup_policy

policy

)

Definition at line 192 of file tester.cpp.

                                                                   {
      const auto& pfm = control->get_protocol_feature_manager();
 
      auto schedule_preactivate_protocol_feature = [&]() {
         auto preactivate_feature_digest = pfm.get_builtin_digest(builtin_protocol_feature_t::preactivate_feature);
         FC_ASSERT( preactivate_feature_digest, "PREACTIVATE_FEATURE not found" );
         schedule_protocol_features_wo_preactivation( { *preactivate_feature_digest } );
      };
 
      switch (policy) {
         case setup_policy::old_bios_only: {
            set_before_preactivate_bios_contract();
            break;
         }
         case setup_policy::preactivate_feature_only: {
            schedule_preactivate_protocol_feature();
            produce_block(); // block production is required to activate protocol feature
            break;
         }
         case setup_policy::preactivate_feature_and_new_bios: {
            schedule_preactivate_protocol_feature();
            produce_block();
            set_before_producer_authority_bios_contract();
            break;
         }
         case setup_policy::old_wasm_parser: {
            schedule_preactivate_protocol_feature();
            produce_block();
            set_before_producer_authority_bios_contract();
            preactivate_builtin_protocol_features({
               builtin_protocol_feature_t::only_link_to_existing_permission,
               builtin_protocol_feature_t::replace_deferred,
               builtin_protocol_feature_t::no_duplicate_deferred_id,
               builtin_protocol_feature_t::fix_linkauth_restriction,
               builtin_protocol_feature_t::disallow_empty_producer_schedule,
               builtin_protocol_feature_t::restrict_action_to_self,
               builtin_protocol_feature_t::only_bill_first_authorizer,
               builtin_protocol_feature_t::forward_setcode,
               builtin_protocol_feature_t::get_sender,
               builtin_protocol_feature_t::ram_restrictions,
               builtin_protocol_feature_t::webauthn_key,
               builtin_protocol_feature_t::wtmsig_block_signatures,
               builtin_protocol_feature_t::em_key
            });
            produce_block();
            set_bios_contract();
            break;
         }
         case setup_policy::full: {
            schedule_preactivate_protocol_feature();
            produce_block();
            set_before_producer_authority_bios_contract();
            preactivate_all_builtin_protocol_features();
            produce_block();
            set_bios_contract();
            break;
         }
         case setup_policy::none:
         default:
            break;
      };
   }

Here is the call graph for this function:

Here is the caller graph for this function:

find()

template<typename ObjectType , typename IndexBy , typename... Args>

const auto * sysio::testing::base_tester::find ( Args &&... args )

inline

Definition at line 288 of file tester.hpp.

                                            {
            return control->db().find<ObjectType,IndexBy>( forward<Args>(args)... );
         }

find_table()

const table_id_object * sysio::testing::base_tester::find_table	(	name	code,
		name	scope,
		name	table )

Definition at line 1125 of file tester.cpp.

                                                                                     {
      auto tid = control->db().find<table_id_object, by_code_scope_table>(boost::make_tuple(code, scope, table));
      return tid;
   }

Here is the caller graph for this function:

finish_block()

virtual signed_block_ptr sysio::testing::base_tester::finish_block ( )

pure virtual

Implemented in sysio::testing::tester, and sysio::testing::validating_tester.

get() [1/2]

template<typename ObjectType , typename IndexBy , typename... Args>

const auto & sysio::testing::base_tester::get ( Args &&... args )

inline

Definition at line 283 of file tester.hpp.

                                           {
            return control->db().get<ObjectType,IndexBy>( forward<Args>(args)... );
         }

get() [2/2]

template<typename ObjectType >

const auto & sysio::testing::base_tester::get ( const chainbase::oid< ObjectType > & key )

inline

Definition at line 278 of file tester.hpp.

                                                                {
            return control->db().get<ObjectType>(key);
         }

get_action()

action sysio::testing::base_tester::get_action	(	account_name	code,
		action_name	acttype,
		vector< permission_level >	auths,
		const variant_object &	data ) const

Definition at line 680 of file tester.cpp.

                                                                     { try {
      const auto& acnt = control->get_account(code);
      auto abi = acnt.get_abi();
      chain::abi_serializer abis(abi, abi_serializer::create_yield_function( abi_serializer_max_time ));
 
      string action_type_name = abis.get_action_type(acttype);
      FC_ASSERT( action_type_name != string(), "unknown action type ${a}", ("a",acttype) );
 
 
      action act;
      act.account = code;
      act.name = acttype;
      act.authorization = auths;
      act.data = abis.variant_to_binary(action_type_name, data, abi_serializer::create_yield_function( abi_serializer_max_time ));
      return act;
   } FC_CAPTURE_AND_RETHROW() }

Here is the call graph for this function:

get_config()

const controller::config & sysio::testing::base_tester::get_config ( ) const

inline

Definition at line 379 of file tester.hpp.

                                                    {
            return cfg;
         }

get_currency_balance()

asset sysio::testing::base_tester::get_currency_balance	(	const account_name &	code,
		const symbol &	asset_symbol,
		const account_name &	account ) const

Reads balance as stored by generic_currency contract

Definition at line 966 of file tester.cpp.

                                                                           {
      const auto& db  = control->db();
      const auto* tbl = db.template find<table_id_object, by_code_scope_table>(boost::make_tuple(code, account, "accounts"_n));
      share_type result = 0;
 
      // the balance is implied to be 0 if either the table or row does not exist
      if (tbl) {
         const auto *obj = db.template find<key_value_object, by_scope_primary>(boost::make_tuple(tbl->id, asset_symbol.to_symbol_code().value));
         if (obj) {
            //balance is the first field in the serialization
            fc::datastream<const char *> ds(obj->value.data(), obj->value.size());
            fc::raw::unpack(ds, result);
         }
      }
      return asset(result, asset_symbol);
   }

Here is the call graph for this function:

get_last_produced_block_map()

map< account_name, block_id_type > sysio::testing::base_tester::get_last_produced_block_map ( ) const

inline

Definition at line 320 of file tester.hpp.

{ return last_produced_block; };

get_private_key()

template<typename KeyType = fc::ecc::private_key_shim>

static auto sysio::testing::base_tester::get_private_key ( name keyname, string role = "owner" )

inlinestatic

Definition at line 293 of file tester.hpp.

                                                                            {
            auto secret = fc::sha256::hash(keyname.to_string() + role);
            if constexpr (std::is_same_v<KeyType, mock::webauthn_private_key>) {
               return mock::webauthn_private_key::regenerate(secret);
            } else {
               return private_key_type::regenerate<KeyType>(secret);
            }
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_producer_authorities()

vector< producer_authority > sysio::testing::base_tester::get_producer_authorities

(

const vector< account_name > &

producer_names

)

const

Definition at line 1079 of file tester.cpp.

                                                                                                                     {
       // Create producer schedule
       vector<producer_authority> schedule;
       for (auto& producer_name: producer_names) {
          schedule.emplace_back(producer_authority{ producer_name, block_signing_authority_v0{1, {{ get_public_key( producer_name, "active" ), 1}} } });
       }
       return schedule;
   }

Here is the call graph for this function:

get_public_key()

template<typename KeyType = fc::ecc::private_key_shim>

static auto sysio::testing::base_tester::get_public_key ( name keyname, string role = "owner" )

inlinestatic

Definition at line 303 of file tester.hpp.

                                                                           {
            return get_private_key<KeyType>( keyname, role ).get_public_key();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_resolver()

auto sysio::testing::base_tester::get_resolver ( )

inline

Definition at line 339 of file tester.hpp.

                             {
            return [this]( const account_name& name ) -> std::optional<abi_serializer> {
               try {
                  const auto& accnt = control->db().get<account_object, by_name>( name );
                  abi_def abi;
                  if( abi_serializer::to_abi( accnt.abi, abi )) {
                     return abi_serializer( abi, abi_serializer::create_yield_function( abi_serializer_max_time ) );
                  }
                  return std::optional<abi_serializer>();
               } FC_RETHROW_EXCEPTIONS( error, "Failed to find or parse ABI for ${name}", ("name", name))
            };
         }

Here is the call graph for this function:

get_row_by_account()

vector< char > sysio::testing::base_tester::get_row_by_account	(	name	code,
		name	scope,
		name	table,
		const account_name &	act ) const

Definition at line 986 of file tester.cpp.

                                                                                                                  {
      vector<char> data;
      const auto& db = control->db();
      const auto* t_id = db.find<chain::table_id_object, chain::by_code_scope_table>( boost::make_tuple( code, scope, table ) );
      if ( !t_id ) {
         return data;
      }
      //FC_ASSERT( t_id != 0, "object not found" );
 
      const auto& idx = db.get_index<chain::key_value_index, chain::by_scope_primary>();
 
      auto itr = idx.lower_bound( boost::make_tuple( t_id->id, act.to_uint64_t() ) );
      if ( itr == idx.end() || itr->t_id != t_id->id || act.to_uint64_t() != itr->primary_key ) {
         return data;
      }
 
      data.resize( itr->value.size() );
      memcpy( data.data(), itr->value.data(), data.size() );
      return data;
   }

Here is the call graph for this function:

get_scheduled_transactions()

vector< transaction_id_type > sysio::testing::base_tester::get_scheduled_transactions

(

)

const

These transaction IDs represent transactions available in the head chain state as scheduled or otherwise generated transactions.

calling push_scheduled_transaction with these IDs will remove the associated transaction from the chain state IFF it succeeds or objectively fails

Returns

Definition at line 461 of file tester.cpp.

                                                                             {
      const auto& idx = control->db().get_index<generated_transaction_multi_index,by_delay>();
 
      vector<transaction_id_type> result;
 
      auto itr = idx.begin();
      while( itr != idx.end() && itr->delay_until <= control->pending_block_time() ) {
         result.emplace_back(itr->trx_id);
         ++itr;
      }
      return result;
   }

get_table_entry()

template<typename Object >

bool sysio::testing::base_tester::get_table_entry ( Object & obj, account_name code, account_name scope, account_name table, uint64_t key, bool require = true )

inline

Definition at line 358 of file tester.hpp.

                                                                                                                                         {
            auto* maybe_tid = find_table(code, scope, table);
            if( maybe_tid == nullptr ) {
               BOOST_FAIL( "table for code=\"" + code.to_string()
                            + "\" scope=\"" + scope.to_string()
                            + "\" table=\"" + table.to_string()
                            + "\" does not exist"                 );
            }
 
            auto* o = control->db().find<key_value_object, by_scope_primary>(boost::make_tuple(maybe_tid->id, key));
            if( o == nullptr ) {
               if( require )
                  BOOST_FAIL("object does not exist for primary_key=\"" + name(key).to_string() + "\"");
 
               return false;
            }
 
            fc::raw::unpack(o->value.data(), o->value.size(), obj);
            return true;
         }

Here is the call graph for this function:

get_transaction_receipt()

const transaction_receipt & sysio::testing::base_tester::get_transaction_receipt

(

const transaction_id_type &

txid

)

const

Definition at line 958 of file tester.cpp.

                                                                                                          {
      return chain_transactions.at(txid);
   }

get_unapplied_transaction_queue()

unapplied_transaction_queue & sysio::testing::base_tester::get_unapplied_transaction_queue ( )

inline

Definition at line 199 of file tester.hpp.

{ return unapplied_transactions; }

init() [1/7]

void sysio::testing::base_tester::init	(	const setup_policy	policy = setup_policy::full,
		db_read_mode	read_mode = db_read_mode::SPECULATIVE,
		std::optional< uint32_t >	genesis_max_inline_action_size = std::optional<uint32_t>{},
		std::optional< uint32_t >	config_max_nonprivileged_inline_action_size = std::optional<uint32_t>{} )

Definition at line 153 of file tester.cpp.

                                                                                                                                                                                                    {
      auto def_conf = default_config(tempdir, genesis_max_inline_action_size, config_max_nonprivileged_inline_action_size);
      def_conf.first.read_mode = read_mode;
      cfg = def_conf.first;
 
      open(def_conf.second);
      execute_setup_policy(policy);
   }

Here is the call graph for this function:

init() [2/7]

void sysio::testing::base_tester::init

(

controller::config

config

)

Definition at line 172 of file tester.cpp.

                                                 {
      cfg = config;
      open(default_genesis().compute_chain_id());
   }

Here is the call graph for this function:

init() [3/7]

void sysio::testing::base_tester::init	(	controller::config	config,
		const genesis_state &	genesis )

Definition at line 167 of file tester.cpp.

                                                                               {
      cfg = config;
      open(genesis);
   }

Here is the call graph for this function:

init() [4/7]

void sysio::testing::base_tester::init	(	controller::config	config,
		const snapshot_reader_ptr &	snapshot )

Definition at line 162 of file tester.cpp.

                                                                                      {
      cfg = config;
      open(snapshot);
   }

Here is the call graph for this function:

init() [5/7]

void sysio::testing::base_tester::init	(	controller::config	config,
		protocol_feature_set &&	pfs )

Definition at line 187 of file tester.cpp.

                                                                             {
      cfg = config;
      open(std::move(pfs), default_genesis().compute_chain_id());
   }

Here is the call graph for this function:

init() [6/7]

void sysio::testing::base_tester::init	(	controller::config	config,
		protocol_feature_set &&	pfs,
		const genesis_state &	genesis )

Definition at line 182 of file tester.cpp.

                                                                                                           {
      cfg = config;
      open(std::move(pfs), genesis);
   }

Here is the call graph for this function:

init() [7/7]

void sysio::testing::base_tester::init	(	controller::config	config,
		protocol_feature_set &&	pfs,
		const snapshot_reader_ptr &	snapshot )

Definition at line 177 of file tester.cpp.

                                                                                                                  {
      cfg = config;
      open(std::move(pfs), snapshot);
   }

Here is the call graph for this function:

is_same_chain()

bool sysio::testing::base_tester::is_same_chain

(

base_tester &

other

)

Definition at line 149 of file tester.cpp.

                                                       {
     return control->head_block_id() == other.control->head_block_id();
   }

issue()

transaction_trace_ptr sysio::testing::base_tester::issue	(	account_name	to,
		string	amount,
		account_name	currency,
		string	memo )

Definition at line 800 of file tester.cpp.

                                                                                                                {
      fc::variant pretty_trx = fc::mutable_variant_object()
         ("actions", fc::variants({
            fc::mutable_variant_object()
               ("account", currency)
               ("name", "issue")
               ("authorization", fc::variants({
                  fc::mutable_variant_object()
                     ("actor", currency )
                     ("permission", name(config::active_name))
               }))
               ("data", fc::mutable_variant_object()
                  ("to", to)
                  ("quantity", amount)
                  ("memo", memo)
               )
            })
         );
 
      signed_transaction trx;
      abi_serializer::from_variant(pretty_trx, trx, get_resolver(), abi_serializer::create_yield_function( abi_serializer_max_time ));
      set_transaction_headers(trx);
 
      trx.sign( get_private_key( currency, name(config::active_name).to_string() ), control->get_chain_id()  );
      return push_transaction( trx );
   }

Here is the call graph for this function:

link_authority()

void sysio::testing::base_tester::link_authority	(	account_name	account,
		account_name	code,
		permission_name	req,
		action_name	type = {} )

Definition at line 828 of file tester.cpp.

                                                                                                                    {
      signed_transaction trx;
 
      trx.actions.emplace_back( vector<permission_level>{{account, config::active_name}},
                                linkauth(account, code, type, req));
      set_transaction_headers(trx);
      trx.sign( get_private_key( account, "active" ), control->get_chain_id()  );
 
      push_transaction( trx );
   }

Here is the call graph for this function:

open() [1/7]

void sysio::testing::base_tester::open

(

const genesis_state &

genesis

)

Definition at line 264 of file tester.cpp.

                                                        {
      open( make_protocol_feature_set(), genesis );
   }

Here is the call graph for this function:

open() [2/7]

void sysio::testing::base_tester::open

(

const snapshot_reader_ptr &

snapshot

)

Definition at line 260 of file tester.cpp.

                                                               {
      open( make_protocol_feature_set(), snapshot );
   }

Here is the call graph for this function:

open() [3/7]

void sysio::testing::base_tester::open	(	protocol_feature_set &&	pfs,
		const genesis_state &	genesis )

Definition at line 311 of file tester.cpp.

                                                                                    {
      open(std::move(pfs), genesis.compute_chain_id(), [&genesis,&control=this->control]() {
         control->startup( [](){}, []() { return false; }, genesis );
      });
   }

Here is the call graph for this function:

open() [4/7]

void sysio::testing::base_tester::open	(	protocol_feature_set &&	pfs,
		const snapshot_reader_ptr &	snapshot )

Definition at line 303 of file tester.cpp.

                                                                                           {
      const auto& snapshot_chain_id = controller::extract_chain_id( *snapshot );
      snapshot->return_to_header();
      open(std::move(pfs), snapshot_chain_id, [&snapshot,&control=this->control]() {
         control->startup( [](){}, []() { return false; }, snapshot );
      });
   }

Here is the call graph for this function:

open() [5/7]

template<typename Lambda >

void sysio::testing::base_tester::open	(	protocol_feature_set &&	pfs,
		std::optional< chain_id_type >	expected_chain_id,
		Lambda	lambda )

Definition at line 273 of file tester.cpp.

                                                                                                                   {
      if( !expected_chain_id ) {
         expected_chain_id = controller::extract_chain_id_from_db( cfg.state_dir );
         if( !expected_chain_id ) {
            if( fc::is_regular_file( cfg.blocks_dir / "blocks.log" ) ) {
               expected_chain_id = block_log::extract_chain_id( cfg.blocks_dir );
            } else {
               expected_chain_id = genesis_state().compute_chain_id();
            }
         }
      }
 
      control.reset( new controller(cfg, std::move(pfs), *expected_chain_id) );
      control->add_indices();
      lambda();
      chain_transactions.clear();
      control->accepted_block.connect([this]( const block_state_ptr& block_state ){
        FC_ASSERT( block_state->block );
          for( auto receipt : block_state->block->transactions ) {
              if( std::holds_alternative<packed_transaction>(receipt.trx) ) {
                  auto &pt = std::get<packed_transaction>(receipt.trx);
                  chain_transactions[pt.get_transaction().id()] = std::move(receipt);
              } else {
                  auto& id = std::get<transaction_id_type>(receipt.trx);
                  chain_transactions[id] = std::move(receipt);
              }
          }
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

open() [6/7]

void sysio::testing::base_tester::open	(	protocol_feature_set &&	pfs,
		std::optional< chain_id_type >	expected_chain_id = {} )

Definition at line 317 of file tester.cpp.

                                                                                                    {
      open(std::move(pfs), expected_chain_id, [&control=this->control]() {
         control->startup( [](){}, []() { return false; } );
      });
   }

open() [7/7]

void sysio::testing::base_tester::open

(

std::optional< chain_id_type >

expected_chain_id = {}

)

Definition at line 268 of file tester.cpp.

                                                                        {
      open( make_protocol_feature_set(), expected_chain_id );
   }

Here is the call graph for this function:

preactivate_all_builtin_protocol_features()

void sysio::testing::base_tester::preactivate_all_builtin_protocol_features

(

)

Definition at line 1158 of file tester.cpp.

                                                               {
      const auto& pfm = control->get_protocol_feature_manager();
      const auto& pfs = pfm.get_protocol_feature_set();
      const auto current_block_num  =  control->head_block_num() + (control->is_building_block() ? 1 : 0);
      const auto current_block_time = ( control->is_building_block() ? control->pending_block_time()
                                        : control->head_block_time() + fc::milliseconds(config::block_interval_ms) );
 
      set<digest_type>    preactivation_set;
      vector<digest_type> preactivations;
 
      std::function<void(const digest_type&)> add_digests =
      [&pfm, &pfs, current_block_num, current_block_time, &preactivation_set, &preactivations, &add_digests]
      ( const digest_type& feature_digest ) {
         const auto& pf = pfs.get_protocol_feature( feature_digest );
         FC_ASSERT( pf.builtin_feature, "called add_digests on a non-builtin protocol feature" );
         if( !pf.enabled || pf.earliest_allowed_activation_time > current_block_time
             || pfm.is_builtin_activated( *pf.builtin_feature, current_block_num ) ) return;
 
         auto res = preactivation_set.emplace( feature_digest );
         if( !res.second ) return;
 
         for( const auto& dependency : pf.dependencies ) {
            add_digests( dependency );
         }
 
         preactivations.emplace_back( feature_digest );
      };
 
      std::vector<builtin_protocol_feature_t> ordered_builtins;
      for( const auto& f : builtin_protocol_feature_codenames ) {
         ordered_builtins.push_back( f.first );
      }
      std::sort( ordered_builtins.begin(), ordered_builtins.end() );
      for( const auto& f : ordered_builtins ) {
         auto digest = pfs.get_builtin_digest( f);
         if( !digest ) continue;
         add_digests( *digest );
      }
 
      preactivate_protocol_features( preactivations );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

preactivate_builtin_protocol_features()

void sysio::testing::base_tester::preactivate_builtin_protocol_features

(

const std::vector< builtin_protocol_feature_t > &

features

)

Definition at line 1145 of file tester.cpp.

                                                                                                                        {
      const auto& pfs = control->get_protocol_feature_manager().get_protocol_feature_set();
 
      // This behavior is disabled by configurable_wasm_limits
      std::vector<digest_type> features;
      for(builtin_protocol_feature_t feature : builtin_features ) {
         if( auto digest = pfs.get_builtin_digest( feature ) ) {
            features.push_back( *digest );
         }
      }
      preactivate_protocol_features(features);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

preactivate_protocol_features()

void sysio::testing::base_tester::preactivate_protocol_features

(

const vector< digest_type >

feature_digests

)

Definition at line 1138 of file tester.cpp.

                                                                                            {
      for( const auto& feature_digest: feature_digests ) {
         push_action( config::system_account_name, "activate"_n, config::system_account_name,
                      fc::mutable_variant_object()("feature_digest", feature_digest) );
      }
   }

produce_block() [1/2]

virtual signed_block_ptr sysio::testing::base_tester::produce_block ( fc::microseconds skip_time = fc::milliseconds(config::block_interval_ms) )

pure virtual

Implemented in sysio::testing::tester, and sysio::testing::validating_tester.

Here is the caller graph for this function:

produce_block() [2/2]

signed_block_ptr sysio::testing::base_tester::produce_block

(

std::vector< transaction_trace_ptr > &

traces

)

Definition at line 447 of file tester.cpp.

                                                                                         {
      return _produce_block( fc::milliseconds(config::block_interval_ms), false, true, traces );
   }

Here is the call graph for this function:

produce_blocks()

void sysio::testing::base_tester::produce_blocks	(	uint32_t	n = 1,
		bool	empty = false )

Definition at line 451 of file tester.cpp.

                                                            {
      if( empty ) {
         for( uint32_t i = 0; i < n; ++i )
            produce_empty_block();
      } else {
         for( uint32_t i = 0; i < n; ++i )
            produce_block();
      }
   }

Here is the caller graph for this function:

produce_blocks_for_n_rounds()

void sysio::testing::base_tester::produce_blocks_for_n_rounds

(

const uint32_t

num_of_rounds = 1

)

Definition at line 483 of file tester.cpp.

                                                                             {
      for(uint32_t i = 0; i < num_of_rounds; i++) {
         produce_blocks_until_end_of_round();
      }
   }

produce_blocks_until_end_of_round()

void sysio::testing::base_tester::produce_blocks_until_end_of_round

(

)

Definition at line 474 of file tester.cpp.

                                                       {
      uint64_t blocks_per_round;
      while(true) {
         blocks_per_round = control->active_producers().producers.size() * config::producer_repetitions;
         produce_block();
         if (control->head_block_num() % blocks_per_round == (blocks_per_round - 1)) break;
      }
   }

produce_empty_block()

virtual signed_block_ptr sysio::testing::base_tester::produce_empty_block ( fc::microseconds skip_time = fc::milliseconds(config::block_interval_ms) )

pure virtual

Implemented in sysio::testing::tester, and sysio::testing::validating_tester.

produce_min_num_of_blocks_to_spend_time_wo_inactive_prod()

void sysio::testing::base_tester::produce_min_num_of_blocks_to_spend_time_wo_inactive_prod

(

const fc::microseconds

target_elapsed_time = fc::microseconds()

)

Definition at line 489 of file tester.cpp.

                                                                                                                      {
      fc::microseconds elapsed_time;
      while (elapsed_time < target_elapsed_time) {
         for(uint32_t i = 0; i < control->head_block_state()->active_schedule.producers.size(); i++) {
            const auto time_to_skip = fc::milliseconds(config::producer_repetitions * config::block_interval_ms);
            produce_block(time_to_skip);
            elapsed_time += time_to_skip;
         }
         // if it is more than 24 hours, producer will be marked as inactive
         const auto time_to_skip = fc::seconds(23 * 60 * 60);
         produce_block(time_to_skip);
         elapsed_time += time_to_skip;
      }
 
   }

Here is the call graph for this function:

push_action() [1/4]

base_tester::action_result sysio::testing::base_tester::push_action ( action && cert_act, uint64_t authorizer )

nodiscard

Definition at line 609 of file tester.cpp.

                                                                                               {
      signed_transaction trx;
      if (authorizer) {
         act.authorization = vector<permission_level>{{account_name(authorizer), config::active_name}};
      }
      trx.actions.emplace_back(std::move(act));
      set_transaction_headers(trx);
      if (authorizer) {
         trx.sign(get_private_key(account_name(authorizer), "active"), control->get_chain_id());
      }
      try {
         push_transaction(trx);
      } catch (const fc::exception& ex) {
         edump((ex.to_detail_string()));
         return error(ex.top_message()); // top_message() is assumed by many tests; otherwise they fail
         //return error(ex.to_detail_string());
      }
      produce_block();
      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
      return success();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

push_action() [2/4]

transaction_trace_ptr sysio::testing::base_tester::push_action	(	const account_name &	code,
		const action_name &	acttype,
		const account_name &	actor,
		const variant_object &	data,
		uint32_t	expiration = DEFAULT_EXPIRATION_DELTA,
		uint32_t	delay_sec = 0 )

Definition at line 631 of file tester.cpp.

   {
      vector<permission_level> auths;
      auths.push_back( permission_level{actor, config::active_name} );
      return push_action( code, acttype, auths, data, expiration, delay_sec );
   }

push_action() [3/4]

transaction_trace_ptr sysio::testing::base_tester::push_action	(	const account_name &	code,
		const action_name &	acttype,
		const vector< account_name > &	actors,
		const variant_object &	data,
		uint32_t	expiration = DEFAULT_EXPIRATION_DELTA,
		uint32_t	delay_sec = 0 )

Definition at line 645 of file tester.cpp.

   {
      vector<permission_level> auths;
      for (const auto& actor : actors) {
         auths.push_back( permission_level{actor, config::active_name} );
      }
      return push_action( code, acttype, auths, data, expiration, delay_sec );
   }

push_action() [4/4]

transaction_trace_ptr sysio::testing::base_tester::push_action	(	const account_name &	code,
		const action_name &	acttype,
		const vector< permission_level > &	auths,
		const variant_object &	data,
		uint32_t	expiration = DEFAULT_EXPIRATION_DELTA,
		uint32_t	delay_sec = 0 )

Definition at line 661 of file tester.cpp.

   { try {
      signed_transaction trx;
      trx.actions.emplace_back( get_action( code, acttype, auths, data ) );
      set_transaction_headers( trx, expiration, delay_sec );
      for (const auto& auth : auths) {
         trx.sign( get_private_key( auth.actor, auth.permission.to_string() ), control->get_chain_id() );
      }
 
      return push_transaction( trx );
   } FC_CAPTURE_AND_RETHROW( (code)(acttype)(auths)(data)(expiration)(delay_sec) ) }

Here is the call graph for this function:

push_block()

void sysio::testing::base_tester::push_block

(

signed_block_ptr

b

)

Definition at line 323 of file tester.cpp.

                                                  {
      auto bsf = control->create_block_state_future(b->calculate_id(), b);
      unapplied_transactions.add_aborted( control->abort_block() );
      control->push_block( bsf.get(), [this]( const branch_type& forked_branch ) {
         unapplied_transactions.add_forked( forked_branch );
      }, [this]( const transaction_id_type& id ) {
         return unapplied_transactions.get_trx( id );
      } );
 
      auto itr = last_produced_block.find(b->producer);
      if (itr == last_produced_block.end() || b->block_num() > block_header::num_from_id(itr->second)) {
         last_produced_block[b->producer] = b->calculate_id();
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

push_dummy()

transaction_trace_ptr sysio::testing::base_tester::push_dummy	(	account_name	from,
		const string &	v = "blah",
		uint32_t	billed_cpu_time_us = DEFAULT_BILLED_CPU_TIME_US )

Definition at line 731 of file tester.cpp.

                                                                                                                {
      // use reqauth for a normal action, this could be anything
      fc::variant pretty_trx = fc::mutable_variant_object()
         ("actions", fc::variants({
            fc::mutable_variant_object()
               ("account", name(config::system_account_name))
               ("name", "reqauth")
               ("authorization", fc::variants({
                  fc::mutable_variant_object()
                     ("actor", from)
                     ("permission", name(config::active_name))
               }))
               ("data", fc::mutable_variant_object()
                  ("from", from)
               )
            })
        )
        // lets also push a context free action, the multi chain test will then also include a context free action
        ("context_free_actions", fc::variants({
            fc::mutable_variant_object()
               ("account", name(config::null_account_name))
               ("name", "nonce")
               ("data", fc::raw::pack(v))
            })
         );
 
      signed_transaction trx;
      abi_serializer::from_variant(pretty_trx, trx, get_resolver(), abi_serializer::create_yield_function( abi_serializer_max_time ));
      set_transaction_headers(trx);
 
      trx.sign( get_private_key( from, "active" ), control->get_chain_id() );
      return push_transaction( trx, fc::time_point::maximum(), billed_cpu_time_us );
   }

Here is the call graph for this function:

push_reqauth() [1/2]

transaction_trace_ptr sysio::testing::base_tester::push_reqauth	(	account_name	from,
		const vector< permission_level > &	auths,
		const vector< private_key_type > &	keys )

Definition at line 698 of file tester.cpp.

                                                                                                                                                   {
      fc::variant pretty_trx = fc::mutable_variant_object()
         ("actions", fc::variants({
            fc::mutable_variant_object()
               ("account", name(config::system_account_name))
               ("name", "reqauth")
               ("authorization", auths)
               ("data", fc::mutable_variant_object()
                  ("from", from)
               )
            })
        );
 
      signed_transaction trx;
      abi_serializer::from_variant(pretty_trx, trx, get_resolver(), abi_serializer::create_yield_function( abi_serializer_max_time ));
      set_transaction_headers(trx);
      for(auto iter = keys.begin(); iter != keys.end(); iter++)
         trx.sign( *iter, control->get_chain_id() );
      return push_transaction( trx );
   }

Here is the call graph for this function:

push_reqauth() [2/2]

transaction_trace_ptr sysio::testing::base_tester::push_reqauth	(	account_name	from,
		string	role,
		bool	multi_sig = false )

Definition at line 720 of file tester.cpp.

                                                                                                  {
        if (!multi_sig) {
            return push_reqauth(from, vector<permission_level>{{from, config::owner_name}},
                                        {get_private_key(from, role)});
        } else {
            return push_reqauth(from, vector<permission_level>{{from, config::owner_name}},
                                        {get_private_key(from, role), get_private_key( config::system_account_name, "active" )} );
        }
    }

push_transaction() [1/2]

transaction_trace_ptr sysio::testing::base_tester::push_transaction	(	packed_transaction &	trx,
		fc::time_point	deadline = fc::time_point::maximum(),
		uint32_t	billed_cpu_time_us = DEFAULT_BILLED_CPU_TIME_US )

Definition at line 562 of file tester.cpp.

   { try {
      if( !control->is_building_block() )
         _start_block(control->head_block_time() + fc::microseconds(config::block_interval_us));
 
      auto ptrx = std::make_shared<packed_transaction>(trx);
      auto time_limit = deadline == fc::time_point::maximum() ?
            fc::microseconds::maximum() :
            fc::microseconds( deadline - fc::time_point::now() );
      auto fut = transaction_metadata::start_recover_keys( ptrx, control->get_thread_pool(), control->get_chain_id(), time_limit, transaction_metadata::trx_type::input );
      auto r = control->push_transaction( fut.get(), deadline, fc::microseconds::maximum(), billed_cpu_time_us, billed_cpu_time_us > 0, 0 );
      if( r->except_ptr ) std::rethrow_exception( r->except_ptr );
      if( r->except ) throw *r->except;
      return r;
   } FC_RETHROW_EXCEPTIONS( warn, "transaction_header: ${header}", ("header", transaction_header(trx.get_transaction()) )) }

Here is the call graph for this function:

push_transaction() [2/2]

transaction_trace_ptr sysio::testing::base_tester::push_transaction	(	signed_transaction &	trx,
		fc::time_point	deadline = fc::time_point::maximum(),
		uint32_t	billed_cpu_time_us = DEFAULT_BILLED_CPU_TIME_US,
		bool	no_throw = false )

Definition at line 581 of file tester.cpp.

   { try {
      if( !control->is_building_block() )
         _start_block(control->head_block_time() + fc::microseconds(config::block_interval_us));
      auto c = packed_transaction::compression_type::none;
 
      if( fc::raw::pack_size(trx) > 1000 ) {
         c = packed_transaction::compression_type::zlib;
      }
 
      auto time_limit = deadline == fc::time_point::maximum() ?
            fc::microseconds::maximum() :
            fc::microseconds( deadline - fc::time_point::now() );
      auto ptrx = std::make_shared<packed_transaction>( trx, c );
      auto fut = transaction_metadata::start_recover_keys( ptrx, control->get_thread_pool(), control->get_chain_id(), time_limit, transaction_metadata::trx_type::input );
      auto r = control->push_transaction( fut.get(), deadline, fc::microseconds::maximum(), billed_cpu_time_us, billed_cpu_time_us > 0, 0 );
      if (no_throw) return r;
      if( r->except_ptr ) std::rethrow_exception( r->except_ptr );
      if( r->except)  throw *r->except;
      return r;
   } FC_RETHROW_EXCEPTIONS( warn, "transaction_header: ${header}, billed_cpu_time_us: ${billed}",
                            ("header", transaction_header(trx) ) ("billed", billed_cpu_time_us))
   }

Here is the call graph for this function:

schedule_protocol_features_wo_preactivation()

void sysio::testing::base_tester::schedule_protocol_features_wo_preactivation

(

const vector< digest_type >

feature_digests

)

Definition at line 1130 of file tester.cpp.

                                                                                                          {
      protocol_features_to_be_activated_wo_preactivation.insert(
         protocol_features_to_be_activated_wo_preactivation.end(),
         feature_digests.begin(),
         feature_digests.end()
      );
   }

Here is the caller graph for this function:

set_abi()

void sysio::testing::base_tester::set_abi	(	account_name	name,
		const char *	abi_json,
		const private_key_type *	signer = nullptr )

set_authority() [1/2]

void sysio::testing::base_tester::set_authority	(	account_name	account,
		permission_name	perm,
		authority	auth,
		permission_name	parent,
		const vector< permission_level > &	auths,
		const vector< private_key_type > &	keys )

Definition at line 852 of file tester.cpp.

                                                                     { try {
      signed_transaction trx;
 
      trx.actions.emplace_back( auths,
                                updateauth{
                                   .account    = account,
                                   .permission = perm,
                                   .parent     = parent,
                                   .auth       = move(auth),
                                });
 
         set_transaction_headers(trx);
      for (const auto& key: keys) {
         trx.sign( key, control->get_chain_id()  );
      }
 
      push_transaction( trx );
   } FC_CAPTURE_AND_RETHROW( (account)(perm)(auth)(parent) ) }

Here is the call graph for this function:

set_authority() [2/2]

void sysio::testing::base_tester::set_authority	(	account_name	account,
		permission_name	perm,
		authority	auth,
		permission_name	parent = config::owner_name )

Definition at line 877 of file tester.cpp.

                                                            {
      set_authority(account, perm, auth, parent, { { account, config::owner_name } }, { get_private_key( account, "owner" ) });
   }

set_before_preactivate_bios_contract()

void sysio::testing::base_tester::set_before_preactivate_bios_contract

(

)

Definition at line 1063 of file tester.cpp.

                                                          {
      set_code(config::system_account_name, contracts::before_preactivate_sysio_bios_wasm());
      set_abi(config::system_account_name, contracts::before_preactivate_sysio_bios_abi().data());
   }

Here is the caller graph for this function:

set_before_producer_authority_bios_contract()

void sysio::testing::base_tester::set_before_producer_authority_bios_contract

(

)

Definition at line 1068 of file tester.cpp.

                                                                 {
      set_code(config::system_account_name, contracts::before_producer_authority_sysio_bios_wasm());
      set_abi(config::system_account_name, contracts::before_producer_authority_sysio_bios_abi().data());
   }

Here is the caller graph for this function:

set_bios_contract()

void sysio::testing::base_tester::set_bios_contract

(

)

Definition at line 1073 of file tester.cpp.

                                       {
      set_code(config::system_account_name, contracts::sysio_bios_wasm());
      set_abi(config::system_account_name, contracts::sysio_bios_abi().data());
   }

Here is the caller graph for this function:

set_code() [1/2]

void sysio::testing::base_tester::set_code	(	account_name	name,
		const char *	wast,
		const private_key_type *	signer = nullptr )

Definition at line 909 of file tester.cpp.

                                                                                                           {
      set_code(account, wast_to_wasm(wast), signer);
   } FC_CAPTURE_AND_RETHROW( (account) )

Here is the call graph for this function:

set_code() [2/2]

void sysio::testing::base_tester::set_code	(	account_name	name,
		const vector< uint8_t >	wasm,
		const private_key_type *	signer = nullptr )

set_last_produced_block_map()

void sysio::testing::base_tester::set_last_produced_block_map ( const map< account_name, block_id_type > & lpb )

inline

Definition at line 321 of file tester.hpp.

{ last_produced_block = lpb; }

set_producer_schedule()

transaction_trace_ptr sysio::testing::base_tester::set_producer_schedule

(

const vector< producer_authority > &

schedule

)

Definition at line 1094 of file tester.cpp.

                                                                                                       {
      // FC reflection does not create variants that are compatible with ABI 1.1 so we manually translate.
      fc::variants schedule_variant;
      schedule_variant.reserve(schedule.size());
      for( const auto& e: schedule ) {
         schedule_variant.emplace_back(e.get_abi_variant());
      }
 
      return push_action( config::system_account_name, "setprods"_n, config::system_account_name,
                          fc::mutable_variant_object()("schedule", schedule_variant));
 
   }

set_producers()

transaction_trace_ptr sysio::testing::base_tester::set_producers

(

const vector< account_name > &

producer_names

)

Definition at line 1088 of file tester.cpp.

                                                                                              {
      auto schedule = get_producer_authorities( producer_names );
 
      return set_producer_schedule(schedule);
   }

set_producers_legacy()

transaction_trace_ptr sysio::testing::base_tester::set_producers_legacy

(

const vector< account_name > &

producer_names

)

Definition at line 1107 of file tester.cpp.

                                                                                                     {
      auto schedule = get_producer_authorities( producer_names );
      // down-rank to old version
 
      vector<legacy::producer_key> legacy_keys;
      legacy_keys.reserve(schedule.size());
      for (const auto &p : schedule) {
         std::visit([&legacy_keys, &p](const auto& auth){
            legacy_keys.emplace_back(legacy::producer_key{p.producer_name, auth.keys.front().key});
         }, p.authority);
      }
 
      return push_action( config::system_account_name, "setprods"_n, config::system_account_name,
                          fc::mutable_variant_object()("schedule", legacy_keys));
 
   }

set_transaction_headers()

void sysio::testing::base_tester::set_transaction_headers	(	transaction &	trx,
		uint32_t	expiration = DEFAULT_EXPIRATION_DELTA,
		uint32_t	delay_sec = 0 ) const

Definition at line 506 of file tester.cpp.

                                                                                                             {
     trx.expiration = control->head_block_time() + fc::seconds(expiration);
     trx.set_reference_block( control->head_block_id() );
 
     trx.max_net_usage_words = 0; // No limit
     trx.max_cpu_usage_ms = 0; // No limit
     trx.delay_sec = delay_sec;
  }

Here is the call graph for this function:

success()

static action_result sysio::testing::base_tester::success ( )

inlinestatic

Definition at line 331 of file tester.hpp.

{ return string(); }

sync_with()

void sysio::testing::base_tester::sync_with

(

base_tester &

other

)

Definition at line 1039 of file tester.cpp.

                                                 {
      // Already in sync?
      if (control->head_block_id() == other.control->head_block_id())
         return;
      // If other has a longer chain than we do, sync it to us first
      if (control->head_block_num() < other.control->head_block_num())
         return other.sync_with(*this);
 
      auto sync_dbs = [](base_tester& a, base_tester& b) {
         for( uint32_t i = 1; i <= a.control->head_block_num(); ++i ) {
 
            auto block = a.control->fetch_block_by_number(i);
            if( block ) { //&& !b.control->is_known_block(block->id()) ) {
               auto bsf = b.control->create_block_state_future( block->calculate_id(), block );
               b.control->abort_block();
               b.control->push_block(bsf.get(), forked_branch_callback{}, trx_meta_cache_lookup{}); //, sysio::chain::validation_steps::created_block);
            }
         }
      };
 
      sync_dbs(*this, other);
      sync_dbs(other, *this);
   }

Here is the call graph for this function:

to_string()

string sysio::testing::base_tester::to_string ( fc::variant x )

static

Definition at line 1030 of file tester.cpp.

                                            {
      vector<uint8_t> v;
      fc::from_variant<uint8_t>(x, v);
      string s(v.size(), 0);
      copy(v.begin(), v.end(), s.begin());
      return s;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

to_uint64()

uint64_t sysio::testing::base_tester::to_uint64 ( fc::variant x )

static

Definition at line 1022 of file tester.cpp.

                                              {
      vector<uint8_t> blob;
      fc::from_variant<uint8_t>(x, blob);
      FC_ASSERT(8 == blob.size());
      return *reinterpret_cast<uint64_t*>(blob.data());
   }

Here is the call graph for this function:

to_uint8_vector() [1/2]

vector< uint8_t > sysio::testing::base_tester::to_uint8_vector ( const string & s )

static

Definition at line 1008 of file tester.cpp.

                                                               {
      vector<uint8_t> v(s.size());
      copy(s.begin(), s.end(), v.begin());
      return v;
   };

Here is the call graph for this function:

to_uint8_vector() [2/2]

vector< uint8_t > sysio::testing::base_tester::to_uint8_vector ( uint64_t x )

static

Definition at line 1015 of file tester.cpp.

                                                          {
      vector<uint8_t> v(sizeof(x));
      *reinterpret_cast<uint64_t*>(v.data()) = x;
      return v;
   };

transfer() [1/2]

transaction_trace_ptr sysio::testing::base_tester::transfer	(	account_name	from,
		account_name	to,
		asset	amount,
		string	memo,
		account_name	currency )

Definition at line 771 of file tester.cpp.

                                                                                                                                     {
      fc::variant pretty_trx = fc::mutable_variant_object()
         ("actions", fc::variants({
            fc::mutable_variant_object()
               ("account", currency)
               ("name", "transfer")
               ("authorization", fc::variants({
                  fc::mutable_variant_object()
                     ("actor", from)
                     ("permission", name(config::active_name))
               }))
               ("data", fc::mutable_variant_object()
                  ("from", from)
                  ("to", to)
                  ("quantity", amount)
                  ("memo", memo)
               )
            })
         );
 
      signed_transaction trx;
      abi_serializer::from_variant(pretty_trx, trx, get_resolver(), abi_serializer::create_yield_function( abi_serializer_max_time ));
      set_transaction_headers(trx);
 
      trx.sign( get_private_key( from, name(config::active_name).to_string() ), control->get_chain_id()  );
      return push_transaction( trx );
   }

Here is the call graph for this function:

transfer() [2/2]

transaction_trace_ptr sysio::testing::base_tester::transfer	(	account_name	from,
		account_name	to,
		string	amount,
		string	memo,
		account_name	currency )

Definition at line 766 of file tester.cpp.

                                                                                                                                      {
      return transfer( from, to, asset::from_string(amount), memo, currency );
   }

Here is the call graph for this function:

unlink_authority()

void sysio::testing::base_tester::unlink_authority	(	account_name	account,
		account_name	code,
		action_name	type = {} )

Definition at line 840 of file tester.cpp.

                                                                                                 {
      signed_transaction trx;
 
      trx.actions.emplace_back( vector<permission_level>{{account, config::active_name}},
                                unlinkauth(account, code, type ));
      set_transaction_headers(trx);
      trx.sign( get_private_key( account, "active" ), control->get_chain_id()  );
 
      push_transaction( trx );
   }

Here is the call graph for this function:

wasm_assert_code()

static action_result sysio::testing::base_tester::wasm_assert_code ( uint64_t error_code )

inlinestatic

Definition at line 337 of file tester.hpp.

{ return "assertion failure with error code: " + std::to_string(error_code); }

wasm_assert_msg()

static action_result sysio::testing::base_tester::wasm_assert_msg ( const string & msg )

inlinestatic

Definition at line 335 of file tester.hpp.

{ return "assertion failure with message: " + msg; }

Member Data Documentation

abi_serializer_max_time

const fc::microseconds sysio::testing::base_tester::abi_serializer_max_time {1000*1000}

static

Definition at line 153 of file tester.hpp.

block_signing_private_keys

std::map<chain::public_key_type, chain::private_key_type> sysio::testing::base_tester::block_signing_private_keys

Definition at line 437 of file tester.hpp.

cfg

controller::config sysio::testing::base_tester::cfg

protected

Definition at line 439 of file tester.hpp.

chain_transactions

map<transaction_id_type, transaction_receipt> sysio::testing::base_tester::chain_transactions

protected

Definition at line 440 of file tester.hpp.

control

unique_ptr<controller> sysio::testing::base_tester::control

Definition at line 436 of file tester.hpp.

DEFAULT_BILLED_CPU_TIME_US

const uint32_t sysio::testing::base_tester::DEFAULT_BILLED_CPU_TIME_US = 2000

static

Definition at line 152 of file tester.hpp.

DEFAULT_EXPIRATION_DELTA

const uint32_t sysio::testing::base_tester::DEFAULT_EXPIRATION_DELTA = 6

static

Definition at line 150 of file tester.hpp.

last_produced_block

map<account_name, block_id_type> sysio::testing::base_tester::last_produced_block

protected

Definition at line 441 of file tester.hpp.

protocol_features_to_be_activated_wo_preactivation

vector<digest_type> sysio::testing::base_tester::protocol_features_to_be_activated_wo_preactivation

Definition at line 445 of file tester.hpp.

tempdir

fc::temp_directory sysio::testing::base_tester::tempdir

protected

Definition at line 434 of file tester.hpp.

unapplied_transactions

unapplied_transaction_queue sysio::testing::base_tester::unapplied_transactions

protected

Definition at line 442 of file tester.hpp.

---

The documentation for this class was generated from the following files:

• libraries/testing/include/sysio/testing/tester.hpp
• libraries/testing/tester.cpp