moving around setups

ethcore/src/executive.rs

@@ -43,11 +43,11 @@ pub struct Executed {
 	pub gas: U256,
 	/// Gas used during execution of transaction.
 	pub gas_used: U256,
-	/// Gas refunded after the execution of transaction. 
+	/// Gas refunded after the execution of transaction.
 	/// To get gas that was required up front, add `refunded` and `gas_used`.
 	pub refunded: U256,
 	/// Cumulative gas used in current block so far.
-	/// 
+	///
 	/// `cumulative_gas_used = gas_used(t0) + gas_used(t1) + ... gas_used(tn)`
 	///
 	/// where `tn` is current transaction.
@@ -56,9 +56,9 @@ pub struct Executed {
 	pub logs: Vec<LogEntry>,
 	/// Addresses of contracts created during execution of transaction.
 	/// Ordered from earliest creation.
-	/// 
+	///
-	/// eg. sender creates contract A and A in constructor creates contract B 
+	/// eg. sender creates contract A and A in constructor creates contract B
-	/// 
+	///
 	/// B creation ends first, and it will be the first element of the vector.
 	pub contracts_created: Vec<Address>
 }
@@ -119,13 +119,13 @@ impl<'a> Executive<'a> {
 		if t.nonce != nonce {
 			return Err(From::from(ExecutionError::InvalidNonce { expected: nonce, got: t.nonce }));
 		}
-		
+
 		// validate if transaction fits into given block
 		if self.info.gas_used + t.gas > self.info.gas_limit {
-			return Err(From::from(ExecutionError::BlockGasLimitReached { 
+			return Err(From::from(ExecutionError::BlockGasLimitReached {
-				gas_limit: self.info.gas_limit, 
+				gas_limit: self.info.gas_limit,
-				gas_used: self.info.gas_used, 
+				gas_used: self.info.gas_used,
-				gas: t.gas 
+				gas: t.gas
 			}));
 		}
 
@@ -220,7 +220,7 @@ impl<'a> Executive<'a> {
 
 		if self.engine.is_builtin(&params.code_address) {
 			// if destination is builtin, try to execute it
-			
+
 			let default = [];
 			let data = if let Some(ref d) = params.data { d as &[u8] } else { &default as &[u8] };
 
@@ -239,7 +239,7 @@ impl<'a> Executive<'a> {
 			}
 		} else if params.code.is_some() {
 			// if destination is a contract, do normal message call
-			
+
 			// part of substate that may be reverted
 			let mut unconfirmed_substate = Substate::new();
 
@@ -258,7 +258,7 @@ impl<'a> Executive<'a> {
 			Ok(params.gas)
 		}
 	}
-	
+
 	/// Creates contract with given contract params.
 	/// NOTE. It does not finalize the transaction (doesn't do refunds, nor suicides).
 	/// Modifies the substate.
@@ -317,7 +317,7 @@ impl<'a> Executive<'a> {
 			self.state.kill_account(address);
 		}
 
-		match result { 
+		match result {
 			Err(evm::Error::Internal) => Err(ExecutionError::Internal),
 			Err(_) => {
 				Ok(Executed {
@@ -345,8 +345,8 @@ impl<'a> Executive<'a> {
 	fn enact_result(&mut self, result: &evm::Result, substate: &mut Substate, un_substate: Substate) {
 		match *result {
 			Err(evm::Error::OutOfGas)
-				| Err(evm::Error::BadJumpDestination {..}) 
+				| Err(evm::Error::BadJumpDestination {..})
-				| Err(evm::Error::BadInstruction {.. }) 
+				| Err(evm::Error::BadInstruction {.. })
 				| Err(evm::Error::StackUnderflow {..})
 				| Err(evm::Error::OutOfStack {..}) => {
 				self.state.revert_snapshot();
@@ -364,42 +364,10 @@ impl<'a> Executive<'a> {
 mod tests {
 	use super::*;
 	use common::*;
-	use ethereum;
+	use evm::{Factory, VMType};
-	use engine::*;
-	use spec::*;
-	use evm::{Schedule, Factory, VMType};
 	use substate::*;
 	use tests::helpers::*;
 
-	struct TestEngine {
-		factory: Factory,
-		spec: Spec,
-		max_depth: usize
-	}
-
-	impl TestEngine {
-		fn new(max_depth: usize, factory: Factory) -> TestEngine {
-			TestEngine {
-				factory: factory,
-				spec: ethereum::new_frontier_test(),
-				max_depth: max_depth 
-			}
-		}
-	}
-
-	impl Engine for TestEngine {
-		fn name(&self) -> &str { "TestEngine" }
-		fn spec(&self) -> &Spec { &self.spec }
-		fn vm_factory(&self) -> &Factory {
-			&self.factory
-		}
-		fn schedule(&self, _env_info: &EnvInfo) -> Schedule { 
-			let mut schedule = Schedule::new_frontier();
-			schedule.max_depth = self.max_depth;
-			schedule
-		}
-	}
-
 	#[test]
 	fn test_contract_address() {
 		let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
@@ -488,7 +456,7 @@ mod tests {
 			let mut ex = Executive::new(&mut state, &info, &engine);
 			ex.create(params, &mut substate).unwrap()
 		};
-		
+
 		assert_eq!(gas_left, U256::from(62_976));
 		// ended with max depth
 		assert_eq!(substate.contracts_created.len(), 0);
@@ -542,7 +510,7 @@ mod tests {
 			let mut ex = Executive::new(&mut state, &info, &engine);
 			ex.create(params, &mut substate).unwrap()
 		};
-		
+
 		assert_eq!(gas_left, U256::from(62_976));
 		assert_eq!(substate.contracts_created.len(), 0);
 	}
@@ -594,7 +562,7 @@ mod tests {
 			let mut ex = Executive::new(&mut state, &info, &engine);
 			ex.create(params, &mut substate).unwrap();
 		}
-		
+
 		assert_eq!(substate.contracts_created.len(), 1);
 		assert_eq!(substate.contracts_created[0], next_address);
 	}
@@ -666,7 +634,7 @@ mod tests {
 	fn test_recursive_bomb1(factory: Factory) {
 		// 60 01 - push 1
 		// 60 00 - push 0
-		// 54 - sload 
+		// 54 - sload
 		// 01 - add
 		// 60 00 - push 0
 		// 55 - sstore
@@ -766,7 +734,7 @@ mod tests {
 			let mut ex = Executive::new(&mut state, &info, &engine);
 			ex.transact(&t)
 		};
-		
+
 		match res {
 			Err(Error::Util(UtilError::Crypto(CryptoError::InvalidSignature))) => (),
 			_ => assert!(false, "Expected invalid signature error.")
@@ -797,10 +765,10 @@ mod tests {
 			let mut ex = Executive::new(&mut state, &info, &engine);
 			ex.transact(&t)
 		};
-		
+
 		match res {
-			Err(Error::Execution(ExecutionError::InvalidNonce { expected, got })) 
+			Err(Error::Execution(ExecutionError::InvalidNonce { expected, got }))
-				if expected == U256::zero() && got == U256::one() => (), 
+				if expected == U256::zero() && got == U256::one() => (),
 			_ => assert!(false, "Expected invalid nonce error.")
 		}
 	}
@@ -832,8 +800,8 @@ mod tests {
 		};
 
 		match res {
-			Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, gas })) 
+			Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, gas }))
-				if gas_limit == U256::from(100_000) && gas_used == U256::from(20_000) && gas == U256::from(80_001) => (), 
+				if gas_limit == U256::from(100_000) && gas_used == U256::from(20_000) && gas == U256::from(80_001) => (),
 			_ => assert!(false, "Expected block gas limit error.")
 		}
 	}
@@ -863,10 +831,10 @@ mod tests {
 			let mut ex = Executive::new(&mut state, &info, &engine);
 			ex.transact(&t)
 		};
-		
+
 		match res {
-			Err(Error::Execution(ExecutionError::NotEnoughCash { required , got })) 
+			Err(Error::Execution(ExecutionError::NotEnoughCash { required , got }))
-				if required == U512::from(100_018) && got == U512::from(100_017) => (), 
+				if required == U512::from(100_018) && got == U512::from(100_017) => (),
 			_ => assert!(false, "Expected not enough cash error. {:?}", res)
 		}
 	}

ethcore/src/externalities.rs

@@ -300,6 +300,23 @@ mod tests {
 		let env_info = get_test_env_info();
 
 		let ext = Externalities::new(state, &env_info, test_engine, 0, get_test_origin(), &mut test_sub_state, OutputPolicy::InitContract);
+
+		assert_eq!(ext.env_info().number, 100);
+	}
+
+	#[test]
+	fn can_return_block_hash() {
+		let mut state_result = get_temp_state();
+		let state = state_result.reference_mut();
+		let test_spec = get_test_spec();
+		let test_engine: &Engine = &*test_spec.to_engine().unwrap();
+		let mut test_sub_state = Substate::new();
+		let env_info = get_test_env_info();
+
+		let ext = Externalities::new(state, &env_info, test_engine, 0, get_test_origin(), &mut test_sub_state, OutputPolicy::InitContract);
+
+		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+		assert_eq!(hash, H256::zero());
 	}
 
 }

ethcore/src/tests/helpers.rs

@@ -23,7 +23,9 @@ use std::fs::{remove_dir_all};
 use blockchain::{BlockChain};
 use state::*;
 use rocksdb::*;
-
+use evm::{Schedule, Factory};
+use engine::*;
+use ethereum;
 
 #[cfg(feature = "json-tests")]
 pub enum ChainEra {
@@ -81,6 +83,35 @@ impl<T> GuardedTempResult<T> {
 	}
 }
 
+pub struct TestEngine {
+	factory: Factory,
+	spec: Spec,
+	max_depth: usize
+}
+
+impl TestEngine {
+	pub fn new(max_depth: usize, factory: Factory) -> TestEngine {
+		TestEngine {
+			factory: factory,
+			spec: ethereum::new_frontier_test(),
+			max_depth: max_depth
+		}
+	}
+}
+
+impl Engine for TestEngine {
+	fn name(&self) -> &str { "TestEngine" }
+	fn spec(&self) -> &Spec { &self.spec }
+	fn vm_factory(&self) -> &Factory {
+		&self.factory
+	}
+	fn schedule(&self, _env_info: &EnvInfo) -> Schedule {
+		let mut schedule = Schedule::new_frontier();
+		schedule.max_depth = self.max_depth;
+		schedule
+	}
+}
+
 pub fn get_test_spec() -> Spec {
 	Spec::new_test()
 }