Merge pull request #394 from ethcore/ext-tests

Externalities tests (still clumsy)

ethcore/src/account.rs

@@ -198,7 +198,11 @@ impl Account {
 	pub fn add_balance(&mut self, x: &U256) { self.balance = self.balance + *x; }
 
 	/// Increment the nonce of the account by one.
-	pub fn sub_balance(&mut self, x: &U256) { self.balance = self.balance - *x; }
+	/// Panics if balance is less than `x`
+	pub fn sub_balance(&mut self, x: &U256) {
+		assert!(self.balance >= *x);
+		self.balance = self.balance - *x;
+	}
 
 	/// Commit the `storage_overlay` to the backing DB and update `storage_root`.
 	pub fn commit_storage(&mut self, db: &mut AccountDBMut) {

ethcore/src/executive.rs

@@ -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();

ethcore/src/externalities.rs

@@ -106,16 +106,18 @@ impl<'a> Ext for Externalities<'a> {
 	}
 
 	fn blockhash(&self, number: &U256) -> H256 {
+		// TODO: comment out what this function expects from env_info, since it will produce panics if the latter is inconsistent
 		match *number < U256::from(self.env_info.number) && number.low_u64() >= cmp::max(256, self.env_info.number) - 256 {
 			true => {
 				let index = self.env_info.number - number.low_u64() - 1;
+				assert!(index < self.env_info.last_hashes.len() as u64, format!("Inconsistent env_info, should contain at least {:?} last hashes", index+1));
 				let r = self.env_info.last_hashes[index as usize].clone();
 				trace!("ext: blockhash({}) -> {} self.env_info.number={}\n", number, r, self.env_info.number);
 				r
 			},
 			false => {
 				trace!("ext: blockhash({}) -> null self.env_info.number={}\n", number, self.env_info.number);
-				H256::from(&U256::zero())
+				H256::zero()
 			},
 		}
 	}
@@ -257,3 +259,144 @@ impl<'a> Ext for Externalities<'a> {
 		self.substate.sstore_clears_count = self.substate.sstore_clears_count + U256::one();
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use common::*;
+	use state::*;
+	use engine::*;
+	use evm::{Ext};
+	use substate::*;
+	use tests::helpers::*;
+	use super::*;
+
+	fn get_test_origin() -> OriginInfo {
+		OriginInfo {
+			address: Address::zero(),
+			origin: Address::zero(),
+			gas_price: U256::zero(),
+			value: U256::zero()
+		}
+	}
+
+	fn get_test_env_info() -> EnvInfo {
+		EnvInfo {
+			number: 100,
+			author: x!(0),
+			timestamp: 0,
+			difficulty: x!(0),
+			last_hashes: vec![],
+			gas_used: x!(0),
+			gas_limit: x!(0)
+		}
+	}
+
+	struct TestSetup {
+		state: GuardedTempResult<State>,
+		engine: Box<Engine>,
+		sub_state: Substate,
+		env_info: EnvInfo
+	}
+
+	impl TestSetup {
+		fn new() -> TestSetup {
+			TestSetup {
+				state: get_temp_state(),
+				engine: get_test_spec().to_engine().unwrap(),
+				sub_state: Substate::new(),
+				env_info: get_test_env_info()
+			}
+		}
+	}
+
+	#[test]
+	fn can_be_created() {
+		let mut setup = TestSetup::new();
+		let state = setup.state.reference_mut();
+
+		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+
+		assert_eq!(ext.env_info().number, 100);
+	}
+
+	#[test]
+	fn can_return_block_hash_no_env() {
+		let mut setup = TestSetup::new();
+		let state = setup.state.reference_mut();
+		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+
+		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+
+		assert_eq!(hash, H256::zero());
+	}
+
+	#[test]
+	fn can_return_block_hash() {
+		let test_hash = H256::from("afafafafafafafafafafafbcbcbcbcbcbcbcbcbcbeeeeeeeeeeeeedddddddddd");
+		let test_env_number = 0x120001;
+
+		let mut setup = TestSetup::new();
+		{
+			let env_info = &mut setup.env_info;
+			env_info.number = test_env_number;
+			env_info.last_hashes.push(test_hash.clone());
+		}
+		let state = setup.state.reference_mut();
+		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+
+		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+
+		assert_eq!(test_hash, hash);
+	}
+
+	#[test]
+	#[should_panic]
+	fn can_call_fail_empty() {
+		let mut setup = TestSetup::new();
+		let state = setup.state.reference_mut();
+		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+
+		let mut output = vec![];
+
+		// this should panic because we have no balance on any account
+		ext.call(
+			&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap(),
+			&Address::new(),
+			&Address::new(),
+			Some(U256::from_str("0000000000000000000000000000000000000000000000000000000000150000").unwrap()),
+			&vec![],
+			&Address::new(),
+			&mut output);
+	}
+
+	#[test]
+	fn can_log() {
+		let log_data = vec![120u8, 110u8];
+		let log_topics = vec![H256::from("af0fa234a6af46afa23faf23bcbc1c1cb4bcb7bcbe7e7e7ee3ee2edddddddddd")];
+
+		let mut setup = TestSetup::new();
+		let state = setup.state.reference_mut();
+
+		{
+			let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+			ext.log(log_topics, &log_data);
+		}
+
+		assert_eq!(setup.sub_state.logs.len(), 1);
+	}
+
+	#[test]
+	fn can_suicide() {
+		let refund_account = &Address::new();
+
+		let mut setup = TestSetup::new();
+		let state = setup.state.reference_mut();
+
+		{
+			let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+			ext.suicide(&refund_account);
+		}
+
+		assert_eq!(setup.sub_state.suicides.len(), 1);
+	}
+}

ethcore/src/json_tests/executive.rs

@@ -26,15 +26,15 @@ use externalities::*;
 use substate::*;
 use tests::helpers::*;
 
-struct TestEngine {
+struct TestEngineFrontier {
 	vm_factory: Factory,
 	spec: Spec,
 	max_depth: usize
 }
 
-impl TestEngine {
+impl TestEngineFrontier {
-	fn new(max_depth: usize, vm_type: VMType) -> TestEngine {
+	fn new(max_depth: usize, vm_type: VMType) -> TestEngineFrontier {
-		TestEngine {
+		TestEngineFrontier {
 			vm_factory: Factory::new(vm_type),
 			spec: ethereum::new_frontier_test(),
 			max_depth: max_depth
@@ -42,7 +42,7 @@ impl TestEngine {
 	}
 }
 
-impl Engine for TestEngine {
+impl Engine for TestEngineFrontier {
 	fn name(&self) -> &str { "TestEngine" }
 	fn spec(&self) -> &Spec { &self.spec }
 	fn vm_factory(&self) -> &Factory { &self.vm_factory }
@@ -209,7 +209,7 @@ fn do_json_test_for(vm: &VMType, json_data: &[u8]) -> Vec<String> {
 			EnvInfo::from_json(env)
 		}).unwrap_or_default();
 
-		let engine = TestEngine::new(1, vm.clone());
+		let engine = TestEngineFrontier::new(1, vm.clone());
 
 		// params
 		let mut params = ActionParams::default();

ethcore/src/substate.rs

@@ -56,6 +56,12 @@ mod tests {
 	use super::*;
 	use common::*;
 
+	#[test]
+	fn created() {
+		let sub_state = Substate::new();
+		assert_eq!(sub_state.suicides.len(), 0);
+	}
+
 	#[test]
 	fn accrue() {
 		let mut sub_state = Substate::new();

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()
 }