util cleanup (#1474)

* removed old json-tests

* simplify folds in triehash.rs

* removed unused json_aid

* removed unused squeeze.rs

* json branching tests for trie

* loading trie consensus tests

json/src/bytes.rs

@@ -16,15 +16,23 @@
 
 //! Lenient bytes json deserialization for test json files.
 
+use std::str::FromStr;
+use std::ops::Deref;
 use rustc_serialize::hex::FromHex;
 use serde::{Deserialize, Deserializer, Error};
 use serde::de::Visitor;
-use std::ops::Deref;
 
 /// Lenient bytes json deserialization for test json files.
-#[derive(Default, Debug, PartialEq, Clone)]
+#[derive(Default, Debug, PartialEq, Eq, Clone, PartialOrd, Ord)]
 pub struct Bytes(Vec<u8>);
 
+impl Bytes {
+	/// Creates bytes struct.
+	pub fn new(v: Vec<u8>) -> Self {
+		Bytes(v)
+	}
+}
+
 impl Into<Vec<u8>> for Bytes {
 	fn into(self) -> Vec<u8> {
 		self.0
@@ -39,6 +47,25 @@ impl Deref for Bytes {
 	}
 }
 
+impl FromStr for Bytes {
+	type Err = String;
+
+	fn from_str(value: &str) -> Result<Self, Self::Err> {
+		let v = match value.len() {
+			0 => vec![],
+			2 if value.starts_with("0x") => vec![],
+			_ if value.starts_with("0x") && value.len() % 2 == 1 => {
+				let v = "0".to_owned() + &value[2..];
+				FromHex::from_hex(v.as_ref() as &str).unwrap_or(vec![]),
+			},
+			_ if value.starts_with("0x") => FromHex::from_hex(&value[2..]).unwrap_or(vec![]),
+			_ => FromHex::from_hex(value).unwrap_or(vec![]),
+		};
+
+		Ok(Bytes(v))
+	}
+}
+
 impl Deserialize for Bytes {
 	fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
 		where D: Deserializer {
@@ -52,17 +79,7 @@ impl Visitor for BytesVisitor {
 	type Value = Bytes;
 
 	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: Error {
-		let v = match value.len() {
-			0 => vec![],
-			2 if value.starts_with("0x") => vec![],
-			_ if value.starts_with("0x") && value.len() % 2 == 1 => {
-				let v = "0".to_owned() + &value[2..];
-				FromHex::from_hex(v.as_ref() as &str).unwrap_or(vec![]),
-			},
-			_ if value.starts_with("0x") => FromHex::from_hex(&value[2..]).unwrap_or(vec![]),
-			_ => FromHex::from_hex(value).unwrap_or(vec![]),
-		};
-		Ok(Bytes(v))
+		Bytes::from_str(value).map_err(Error::custom)
 	}
 
 	fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: Error {

json/src/lib.rs.in

@@ -24,6 +24,7 @@ pub mod uint;
 pub mod bytes;
 pub mod blockchain;
 pub mod spec;
+pub mod trie;
 pub mod vm;
 pub mod maybe;
 pub mod state;

json/src/trie/input.rs

@@ -0,0 +1,155 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Trie test input deserialization.
+
+use std::collections::BTreeMap;
+use std::str::FromStr;
+use bytes::Bytes;
+use serde::{Deserialize, Deserializer, Error};
+use serde::de::{Visitor, MapVisitor, SeqVisitor};
+
+/// Trie test input.
+#[derive(Debug, PartialEq)]
+pub struct Input {
+	/// Input params.
+	pub data: BTreeMap<Bytes, Option<Bytes>>,
+}
+
+impl Deserialize for Input {
+	fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+		where D: Deserializer
+	{
+		deserializer.deserialize(InputVisitor)
+	}
+}
+
+struct InputVisitor;
+
+impl Visitor for InputVisitor {
+	type Value = Input;
+
+	fn visit_map<V>(&mut self, mut visitor: V) -> Result<Self::Value, V::Error> where V: MapVisitor {
+		let mut result = BTreeMap::new();
+
+		loop {
+			let key_str: Option<String> = try!(visitor.visit_key());
+			let key = match key_str {
+				Some(ref k) if k.starts_with("0x") => try!(Bytes::from_str(k).map_err(Error::custom)),
+				Some(k) => Bytes::new(k.into_bytes()),
+				None => { break; }
+			};
+
+			let val_str: Option<String> = try!(visitor.visit_value());
+			let val = match val_str {
+				Some(ref v) if v.starts_with("0x") => Some(try!(Bytes::from_str(v).map_err(Error::custom))),
+				Some(v) => Some(Bytes::new(v.into_bytes())),
+				None => None,
+			};
+
+			result.insert(key, val);
+		}
+
+		try!(visitor.end());
+
+		let input = Input {
+			data: result
+		};
+
+		Ok(input)
+	}
+
+	fn visit_seq<V>(&mut self, mut visitor: V) -> Result<Self::Value, V::Error> where V: SeqVisitor {
+		let mut result = BTreeMap::new();
+
+		loop {
+			let keyval: Option<Vec<Option<String>>> = try!(visitor.visit());
+			let keyval = match keyval {
+				Some(k) => k,
+				_ => { break; },
+			};
+
+			if keyval.len() != 2 {
+				return Err(Error::custom("Invalid key value pair."));
+			}
+
+			let ref key_str: Option<String> = keyval[0];
+			let ref val_str: Option<String> = keyval[1];
+
+			let key = match *key_str {
+				Some(ref k) if k.starts_with("0x") => try!(Bytes::from_str(k).map_err(Error::custom)),
+				Some(ref k) => Bytes::new(k.clone().into_bytes()),
+				None => { break; }
+			};
+
+			let val = match *val_str {
+				Some(ref v) if v.starts_with("0x") => Some(try!(Bytes::from_str(v).map_err(Error::custom))),
+				Some(ref v) => Some(Bytes::new(v.clone().into_bytes())),
+				None => None,
+			};
+
+			result.insert(key, val);
+		}
+
+		try!(visitor.end());
+
+		let input = Input {
+			data: result
+		};
+
+		Ok(input)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::collections::BTreeMap;
+	use serde_json;
+	use bytes::Bytes;
+	use super::Input;
+
+	#[test]
+	fn input_deserialization_from_map() {
+		let s = r#"{
+			"0x0045" : "0x0123456789",
+			"be" : "e",
+			"0x0a" : null
+		}"#;
+
+		let input: Input = serde_json::from_str(s).unwrap();
+		let mut map = BTreeMap::new();
+		map.insert(Bytes::new(vec![0, 0x45]), Some(Bytes::new(vec![0x01, 0x23, 0x45, 0x67, 0x89])));
+		map.insert(Bytes::new(vec![0x62, 0x65]), Some(Bytes::new(vec![0x65])));
+		map.insert(Bytes::new(vec![0x0a]), None);
+		assert_eq!(input.data, map);
+	}
+
+	#[test]
+	fn input_deserialization_from_array() {
+		let s = r#"[
+			["0x0045", "0x0123456789"],
+			["be", "e"],
+			["0x0a", null]
+		]"#;
+
+		let input: Input = serde_json::from_str(s).unwrap();
+		let mut map = BTreeMap::new();
+		map.insert(Bytes::new(vec![0, 0x45]), Some(Bytes::new(vec![0x01, 0x23, 0x45, 0x67, 0x89])));
+		map.insert(Bytes::new(vec![0x62, 0x65]), Some(Bytes::new(vec![0x65])));
+		map.insert(Bytes::new(vec![0x0a]), None);
+		assert_eq!(input.data, map);
+	}
+}

json/src/trie/mod.rs

@@ -0,0 +1,25 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Trie test deserialization.
+
+mod input;
+mod trie;
+mod test;
+
+pub use self::input::Input;
+pub use self::trie::Trie;
+pub use self::test::Test;

json/src/trie/test.rs

@@ -0,0 +1,43 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! TransactionTest test deserializer.
+
+use std::collections::BTreeMap;
+use std::io::Read;
+use serde_json;
+use serde_json::Error;
+use trie::Trie;
+
+/// TransactionTest test deserializer.
+#[derive(Debug, PartialEq, Deserialize)]
+pub struct Test(BTreeMap<String, Trie>);
+
+impl IntoIterator for Test {
+	type Item = <BTreeMap<String, Trie> as IntoIterator>::Item;
+	type IntoIter = <BTreeMap<String, Trie> as IntoIterator>::IntoIter;
+
+	fn into_iter(self) -> Self::IntoIter {
+		self.0.into_iter()
+	}
+}
+
+impl Test {
+	/// Loads test from json.
+	pub fn load<R>(reader: R) -> Result<Self, Error> where R: Read {
+		serde_json::from_reader(reader)
+	}
+}

json/src/trie/trie.rs

@@ -0,0 +1,30 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Trie test deserialization.
+
+use hash::H256;
+use trie::Input;
+
+/// Trie test deserialization.
+#[derive(Debug, Deserialize, PartialEq)]
+pub struct Trie {
+	/// Trie test input.
+	#[serde(rename="in")]
+	pub input: Input,
+	/// Trie root hash.
+	pub root: H256,
+}