trezor_tests.cpp File Reference

#include "include_base_utils.h"
#include "cryptonote_basic/cryptonote_basic_impl.h"
#include "cryptonote_basic/account.h"
#include "cryptonote_core/cryptonote_tx_utils.h"
#include "misc_language.h"
#include "string_tools.h"
#include <boost/regex.hpp>
#include "common/util.h"
#include "common/command_line.h"
#include "trezor_tests.h"
#include "tools.h"
#include "device/device_cold.hpp"
#include "device_trezor/device_trezor.hpp"

Include dependency graph for trezor_tests.cpp:

Go to the source code of this file.

Macros
#define	HW_TREZOR_NAME   "Trezor"
#define	TREZOR_ACCOUNT_ORDERING   &m_miner_account, &m_alice_account, &m_bob_account, &m_eve_account
#define	TREZOR_COMMON_TEST_CASE(genclass, CORE, BASE)
#define	TREZOR_SETUP_CHAIN(NAME)
#define	TREZOR_TEST_PREFIX()
#define	TREZOR_TEST_SUFFIX()
#define	TREZOR_SKIP_IF_VERSION_LEQ(x)
#define	TREZOR_TEST_PAYMENT_ID   "\xde\xad\xc0\xde\xde\xad\xc0\xde"
#define	TREZOR_TEST_PAYMENT_ID_LONG   "\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde"

Functions
int	main (int argc, char *argv[])
bool	get_short_payment_id (crypto::hash8 &payment_id8, const tools::wallet2::pending_tx &ptx, hw::device &hwdev)

Macro Definition Documentation

HW_TREZOR_NAME

#define HW_TREZOR_NAME   "Trezor"

Definition at line 61 of file trezor_tests.cpp.

TREZOR_ACCOUNT_ORDERING

#define TREZOR_ACCOUNT_ORDERING   &m_miner_account, &m_alice_account, &m_bob_account, &m_eve_account

Definition at line 62 of file trezor_tests.cpp.

TREZOR_COMMON_TEST_CASE

#define TREZOR_COMMON_TEST_CASE	(		genclass,
			CORE,
			BASE )

Value:

  do {                                                     \
  rollback_chain(CORE, BASE.head_block());                                                                      \
  {                                                                                                             \
    genclass ctest;                                                                                             \
    BASE.fork(ctest);                                                                                           \
    GENERATE_AND_PLAY_INSTANCE(genclass, ctest, *(CORE));                                                       \
  }                                                                                                             \
} while(0)

Definition at line 63 of file trezor_tests.cpp.

#define TREZOR_COMMON_TEST_CASE(genclass, CORE, BASE)  do {                                                     \
  rollback_chain(CORE, BASE.head_block());                                                                      \
  {                                                                                                             \
    genclass ctest;                                                                                             \
    BASE.fork(ctest);                                                                                           \
    GENERATE_AND_PLAY_INSTANCE(genclass, ctest, *(CORE));                                                       \
  }                                                                                                             \
} while(0)

TREZOR_SETUP_CHAIN

#define TREZOR_SETUP_CHAIN

(

NAME

)

Value:

  do {                                                                           \
  ++tests_count;                                                                                                \
  try {                                                                                                         \
    setup_chain(core, trezor_base, chain_path, fix_chain, vm_core);                                            \
  } catch (const std::exception& ex) {                                                                          \
    failed_tests.emplace_back("gen_trezor_base " #NAME);                                                        \
  }                                                                                                             \
} while(0)

Definition at line 72 of file trezor_tests.cpp.

#define TREZOR_SETUP_CHAIN(NAME) do {                                                                           \
  ++tests_count;                                                                                                \
  try {                                                                                                         \
    setup_chain(core, trezor_base, chain_path, fix_chain, vm_core);                                            \
  } catch (const std::exception& ex) {                                                                          \
    failed_tests.emplace_back("gen_trezor_base " #NAME);                                                        \
  }                                                                                                             \
} while(0)

TREZOR_SKIP_IF_VERSION_LEQ

#define TREZOR_SKIP_IF_VERSION_LEQ

(

x

)

Value:

if (m_trezor->get_version() <= x) { MDEBUG("Test skipped"); return true; }

Definition at line 1282 of file trezor_tests.cpp.

TREZOR_TEST_PAYMENT_ID

#define TREZOR_TEST_PAYMENT_ID   "\xde\xad\xc0\xde\xde\xad\xc0\xde"

Definition at line 1283 of file trezor_tests.cpp.

TREZOR_TEST_PAYMENT_ID_LONG

#define TREZOR_TEST_PAYMENT_ID_LONG   "\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde\xde\xad\xc0\xde"

Definition at line 1284 of file trezor_tests.cpp.

TREZOR_TEST_PREFIX

#define TREZOR_TEST_PREFIX

(

)

Value:

test_generator generator(m_generator);                  \
test_setup(events);                                     \
tsx_builder t_builder_o(this);                          \
tsx_builder * t_builder = &t_builder_o

Definition at line 1270 of file trezor_tests.cpp.

#define TREZOR_TEST_PREFIX()                              \
  test_generator generator(m_generator);                  \
  test_setup(events);                                     \
  tsx_builder t_builder_o(this);                          \
  tsx_builder * t_builder = &t_builder_o

TREZOR_TEST_SUFFIX

#define TREZOR_TEST_SUFFIX

(

)

Value:

auto _dsts = t_builder->build();                        \
auto _dsts_info = t_builder->dest_info();               \
test_trezor_tx(events, _dsts, _dsts_info, generator, vct_wallets(m_wl_alice.get(), m_wl_bob.get(), m_wl_eve.get())); \
return true

Definition at line 1276 of file trezor_tests.cpp.

#define TREZOR_TEST_SUFFIX()                              \
  auto _dsts = t_builder->build();                        \
  auto _dsts_info = t_builder->dest_info();               \
  test_trezor_tx(events, _dsts, _dsts_info, generator, vct_wallets(m_wl_alice.get(), m_wl_bob.get(), m_wl_eve.get())); \
  return true

Function Documentation

get_short_payment_id()

bool get_short_payment_id	(	crypto::hash8 &	payment_id8,
		const tools::wallet2::pending_tx &	ptx,
		hw::device &	hwdev )

Definition at line 430 of file trezor_tests.cpp.

{
  std::vector<tx_extra_field> tx_extra_fields;
  parse_tx_extra(ptx.tx.extra, tx_extra_fields); // ok if partially parsed
  cryptonote::tx_extra_nonce extra_nonce;
  if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
  {
    if(get_encrypted_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id8))
    {
      if (ptx.dests.empty())
      {
        MWARNING("Encrypted payment id found, but no destinations public key, cannot decrypt");
        return false;
      }
      return hwdev.decrypt_payment_id(payment_id8, ptx.dests[0].addr.m_view_public_key, ptx.tx_key);
    }
  }
  return false;
}

Here is the call graph for this function:

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 92 of file trezor_tests.cpp.

{
  TRY_ENTRY();
    tools::on_startup();
    epee::string_tools::set_module_name_and_folder(argv[0]);
 
    //set up logging options
    mlog_configure(mlog_get_default_log_path("trezor_tests.log"), true);
    mlog_set_log_level(2);
 
    po::options_description desc_options("Allowed options");
    command_line::add_arg(desc_options, command_line::arg_help);
    command_line::add_arg(desc_options, arg_filter);
    command_line::add_arg(desc_options, arg_trezor_path);
    command_line::add_arg(desc_options, arg_heavy_tests);
    command_line::add_arg(desc_options, arg_chain_path);
    command_line::add_arg(desc_options, arg_fix_chain);
 
    po::variables_map vm;
    bool r = command_line::handle_error_helper(desc_options, [&]()
    {
      po::store(po::parse_command_line(argc, argv, desc_options), vm);
      po::notify(vm);
      return true;
    });
    if (!r)
      return 1;
 
    if (command_line::get_arg(vm, command_line::arg_help))
    {
      std::cout << desc_options << std::endl;
      return 0;
    }
 
    const std::string filter = tools::glob_to_regex(command_line::get_arg(vm, arg_filter));
    boost::smatch match;
 
    size_t tests_count = 0;
    std::vector<std::string> failed_tests;
    std::string trezor_path = command_line::get_arg(vm, arg_trezor_path);
    std::string chain_path = command_line::get_arg(vm, arg_chain_path);
    const bool heavy_tests = command_line::get_arg(vm, arg_heavy_tests);
    const bool fix_chain = command_line::get_arg(vm, arg_fix_chain);
 
    hw::register_device(HW_TREZOR_NAME, ensure_trezor_test_device());  // shim device for call tracking
 
    // Bootstrapping common chain & accounts
    const uint8_t initial_hf =  (uint8_t)get_env_long("TEST_MIN_HF", 11);
    const uint8_t max_hf = (uint8_t)get_env_long("TEST_MAX_HF", 11);
    MINFO("Test versions " << ELECTRONEUM_RELEASE_NAME << "' (v" << ELECTRONEUM_VERSION_FULL << ")");
    MINFO("Testing hardforks [" << (int)initial_hf << ", " << (int)max_hf << "]");
 
    cryptonote::core core_obj(nullptr);
    cryptonote::core * const core = &core_obj;
    std::shared_ptr<mock_daemon> daemon = nullptr;
 
    gen_trezor_base trezor_base;
    trezor_base.setup_args(trezor_path, heavy_tests);
    trezor_base.set_hard_fork(initial_hf);
 
    // Arguments for core & daemon
    po::variables_map vm_core;
    po::options_description desc_params_core("Core");
    mock_daemon::init_options(desc_params_core);
    tools::options::build_options(vm_core, desc_params_core);
    mock_daemon::default_options(vm_core);
 
    // Transaction tests
    for(uint8_t hf=initial_hf; hf <= max_hf + 1; ++hf)
    {
      if (hf > initial_hf || hf > max_hf)
      {
        daemon->stop_and_deinit();
        daemon = nullptr;
        trezor_base.daemon(nullptr);
        if (hf > max_hf)
        {
          break;
        }
      }
 
      MDEBUG("Transaction tests for HF " << (int)hf);
      trezor_base.set_hard_fork(hf);
      TREZOR_SETUP_CHAIN(std::string("HF") + std::to_string((int)hf));
 
      daemon = std::make_shared<mock_daemon>(core, vm_core);
      CHECK_AND_ASSERT_THROW_MES(daemon->nettype() == trezor_base.nettype(), "Serialized chain network type does not match");
 
      daemon->try_init_and_run();
      trezor_base.daemon(daemon);
 
      // Hard-fork independent tests
      if (hf == initial_hf)
      {
        TREZOR_COMMON_TEST_CASE(gen_trezor_ki_sync_without_refresh, core, trezor_base);
        TREZOR_COMMON_TEST_CASE(gen_trezor_live_refresh, core, trezor_base);
        TREZOR_COMMON_TEST_CASE(gen_trezor_ki_sync_with_refresh, core, trezor_base);
      }
 
      TREZOR_COMMON_TEST_CASE(gen_trezor_1utxo, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_1utxo_paymentid_short, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_1utxo_paymentid_short_integrated, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_1utxo_paymentid_long, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_4utxo, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_4utxo_acc1, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_4utxo_to_sub, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_4utxo_to_2sub, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_4utxo_to_1norm_2sub, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_2utxo_sub_acc_to_1norm_2sub, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(gen_trezor_4utxo_to_7outs, core, trezor_base);
      TREZOR_COMMON_TEST_CASE(wallet_api_tests, core, trezor_base);
    }
 
    if (trezor_base.heavy_tests())
    {
      TREZOR_COMMON_TEST_CASE(gen_trezor_many_utxo, core, trezor_base);
    }
 
    core->deinit();
    el::Level level = (failed_tests.empty() ? el::Level::Info : el::Level::Error);
    MLOG(level, "\nREPORT:");
    MLOG(level, "  Test run: " << tests_count);
    MLOG(level, "  Failures: " << failed_tests.size());
    if (!failed_tests.empty())
    {
      MLOG(level, "FAILED TESTS:");
      BOOST_FOREACH(auto test_name, failed_tests)
      {
        MLOG(level, "  " << test_name);
      }
    }
 
    return failed_tests.empty() ? 0 : 1;
 
  CATCH_ENTRY_L0("main", 1);
}

Here is the call graph for this function: