Handle missing r, s, v params in json tests

Light cleanup of json test runner

Author: dvdplm

ethcore/account-state/src/state.rs

@@ -746,7 +746,7 @@ impl<B: Backend> State<B> {
 	/// Propagate local cache into shared canonical state cache.
 	fn propagate_to_global_cache(&mut self) {
 		let mut addresses = self.cache.borrow_mut();
-		trace!("Committing cache {:?} entries", addresses.len());
+		trace!(target: "state", "Committing cache {:?} entries", addresses.len());
 		for (address, a) in addresses.drain().filter(|&(_, ref a)| a.state == AccountState::Committed || a.state == AccountState::CleanFresh) {
 			self.db.add_to_account_cache(address, a.account, a.state == AccountState::Committed);
 		}

ethcore/spec/src/genesis.rs

@@ -20,6 +20,7 @@ use keccak_hash::KECCAK_NULL_RLP;
 use crate::seal::Seal;
 
 /// Genesis components.
+#[derive(Debug)]
 pub struct Genesis {
 	/// Seal.
 	pub seal: Seal,

ethcore/spec/src/seal.rs

@@ -21,6 +21,7 @@ use ethereum_types::{H64, H256, H520};
 use ethjson;
 
 /// Classic ethereum seal.
+#[derive(Debug)]
 pub struct Ethereum {
 	/// Seal nonce.
 	pub nonce: H64,
@@ -37,6 +38,7 @@ impl Into<Generic> for Ethereum {
 }
 
 /// AuthorityRound seal.
+#[derive(Debug)]
 pub struct AuthorityRound {
 	/// Seal step.
 	pub step: usize,
@@ -45,6 +47,7 @@ pub struct AuthorityRound {
 }
 
 /// Tendermint seal.
+#[derive(Debug)]
 pub struct Tendermint {
 	/// Seal round.
 	pub round: usize,
@@ -73,9 +76,11 @@ impl Into<Generic> for Tendermint {
 	}
 }
 
+#[derive(Debug)]
 pub struct Generic(pub Vec<u8>);
 
 /// Genesis seal type.
+#[derive(Debug)]
 pub enum Seal {
 	/// Classic ethereum seal.
 	Ethereum(Ethereum),

ethcore/spec/src/spec.rs

@@ -58,9 +58,6 @@ use crate::{
 	seal::Generic as GenericSeal,
 };
 
-
-
-
 /// Runtime parameters for the spec that are related to how the software should run the chain,
 /// rather than integral properties of the chain itself.
 pub struct SpecParams<'a> {
@@ -219,7 +216,7 @@ pub struct Spec {
 	pub hardcoded_sync: Option<SpecHardcodedSync>,
 	/// Contract constructors to be executed on genesis.
 	pub constructors: Vec<(Address, Bytes)>,
-	/// May be prepopulated if we know this in advance.
+	/// May be pre-populated if we know this in advance.
 	pub state_root: H256,
 	/// Genesis state as plain old data.
 	pub genesis_state: PodState,

ethcore/src/json_tests/chain.rs

@@ -24,7 +24,7 @@ use miner::Miner;
 use io::IoChannel;
 use test_helpers;
 use types::verification::Unverified;
-use verification::VerifierType;
+use verification::{VerifierType, queue::kind::BlockLike};
 use super::SKIP_TEST_STATE;
 use super::HookType;
 
@@ -39,7 +39,10 @@ pub fn run_test_file<H: FnMut(&str, HookType)>(p: &Path, h: &mut H) {
 }
 
 fn skip_test(name: &String) -> bool {
-	SKIP_TEST_STATE.block.iter().any(|block_test|block_test.subtests.contains(name))
+	SKIP_TEST_STATE
+		.block
+		.iter()
+		.any(|block_test|block_test.subtests.contains(name))
 }
 
 pub fn json_chain_test<H: FnMut(&str, HookType)>(json_data: &[u8], start_stop_hook: &mut H) -> Vec<String> {
@@ -52,18 +55,23 @@ pub fn json_chain_test<H: FnMut(&str, HookType)>(json_data: &[u8], start_stop_ho
 			println!("   - {} | {:?} Ignoring tests because in skip list", name, blockchain.network);
 			continue;
 		}
+
 		start_stop_hook(&name, HookType::OnStart);
 
 		let mut fail = false;
 		{
-			let mut fail_unless = |cond: bool| if !cond && !fail {
-				failed.push(name.clone());
-				flushln!("FAIL");
-				fail = true;
-				true
-			} else {false};
+			let mut fail_unless = |cond: bool| {
+				if !cond && !fail {
+					failed.push(name.clone());
+					flushln!("FAIL");
+					fail = true;
+					true
+				} else {
+					false
+				}
+			};
 
-			flush!("   - {}...", name);
+			info!("   - {}...", name);
 
 			let spec = {
 				let mut spec = match EvmTestClient::fork_spec_from_json(&blockchain.network) {
@@ -89,16 +97,25 @@ pub fn json_chain_test<H: FnMut(&str, HookType)>(json_data: &[u8], start_stop_ho
 					config.check_seal = false;
 				}
 				config.history = 8;
+				config.queue.verifier_settings.num_verifiers = 1;
 				let client = Client::new(
 					config,
 					&spec,
 					db,
 					Arc::new(Miner::new_for_tests(&spec, None)),
 					IoChannel::disconnected(),
-				).unwrap();
+				).expect("Failed to instantiate a new Client");
+
 				for b in blockchain.blocks_rlp() {
+					let bytes_len = b.len();
 					if let Ok(block) = Unverified::from_rlp(b) {
-						let _ = client.import_block(block);
+						let num = block.header.number();
+						let hash = block.hash();
+						trace!(target: "json-tests", "{} – Importing {} bytes. Block #{}/{}", name, bytes_len, num, hash);
+						let res = client.import_block(block);
+						if let Err(e) = res {
+							warn!(target: "json-tests", "{} – Error importing block #{}/{}: {:?}", name, num, hash, e);
+						}
 						client.flush_queue();
 					}
 				}
@@ -113,7 +130,9 @@ pub fn json_chain_test<H: FnMut(&str, HookType)>(json_data: &[u8], start_stop_ho
 		start_stop_hook(&name, HookType::OnStop);
 	}
 
-	println!("!!! {:?} tests from failed.", failed.len());
+	if failed.len() > 0 {
+		println!("!!! {:?} tests failed.", failed.len());
+	}
 	failed
 }
 

json/src/maybe.rs

@@ -18,9 +18,13 @@
 
 use std::fmt;
 use std::marker::PhantomData;
+
+use ethereum_types::U256;
 use serde::{Deserialize, Deserializer};
 use serde::de::{Error, Visitor, IntoDeserializer};
 
+use crate::uint::Uint;
+
 /// Deserializer of empty string values into optionals.
 #[derive(Debug, PartialEq, Clone)]
 pub enum MaybeEmpty<T> {
@@ -32,7 +36,8 @@ pub enum MaybeEmpty<T> {
 
 impl<'a, T> Deserialize<'a> for MaybeEmpty<T> where T: Deserialize<'a> {
 	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-		where D: Deserializer<'a> {
+		where D: Deserializer<'a>
+	{
 		deserializer.deserialize_any(MaybeEmptyVisitor::new())
 	}
 }
@@ -78,6 +83,30 @@ impl<T> Into<Option<T>> for MaybeEmpty<T> {
 	}
 }
 
+impl From<MaybeEmpty<Uint>> for U256 {
+	fn from(maybe: MaybeEmpty<Uint>) -> U256 {
+		match maybe {
+			MaybeEmpty::Some(v) => v.0,
+			MaybeEmpty::None => U256::zero(),
+		}
+	}
+}
+
+impl From<MaybeEmpty<Uint>> for u64 {
+	fn from(maybe: MaybeEmpty<Uint>) -> u64 {
+		match maybe {
+			MaybeEmpty::Some(v) => v.0.low_u64(),
+			MaybeEmpty::None => 0u64,
+		}
+	}
+}
+
+impl Default for MaybeEmpty<Uint> {
+	fn default() -> Self {
+		MaybeEmpty::Some(Uint::default())
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;

json/src/transaction.rs

@@ -36,11 +36,14 @@ pub struct Transaction {
 	/// Value.
 	pub value: Uint,
 	/// R.
-	pub r: Uint,
+	#[serde(default)]
+	pub r: MaybeEmpty<Uint>,
 	/// S.
-	pub s: Uint,
+	#[serde(default)]
+	pub s: MaybeEmpty<Uint>,
 	/// V.
-	pub v: Uint,
+	#[serde(default)]
+	pub v: MaybeEmpty<Uint>,
 	/// Secret
 	#[serde(rename = "secretKey")]
 	pub secret: Option<H256>,
@@ -72,9 +75,9 @@ mod tests {
 		assert_eq!(tx.nonce, Uint(U256::zero()));
 		assert_eq!(tx.to, MaybeEmpty::None);
 		assert_eq!(tx.value, Uint(U256::zero()));
-		assert_eq!(tx.r, Uint(U256::zero()));
-		assert_eq!(tx.s, Uint(U256::one()));
-		assert_eq!(tx.v, Uint(U256::from(2)));
+		assert_eq!(tx.r, Uint(U256::zero()).into());
+		assert_eq!(tx.s, Uint(U256::one()).into());
+		assert_eq!(tx.v, Uint(U256::from(2)).into());
 		assert_eq!(tx.secret, Some(H256(Eth256::zero())));
 	}
 }