From ef784b10dfc6b7cc7b66ab76968f3daeea2367b1 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 20 Jun 2017 11:29:36 -0500 Subject: [PATCH] Removing non-applicable tests. --- CMakeLists.txt | 1 - rai/core_test/block_synchronization.cpp | 279 ------------------------ rai/core_test/gap_cache.cpp | 15 +- rai/core_test/network.cpp | 19 -- 4 files changed, 3 insertions(+), 311 deletions(-) delete mode 100644 rai/core_test/block_synchronization.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 339cb049..c562b74e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -212,7 +212,6 @@ if (RAIBLOCKS_TEST) add_executable (core_test rai/core_test/block.cpp rai/core_test/block_store.cpp - rai/core_test/block_synchronization.cpp rai/core_test/node.cpp rai/core_test/conflicts.cpp rai/core_test/daemon.cpp diff --git a/rai/core_test/block_synchronization.cpp b/rai/core_test/block_synchronization.cpp deleted file mode 100644 index 094ace04..00000000 --- a/rai/core_test/block_synchronization.cpp +++ /dev/null @@ -1,279 +0,0 @@ -#include -#include -#include - -static boost::log::sources::logger_mt test_log; - -class test_synchronization : public rai::block_synchronization -{ -public: - test_synchronization (rai::block_store & store_a) : - rai::block_synchronization (test_log), - store (store_a) - { - } - bool synchronized (MDB_txn * transaction_a, rai::block_hash const & hash_a) override - { - return store.block_exists (transaction_a, hash_a); - } - std::unique_ptr retrieve (MDB_txn * transaction_a, rai::block_hash const & hash_a) override - { - //return store.unchecked_get (transaction_a, hash_a); - return nullptr; - } - rai::sync_result target (MDB_txn * transaction_a, rai::block const & block_a) override - { - store.block_put (transaction_a, block_a.hash (), block_a); - return rai::sync_result::success; - } - rai::block_store & store; -}; - -TEST (pull_synchronization, empty) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - test_synchronization sync (store); - rai::transaction transaction (store.environment, nullptr, true); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, 0)); - ASSERT_EQ (0, store.block_count (transaction).sum ()); -} - -TEST (pull_synchronization, one) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.unchecked_put (transaction, block2.hash (), block2); - test_synchronization sync (store); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block2.hash ())); - ASSERT_EQ (2, store.block_count (transaction).sum ()); - ASSERT_NE (nullptr, store.block_get (transaction, block2.hash ())); -} - -TEST (pull_synchronization, send_dependencies) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::send_block block3 (block2.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.unchecked_put (transaction, block2.hash (), block2); - store.unchecked_put (transaction, block3.hash (), block3); - test_synchronization sync (store); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block3.hash ())); - ASSERT_EQ (3, store.block_count (transaction).sum ()); - ASSERT_NE (nullptr, store.block_get (transaction, block2.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block3.hash ())); -} - -TEST (pull_synchronization, change_dependencies) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::change_block block3 (block2.hash (), 0, rai::keypair ().prv, 2, 3); - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.unchecked_put (transaction, block2.hash (), block2); - store.unchecked_put (transaction, block3.hash (), block3); - test_synchronization sync (store); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block3.hash ())); - ASSERT_EQ (3, store.block_count (transaction).sum ()); - ASSERT_NE (nullptr, store.block_get (transaction, block2.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block3.hash ())); -} - -TEST (pull_synchronization, open_dependencies) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5); - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.unchecked_put (transaction, block2.hash (), block2); - store.unchecked_put (transaction, block3.hash (), block3); - test_synchronization sync (store); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block3.hash ())); - ASSERT_EQ (3, store.block_count (transaction).sum ()); - ASSERT_NE (nullptr, store.block_get (transaction, block2.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block3.hash ())); -} - -TEST (pull_synchronization, receive_dependencies) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5); - rai::send_block block4 (block2.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::receive_block block5 (block3.hash (), block4.hash (), rai::keypair ().prv, 0, 0); - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.unchecked_put (transaction, block2.hash (), block2); - store.unchecked_put (transaction, block3.hash (), block3); - store.unchecked_put (transaction, block4.hash (), block4); - store.unchecked_put (transaction, block5.hash (), block5); - test_synchronization sync (store); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block5.hash ())); - ASSERT_EQ (3, store.block_count (transaction).sum ()); - // Synchronize 2 per iteration in test mode - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block5.hash ())); - ASSERT_EQ (5, store.block_count (transaction).sum ()); - ASSERT_NE (nullptr, store.block_get (transaction, block2.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block3.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block4.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block5.hash ())); -} - -TEST (pull_synchronization, ladder_dependencies) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5); - rai::send_block block4 (block3.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::receive_block block5 (block2.hash (), block4.hash (), rai::keypair ().prv, 0, 0); - rai::send_block block6 (block5.hash (), 0, 1, rai::keypair ().prv, 3, 4); - rai::receive_block block7 (block4.hash (), block6.hash (), rai::keypair ().prv, 0, 0); - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.unchecked_put (transaction, block2.hash (), block2); - store.unchecked_put (transaction, block3.hash (), block3); - store.unchecked_put (transaction, block4.hash (), block4); - store.unchecked_put (transaction, block5.hash (), block5); - store.unchecked_put (transaction, block6.hash (), block6); - store.unchecked_put (transaction, block7.hash (), block7); - test_synchronization sync (store); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block7.hash ())); - ASSERT_EQ (3, store.block_count (transaction).sum ()); - // Synchronize 2 per iteration in test mode - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block7.hash ())); - // Synchronize 2 per iteration in test mode - ASSERT_EQ (5, store.block_count (transaction).sum ()); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block7.hash ())); - ASSERT_EQ (7, store.block_count (transaction).sum ()); - ASSERT_NE (nullptr, store.block_get (transaction, block2.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block3.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block4.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block5.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block6.hash ())); - ASSERT_NE (nullptr, store.block_get (transaction, block7.hash ())); -} - -/*TEST (push_synchronization, empty) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - std::vector > blocks; - rai::push_synchronization sync (test_log, [&blocks] (MDB_txn * transaction_a, rai::block const & block_a) - { - blocks.push_back (block_a.clone ()); - return rai::sync_result::success; - }); - { - rai::transaction transaction (store.environment, nullptr, true); - ASSERT_EQ (rai::sync_result::error, sync.synchronize (transaction, 0)); - } - ASSERT_EQ (0, blocks.size ()); -} - -TEST (push_synchronization, one) -{ - bool init (false); - rai::block_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); - rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4); - std::vector > blocks; - { - rai::transaction transaction (store.environment, nullptr, true); - store.block_put (transaction, block1.hash (), block1); - store.block_put (transaction, block2.hash (), block2); - } - rai::push_synchronization sync (test_log, [&blocks, &store] (MDB_txn * transaction_a, rai::block const & block_a) - { - store.block_put (transaction_a, block_a.hash (), block_a); - blocks.push_back (block_a.clone ()); - return rai::sync_result::success; - }, store); - { - rai::transaction transaction (store.environment, nullptr, true); - store.unsynced_put (transaction, block2.hash ()); - ASSERT_EQ (rai::sync_result::success, sync.synchronize (transaction, block2.hash ())); - } - ASSERT_EQ (1, blocks.size ()); - ASSERT_EQ (block2, *blocks [0]); -}*/ - -// Make sure synchronize terminates even with forks -TEST (pull_synchronization, dependent_fork) -{ - rai::system system0 (24000, 1); - auto & node0 (*system0.nodes [0]); - rai::keypair key0; - rai::keypair key1; - rai::transaction transaction (node0.store.environment, nullptr, true); - auto genesis (node0.ledger.latest (transaction, rai::test_genesis_key.pub)); - rai::send_block send0 (genesis, key0.pub, rai::genesis_amount - 1 * rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::send_block send1 (genesis, key0.pub, rai::genesis_amount - 2 * rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::send_block send2 (send0.hash (), key0.pub, rai::genesis_amount - 3 * rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::send_block send3 (send1.hash (), key0.pub, rai::genesis_amount - 4 * rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, node0.ledger.process (transaction, send0).code); - ASSERT_EQ (rai::process_result::progress, node0.ledger.process (transaction, send2).code); - node0.store.unchecked_put (transaction, send1.hash (), send1); - node0.store.unchecked_put (transaction, send3.hash (), send3); - rai::pull_synchronization sync (node0, nullptr); - ASSERT_EQ (rai::sync_result::fork, sync.synchronize (transaction, send3.hash ())); - // Voting will either discard this block or commit it. If it's discarded we don't want to attempt it again - ASSERT_FALSE (node0.store.unchecked_get (transaction, send1.hash ()).empty ()); - // This block will either succeed, if its predecessor is comitted by voting, or will be a gap and will be discarded - ASSERT_FALSE (node0.store.unchecked_get (transaction, send3.hash ()).empty ()); - ASSERT_TRUE (node0.active.active (send1)); -} - -// After a synchronization with no pulls or pushes required, clear blocks out of unchecked -TEST (pull_synchronization, clear_blocks) -{ - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); - auto & node0 (*system0.nodes [0]); - auto & node1 (*system1.nodes [0]); - rai::send_block send0 (0, 0, rai::genesis_amount - 1 * rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - { - rai::transaction transaction (node1.store.environment, nullptr, true); - node1.store.unchecked_put (transaction, send0.hash (), send0); - } - node1.bootstrap_initiator.bootstrap (node0.network.endpoint ()); - auto iterations (0); - auto done (false); - while (!done) - { - { - rai::transaction transaction (node1.store.environment, nullptr, false); - done = node1.store.unchecked_get (transaction, send0.hash ()).empty (); - } - ++iterations; - ASSERT_GT (200, iterations); - system0.poll (); - system1.poll (); - } -} diff --git a/rai/core_test/gap_cache.cpp b/rai/core_test/gap_cache.cpp index d386fe8e..793c1312 100644 --- a/rai/core_test/gap_cache.cpp +++ b/rai/core_test/gap_cache.cpp @@ -84,20 +84,11 @@ TEST (gap_cache, two_dependencies) rai::send_block send2 (send1.hash (), key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1.hash ())); rai::open_block open (send1.hash (), key.pub, key.pub, key.prv, key.pub, system.work.generate (key.pub)); ASSERT_EQ (0, system.nodes [0]->gap_cache.blocks.size ()); - { - rai::transaction transaction (system.nodes [0]->store.environment, nullptr, true); - system.nodes [0]->process_receive_many (transaction, send2); - } + system.nodes [0]->process_receive_many (send2); ASSERT_EQ (1, system.nodes [0]->gap_cache.blocks.size ()); - { - rai::transaction transaction (system.nodes [0]->store.environment, nullptr, true); - system.nodes [0]->process_receive_many (transaction, open); - } + system.nodes [0]->process_receive_many (open); ASSERT_EQ (2, system.nodes [0]->gap_cache.blocks.size ()); - { - rai::transaction transaction (system.nodes [0]->store.environment, nullptr, true); - system.nodes [0]->process_receive_many (transaction, send1); - } + system.nodes [0]->process_receive_many (send1); ASSERT_EQ (0, system.nodes [0]->gap_cache.blocks.size ()); rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false); ASSERT_TRUE (system.nodes [0]->store.block_exists (transaction, send1.hash ())); diff --git a/rai/core_test/network.cpp b/rai/core_test/network.cpp index 71fac14a..4da0c652 100644 --- a/rai/core_test/network.cpp +++ b/rai/core_test/network.cpp @@ -867,25 +867,6 @@ TEST (network, ipv6_bind_send_ipv4) }); } -TEST (bootstrap_processor, unchecked_only) -{ - rai::system system (24000, 1); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - rai::send_block block1 (node1->latest (rai::test_genesis_key.pub), rai::test_genesis_key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - node1->store.unchecked_put (rai::transaction (node1->store.environment, nullptr, true), block1.hash (), block1); - node1->bootstrap_initiator.bootstrap (system.nodes [0]->network.endpoint ()); - ASSERT_EQ (block1.previous (), node1->latest (rai::test_genesis_key.pub)); - auto iterations (0); - while (node1->latest (rai::test_genesis_key.pub) == block1.previous ()) - { - system.poll (); - ++iterations; - ASSERT_LT (iterations, 200); - } - node1->stop (); -} - TEST (network, endpoint_bad_fd) { rai::system system (24000, 1);