sysio::trace_api::test_common Namespace Reference

Functions
fc::sha256	operator""_h (const char *input, std::size_t)
chain::name	operator""_n (const char *input, std::size_t)
chain::asset	operator""_t (const char *input, std::size_t)
auto	get_private_key (chain::name keyname, std::string role="owner")
auto	get_public_key (chain::name keyname, std::string role="owner")
chain::bytes	make_transfer_data (chain::name from, chain::name to, chain::asset quantity, std::string &&memo)
auto	make_block_state (chain::block_id_type previous, uint32_t height, uint32_t slot, chain::name producer, std::vector< chain::packed_transaction > trxs)
void	to_kv_helper (const fc::variant &v, std::function< void(const std::string &, const std::string &)> &&append)
auto	to_kv (const fc::variant &v)

Detailed Description

Utilities that make writing tests easier

Function Documentation

get_private_key()

auto sysio::trace_api::test_common::get_private_key	(	chain::name	keyname,
		std::string	role = "owner" )

Definition at line 34 of file test_common.hpp.

                                                                          {
         auto secret = fc::sha256::hash( keyname.to_string() + role );
         return chain::private_key_type::regenerate<fc::ecc::private_key_shim>( secret );
      }

Here is the call graph for this function:

Here is the caller graph for this function:

get_public_key()

auto sysio::trace_api::test_common::get_public_key	(	chain::name	keyname,
		std::string	role = "owner" )

Definition at line 39 of file test_common.hpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

make_block_state()

auto sysio::trace_api::test_common::make_block_state	(	chain::block_id_type	previous,
		uint32_t	height,
		uint32_t	slot,
		chain::name	producer,
		std::vector< chain::packed_transaction >	trxs )

Definition at line 55 of file test_common.hpp.

                                                                       {
         chain::signed_block_ptr block = std::make_shared<chain::signed_block>();
         for( auto& trx : trxs ) {
            block->transactions.emplace_back( trx );
         }
         block->producer = producer;
         block->timestamp = chain::block_timestamp_type(slot);
         // make sure previous contains correct block # so block_header::block_num() returns correct value
         if( previous == chain::block_id_type() ) {
            previous._hash[0] &= 0xffffffff00000000;
            previous._hash[0] += fc::endian_reverse_u32(height - 1);
         }
         block->previous = previous;
 
         auto priv_key = get_private_key( block->producer, "active" );
         auto pub_key = get_public_key( block->producer, "active" );
 
         auto prev = std::make_shared<chain::block_state>();
         auto header_bmroot = chain::digest_type::hash( std::make_pair( block->digest(), prev->blockroot_merkle.get_root()));
         auto sig_digest = chain::digest_type::hash( std::make_pair( header_bmroot, prev->pending_schedule.schedule_hash ));
         block->producer_signature = priv_key.sign( sig_digest );
 
         std::vector<chain::private_key_type> signing_keys;
         signing_keys.emplace_back( std::move( priv_key ));
         auto signer = [&]( chain::digest_type d ) {
            std::vector<chain::signature_type> result;
            result.reserve( signing_keys.size());
            for( const auto& k: signing_keys )
               result.emplace_back( k.sign( d ));
            return result;
         };
         chain::pending_block_header_state pbhs;
         pbhs.producer = block->producer;
         pbhs.timestamp = block->timestamp;
         chain::producer_authority_schedule schedule = {0, {chain::producer_authority{block->producer,
                                                                                      chain::block_signing_authority_v0{1, {{pub_key, 1}}}}}};
         pbhs.active_schedule = schedule;
         pbhs.valid_block_signing_authority = chain::block_signing_authority_v0{1, {{pub_key, 1}}};
         auto bsp = std::make_shared<chain::block_state>(
            std::move( pbhs ),
            std::move( block ),
            std::vector<chain::transaction_metadata_ptr>(),
            chain::protocol_feature_set(),
            []( chain::block_timestamp_type timestamp,
                const fc::flat_set<chain::digest_type>& cur_features,
                const std::vector<chain::digest_type>& new_features ) {},
            signer
         );
         bsp->block_num = height;
 
         return bsp;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

make_transfer_data()

chain::bytes sysio::trace_api::test_common::make_transfer_data	(	chain::name	from,
		chain::name	to,
		chain::asset	quantity,
		std::string &&	memo )

Definition at line 43 of file test_common.hpp.

                                                                                                          {
         fc::datastream<size_t> ps;
         fc::raw::pack(ps, from, to, quantity, memo);
         chain::bytes result( ps.tellp());
 
         if( result.size()) {
            fc::datastream<char *> ds( result.data(), size_t( result.size()));
            fc::raw::pack(ds, from, to, quantity, memo);
         }
         return result;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

operator""_h()

fc::sha256 sysio::trace_api::test_common::operator""_h	(	const char *	input,
		std::size_t	)

Definition at line 22 of file test_common.hpp.

                                                           {
         return fc::sha256(input);
      }

operator""_n()

chain::name sysio::trace_api::test_common::operator""_n	(	const char *	input,
		std::size_t	)

Definition at line 26 of file test_common.hpp.

                                                            {
         return chain::name(input);
      }

operator""_t()

chain::asset sysio::trace_api::test_common::operator""_t	(	const char *	input,
		std::size_t	)

Definition at line 30 of file test_common.hpp.

                                                             {
         return chain::asset::from_string(input);
      }

Here is the call graph for this function:

to_kv()

auto sysio::trace_api::test_common::to_kv

(

const fc::variant &

v

)

Definition at line 132 of file test_common.hpp.

                                     {
         std::map<std::string, std::string> result;
         to_kv_helper(v, [&result](const std::string& k, const std::string& v){
            result.emplace(k, v);
         });
         return result;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

to_kv_helper()

void sysio::trace_api::test_common::to_kv_helper	(	const fc::variant &	v,
		std::function< void(const std::string &, const std::string &)> &&	append )

Definition at line 109 of file test_common.hpp.

                                                                                                           {
         if (v.is_object() ) {
            const auto& obj = v.get_object();
            static const std::string sep = ".";
 
            for (const auto& entry: obj) {
               to_kv_helper( entry.value(), [&append, &entry](const std::string& path, const std::string& value){
                  append(sep + entry.key() + path, value);
               });
            }
         } else if (v.is_array()) {
            const auto& arr = v.get_array();
            for (size_t idx = 0; idx < arr.size(); idx++) {
               const auto& entry = arr.at(idx);
               to_kv_helper( entry, [&append, idx](const std::string& path, const std::string& value){
                  append(std::string("[") + std::to_string(idx) + std::string("]") + path, value);
               });
            }
         } else if (!v.is_null()) {
            append("", v.as_string());
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function: