//-----------------------------------------------------------------------------------------------------
bool gen_chain_switch_1::check_split_switched(CryptoNote::Core& c, size_t ev_index,
                                              const std::vector<test_event_entry>& events) {
  DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_switched");

  std::vector<BlockTemplate> blocks;
  auto rawBlocks = c.getBlocks(0, 10000);
  blocks.resize(rawBlocks.size());
  for (size_t i = 0; i < rawBlocks.size(); ++i) {
    CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
  }

  CHECK_EQ(7 + 2 * m_currency->minedMoneyUnlockWindow(), blocks.size());
  auto it = blocks.end();
  --it;
  --it;
  --it;
  CHECK_TEST_CONDITION(std::equal(blocks.begin(), it, m_chain_1.begin()));
  CHECK_TEST_CONDITION(blocks.back() ==
                       boost::get<BlockTemplate>(events[25 + 2 * m_currency->minedMoneyUnlockWindow()])); // blk_7

  auto alt_blocks = c.getAlternativeBlocks();
  CHECK_EQ(2, c.getAlternativeBlockCount());

  // Some blocks that were in main chain are in alt chain now
  for (const auto& b : alt_blocks) {
    CHECK_TEST_CONDITION(
        !(m_chain_1.end() == std::find_if(m_chain_1.cbegin(), m_chain_1.cend(),
                                          [&b](const CryptoNote::BlockTemplate& arg) -> bool { return b == arg; })));
  }

  std::vector<CryptoNote::BlockTemplate> chain;
  map_hash2tx_t mtx;
  bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
  CHECK_TEST_CONDITION(r);
  CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx));
  CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_2, chain, mtx));
  CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx));
  CHECK_EQ(MK_COINS(16), get_balance(m_recipient_account_4, chain, mtx));

  auto tx_pool = c.getPoolTransactions();
  CHECK_EQ(1, tx_pool.size());
  CHECK_TEST_CONDITION(!(tx_pool.front() == m_tx_pool.front()));

  std::vector<size_t> tx_outs;
  uint64_t transfered;
  lookup_acc_outs(m_recipient_account_2.getAccountKeys(), tx_pool.front(), tx_outs, transfered);
  CHECK_EQ(MK_COINS(7), transfered);

  return true;
}
//-----------------------------------------------------------------------------------------------------
bool gen_chain_switch_1::check_split_not_switched(CryptoNote::Core& c, size_t ev_index,
                                                  const std::vector<test_event_entry>& events) {
  DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_not_switched");

  m_recipient_account_1 = boost::get<AccountBase>(events[2]);
  m_recipient_account_2 = boost::get<AccountBase>(events[3]);
  m_recipient_account_3 = boost::get<AccountBase>(events[4]);
  m_recipient_account_4 = boost::get<AccountBase>(events[5]);

  std::vector<BlockTemplate> blocks;
  auto rawBlocks = c.getBlocks(0, 10000);
  blocks.resize(rawBlocks.size());
  for (size_t i = 0; i < rawBlocks.size(); ++i) {
    CHECK_TEST_CONDITION(fromBinaryArray(blocks[i], rawBlocks[i].block));
  }

  CHECK_EQ(6 + 2 * m_currency->minedMoneyUnlockWindow(), blocks.size());
  auto blk_4 = CryptoNote::fromBinaryArray<BlockTemplate>(
      boost::get<RawBlock>(events[21 + 2 * m_currency->minedMoneyUnlockWindow()]).block);
  CHECK_TEST_CONDITION(getBlockHash(blocks.back()) == getBlockHash(blk_4)); // blk_4

  CHECK_EQ(2, c.getAlternativeBlockCount());

  std::vector<CryptoNote::BlockTemplate> chain;
  map_hash2tx_t mtx;
  bool r = find_block_chain(events, chain, mtx, getBlockHash(blocks.back()));
  CHECK_TEST_CONDITION(r);
  CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx));
  CHECK_EQ(MK_COINS(10), get_balance(m_recipient_account_2, chain, mtx));
  CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx));
  CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_4, chain, mtx));

  auto tx_pool = c.getPoolTransactions();
  CHECK_EQ(1, tx_pool.size());

  std::vector<size_t> tx_outs;
  uint64_t transfered;
  lookup_acc_outs(m_recipient_account_4.getAccountKeys(), tx_pool.front(),
                  getTransactionPublicKeyFromExtra(tx_pool.front().extra), tx_outs, transfered);
  CHECK_EQ(MK_COINS(13), transfered);

  m_chain_1.swap(blocks);
  m_tx_pool.swap(tx_pool);

  return true;
}