Merge branch 'slim' of https://github.com/eosio/eos into slim

plugins/net_plugin/include/eosio/net_plugin/message_buffer.hpp → libraries/fc/include/fc/network/message_buffer.hpp

@@ -9,7 +9,7 @@
 #include <deque>
 #include <array>
 
-namespace eosio {
+namespace fc {
   template <uint32_t buffer_len>
   class mb_datastream;
 
@@ -299,4 +299,4 @@ namespace eosio {
     return mb_datastream<buffer_len>(*this);
   }
 
-} // namespace eosio
+} // namespace fc

libraries/testing/include/eosio/testing/tester.hpp

@@ -244,8 +244,8 @@ namespace eosio { namespace testing {
       }
       validating_tester(controller::config::runtime_limits limits = controller::config::runtime_limits()) {
          controller::config vcfg;
-         vcfg.block_log_dir      = tempdir.path() / "blocklog";
-         vcfg.shared_memory_dir  = tempdir.path() / "shared";
+         vcfg.block_log_dir      = tempdir.path() / "vblocklog";
+         vcfg.shared_memory_dir  = tempdir.path() / "vshared";
          vcfg.shared_memory_size = 1024*1024*8;
 
          vcfg.genesis.initial_timestamp = fc::time_point::from_iso_string("2020-01-01T00:00:00.000");
@@ -275,8 +275,8 @@ namespace eosio { namespace testing {
       }
 
       bool validate() {
-        auto hbh = control->head_block_header();
-        auto vn_hbh = validating_node->head_block_header();
+        auto hbh = control->head_block_state()->header;
+        auto vn_hbh = validating_node->head_block_state()->header;
         return control->head_block_id() == validating_node->head_block_id() &&
                hbh.previous == vn_hbh.previous &&
                hbh.timestamp == vn_hbh.timestamp &&

plugins/net_plugin/net_plugin.cpp

@@ -6,7 +6,6 @@
 
 #include <eosio/net_plugin/net_plugin.hpp>
 #include <eosio/net_plugin/protocol.hpp>
-#include <eosio/net_plugin/message_buffer.hpp>
 #include <eosio/chain/chain_controller.hpp>
 #include <eosio/chain/exceptions.hpp>
 #include <eosio/chain/block.hpp>
@@ -14,6 +13,7 @@
 #include <eosio/utilities/key_conversion.hpp>
 #include <eosio/chain/contracts/types.hpp>
 
+#include <fc/network/message_buffer.hpp>
 #include <fc/network/ip.hpp>
 #include <fc/io/json.hpp>
 #include <fc/io/raw.hpp>
@@ -399,7 +399,7 @@ namespace eosio {
       optional<sync_state>    peer_requested;  // this peer is requesting info from us
       socket_ptr              socket;
 
-      message_buffer<1024*1024>    pending_message_buffer;
+      fc::message_buffer<1024*1024>    pending_message_buffer;
       vector<char>            blk_buffer;
 
       struct queued_write {

tests/CMakeLists.txt

@@ -19,7 +19,7 @@ include_directories("${CMAKE_SOURCE_DIR}/plugins/wallet_plugin/include")
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/tests/config.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/tests/config.hpp ESCAPE_QUOTES)
 
-file(GLOB UNIT_TESTS "chain_tests/*.cpp" "api_tests/*.cpp" "tests/abi_tests.cpp" "tests/database_tests.cpp" "tests/misc_tests.cpp" "wasm_tests/*.cpp" "tests/message_buffer_tests.cpp" "tests/special_accounts_tests.cpp" "tests/wallet_tests.cpp" "library_tests/*/*.cpp")
+file(GLOB UNIT_TESTS "chain_tests/*.cpp" "api_tests/*.cpp" "tests/abi_tests.cpp" "tests/database_tests.cpp" "wasm_tests/*.cpp" "tests/message_buffer_tests.cpp" "tests/special_accounts_tests.cpp" "tests/wallet_tests.cpp" "library_tests/*/*.cpp")
 
 add_executable( chain_test ${UNIT_TESTS} ${WASM_UNIT_TESTS} common/main.cpp)
 target_link_libraries( chain_test eosio_testing eosio_chain chainbase eos_utilities chain_plugin wallet_plugin abi_generator fc ${PLATFORM_SPECIFIC_LIBS} )

unittests/CMakeLists.txt

@@ -14,18 +14,17 @@ set( CMAKE_CXX_STANDARD 14 )
 
 include_directories("${CMAKE_BINARY_DIR}/contracts")
 include_directories("${CMAKE_SOURCE_DIR}/contracts")
-include_directories("${CMAKE_SOURCE_DIR}/plugins/wallet_plugin/include")
+include_directories("${CMAKE_SOURCE_DIR}/libraries/testing/include")
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/config.hpp ESCAPE_QUOTES)
 
 file(GLOB UNIT_TESTS "*.cpp")
 
 add_executable( unit_test ${UNIT_TESTS} ${WASM_UNIT_TESTS} )
-target_link_libraries( unit_test eosio_chain chainbase eos_utilities wallet_plugin abi_generator fc ${PLATFORM_SPECIFIC_LIBS} )
+target_link_libraries( unit_test eosio_chain chainbase eosio_testing eos_utilities abi_generator fc ${PLATFORM_SPECIFIC_LIBS} )
 
 target_include_directories( unit_test PUBLIC ${CMAKE_BINARY_DIR}/contracts ${CMAKE_CURRENT_BINARY_DIR}/tests/contracts )
 target_include_directories( unit_test PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/wasm_tests )
-target_include_directories( unit_test PUBLIC ${CMAKE_SOURCE_DIR}/plugins/net_plugin/include )
 target_include_directories( unit_test PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include )
 add_dependencies(unit_test asserter test_api test_api_mem test_api_db test_api_multi_index exchange currency proxy identity identity_test stltest infinite eosio.system eosio.token eosio.bios test.inline multi_index_test noop dice eosio.msig)
 

unittests/block_timestamp_tests.cpp

+/**
+ *  @file
+ *  @copyright defined in eos/LICENSE.txt
+ */
+
+#include <boost/test/unit_test.hpp>
+#include <eosio/chain/block_timestamp.hpp>
+#include <fc/time.hpp>
+#include <fc/exception/exception.hpp>
+
+using namespace eosio;
+using namespace chain;
+
+
+
+BOOST_AUTO_TEST_SUITE(block_timestamp_tests)
+
+
+BOOST_AUTO_TEST_CASE(constructor_test) {
+	block_timestamp_type bt;
+        BOOST_TEST( bt.slot == 0, "Default constructor gives wrong value");
+        
+	fc::time_point t(fc::seconds(978307200));	
+	block_timestamp_type bt2(t);
+	BOOST_TEST( bt2.slot == (978307200 - 946684800)*2, "Time point constructor gives wrong value");
+}
+
+BOOST_AUTO_TEST_CASE(conversion_test) {
+	block_timestamp_type bt;
+	fc::time_point t = (fc::time_point)bt;
+	BOOST_TEST(t.time_since_epoch().to_seconds() == 946684800ll, "Time point conversion failed");
+
+	block_timestamp_type bt1(200);
+	t = (fc::time_point)bt1;
+	BOOST_TEST(t.time_since_epoch().to_seconds() == 946684900ll, "Time point conversion failed");
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()

unittests/database_tests.cpp

+/**
+ *  @file
+ *  @copyright defined in eos/LICENSE.txt
+ */
+
+#include <eosio/testing/tester.hpp>
+#include <eosio/chain/global_property_object.hpp>
+#include <fc/crypto/digest.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#ifdef NON_VALIDATING_TEST
+#define TESTER tester
+#else
+#define TESTER validating_tester
+#endif
+
+
+using namespace eosio::chain;
+using namespace eosio::testing;
+namespace bfs = boost::filesystem;
+
+BOOST_AUTO_TEST_SUITE(database_tests)
+
+   // Simple tests of undo infrastructure
+   BOOST_AUTO_TEST_CASE(undo_test) {
+      try {
+         TESTER test;
+         auto &db = test.control->db();
+
+         auto ses = db.start_undo_session(true);
+
+         // Create an account
+         db.create<account_object>([](account_object &a) {
+            a.name = "billy";
+         });
+
+         // Make sure we can retrieve that account by name
+         auto ptr = db.find<account_object, by_name, std::string>("billy");
+         BOOST_TEST(ptr != nullptr);
+
+         // Undo creation of the account
+         ses.undo();
+
+         // Make sure we can no longer find the account
+         ptr = db.find<account_object, by_name, std::string>("billy");
+         BOOST_TEST(ptr == nullptr);
+      } FC_LOG_AND_RETHROW()
+   }
+
+   // Test the block fetching methods on database, fetch_bock_by_id, and fetch_block_by_number
+   BOOST_AUTO_TEST_CASE(get_blocks) {
+      try {
+         TESTER test;
+         vector<block_id_type> block_ids;
+
+         const uint32_t num_of_blocks_to_prod = 200;
+         // Produce 200 blocks and check their IDs should match the above
+         test.produce_blocks(num_of_blocks_to_prod);
+         for (uint32_t i = 0; i < num_of_blocks_to_prod; ++i) {
+            block_ids.emplace_back(test.control->fetch_block_by_number(i + 1)->id());
+            BOOST_TEST(block_header::num_from_id(block_ids.back()) == i + 1);
+            BOOST_TEST(test.control->fetch_block_by_number(i + 1)->id() == block_ids.back());
+         }
+
+         // Utility function to check expected irreversible block
+         auto calc_exp_last_irr_block_num = [&](uint32_t head_block_num) -> uint32_t {
+            const auto producers_size = test.control->head_block_state()->active_schedule.producers.size();
+            const auto max_reversible_rounds = EOS_PERCENT(producers_size, config::percent_100 - config::irreversible_threshold_percent);
+            if( max_reversible_rounds == 0) {
+               return head_block_num;
+            } else {
+               const auto current_round = head_block_num / config::producer_repetitions;
+               const auto irreversible_round = current_round - max_reversible_rounds;
+               return (irreversible_round + 1) * config::producer_repetitions - 1;
+            }
+         };
+
+         // Check the last irreversible block number is set correctly
+         const auto expected_last_irreversible_block_number = calc_exp_last_irr_block_num(num_of_blocks_to_prod) + 1;
+         BOOST_TEST(test.control->head_block_state()->dpos_last_irreversible_blocknum == expected_last_irreversible_block_number);
+         // Check that block 201 cannot be found (only 20 blocks exist)
+         BOOST_CHECK_THROW(test.control->fetch_block_by_number(num_of_blocks_to_prod + 1 + 1),
+                           fc::exception);
+
+         const uint32_t next_num_of_blocks_to_prod = 100;
+         // Produce 100 blocks and check their IDs should match the above
+         test.produce_blocks(next_num_of_blocks_to_prod);
+
+         const auto next_expected_last_irreversible_block_number = calc_exp_last_irr_block_num(
+                 num_of_blocks_to_prod + next_num_of_blocks_to_prod) + 1;
+         // Check the last irreversible block number is updated correctly
+         BOOST_TEST(test.control->head_block_state()->dpos_last_irreversible_blocknum == next_expected_last_irreversible_block_number);
+         // Check that block 201 can now be found
+         BOOST_CHECK_NO_THROW(test.control->fetch_block_by_number(num_of_blocks_to_prod + 1));
+         // Check the latest head block match
+         BOOST_TEST(test.control->fetch_block_by_number(num_of_blocks_to_prod + next_num_of_blocks_to_prod + 1)->id() ==
+                    test.control->head_block_id());
+      } FC_LOG_AND_RETHROW()
+   }
+
+
+BOOST_AUTO_TEST_SUITE_END()

unittests/message_buffer_tests.cpp

+/**
+ *  @file
+ *  @copyright defined in eos/LICENSE.txt
+ */
+
+#include <fc/network/message_buffer.hpp>
+#include <boost/test/unit_test.hpp>
+#include <iostream>
+
+
+namespace eosio {
+using namespace std;
+
+size_t mb_size(boost::asio::mutable_buffer& mb) {
+#if BOOST_VERSION >= 106600
+   return mb.size();
+#else
+   return boost::asio::detail::buffer_size_helper(mb);
+#endif
+}
+
+void* mb_data(boost::asio::mutable_buffer& mb) {
+#if BOOST_VERSION >= 106600
+   return mb.data();
+#else
+   return boost::asio::detail::buffer_cast_helper(mb);
+#endif
+}
+
+BOOST_AUTO_TEST_SUITE(message_buffer_tests)
+
+constexpr auto     def_buffer_size_mb = 4;
+constexpr auto     def_buffer_size = 1024*1024*def_buffer_size_mb;
+
+/// Test default construction and buffer sequence generation
+BOOST_AUTO_TEST_CASE(message_buffer_construction)
+{
+  try {
+    fc::message_buffer<def_buffer_size> mb;
+    BOOST_CHECK_EQUAL(mb.total_bytes(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+    BOOST_CHECK_EQUAL(mb.read_ptr(), mb.write_ptr());
+
+    auto mbs = mb.get_buffer_sequence_for_boost_async_read();
+    auto mbsi = mbs.begin();
+    BOOST_CHECK_EQUAL(mb_size(*mbsi), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb_data(*mbsi), mb.write_ptr());
+    mbsi++;
+    BOOST_CHECK(mbsi == mbs.end());
+  }
+  FC_LOG_AND_RETHROW()
+}
+
+/// Test buffer growth and shrinking
+BOOST_AUTO_TEST_CASE(message_buffer_growth)
+{
+  try {
+    fc::message_buffer<def_buffer_size> mb;
+    mb.add_buffer_to_chain();
+    BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+    BOOST_CHECK_EQUAL(mb.read_ptr(), mb.write_ptr());
+
+    {
+      auto mbs = mb.get_buffer_sequence_for_boost_async_read();
+      auto mbsi = mbs.begin();
+      BOOST_CHECK_EQUAL(mb_size(*mbsi), def_buffer_size);
+      BOOST_CHECK_EQUAL(mb_data(*mbsi), mb.write_ptr());
+      mbsi++;
+      BOOST_CHECK(mbsi != mbs.end());
+      BOOST_CHECK_EQUAL(mb_size(*mbsi), def_buffer_size);
+      BOOST_CHECK_NE(mb_data(*mbsi), nullptr);
+      mbsi++;
+      BOOST_CHECK(mbsi == mbs.end());
+    }
+
+    mb.advance_write_ptr(100);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), 2 * def_buffer_size - 100);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 100);
+    BOOST_CHECK_NE(mb.read_ptr(), nullptr);
+    BOOST_CHECK_NE(mb.write_ptr(), nullptr);
+    BOOST_CHECK_EQUAL((mb.read_ptr() + 100), mb.write_ptr());
+
+    {
+      auto mbs = mb.get_buffer_sequence_for_boost_async_read();
+      auto mbsi = mbs.begin();
+      BOOST_CHECK_EQUAL(mb_size(*mbsi), def_buffer_size - 100);
+      BOOST_CHECK_EQUAL(mb_data(*mbsi), mb.write_ptr());
+      mbsi++;
+      BOOST_CHECK(mbsi != mbs.end());
+      BOOST_CHECK_EQUAL(mb_size(*mbsi), def_buffer_size);
+      BOOST_CHECK_NE(mb_data(*mbsi), nullptr);
+      mbsi++;
+      BOOST_CHECK(mbsi == mbs.end());
+    }
+
+    mb.advance_read_ptr(50);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), 2 * def_buffer_size - 100);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 50);
+
+    mb.advance_write_ptr(def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), def_buffer_size - 100);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 50 + def_buffer_size);
+
+    // Moving read_ptr into second block should reset second block to first
+    mb.advance_read_ptr(def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), def_buffer_size - 100);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 50);
+
+    // Moving read_ptr to write_ptr should shrink chain and reset ptrs
+    mb.advance_read_ptr(50);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+
+    mb.add_buffer_to_chain();
+    BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+
+    mb.advance_write_ptr(50);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), 2 * def_buffer_size - 50);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 50);
+
+    // Moving read_ptr to write_ptr should shrink chain and reset ptrs
+    mb.advance_read_ptr(50);
+    BOOST_CHECK_EQUAL(mb.total_bytes(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_write(), def_buffer_size);
+    BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+  }
+  FC_LOG_AND_RETHROW()
+}
+
+/// Test peek and read across multiple buffers
+BOOST_AUTO_TEST_CASE(message_buffer_peek_read)
+{
+  try {
+    {
+      const uint32_t small = 32;
+      fc::message_buffer<small> mb;
+      BOOST_CHECK_EQUAL(mb.total_bytes(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+      BOOST_CHECK_EQUAL(mb.read_ptr(), mb.write_ptr());
+      BOOST_CHECK_EQUAL(mb.read_index().first, 0);
+      BOOST_CHECK_EQUAL(mb.read_index().second, 0);
+      BOOST_CHECK_EQUAL(mb.write_index().first, 0);
+      BOOST_CHECK_EQUAL(mb.write_index().second, 0);
+
+      mb.add_space(100 - small);
+      BOOST_CHECK_EQUAL(mb.total_bytes(), 4 * small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), 4 * small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+      BOOST_CHECK_EQUAL(mb.read_ptr(), mb.write_ptr());
+
+      char* write_ptr = mb.write_ptr();
+      for (char ind = 0; ind < 100; ) {
+        *write_ptr = ind;
+        ind++;
+        if (ind % small == 0) {
+          mb.advance_write_ptr(small);
+          write_ptr = mb.write_ptr();
+        } else {
+          write_ptr++;
+        }
+      }
+      mb.advance_write_ptr(100 % small);
+
+      BOOST_CHECK_EQUAL(mb.total_bytes(), 4 * small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), 4 * small - 100);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), 100);
+      BOOST_CHECK_NE((void*) mb.read_ptr(), (void*) mb.write_ptr());
+      BOOST_CHECK_EQUAL(mb.read_index().first, 0);
+      BOOST_CHECK_EQUAL(mb.read_index().second, 0);
+      BOOST_CHECK_EQUAL(mb.write_index().first, 3);
+      BOOST_CHECK_EQUAL(mb.write_index().second, 4);
+
+      char buffer[100];
+      auto index = mb.read_index();
+      mb.peek(buffer, 50, index);
+      mb.peek(buffer+50, 50, index);
+      for (int i=0; i < 100; i++) {
+        BOOST_CHECK_EQUAL(i, buffer[i]);
+      }
+
+      BOOST_CHECK_EQUAL(mb.total_bytes(), 4 * small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), 4 * small - 100);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), 100);
+      BOOST_CHECK_NE((void*) mb.read_ptr(), (void*) mb.write_ptr());
+
+      char buffer2[100];
+      mb.read(buffer2, 100);
+      for (int i=0; i < 100; i++) {
+        BOOST_CHECK_EQUAL(i, buffer2[i]);
+      }
+
+      BOOST_CHECK_EQUAL(mb.total_bytes(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+      BOOST_CHECK_EQUAL(mb.read_ptr(), mb.write_ptr());
+    }
+  }
+  FC_LOG_AND_RETHROW()
+}
+
+/// Test automatic allocation when advancing the read_ptr to the end.
+BOOST_AUTO_TEST_CASE(message_buffer_write_ptr_to_end)
+{
+  try {
+    {
+      const uint32_t small = 32;
+      fc::message_buffer<small> mb;
+      BOOST_CHECK_EQUAL(mb.total_bytes(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), 0);
+      BOOST_CHECK_EQUAL(mb.read_ptr(), mb.write_ptr());
+      BOOST_CHECK_EQUAL(mb.read_index().first, 0);
+      BOOST_CHECK_EQUAL(mb.read_index().second, 0);
+      BOOST_CHECK_EQUAL(mb.write_index().first, 0);
+      BOOST_CHECK_EQUAL(mb.write_index().second, 0);
+
+      char* write_ptr = mb.write_ptr();
+      for (char ind = 0; ind < small; ind++) {
+        *write_ptr = ind;
+        write_ptr++;
+      }
+      mb.advance_write_ptr(small);
+
+      BOOST_CHECK_EQUAL(mb.total_bytes(), 2 * small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_write(), small);
+      BOOST_CHECK_EQUAL(mb.bytes_to_read(), small);
+      BOOST_CHECK_NE((void*) mb.read_ptr(), (void*) mb.write_ptr());
+      BOOST_CHECK_EQUAL(mb.read_index().first, 0);
+      BOOST_CHECK_EQUAL(mb.read_index().second, 0);
+      BOOST_CHECK_EQUAL(mb.write_index().first, 1);
+      BOOST_CHECK_EQUAL(mb.write_index().second, 0);
+
+      auto mbs = mb.get_buffer_sequence_for_boost_async_read();
+      auto mbsi = mbs.begin();
+      BOOST_CHECK_EQUAL(mb_size(*mbsi), small);
+      BOOST_CHECK_EQUAL(mb_data(*mbsi), mb.write_ptr());
+      BOOST_CHECK_EQUAL(mb.read_ptr()+small, mb.write_ptr());
+      mbsi++;
+      BOOST_CHECK(mbsi == mbs.end());
+    }
+  }
+  FC_LOG_AND_RETHROW()
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace eosio
+

unittests/wallet_tests.cpp

-/**
- *  @file
- *  @copyright defined in eos/LICENSE.txt
- */
-#include <eosio/utilities/key_conversion.hpp>
-#include <eosio/utilities/rand.hpp>
-#include <eosio/wallet_plugin/wallet.hpp>
-#include <eosio/wallet_plugin/wallet_manager.hpp>
-
-#include <boost/test/unit_test.hpp>
-#include <eosio/chain/authority.hpp>
-
-namespace eosio {
-
-BOOST_AUTO_TEST_SUITE(wallet_tests)
-
-
-/// Test creating the wallet
-BOOST_AUTO_TEST_CASE(wallet_test)
-{ try {
-   using namespace eosio::wallet;
-   using namespace eosio::utilities;
-
-   wallet_data d;
-   wallet_api wallet(d);
-   BOOST_CHECK(wallet.is_locked());
-
-   wallet.set_password("pass");
-   BOOST_CHECK(wallet.is_locked());
-
-   wallet.unlock("pass");
-   BOOST_CHECK(!wallet.is_locked());
-
-   wallet.set_wallet_filename("test");
-   BOOST_CHECK_EQUAL("test", wallet.get_wallet_filename());
-
-   BOOST_CHECK_EQUAL(0, wallet.list_keys().size());
-
-   auto priv = fc::crypto::private_key::generate();
-   auto pub = priv.get_public_key();
-   auto wif = (std::string)priv;
-   wallet.import_key(wif);
-   BOOST_CHECK_EQUAL(1, wallet.list_keys().size());
-
-   auto privCopy = wallet.get_private_key(pub);
-   BOOST_CHECK_EQUAL(wif, (std::string)privCopy);
-
-   wallet.lock();
-   BOOST_CHECK(wallet.is_locked());
-   wallet.unlock("pass");
-   BOOST_CHECK_EQUAL(1, wallet.list_keys().size());
-   wallet.save_wallet_file("wallet_test.json");
-
-   wallet_data d2;
-   wallet_api wallet2(d2);
-
-   BOOST_CHECK(wallet2.is_locked());
-   wallet2.load_wallet_file("wallet_test.json");
-   BOOST_CHECK(wallet2.is_locked());
-
-   wallet2.unlock("pass");
-   BOOST_CHECK_EQUAL(1, wallet2.list_keys().size());
-
-   auto privCopy2 = wallet2.get_private_key(pub);
-   BOOST_CHECK_EQUAL(wif, (std::string)privCopy2);
-} FC_LOG_AND_RETHROW() }
-
-/// Test wallet manager
-BOOST_AUTO_TEST_CASE(wallet_manager_test)
-{ try {
-   using namespace eosio::wallet;
-
-   if (fc::exists("test.wallet")) fc::remove("test.wallet");
-   if (fc::exists("test2.wallet")) fc::remove("test2.wallet");
-
-   constexpr auto key1 = "5JktVNHnRX48BUdtewU7N1CyL4Z886c42x7wYW7XhNWkDQRhdcS";
-   constexpr auto key2 = "5Ju5RTcVDo35ndtzHioPMgebvBM6LkJ6tvuU6LTNQv8yaz3ggZr";
-   constexpr auto key3 = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"; // eosio key
-
-   wallet_manager wm;
-   BOOST_CHECK_EQUAL(0, wm.list_wallets().size());
-   BOOST_CHECK_EQUAL(0, wm.list_keys().size());
-   BOOST_CHECK_NO_THROW(wm.lock_all());
-
-   BOOST_CHECK_THROW(wm.lock("test"), fc::exception);
-   BOOST_CHECK_THROW(wm.unlock("test", "pw"), fc::exception);
-   BOOST_CHECK_THROW(wm.import_key("test", "pw"), fc::exception);
-
-   auto pw = wm.create("test");
-   BOOST_CHECK(!pw.empty());
-   BOOST_CHECK_EQUAL(0, pw.find("PW")); // starts with PW
-   BOOST_CHECK_EQUAL(1, wm.list_wallets().size());
-   // eosio key is imported automatically when a wallet is created
-   BOOST_CHECK_EQUAL(1, wm.list_keys().size());
-   BOOST_CHECK(wm.list_wallets().at(0).find("*") != std::string::npos);
-   wm.lock("test");
-   BOOST_CHECK(wm.list_wallets().at(0).find("*") == std::string::npos);
-   wm.unlock("test", pw);
-   BOOST_CHECK(wm.list_wallets().at(0).find("*") != std::string::npos);
-   wm.import_key("test", key1);
-   BOOST_CHECK_EQUAL(2, wm.list_keys().size());
-   auto keys = wm.list_keys();
-   
-   auto pub_pri_pair = [](const char *key) -> auto {
-       private_key_type prikey = private_key_type(std::string(key));
-       return std::pair<const public_key_type, private_key_type>(prikey.get_public_key(), prikey);
-   };
-
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key1)) != keys.cend());
-
-   wm.import_key("test", key2);
-   keys = wm.list_keys();
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key1)) != keys.cend());
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key2)) != keys.cend());
-   // key3 was automatically imported
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key3)) != keys.cend());
-   wm.lock("test");
-   BOOST_CHECK_EQUAL(0, wm.list_keys().size());
-   wm.unlock("test", pw);
-   BOOST_CHECK_EQUAL(3, wm.list_keys().size());
-   wm.lock_all();
-   BOOST_CHECK_EQUAL(0, wm.list_keys().size());
-   BOOST_CHECK(wm.list_wallets().at(0).find("*") == std::string::npos);
-
-   auto pw2 = wm.create("test2");
-   BOOST_CHECK_EQUAL(2, wm.list_wallets().size());
-   // eosio key is imported automatically when a wallet is created
-   BOOST_CHECK_EQUAL(1, wm.list_keys().size());
-   BOOST_CHECK_THROW(wm.import_key("test2", key3), fc::exception);
-   keys = wm.list_keys();
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key1)) == keys.cend());
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key2)) == keys.cend());
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key3)) != keys.cend());
-   wm.unlock("test", pw);
-   keys = wm.list_keys();
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key1)) != keys.cend());
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key2)) != keys.cend());
-   BOOST_CHECK(std::find(keys.cbegin(), keys.cend(), pub_pri_pair(key3)) != keys.cend());
-
-   private_key_type pkey1{std::string(key1)};
-   private_key_type pkey2{std::string(key2)};
-   private_key_type pkey3{std::string(key3)};
-
-   chain::signed_transaction trx;
-   flat_set<public_key_type> pubkeys;
-   pubkeys.emplace(pkey1.get_public_key());
-   pubkeys.emplace(pkey2.get_public_key());
-   pubkeys.emplace(pkey3.get_public_key());
-   trx = wm.sign_transaction(trx, pubkeys, chain_id_type{});
-   const auto& pks = trx.get_signature_keys(chain_id_type{});
-   BOOST_CHECK_EQUAL(3, pks.size());
-   BOOST_CHECK(find(pks.cbegin(), pks.cend(), pkey1.get_public_key()) != pks.cend());
-   BOOST_CHECK(find(pks.cbegin(), pks.cend(), pkey2.get_public_key()) != pks.cend());
-   BOOST_CHECK(find(pks.cbegin(), pks.cend(), pkey3.get_public_key()) != pks.cend());
-
-   BOOST_CHECK_EQUAL(3, wm.list_keys().size());
-   wm.set_timeout(chrono::seconds(0));
-   BOOST_CHECK_EQUAL(0, wm.list_keys().size());
-
-
-   BOOST_CHECK(fc::exists("test.wallet"));
-   BOOST_CHECK(fc::exists("test2.wallet"));
-   fc::remove("test.wallet");
-   fc::remove("test2.wallet");
-
-} FC_LOG_AND_RETHROW() }
-
-
-
-BOOST_AUTO_TEST_SUITE_END()
-
-} // namespace eos