sysio::testing Namespace Reference

Namespaces
namespace	mock

Classes
class	base_tester
struct	chainbase_fixture
struct	fc_assert_exception_message_is
struct	fc_assert_exception_message_starts_with
struct	fc_exception_message_is
struct	fc_exception_message_starts_with
struct	sysio_assert_code_is
struct	sysio_assert_message_is
struct	sysio_assert_message_starts_with
class	tester
	provides utility function to simplify the creation of unit tests More...
class	tester_network
	The tester_network class provides a simplistic virtual P2P network connecting testing_blockchains together. More...
class	validating_tester

Typedefs
using	subjective_restriction_map = std::map<builtin_protocol_feature_t, protocol_feature_subjective_restrictions>

Enumerations
enum class	setup_policy {   none , old_bios_only , preactivate_feature_only , preactivate_feature_and_new_bios ,   old_wasm_parser , full }

Functions
std::vector< uint8_t >	read_wasm (const char *fn)
std::vector< char >	read_abi (const char *fn)
std::string	read_wast (const char *fn)
std::string	read_binary_snapshot (const char *fn)
fc::variant	read_json_snapshot (const char *fn)
fc::variant_object	filter_fields (const fc::variant_object &filter, const fc::variant_object &value)
void	copy_row (const chain::key_value_object &obj, vector< char > &data)
bool	expect_assert_message (const fc::exception &ex, string expected)
protocol_feature_set	make_protocol_feature_set (const subjective_restriction_map &custom_subjective_restrictions={})
	FC_CAPTURE_AND_RETHROW ((account)) void base_tester

Typedef Documentation

subjective_restriction_map

using sysio::testing::subjective_restriction_map = std::map<builtin_protocol_feature_t, protocol_feature_subjective_restrictions>

Definition at line 85 of file tester.hpp.

Enumeration Type Documentation

setup_policy

enum class sysio::testing::setup_policy

strong

Enumerator
none
old_bios_only
preactivate_feature_only
preactivate_feature_and_new_bios
old_wasm_parser
full

Definition at line 61 of file tester.hpp.

                           {
      none,
      old_bios_only,
      preactivate_feature_only,
      preactivate_feature_and_new_bios,
      old_wasm_parser,
      full
   };

Function Documentation

copy_row()

void sysio::testing::copy_row	(	const chain::key_value_object &	obj,
		vector< char > &	data )

Definition at line 105 of file tester.cpp.

                                                                       {
      data.resize( obj.value.size() );
      memcpy( data.data(), obj.value.data(), obj.value.size() );
   }

Here is the call graph for this function:

expect_assert_message()

bool sysio::testing::expect_assert_message	(	const fc::exception &	ex,
		string	expected )

Definition at line 91 of file tester.cpp.

                                                                      {
      BOOST_TEST_MESSAGE("LOG : " << "expected: " << expected << ", actual: " << ex.get_log().at(0).get_message());
      return (ex.get_log().at(0).get_message().find(expected) != std::string::npos);
   }

Here is the call graph for this function:

FC_CAPTURE_AND_RETHROW()

sysio::testing::FC_CAPTURE_AND_RETHROW

(

(account)

)

Definition at line 911 of file tester.cpp.

                                                                                                                    {
      signed_transaction trx;
      trx.actions.emplace_back( vector<permission_level>{{account,config::active_name}},
                                setcode{
                                   .account    = account,
                                   .vmtype     = 0,
                                   .vmversion  = 0,
                                   .code       = bytes(wasm.begin(), wasm.end())
                                });
 
      set_transaction_headers(trx);
      if( signer ) {
         trx.sign( *signer, control->get_chain_id()  );
      } else {
         trx.sign( get_private_key( account, "active" ), control->get_chain_id()  );
      }
      push_transaction( trx );
   } FC_CAPTURE_AND_RETHROW( (account) )
 
 
   void base_tester::set_abi( account_name account, const char* abi_json, const private_key_type* signer ) {
      auto abi = fc::json::from_string(abi_json).template as<abi_def>();
      signed_transaction trx;
      trx.actions.emplace_back( vector<permission_level>{{account,config::active_name}},
                                setabi{
                                   .account    = account,
                                   .abi        = fc::raw::pack(abi)
                                });
 
      set_transaction_headers(trx);
      if( signer ) {
         trx.sign( *signer, control->get_chain_id()  );
      } else {
         trx.sign( get_private_key( account, "active" ), control->get_chain_id()  );
      }
      push_transaction( trx );
   }

filter_fields()

fc::variant_object sysio::testing::filter_fields	(	const fc::variant_object &	filter,
		const fc::variant_object &	value )

Definition at line 96 of file tester.cpp.

                                                                                                 {
      fc::mutable_variant_object res;
      for( auto& entry : filter ) {
         auto it = value.find(entry.key());
         res( it->key(), it->value() );
      }
      return res;
   }

make_protocol_feature_set()

protocol_feature_set sysio::testing::make_protocol_feature_set

(

const subjective_restriction_map &

custom_subjective_restrictions = {}

)

Definition at line 110 of file tester.cpp.

                                                                                                                    {
      protocol_feature_set pfs;
 
      map< builtin_protocol_feature_t, std::optional<digest_type> > visited_builtins;
 
      std::function<digest_type(builtin_protocol_feature_t)> add_builtins =
      [&pfs, &visited_builtins, &add_builtins, &custom_subjective_restrictions]
      ( builtin_protocol_feature_t codename ) -> digest_type {
         auto res = visited_builtins.emplace( codename, std::optional<digest_type>() );
         if( !res.second ) {
            SYS_ASSERT( res.first->second, protocol_feature_exception,
                        "invariant failure: cycle found in builtin protocol feature dependencies"
            );
            return *res.first->second;
         }
 
         auto f = protocol_feature_set::make_default_builtin_protocol_feature( codename,
         [&add_builtins]( builtin_protocol_feature_t d ) {
            return add_builtins( d );
         } );
 
         const auto itr = custom_subjective_restrictions.find(codename);
         if( itr != custom_subjective_restrictions.end() ) {
            f.subjective_restrictions = itr->second;
         }
 
         const auto& pf = pfs.add_feature( f );
         res.first->second = pf.feature_digest;
 
         return pf.feature_digest;
      };
 
      for( const auto& p : builtin_protocol_feature_codenames ) {
         add_builtins( p.first );
      }
 
      return pfs;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

read_abi()

std::vector< char > sysio::testing::read_abi

(

const char *

fn

)

Definition at line 52 of file tester.cpp.

                                              {
      std::ifstream abi_file(fn);
      FC_ASSERT( abi_file.is_open(), "abi file cannot be found" );
      abi_file.seekg(0, std::ios::end);
      std::vector<char> abi;
      int len = abi_file.tellg();
      FC_ASSERT( len >= 0, "abi file length is -1" );
      abi.resize(len+1);
      abi_file.seekg(0, std::ios::beg);
      abi_file.read(abi.data(), abi.size());
      abi[abi.size()-1] = '\0';
      abi_file.close();
      return abi;
   }

read_binary_snapshot()

std::string sysio::testing::read_binary_snapshot

(

const char *

fn

)

Definition at line 81 of file tester.cpp.

                                                    {
      return read_gzipped_snapshot(fn);
   }

read_json_snapshot()

fc::variant sysio::testing::read_json_snapshot

(

const char *

fn

)

Definition at line 85 of file tester.cpp.

                                                  {
      return fc::json::from_string( read_gzipped_snapshot(fn) );
   }

Here is the call graph for this function:

read_wasm()

std::vector< uint8_t > sysio::testing::read_wasm

(

const char *

fn

)

Definition at line 38 of file tester.cpp.

                                                  {
      std::ifstream wasm_file(fn, std::ios::binary);
      FC_ASSERT( wasm_file.is_open(), "wasm file cannot be found" );
      wasm_file.seekg(0, std::ios::end);
      std::vector<uint8_t> wasm;
      int len = wasm_file.tellg();
      FC_ASSERT( len >= 0, "wasm file length is -1" );
      wasm.resize(len);
      wasm_file.seekg(0, std::ios::beg);
      wasm_file.read((char*)wasm.data(), wasm.size());
      wasm_file.close();
      return wasm;
   }

read_wast()

std::string sysio::testing::read_wast

(

const char *

fn

)

Definition at line 23 of file tester.cpp.

                                         {
      std::ifstream wast_file(fn);
      FC_ASSERT( wast_file.is_open(), "wast file cannot be found" );
      wast_file.seekg(0, std::ios::end);
      std::vector<char> wast;
      int len = wast_file.tellg();
      FC_ASSERT( len >= 0, "wast file length is -1" );
      wast.resize(len+1);
      wast_file.seekg(0, std::ios::beg);
      wast_file.read(wast.data(), wast.size());
      wast[wast.size()-1] = '\0';
      wast_file.close();
      return {wast.data()};
   }