Merge branch 'master' into json_tests_split

2016-02-02 22:50:53 +01:00
parent 1b6fe392f8 5155ff1fac
commit 7aba3032c8
19 changed files with 1016 additions and 63 deletions
--- a/ethcore/src/block_queue.rs
+++ b/ethcore/src/block_queue.rs
@@ -9,6 +9,7 @@ use engine::Engine;
 use views::*;
 use header::*;
 use service::*;
+use client::BlockStatus;

 /// Block queue status
 #[derive(Debug)]
@@ -41,7 +42,7 @@ pub struct BlockQueue {
 	deleting: Arc<AtomicBool>,
 	ready_signal: Arc<QueueSignal>,
 	empty: Arc<Condvar>,
-	processing: HashSet<H256>
+	processing: RwLock<HashSet<H256>>
 }

 struct UnVerifiedBlock {
@@ -106,7 +107,7 @@ impl BlockQueue {
 			verification: verification.clone(),
 			verifiers: verifiers,
 			deleting: deleting.clone(),
-			processing: HashSet::new(),
+			processing: RwLock::new(HashSet::new()),
 			empty: empty.clone(),
 		}
 	}
@@ -196,11 +197,22 @@ impl BlockQueue {
 		}
 	}

+	/// Check if the block is currently in the queue
+	pub fn block_status(&self, hash: &H256) -> BlockStatus {
+		if self.processing.read().unwrap().contains(&hash) {
+			return BlockStatus::Queued;
+		}
+		if self.verification.lock().unwrap().bad.contains(&hash) {
+			return BlockStatus::Bad;
+		}
+		BlockStatus::Unknown
+	}
+
 	/// Add a block to the queue.
 	pub fn import_block(&mut self, bytes: Bytes) -> ImportResult {
 		let header = BlockView::new(&bytes).header();
 		let h = header.hash();
-		if self.processing.contains(&h) {
+		if self.processing.read().unwrap().contains(&h) {
 			return Err(ImportError::AlreadyQueued);
 		}
 		{
@@ -217,7 +229,7 @@ impl BlockQueue {

 		match verify_block_basic(&header, &bytes, self.engine.deref().deref()) {
 			Ok(()) => {
-				self.processing.insert(h.clone());
+				self.processing.write().unwrap().insert(h.clone());
 				self.verification.lock().unwrap().unverified.push_back(UnVerifiedBlock { header: header, bytes: bytes });
 				self.more_to_verify.notify_all();
 				Ok(h)
@@ -235,10 +247,12 @@ impl BlockQueue {
 		let mut verification_lock = self.verification.lock().unwrap();
 		let mut verification = verification_lock.deref_mut();
 		verification.bad.insert(hash.clone());
+		self.processing.write().unwrap().remove(&hash);
 		let mut new_verified = VecDeque::new();
 		for block in verification.verified.drain(..) {
 			if verification.bad.contains(&block.header.parent_hash) {
 				verification.bad.insert(block.header.hash());
+				self.processing.write().unwrap().remove(&block.header.hash());
 			}
 			else {
 				new_verified.push_back(block);
@@ -247,6 +261,15 @@ impl BlockQueue {
 		verification.verified = new_verified;
 	}

+	/// Mark given block as processed
+	pub fn mark_as_good(&mut self, hashes: &[H256]) {
+		let mut processing = self.processing.write().unwrap();
+		for h in hashes {
+			processing.remove(&h);
+		}
+		//TODO: reward peers
+	}
+
 	/// Removes up to `max` verified blocks from the queue
 	pub fn drain(&mut self, max: usize) -> Vec<PreVerifiedBlock> {
 		let mut verification = self.verification.lock().unwrap();
@@ -254,7 +277,6 @@ impl BlockQueue {
 		let mut result = Vec::with_capacity(count);
 		for _ in 0..count {
 			let block = verification.verified.pop_front().unwrap();
-			self.processing.remove(&block.header.hash());
 			result.push(block);
 		}
 		self.ready_signal.reset();
@@ -294,6 +316,7 @@ mod tests {
 	use block_queue::*;
 	use tests::helpers::*;
 	use error::*;
+	use views::*;

 	fn get_test_queue() -> BlockQueue {
 		let spec = get_test_spec();
@@ -339,11 +362,14 @@ mod tests {
 	#[test]
 	fn returns_ok_for_drained_duplicates() {
 		let mut queue = get_test_queue();
-		if let Err(e) = queue.import_block(get_good_dummy_block()) {
+		let block = get_good_dummy_block();
+		let hash = BlockView::new(&block).header().hash().clone();
+		if let Err(e) = queue.import_block(block) {
 			panic!("error importing block that is valid by definition({:?})", e);
 		}
 		queue.flush();
 		queue.drain(10);
+		queue.mark_as_good(&[ hash ]);

 		if let Err(e) = queue.import_block(get_good_dummy_block()) {
 			panic!("error importing block that has already been drained ({:?})", e);
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -17,7 +17,7 @@ use verification::*;
 use block::*;

 /// General block status
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum BlockStatus {
 	/// Part of the blockchain.
 	InChain,
@@ -206,6 +206,7 @@ impl Client {
 		let mut bad = HashSet::new();
 		let _import_lock = self.import_lock.lock();
 		let blocks = self.block_queue.write().unwrap().drain(128);
+		let mut good_blocks = Vec::with_capacity(128);
 		for block in blocks {
 			if bad.contains(&block.header.parent_hash) {
 				self.block_queue.write().unwrap().mark_as_bad(&block.header.hash());
@@ -258,6 +259,8 @@ impl Client {
 				break;
 			}

+			good_blocks.push(header.hash().clone());
+
 			self.chain.write().unwrap().insert_block(&block.bytes); //TODO: err here?
 			let ancient = if header.number() >= HISTORY { Some(header.number() - HISTORY) } else { None };
 			match result.drain().commit(header.number(), &header.hash(), ancient.map(|n|(n, self.chain.read().unwrap().block_hash(n).unwrap()))) {
@@ -271,6 +274,7 @@ impl Client {
 			trace!(target: "client", "Imported #{} ({})", header.number(), header.hash());
 			ret += 1;
 		}
+		self.block_queue.write().unwrap().mark_as_good(&good_blocks);
 		ret
 	}

@@ -325,7 +329,11 @@ impl BlockChainClient for Client {
 	}

 	fn block_status(&self, hash: &H256) -> BlockStatus {
-		if self.chain.read().unwrap().is_known(&hash) { BlockStatus::InChain } else { BlockStatus::Unknown }
+		if self.chain.read().unwrap().is_known(&hash) {
+			BlockStatus::InChain 
+		} else { 
+			self.block_queue.read().unwrap().block_status(hash) 
+		}
 	}
 	
 	fn block_total_difficulty(&self, hash: &H256) -> Option<U256> {
@@ -372,6 +380,9 @@ impl BlockChainClient for Client {
 		if self.chain.read().unwrap().is_known(&header.hash()) {
 			return Err(ImportError::AlreadyInChain);
 		}
+		if self.block_status(&header.parent_hash) == BlockStatus::Unknown {
+			return Err(ImportError::UnknownParent);
+		}
 		self.block_queue.write().unwrap().import_block(bytes)
 	}

--- a/ethcore/src/error.rs
+++ b/ethcore/src/error.rs
@@ -130,14 +130,16 @@ pub enum BlockError {
 }

 #[derive(Debug)]
-/// TODO [arkpar] Please document me
+/// Import to the block queue result
 pub enum ImportError {
-	/// TODO [arkpar] Please document me
+	/// Bad block detected
 	Bad(Option<Error>),
-	/// TODO [arkpar] Please document me
+	/// Already in the block chain
 	AlreadyInChain,
-	/// TODO [arkpar] Please document me
+	/// Already in the block queue
 	AlreadyQueued,
+	/// Unknown parent
+	UnknownParent,
 }

 impl From<Error> for ImportError {
--- a/ethcore/src/evm/evm.rs
+++ b/ethcore/src/evm/evm.rs
@@ -15,31 +15,30 @@ pub enum Error {
 	/// `BadJumpDestination` is returned when execution tried to move
 	/// to position that wasn't marked with JUMPDEST instruction
 	BadJumpDestination {
-		/// TODO [Tomusdrw] Please document me
+		/// Position the code tried to jump to.
 		destination: usize
 	},
 	/// `BadInstructions` is returned when given instruction is not supported
 	BadInstruction {
-		/// TODO [Tomusdrw] Please document me
+		/// Unrecognized opcode
 		instruction: u8,
 	},
 	/// `StackUnderflow` when there is not enough stack elements to execute instruction
-	/// First parameter says how many elements were needed and the second how many were actually on Stack
 	StackUnderflow {
-		/// TODO [Tomusdrw] Please document me
+		/// Invoked instruction
 		instruction: &'static str,
-		/// TODO [Tomusdrw] Please document me
+		/// How many stack elements was requested by instruction
 		wanted: usize, 
-		/// TODO [Tomusdrw] Please document me
+		/// How many elements were on stack
 		on_stack: usize
 	},
 	/// When execution would exceed defined Stack Limit
 	OutOfStack {
-		/// TODO [Tomusdrw] Please document me
+		/// Invoked instruction
 		instruction: &'static str,
-		/// TODO [Tomusdrw] Please document me
-		wanted: usize, 
-		/// TODO [Tomusdrw] Please document me
+		/// How many stack elements instruction wanted to push
+		wanted: usize,
+		/// What was the stack limit
 		limit: usize
 	},
 	/// Returned on evm internal error. Should never be ignored during development.
--- a/ethcore/src/evm/factory.rs
+++ b/ethcore/src/evm/factory.rs
@@ -5,12 +5,12 @@ use std::fmt;
 use evm::Evm;

 #[derive(Clone)]
-/// TODO [Tomusdrw] Please document me
+/// Type of EVM to use.
 pub enum VMType {
-	/// TODO [Tomusdrw] Please document me
 	#[allow(dead_code)] // crated only by jit
+	/// JIT EVM
 	Jit,
-	/// TODO [Tomusdrw] Please document me
+	/// RUST EVM
 	Interpreter
 }

--- a/ethcore/src/evm/interpreter.rs
+++ b/ethcore/src/evm/interpreter.rs
@@ -1,11 +1,10 @@
 ///! Rust VM implementation

 use common::*;
-use evm;
 use super::instructions as instructions;
 use super::instructions::Instruction;
 use std::marker::Copy;
-use evm::{MessageCallResult, ContractCreateResult};
+use evm::{self, MessageCallResult, ContractCreateResult};

 #[cfg(not(feature = "evm-debug"))]
 macro_rules! evm_debug {
--- a/ethcore/src/evm/tests.rs
+++ b/ethcore/src/evm/tests.rs
@@ -150,7 +150,7 @@ fn test_add(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_988));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe").unwrap());
+	assert_store(&ext, 0, "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
 }

 evm_test!{test_sha3: test_sha3_jit, test_sha3_int}
@@ -170,7 +170,7 @@ fn test_sha3(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_961));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").unwrap());
+	assert_store(&ext, 0, "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
 }

 evm_test!{test_address: test_address_jit, test_address_int}
@@ -190,7 +190,7 @@ fn test_address(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("0000000000000000000000000f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap());
+	assert_store(&ext, 0, "0000000000000000000000000f572e5295c57f15886f9b263e2f6d2d6c7b5ec6");
 }

 evm_test!{test_origin: test_origin_jit, test_origin_int}
@@ -212,7 +212,7 @@ fn test_origin(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("000000000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681").unwrap());
+	assert_store(&ext, 0, "000000000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681");
 }

 // TODO [todr] Fails with Signal 11 on JIT
@@ -235,7 +235,7 @@ fn test_sender(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("000000000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681").unwrap());
+	assert_store(&ext, 0, "000000000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681");
 }

 evm_test!{test_extcodecopy: test_extcodecopy_jit, test_extcodecopy_int}
@@ -270,7 +270,7 @@ fn test_extcodecopy(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_935));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("6005600055000000000000000000000000000000000000000000000000000000").unwrap());
+	assert_store(&ext, 0, "6005600055000000000000000000000000000000000000000000000000000000");
 }

 evm_test!{test_log_empty: test_log_empty_jit, test_log_empty_int}
@@ -369,7 +369,7 @@ fn test_calldataload(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_991));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("23ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23").unwrap());
+	assert_store(&ext, 0, "23ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23");

 }

@@ -390,7 +390,7 @@ fn test_author(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("0000000000000000000000000f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap());
+	assert_store(&ext, 0, "0000000000000000000000000f572e5295c57f15886f9b263e2f6d2d6c7b5ec6");
 }

 evm_test!{test_timestamp: test_timestamp_jit, test_timestamp_int}
@@ -410,7 +410,7 @@ fn test_timestamp(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("0000000000000000000000000000000000000000000000000000000000001234").unwrap());
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000001234");
 }

 evm_test!{test_number: test_number_jit, test_number_int}
@@ -430,7 +430,7 @@ fn test_number(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("0000000000000000000000000000000000000000000000000000000000001234").unwrap());
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000001234");
 }

 evm_test!{test_difficulty: test_difficulty_jit, test_difficulty_int}
@@ -450,7 +450,7 @@ fn test_difficulty(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("0000000000000000000000000000000000000000000000000000000000001234").unwrap());
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000001234");
 }

 evm_test!{test_gas_limit: test_gas_limit_jit, test_gas_limit_int}
@@ -470,6 +470,321 @@ fn test_gas_limit(factory: super::Factory) {
 	};

 	assert_eq!(gas_left, U256::from(79_995));
-	assert_eq!(ext.store.get(&H256::new()).unwrap(), &H256::from_str("0000000000000000000000000000000000000000000000000000000000001234").unwrap());
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000001234");
+}
+
+evm_test!{test_mul: test_mul_jit, test_mul_int}
+fn test_mul(factory: super::Factory) {
+	let code = "65012365124623626543219002600055".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "000000000000000000000000000000000000000000000000734349397b853383");
+	assert_eq!(gas_left, U256::from(79_983));
+}
+
+evm_test!{test_sub: test_sub_jit, test_sub_int}
+fn test_sub(factory: super::Factory) {
+	let code = "65012365124623626543219003600055".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000012364ad0302");
+	assert_eq!(gas_left, U256::from(79_985));
+}
+
+evm_test!{test_div: test_div_jit, test_div_int}
+fn test_div(factory: super::Factory) {
+	let code = "65012365124623626543219004600055".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "000000000000000000000000000000000000000000000000000000000002e0ac");
+	assert_eq!(gas_left, U256::from(79_983));
+}
+
+evm_test!{test_div_zero: test_div_zero_jit, test_div_zero_int}
+fn test_div_zero(factory: super::Factory) {
+	let code = "6501236512462360009004600055".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_eq!(gas_left, U256::from(94_983));
+}
+
+evm_test!{test_mod: test_mod_jit, test_mod_int}
+fn test_mod(factory: super::Factory) {
+	let code = "650123651246236265432290066000556501236512462360009006600155".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000076b4b");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_eq!(gas_left, U256::from(74_966));
+}
+
+evm_test!{test_smod: test_smod_jit, test_smod_int}
+fn test_smod(factory: super::Factory) {
+	let code = "650123651246236265432290076000556501236512462360009007600155".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000076b4b");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_eq!(gas_left, U256::from(74_966));
+}
+
+evm_test!{test_sdiv: test_sdiv_jit, test_sdiv_int}
+fn test_sdiv(factory: super::Factory) {
+	let code = "650123651246236265432290056000556501236512462360009005600155".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "000000000000000000000000000000000000000000000000000000000002e0ac");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_eq!(gas_left, U256::from(74_966));
+}
+
+evm_test!{test_exp: test_exp_jit, test_exp_int}
+fn test_exp(factory: super::Factory) {
+	let code = "6016650123651246230a6000556001650123651246230a6001556000650123651246230a600255".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "90fd23767b60204c3d6fc8aec9e70a42a3f127140879c133a20129a597ed0c59");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000012365124623");
+	assert_store(&ext, 2, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_eq!(gas_left, U256::from(39_923));
+}
+
+evm_test!{test_comparison: test_comparison_jit, test_comparison_int}
+fn test_comparison(factory: super::Factory) {
+	let code = "601665012365124623818181811060005511600155146002556415235412358014600355".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_store(&ext, 2, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_store(&ext, 3, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_eq!(gas_left, U256::from(49_952));
+}
+
+evm_test!{test_signed_comparison: test_signed_comparison_jit, test_signed_comparison_int}
+fn test_signed_comparison(factory: super::Factory) {
+	let code = "60106000036010818112600055136001556010601060000381811260025513600355".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_store(&ext, 2, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_store(&ext, 3, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_eq!(gas_left, U256::from(49_940));
+}
+
+evm_test!{test_bitops: test_bitops_jit, test_bitops_int}
+fn test_bitops(factory: super::Factory) {
+	let code = "60ff610ff08181818116600055176001551860025560008015600355198015600455600555".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(150_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "00000000000000000000000000000000000000000000000000000000000000f0");
+	assert_store(&ext, 1, "0000000000000000000000000000000000000000000000000000000000000fff");
+	assert_store(&ext, 2, "0000000000000000000000000000000000000000000000000000000000000f0f");
+	assert_store(&ext, 3, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_store(&ext, 4, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_store(&ext, 5, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+	assert_eq!(gas_left, U256::from(44_937));
+}
+
+evm_test!{test_addmod_mulmod: test_addmod_mulmod_jit, test_addmod_mulmod_int}
+fn test_addmod_mulmod(factory: super::Factory) {
+	let code = "60ff60f060108282820860005509600155600060f0601082828208196002550919600355".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000001");
+	assert_store(&ext, 1, "000000000000000000000000000000000000000000000000000000000000000f");
+	assert_store(&ext, 2, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+	assert_store(&ext, 3, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+	assert_eq!(gas_left, U256::from(19_914));
+}
+
+evm_test!{test_byte: test_byte_jit, test_byte_int}
+fn test_byte(factory: super::Factory) {
+	let code = "60f061ffff1a600055610fff601f1a600155".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
+	assert_store(&ext, 1, "00000000000000000000000000000000000000000000000000000000000000ff");
+	assert_eq!(gas_left, U256::from(74_976));
+}
+
+evm_test!{test_signextend: test_signextend_jit, test_signextend_int}
+fn test_signextend(factory: super::Factory) {
+	let code = "610fff60020b60005560ff60200b600155".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000fff");
+	assert_store(&ext, 1, "00000000000000000000000000000000000000000000000000000000000000ff");
+	assert_eq!(gas_left, U256::from(59_972));
+}
+
+
+evm_test!{test_badinstruction: test_badinstruction_jit, test_badinstruction_int}
+fn test_badinstruction(factory: super::Factory) {
+	let code = "af".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let err = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap_err()
+	};
+
+	match err {
+		evm::Error::BadInstruction { instruction: 0xaf } => (),
+		_ => assert!(false, "Expected bad instruction")
+	}
+}
+evm_test!{test_pop: test_pop_jit, test_pop_int}
+fn test_pop(factory: super::Factory) {
+	let code = "60f060aa50600055".from_hex().unwrap();
+
+	let mut params = ActionParams::default();
+	params.gas = U256::from(100_000);
+	params.code = Some(code);
+	let mut ext = FakeExt::new();
+
+	let gas_left = {
+		let vm = factory.create();
+		vm.exec(params, &mut ext).unwrap()
+	};
+
+	assert_store(&ext, 0, "00000000000000000000000000000000000000000000000000000000000000f0");
+	assert_eq!(gas_left, U256::from(79_989));
+}
+
+fn assert_store(ext: &FakeExt, pos: u64, val: &str) {
+	assert_eq!(ext.store.get(&H256::from(pos)).unwrap(), &H256::from_str(val).unwrap());
 }