Removing non-applicable tests.
This commit is contained in:
clemahieu
parent
9bfb86cb53
commit
ef784b10df
4 changed files with 3 additions and 311 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -1,279 +0,0 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <rai/node/node.hpp>
|
||||
#include <rai/node/testing.hpp>
|
||||
|
||||
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 <rai::block> 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 <std::unique_ptr <rai::block>> 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 <std::unique_ptr <rai::block>> 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 ();
|
||||
}
|
||||
}
|
||||
|
|
@ -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 ()));
|
||||
|
|
|
|||
|
|
@ -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 <rai::node> (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);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue