Code redundancy between ext implementation and testing. (#3830)

* fix child_storage_hash

* extract common implementation for ext and testing

* cleaning impl.

* replace ExtBasisMut by actual Ext

* remove extbasis.

* Update tests to use Ext from test externalities.

* use Ext constructor for getting ext from TestExternalities.

* Add missing extensions from ext.

* fix wasmi test

* Fix merge error.

substrate/core/executor/src/lib.rs

@@ -98,6 +98,7 @@ mod tests {
 	#[test]
 	fn call_in_interpreted_wasm_works() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let res = call_in_wasm(
 			"test_empty_return",
 			&[],

substrate/core/executor/src/sandbox.rs

@@ -610,6 +610,7 @@ mod tests {
 	#[test]
 	fn sandbox_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -642,6 +643,7 @@ mod tests {
 	#[test]
 	fn sandbox_trap() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -663,6 +665,7 @@ mod tests {
 	#[test]
 	fn sandbox_should_trap_when_heap_exhausted() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -691,6 +694,7 @@ mod tests {
 	#[test]
 	fn start_called() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -729,6 +733,7 @@ mod tests {
 	#[test]
 	fn invoke_args() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -763,6 +768,7 @@ mod tests {
 	#[test]
 	fn return_val() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -785,6 +791,7 @@ mod tests {
 	#[test]
 	fn unlinkable_module() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -805,6 +812,7 @@ mod tests {
 	#[test]
 	fn corrupted_module() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		// Corrupted wasm file
@@ -819,6 +827,7 @@ mod tests {
 	#[test]
 	fn start_fn_ok() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"
@@ -842,6 +851,7 @@ mod tests {
 	#[test]
 	fn start_fn_traps() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let code = wabt::wat2wasm(r#"

substrate/core/executor/src/wasmi_execution.rs

@@ -681,6 +681,7 @@ mod tests {
 	#[test]
 	fn returning_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let output = call(&mut ext, 8, &test_code[..], "test_empty_return", &[]).unwrap();
@@ -690,6 +691,7 @@ mod tests {
 	#[test]
 	fn panicking_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 
 		let output = call(&mut ext, 8, &test_code[..], "test_panic", &[]);
@@ -705,18 +707,22 @@ mod tests {
 	#[test]
 	fn storage_should_work() {
 		let mut ext = TestExternalities::default();
-		ext.set_storage(b"foo".to_vec(), b"bar".to_vec());
-		let test_code = WASM_BINARY;
 
-		let output = call(
+		{
-			&mut ext,
+			let mut ext = ext.ext();
-			8,
+			ext.set_storage(b"foo".to_vec(), b"bar".to_vec());
-			&test_code[..],
+			let test_code = WASM_BINARY;
-			"test_data_in",
-			&b"Hello world".to_vec().encode(),
-		).unwrap();
 
-		assert_eq!(output, b"all ok!".to_vec().encode());
+			let output = call(
+				&mut ext,
+				8,
+				&test_code[..],
+				"test_data_in",
+				&b"Hello world".to_vec().encode(),
+			).unwrap();
+
+			assert_eq!(output, b"all ok!".to_vec().encode());
+		}
 
 		let expected = TestExternalities::new((map![
 			b"input".to_vec() => b"Hello world".to_vec(),
@@ -729,23 +735,26 @@ mod tests {
 	#[test]
 	fn clear_prefix_should_work() {
 		let mut ext = TestExternalities::default();
-		ext.set_storage(b"aaa".to_vec(), b"1".to_vec());
+		{
-		ext.set_storage(b"aab".to_vec(), b"2".to_vec());
+			let mut ext = ext.ext();
-		ext.set_storage(b"aba".to_vec(), b"3".to_vec());
+			ext.set_storage(b"aaa".to_vec(), b"1".to_vec());
-		ext.set_storage(b"abb".to_vec(), b"4".to_vec());
+			ext.set_storage(b"aab".to_vec(), b"2".to_vec());
-		ext.set_storage(b"bbb".to_vec(), b"5".to_vec());
+			ext.set_storage(b"aba".to_vec(), b"3".to_vec());
-		let test_code = WASM_BINARY;
+			ext.set_storage(b"abb".to_vec(), b"4".to_vec());
+			ext.set_storage(b"bbb".to_vec(), b"5".to_vec());
+			let test_code = WASM_BINARY;
 
-		// This will clear all entries which prefix is "ab".
+			// This will clear all entries which prefix is "ab".
-		let output = call(
+			let output = call(
-			&mut ext,
+				&mut ext,
-			8,
+				8,
-			&test_code[..],
+				&test_code[..],
-			"test_clear_prefix",
+				"test_clear_prefix",
-			&b"ab".to_vec().encode(),
+				&b"ab".to_vec().encode(),
-		).unwrap();
+			).unwrap();
 
-		assert_eq!(output, b"all ok!".to_vec().encode());
+			assert_eq!(output, b"all ok!".to_vec().encode());
+		}
 
 		let expected = TestExternalities::new((map![
 			b"aaa".to_vec() => b"1".to_vec(),
@@ -758,6 +767,7 @@ mod tests {
 	#[test]
 	fn blake2_256_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 		assert_eq!(
 			call(&mut ext, 8, &test_code[..], "test_blake2_256", &[0]).unwrap(),
@@ -778,6 +788,7 @@ mod tests {
 	#[test]
 	fn blake2_128_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 		assert_eq!(
 			call(&mut ext, 8, &test_code[..], "test_blake2_128", &[0]).unwrap(),
@@ -798,6 +809,7 @@ mod tests {
 	#[test]
 	fn twox_256_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 		assert_eq!(
 			call(&mut ext, 8, &test_code[..], "test_twox_256", &[0]).unwrap(),
@@ -822,6 +834,7 @@ mod tests {
 	#[test]
 	fn twox_128_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 		assert_eq!(
 			call(&mut ext, 8, &test_code[..], "test_twox_128", &[0]).unwrap(),
@@ -842,6 +855,7 @@ mod tests {
 	#[test]
 	fn ed25519_verify_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 		let key = ed25519::Pair::from_seed(&blake2_256(b"test"));
 		let sig = key.sign(b"all ok!");
@@ -868,6 +882,7 @@ mod tests {
 	#[test]
 	fn sr25519_verify_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let test_code = WASM_BINARY;
 		let key = sr25519::Pair::from_seed(&blake2_256(b"test"));
 		let sig = key.sign(b"all ok!");
@@ -894,6 +909,7 @@ mod tests {
 	#[test]
 	fn ordered_trie_root_should_work() {
 		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
 		let trie_input = vec![b"zero".to_vec(), b"one".to_vec(), b"two".to_vec()];
 		let test_code = WASM_BINARY;
 		assert_eq!(
@@ -910,6 +926,7 @@ mod tests {
 		let (offchain, state) = testing::TestOffchainExt::new();
 		ext.register_extension(OffchainExt::new(offchain));
 		let test_code = WASM_BINARY;
+		let mut ext = ext.ext();
 		assert_eq!(
 			call(&mut ext, 8, &test_code[..], "test_offchain_local_storage", &[0]).unwrap(),
 			true.encode(),
@@ -937,6 +954,7 @@ mod tests {
 		);
 
 		let test_code = WASM_BINARY;
+		let mut ext = ext.ext();
 		assert_eq!(
 			call(&mut ext, 8, &test_code[..], "test_offchain_http", &[0]).unwrap(),
 			true.encode(),

substrate/core/state-machine/src/ext.rs

@@ -32,7 +32,6 @@ use trie::{trie_types::Layout, MemoryDB, default_child_trie_root};
 use externalities::Extensions;
 
 use std::{error, fmt, any::{Any, TypeId}};
-
 use log::{warn, trace};
 
 const EXT_NOT_ALLOWED_TO_FAIL: &str = "Externalities not allowed to fail within runtime";
@@ -99,6 +98,7 @@ where
 	T: 'a + ChangesTrieStorage<H, N>,
 	N: crate::changes_trie::BlockNumber,
 {
+
 	/// Create a new `Ext` from overlayed changes and read-only backend
 	pub fn new(
 		overlay: &'a mut OverlayedChanges,
@@ -467,16 +467,22 @@ where
 		} else {
 			let storage_key = storage_key.as_ref();
 
-			let delta = self.overlay.committed.children.get(storage_key)
+			let (root, is_empty, _) = {
-				.into_iter()
+				let delta = self.overlay.committed.children.get(storage_key)
-				.flat_map(|map| map.iter().map(|(k, v)| (k.clone(), v.value.clone())))
+					.into_iter()
-				.chain(self.overlay.prospective.children.get(storage_key)
+					.flat_map(|map| map.clone().into_iter().map(|(k, v)| (k, v.value)))
-						.into_iter()
+					.chain(self.overlay.prospective.children.get(storage_key)
-						.flat_map(|map| map.clone().into_iter().map(|(k, v)| (k.clone(), v.value.clone()))));
+							.into_iter()
+							.flat_map(|map| map.clone().into_iter().map(|(k, v)| (k, v.value))));
 
-			let root = self.backend.child_storage_root(storage_key, delta).0;
+				self.backend.child_storage_root(storage_key, delta)
+			};
 
-			self.overlay.set_storage(storage_key.to_vec(), Some(root.to_vec()));
+			if is_empty {
+				self.overlay.set_storage(storage_key.into(), None);
+			} else {
+				self.overlay.set_storage(storage_key.into(), Some(root.clone()));
+			}
 
 			trace!(target: "state-trace", "{:04x}: ChildRoot({}) {}",
 				self.id,

substrate/core/state-machine/src/testing.rs

@@ -21,22 +21,20 @@ use hash_db::Hasher;
 use crate::{
 	backend::{InMemory, Backend}, OverlayedChanges,
 	changes_trie::{
-		build_changes_trie, InMemoryStorage as ChangesTrieInMemoryStorage,
+		InMemoryStorage as ChangesTrieInMemoryStorage,
 		BlockNumber as ChangesTrieBlockNumber,
 	},
+	ext::Ext,
 };
 use primitives::{
 	storage::{
-		ChildStorageKey,
 		well_known_keys::{CHANGES_TRIE_CONFIG, CODE, HEAP_PAGES, is_child_storage_key}
 	},
-	traits::Externalities, hash::H256, Blake2Hasher,
+	hash::H256, Blake2Hasher,
 };
 use codec::Encode;
 use externalities::{Extensions, Extension};
 
-const EXT_NOT_ALLOWED_TO_FAIL: &str = "Externalities not allowed to fail within runtime";
-
 type StorageTuple = (HashMap<Vec<u8>, Vec<u8>>, HashMap<Vec<u8>, HashMap<Vec<u8>, Vec<u8>>>);
 
 /// Simple HashMap-based Externalities impl.
@@ -48,6 +46,17 @@ pub struct TestExternalities<H: Hasher<Out=H256>=Blake2Hasher, N: ChangesTrieBlo
 }
 
 impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> TestExternalities<H, N> {
+
+	/// Get externalities implementation.
+	pub fn ext(&mut self) -> Ext<H, N, InMemory<H>, ChangesTrieInMemoryStorage<H, N>> {
+		Ext::new(
+			&mut self.overlay,
+			&self.backend,
+			Some(&self.changes_trie_storage),
+			Some(&mut self.extensions),
+		)
+	}
+
 	/// Create a new instance of `TestExternalities` with storage.
 	pub fn new(storage: StorageTuple) -> Self {
 		Self::new_with_code(&[], storage)
@@ -118,7 +127,8 @@ impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> TestExternalities<H, N> {
 	///
 	/// Returns the result of the given closure.
 	pub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R {
-		externalities::set_and_run_with_externalities(self, execute)
+		let mut ext = self.ext();
+		externalities::set_and_run_with_externalities(&mut ext, execute)
 	}
 }
 
@@ -146,156 +156,6 @@ impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> From<StorageTuple> for Test
 	}
 }
 
-impl<H, N> Externalities for TestExternalities<H, N> where
-	H: Hasher<Out=H256>,
-	N: ChangesTrieBlockNumber,
-{
-	fn storage(&self, key: &[u8]) -> Option<Vec<u8>> {
-		self.overlay.storage(key).map(|x| x.map(|x| x.to_vec())).unwrap_or_else(||
-			self.backend.storage(key).expect(EXT_NOT_ALLOWED_TO_FAIL))
-	}
-
-	fn storage_hash(&self, key: &[u8]) -> Option<H256> {
-		self.storage(key).map(|v| H::hash(&v))
-	}
-
-	fn original_storage(&self, key: &[u8]) -> Option<Vec<u8>> {
-		self.backend.storage(key).expect(EXT_NOT_ALLOWED_TO_FAIL)
-	}
-
-	fn original_storage_hash(&self, key: &[u8]) -> Option<H256> {
-		self.storage_hash(key)
-	}
-
-	fn child_storage(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<Vec<u8>> {
-		self.overlay
-			.child_storage(storage_key.as_ref(), key)
-			.map(|x| x.map(|x| x.to_vec()))
-			.unwrap_or_else(|| self.backend
-				.child_storage(storage_key.as_ref(), key)
-				.expect(EXT_NOT_ALLOWED_TO_FAIL)
-			)
-	}
-
-	fn child_storage_hash(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<H256> {
-		self.child_storage(storage_key, key).map(|v| H::hash(&v))
-	}
-
-	fn original_child_storage(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<Vec<u8>> {
-		self.backend
-			.child_storage(storage_key.as_ref(), key)
-			.map(|x| x.map(|x| x.to_vec()))
-			.expect(EXT_NOT_ALLOWED_TO_FAIL)
-	}
-
-	fn original_child_storage_hash(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<H256> {
-		self.child_storage_hash(storage_key, key)
-	}
-
-	fn place_storage(&mut self, key: Vec<u8>, maybe_value: Option<Vec<u8>>) {
-		if is_child_storage_key(&key) {
-			panic!("Refuse to directly set child storage key");
-		}
-
-		self.overlay.set_storage(key, maybe_value);
-	}
-
-	fn place_child_storage(
-		&mut self,
-		storage_key: ChildStorageKey,
-		key: Vec<u8>,
-		value: Option<Vec<u8>>,
-	) {
-		self.overlay.set_child_storage(storage_key.into_owned(), key, value);
-	}
-
-	fn kill_child_storage(&mut self, storage_key: ChildStorageKey) {
-		let backend = &self.backend;
-		let overlay = &mut self.overlay;
-
-		overlay.clear_child_storage(storage_key.as_ref());
-		backend.for_keys_in_child_storage(storage_key.as_ref(), |key| {
-			overlay.set_child_storage(storage_key.as_ref().to_vec(), key.to_vec(), None);
-		});
-	}
-
-	fn clear_prefix(&mut self, prefix: &[u8]) {
-		if is_child_storage_key(prefix) {
-			panic!("Refuse to directly clear prefix that is part of child storage key");
-		}
-
-		self.overlay.clear_prefix(prefix);
-
-		let backend = &self.backend;
-		let overlay = &mut self.overlay;
-		backend.for_keys_with_prefix(prefix, |key| {
-			overlay.set_storage(key.to_vec(), None);
-		});
-	}
-
-	fn clear_child_prefix(&mut self, storage_key: ChildStorageKey, prefix: &[u8]) {
-		self.overlay.clear_child_prefix(storage_key.as_ref(), prefix);
-
-		let backend = &self.backend;
-		let overlay = &mut self.overlay;
-		backend.for_child_keys_with_prefix(storage_key.as_ref(), prefix, |key| {
-			overlay.set_child_storage(storage_key.as_ref().to_vec(), key.to_vec(), None);
-		});
-	}
-
-	fn chain_id(&self) -> u64 { 42 }
-
-	fn storage_root(&mut self) -> H256 {
-		let child_storage_keys =
-			self.overlay.prospective.children.keys()
-				.chain(self.overlay.committed.children.keys());
-
-		let child_delta_iter = child_storage_keys.map(|storage_key|
-			(storage_key.clone(), self.overlay.committed.children.get(storage_key)
-				.into_iter()
-				.flat_map(|map| map.iter().map(|(k, v)| (k.clone(), v.value.clone())))
-				.chain(self.overlay.prospective.children.get(storage_key)
-					.into_iter()
-					.flat_map(|map| map.iter().map(|(k, v)| (k.clone(), v.value.clone()))))));
-
-
-		// compute and memoize
-		let delta = self.overlay.committed.top.iter().map(|(k, v)| (k.clone(), v.value.clone()))
-			.chain(self.overlay.prospective.top.iter().map(|(k, v)| (k.clone(), v.value.clone())));
-		self.backend.full_storage_root(delta, child_delta_iter).0
-	}
-
-	fn child_storage_root(&mut self, storage_key: ChildStorageKey) -> Vec<u8> {
-		let storage_key = storage_key.as_ref();
-
-		let (root, is_empty, _) = {
-			let delta = self.overlay.committed.children.get(storage_key)
-				.into_iter()
-				.flat_map(|map| map.clone().into_iter().map(|(k, v)| (k, v.value)))
-				.chain(self.overlay.prospective.children.get(storage_key)
-						.into_iter()
-						.flat_map(|map| map.clone().into_iter().map(|(k, v)| (k, v.value))));
-
-			self.backend.child_storage_root(storage_key, delta)
-		};
-		if is_empty {
-			self.overlay.set_storage(storage_key.into(), None);
-		} else {
-			self.overlay.set_storage(storage_key.into(), Some(root.clone()));
-		}
-		root
-	}
-
-	fn storage_changes_root(&mut self, parent: H256) -> Result<Option<H256>, ()> {
-		Ok(build_changes_trie::<_, _, H, N>(
-			&self.backend,
-			Some(&self.changes_trie_storage),
-			&self.overlay,
-			parent,
-		)?.map(|(_, root, _)| root))
-	}
-}
-
 impl<H, N> externalities::ExtensionStore for TestExternalities<H, N> where
 	H: Hasher<Out=H256>,
 	N: ChangesTrieBlockNumber,
@@ -308,12 +168,13 @@ impl<H, N> externalities::ExtensionStore for TestExternalities<H, N> where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use primitives::{Blake2Hasher, H256};
+	use primitives::traits::Externalities;
 	use hex_literal::hex;
 
 	#[test]
 	fn commit_should_work() {
 		let mut ext = TestExternalities::<Blake2Hasher, u64>::default();
+		let mut ext = ext.ext();
 		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
 		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
 		ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
@@ -324,6 +185,7 @@ mod tests {
 	#[test]
 	fn set_and_retrieve_code() {
 		let mut ext = TestExternalities::<Blake2Hasher, u64>::default();
+		let mut ext = ext.ext();
 
 		let code = vec![1, 2, 3];
 		ext.set_storage(CODE.to_vec(), code.clone());

substrate/core/state-machine/src/trie_backend.rs

@@ -168,7 +168,7 @@ impl<S: TrieBackendStorage<H>, H: Hasher> Backend<H> for TrieBackend<S, H> where
 
 		let mut write_overlay = S::Overlay::default();
 		let mut root = match self.storage(storage_key) {
-			Ok(value) => value.unwrap_or(default_child_trie_root::<Layout<H>>(storage_key)),
+			Ok(value) => value.unwrap_or(default_root.clone()),
 			Err(e) => {
 				warn!(target: "trie", "Failed to read child storage root: {}", e);
 				default_root.clone()

substrate/core/test-runtime/src/system.rs

@@ -376,8 +376,9 @@ mod tests {
 	#[test]
 	fn block_import_works_wasm() {
 		block_import_works(|b, ext| {
+			let mut ext = ext.ext();
 			executor().call::<_, NeverNativeValue, fn() -> _>(
-				ext,
+				&mut ext,
 				"Core_execute_block",
 				&b.encode(),
 				false,
@@ -468,8 +469,9 @@ mod tests {
 	#[test]
 	fn block_import_with_transaction_works_wasm() {
 		block_import_with_transaction_works(|b, ext| {
+			let mut ext = ext.ext();
 			executor().call::<_, NeverNativeValue, fn() -> _>(
-				ext,
+				&mut ext,
 				"Core_execute_block",
 				&b.encode(),
 				false,

substrate/node/executor/src/lib.rs

@@ -34,6 +34,7 @@ native_executor_instance!(
 
 #[cfg(test)]
 mod tests {
+	use substrate_executor::error::Result;
 	use super::Executor;
 	use {balances, contracts, indices, system, timestamp};
 	use codec::{Encode, Decode, Joiner};
@@ -122,6 +123,26 @@ mod tests {
 		ext.place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(heap_pages.encode()));
 	}
 
+	fn executor_call<
+		R:Decode + Encode + PartialEq,
+		NC: FnOnce() -> std::result::Result<R, String> + std::panic::UnwindSafe
+	>(
+		t: &mut TestExternalities<Blake2Hasher>,
+		method: &str,
+		data: &[u8],
+		use_native: bool,
+		native_call: Option<NC>,
+	) -> (Result<NativeOrEncoded<R>>, bool) {
+		let mut t = t.ext();
+		executor().call::<_, R, NC>(
+			&mut t,
+			method,
+			data,
+			use_native,
+			native_call,
+		)
+	}
+
 	#[test]
 	fn panic_execution_with_foreign_code_gives_error() {
 		let mut t = TestExternalities::<Blake2Hasher>::new_with_code(BLOATY_CODE, (map![
@@ -139,7 +160,7 @@ mod tests {
 			}
 		], map![]));
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -147,7 +168,7 @@ mod tests {
 			None,
 		).0;
 		assert!(r.is_ok());
-		let v = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let v = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt()),
@@ -175,7 +196,7 @@ mod tests {
 			}
 		], map![]));
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -183,7 +204,7 @@ mod tests {
 			None,
 		).0;
 		assert!(r.is_ok());
-		let v = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let v = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt()),
@@ -207,7 +228,7 @@ mod tests {
 			<system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
 		], map![]));
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -218,7 +239,7 @@ mod tests {
 
 		let fm = t.execute_with(TransactionPayment::next_fee_multiplier);
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt()),
@@ -246,7 +267,7 @@ mod tests {
 			<system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
 		], map![]));
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -257,7 +278,7 @@ mod tests {
 
 		let fm = t.execute_with(TransactionPayment::next_fee_multiplier);
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt()),
@@ -307,7 +328,7 @@ mod tests {
 		};
 
 		// execute the block to get the real header.
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			env,
 			"Core_initialize_block",
 			&header.encode(),
@@ -316,7 +337,7 @@ mod tests {
 		).0.unwrap();
 
 		for i in extrinsics.iter() {
-			executor().call::<_, NeverNativeValue, fn() -> _>(
+			executor_call::<NeverNativeValue, fn() -> _>(
 				env,
 				"BlockBuilder_apply_extrinsic",
 				&i.encode(),
@@ -325,7 +346,7 @@ mod tests {
 			).0.unwrap();
 		}
 
-		let header = match executor().call::<_, NeverNativeValue, fn() -> _>(
+		let header = match executor_call::<NeverNativeValue, fn() -> _>(
 			env,
 			"BlockBuilder_finalize_block",
 			&[0u8;0],
@@ -432,7 +453,7 @@ mod tests {
 		let mut alice_last_known_balance: Balance = Default::default();
 		let mut fm = t.execute_with(TransactionPayment::next_fee_multiplier);
 
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block1.0,
@@ -471,7 +492,7 @@ mod tests {
 
 		fm = t.execute_with(TransactionPayment::next_fee_multiplier);
 
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block2.0,
@@ -544,7 +565,7 @@ mod tests {
 		let mut alice_last_known_balance: Balance = Default::default();
 		let mut fm = t.execute_with(TransactionPayment::next_fee_multiplier);
 
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block1.0,
@@ -560,7 +581,7 @@ mod tests {
 
 		fm = t.execute_with(TransactionPayment::next_fee_multiplier);
 
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block2.0,
@@ -720,7 +741,7 @@ mod tests {
 
 		let mut t = new_test_ext(COMPACT_CODE, false);
 
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&b.0,
@@ -744,9 +765,9 @@ mod tests {
 	fn wasm_big_block_import_fails() {
 		let mut t = new_test_ext(COMPACT_CODE, false);
 
-		set_heap_pages(&mut t, 4);
+		set_heap_pages(&mut t.ext(), 4);
 
-		let result = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let result = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block_with_size(42, 0, 120_000).0,
@@ -760,7 +781,7 @@ mod tests {
 	fn native_big_block_import_succeeds() {
 		let mut t = new_test_ext(COMPACT_CODE, false);
 
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block_with_size(42, 0, 120_000).0,
@@ -774,7 +795,7 @@ mod tests {
 		let mut t = new_test_ext(COMPACT_CODE, false);
 
 		assert!(
-			executor().call::<_, NeverNativeValue, fn() -> _>(
+			executor_call::<NeverNativeValue, fn() -> _>(
 				&mut t,
 				"Core_execute_block",
 				&block_with_size(42, 0, 120_000).0,
@@ -797,7 +818,7 @@ mod tests {
 			<system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
 		], map![]));
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -805,7 +826,7 @@ mod tests {
 			None,
 		).0;
 		assert!(r.is_ok());
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt()),
@@ -829,7 +850,7 @@ mod tests {
 			<system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
 		], map![]));
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -838,7 +859,7 @@ mod tests {
 		).0;
 		assert!(r.is_ok());
 		let fm = t.execute_with(TransactionPayment::next_fee_multiplier);
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt()),
@@ -863,7 +884,7 @@ mod tests {
 		let block = Block::decode(&mut &block_data[..]).unwrap();
 
 		let mut t = new_test_ext(COMPACT_CODE, true);
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block.encode(),
@@ -871,7 +892,7 @@ mod tests {
 			None,
 		).0.unwrap();
 
-		assert!(t.storage_changes_root(GENESIS_HASH.into()).unwrap().is_some());
+		assert!(t.ext().storage_changes_root(GENESIS_HASH.into()).unwrap().is_some());
 	}
 
 	#[test]
@@ -879,7 +900,7 @@ mod tests {
 		let block1 = changes_trie_block();
 
 		let mut t = new_test_ext(COMPACT_CODE, true);
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block1.0,
@@ -887,7 +908,7 @@ mod tests {
 			None,
 		).0.unwrap();
 
-		assert!(t.storage_changes_root(GENESIS_HASH.into()).unwrap().is_some());
+		assert!(t.ext().storage_changes_root(GENESIS_HASH.into()).unwrap().is_some());
 	}
 
 	#[test]
@@ -953,7 +974,7 @@ mod tests {
 		println!("++ Block 1 size: {} / Block 2 size {}", block1.0.encode().len(), block2.0.encode().len());
 
 		// execute a big block.
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block1.0,
@@ -970,7 +991,7 @@ mod tests {
 		});
 
 		// execute a big block.
-		executor().call::<_, NeverNativeValue, fn() -> _>(
+		executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_execute_block",
 			&block2.0,
@@ -1015,7 +1036,7 @@ mod tests {
 			function: Call::Balances(default_transfer_call()),
 		});
 
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"Core_initialize_block",
 			&vec![].and(&from_block_number(1u32)),
@@ -1024,7 +1045,7 @@ mod tests {
 		).0;
 
 		assert!(r.is_ok());
-		let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+		let r = executor_call::<NeverNativeValue, fn() -> _>(
 			&mut t,
 			"BlockBuilder_apply_extrinsic",
 			&vec![].and(&xt.clone()),
@@ -1109,7 +1130,7 @@ mod tests {
 				len / 1024 / 1024,
 			);
 
-			let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+			let r = executor_call::<NeverNativeValue, fn() -> _>(
 				&mut t,
 				"Core_execute_block",
 				&block.0,
@@ -1173,7 +1194,7 @@ mod tests {
 				len / 1024 / 1024,
 			);
 
-			let r = executor().call::<_, NeverNativeValue, fn() -> _>(
+			let r = executor_call::<NeverNativeValue, fn() -> _>(
 				&mut t,
 				"Core_execute_block",
 				&block.0,