grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

refactored to guard

Browse Source
This commit is contained in:
Nikolay Volf 2016-01-28 18:38:42 +04:00
parent 0a8e091f3e
commit 673daf0b29
3 changed files with 109 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/blockchain.rs
View File

@ -766,13 +766,16 @@ mod tests {
#[test]
fn can_contain_arbitrary_block_sequence() {
let bc = generate_dummy_blockchain(50);
let bc_result = generate_dummy_blockchain(50);
let bc = bc_result.reference();
assert_eq!(bc.best_block_number(), 49);
}
#[test]
fn can_collect_garbage() {
let bc = generate_dummy_blockchain(3000);
let bc_result = generate_dummy_blockchain(3000);
let bc = bc_result.reference();
assert_eq!(bc.best_block_number(), 2999);
let best_hash = bc.best_block_hash();
let mut block_header = bc.block_header(&best_hash);
@ -786,4 +789,18 @@ mod tests {
assert!(bc.cache_size().blocks < 1024 * 1024);
}
#[test]
fn can_contain_arbitrary_block_sequence_with_extra() {
let bc_result = generate_dummy_blockchain_with_extra(25);
let bc = bc_result.reference();
assert_eq!(bc.best_block_number(), 24);
}
#[test]
fn can_contain_only_genesis_block() {
let bc_result = generate_dummy_empty_blockchain();
let bc = bc_result.reference();
assert_eq!(bc.best_block_number(), 0);
}
}

27
src/tests/client.rs
View File

@ -30,21 +30,6 @@ fn get_bad_state_dummy_block() -> Bytes {
create_test_block(&block_header)
}
fn get_test_client_with_blocks(blocks: Vec<Bytes>) -> Arc<Client> {
let dir = RandomTempPath::new();
let client = Client::new(get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
for block in &blocks {
if let Err(_) = client.import_block(block.clone()) {
panic!("panic importing block which is well-formed");
}
}
client.flush_queue();
client.import_verified_blocks(&IoChannel::disconnected());
client
}
#[test]
fn created() {
let dir = RandomTempPath::new();
@ -86,7 +71,8 @@ fn query_none_block() {
#[test]
fn query_bad_block() {
let client = get_test_client_with_blocks(vec![get_bad_state_dummy_block()]);
let client_result = get_test_client_with_blocks(vec![get_bad_state_dummy_block()]);
let client = client_result.reference();
let bad_block:Option<Bytes> = client.block_header_at(1);
assert!(bad_block.is_none());
@ -95,7 +81,8 @@ fn query_bad_block() {
#[test]
fn returns_chain_info() {
let dummy_block = get_good_dummy_block();
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
let client_result = get_test_client_with_blocks(vec![dummy_block.clone()]);
let client = client_result.reference();
let block = BlockView::new(&dummy_block);
let info = client.chain_info();
assert_eq!(info.best_block_hash, block.header().hash());
@ -103,7 +90,8 @@ fn returns_chain_info() {
#[test]
fn imports_block_sequence() {
let client = generate_dummy_client(6);
let client_result = generate_dummy_client(6);
let client = client_result.reference();
let block = client.block_header_at(5).unwrap();
assert!(!block.is_empty());
@ -111,7 +99,8 @@ fn imports_block_sequence() {
#[test]
fn can_collect_garbage() {
let client = generate_dummy_client(100);
let client_result = generate_dummy_client(100);
let client = client_result.reference();
client.tick();
assert!(client.cache_info().blocks < 100 * 1024);
}

96
src/tests/helpers.rs
View File

@ -33,6 +33,18 @@ impl Drop for RandomTempPath {
}
}
#[allow(dead_code)]
pub struct GuardedTempResult<T> {
result: T,
temp: RandomTempPath
}
impl<T> GuardedTempResult<T> {
pub fn reference(&self) -> &T {
&self.result
}
}
pub fn get_test_spec() -> Spec {
Spec::new_test()
}
@ -45,7 +57,7 @@ pub fn create_test_block(header: &Header) -> Bytes {
rlp.out()
}
fn create_unverifiable_block_header(order: usize, parent_hash: H256) -> Header {
fn create_unverifiable_block_header(order: u32, parent_hash: H256) -> Header {
let mut header = Header::new();
header.gas_limit = x!(0);
header.difficulty = x!(order * 100);
@ -57,24 +69,24 @@ fn create_unverifiable_block_header(order: usize, parent_hash: H256) -> Header {
header
}
fn create_unverifiable_block(order: usize, parent_hash: H256) -> Bytes {
create_test_block_header(&create_unverifiable_block_header(order, parent_hash))
fn create_unverifiable_block(order: u32, parent_hash: H256) -> Bytes {
create_test_block(&create_unverifiable_block_header(order, parent_hash))
}
fn create_unverifiable_block_with_extra(order: usize, parent_hash: H256, Option<Bytes> extra) -> Bytes {
let mut header = create_test_block_header(order, parent_hash);
fn create_unverifiable_block_with_extra(order: u32, parent_hash: H256, extra: Option<Bytes>) -> Bytes {
let mut header = create_unverifiable_block_header(order, parent_hash);
header.extra_data = match extra {
Some(extra_data) => extra_data,
None => {
let base = order as u8;
vec!([1, 2, 3])
let base = (order & 0x000000ff) as u8;
let generated: Vec<u8> = vec![base + 1, base + 2, base + 3];
generated
}
}
};
create_test_block(&header)
}
pub fn generate_dummy_client(block_number: usize) -> Arc<Client> {
pub fn generate_dummy_client(block_number: u32) -> GuardedTempResult<Arc<Client>> {
let dir = RandomTempPath::new();
let client = Client::new(get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
@ -106,10 +118,32 @@ pub fn generate_dummy_client(block_number: usize) -> Arc<Client> {
}
client.flush_queue();
client.import_verified_blocks(&IoChannel::disconnected());
client
GuardedTempResult::<Arc<Client>> {
temp: dir,
result: client
}
}
pub fn generate_dummy_blockchain(block_number: usize) -> BlockChain {
pub fn get_test_client_with_blocks(blocks: Vec<Bytes>) -> GuardedTempResult<Arc<Client>> {
let dir = RandomTempPath::new();
let client = Client::new(get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
for block in &blocks {
if let Err(_) = client.import_block(block.clone()) {
panic!("panic importing block which is well-formed");
}
}
client.flush_queue();
client.import_verified_blocks(&IoChannel::disconnected());
GuardedTempResult::<Arc<Client>> {
temp: dir,
result: client
}
}
pub fn generate_dummy_blockchain(block_number: u32) -> GuardedTempResult<BlockChain> {
let temp = RandomTempPath::new();
let bc = BlockChain::new(
&create_unverifiable_block(
@ -120,7 +154,41 @@ pub fn generate_dummy_blockchain(block_number: usize) -> BlockChain {
for block_order in 1..block_number {
bc.insert_block(&create_unverifiable_block(block_order, bc.best_block_hash()));
}
bc
GuardedTempResult::<BlockChain> {
temp: temp,
result: bc
}
}
pub fn generate_dummy_blockchain_with_extra(block_number: uszie
pub fn generate_dummy_blockchain_with_extra(block_number: u32) -> GuardedTempResult<BlockChain> {
let temp = RandomTempPath::new();
let bc = BlockChain::new(
&create_unverifiable_block(
0,
H256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap()),
temp.as_path());
for block_order in 1..block_number {
bc.insert_block(&create_unverifiable_block_with_extra(block_order, bc.best_block_hash(), None));
}
GuardedTempResult::<BlockChain> {
temp: temp,
result: bc
}
}
pub fn generate_dummy_empty_blockchain() -> GuardedTempResult<BlockChain> {
let temp = RandomTempPath::new();
let bc = BlockChain::new(
&create_unverifiable_block(
0,
H256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap()),
temp.as_path());
GuardedTempResult::<BlockChain> {
temp: temp,
result: bc
}
}