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

Cargo.lock

@@ -390,7 +390,6 @@ dependencies = [
  "heapsize 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "igd 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "json-tests 0.1.0",
  "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -609,14 +608,6 @@ dependencies = [
  "slab 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
-[[package]]
-name = "json-tests"
-version = "0.1.0"
-dependencies = [
- "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
 [[package]]
 name = "jsonrpc-core"
 version = "2.0.7"

ethcore/src/json_tests/mod.rs

@@ -23,3 +23,4 @@ mod state;
 mod chain;
 mod homestead_state;
 mod homestead_chain;
+mod trie;

ethcore/src/json_tests/trie.rs

@@ -0,0 +1,69 @@
+// 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/>.
+
+use ethjson;
+use util::{H256, MemoryDB, TrieMut, TrieSpec, TrieFactory};
+
+fn test_trie(json: &[u8], trie: TrieSpec) -> Vec<String> {
+	let tests = ethjson::trie::Test::load(json).unwrap();
+	let factory = TrieFactory::new(trie);
+	let mut result = vec![];
+
+	for (name, test) in tests.into_iter() {
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::default();
+		let mut t = factory.create(&mut memdb, &mut root);
+
+		for (key, value) in test.input.data.into_iter() {
+			let key: Vec<u8> = key.into();
+			let value: Vec<u8> = value.map_or_else(Vec::new, Into::into);
+			t.insert(&key, &value);
+		}
+
+		if *t.root() != test.root.into() {
+			result.push(format!("Trie test '{:?}' failed.", name));
+		}
+	}
+
+	for i in &result {
+		println!("FAILED: {}", i);
+	}
+
+	result
+}
+
+mod generic {
+	use util::TrieSpec;
+
+	fn do_json_test(json: &[u8]) -> Vec<String> {
+		super::test_trie(json, TrieSpec::Generic)
+	}
+
+	declare_test!{TrieTests_trietest, "TrieTests/trietest"}
+	declare_test!{TrieTests_trieanyorder, "TrieTests/trieanyorder"}
+}
+
+mod secure {
+	use util::TrieSpec;
+
+	fn do_json_test(json: &[u8]) -> Vec<String> {
+		super::test_trie(json, TrieSpec::Secure)
+	}
+
+	declare_test!{TrieTests_hex_encoded_secure, "TrieTests/hex_encoded_securetrie_test"}
+	declare_test!{TrieTests_trietest_secure, "TrieTests/trietest_secureTrie"}
+	declare_test!{TrieTests_trieanyorder_secure, "TrieTests/trieanyorder_secureTrie"}
+}

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() {
+		Bytes::from_str(value).map_err(Error::custom)
-			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))
 	}
 
 	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

@@ -14,11 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use rustc_serialize::hex::FromHex;
+//! Trie test deserialization.
 
-pub fn hex_or_string(s: &str) -> Vec<u8> {
+mod input;
-	match s.starts_with("0x") {
+mod trie;
-		true => s[2..].from_hex().unwrap(),
+mod test;
-		false => From::from(s)
+
-	}
+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,
+}

util/Cargo.toml

@@ -29,7 +29,6 @@ slab = "0.2"
 sha3 = { path = "sha3" }
 serde = "0.7.0"
 clippy = { version = "0.0.78", optional = true}
-json-tests = { path = "json-tests" }
 igd = "0.4.2"
 ethcore-devtools = { path = "../devtools" }
 libc = "0.2.7"

util/json-tests/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "json-tests"
-version = "0.1.0"
-authors = ["debris <marek.kotewicz@gmail.com>"]
-
-[dependencies]
-rustc-serialize = "0.3"
-glob = "*"

util/json-tests/README.md

@@ -1,15 +0,0 @@
-# How to write json test file?
-
-Cause it's very hard to write generic json test files, each subdirectory should follow its own
-convention. BUT all json files `within` same directory should be consistent.
-
-### Test files should always contain a single test with input and output.
-
-```json
-{
-	input: ...,
-	output: ...
-}
-```
-
-As a reference, please use trietests.

util/json-tests/json/rlp/README.md

@@ -1,39 +0,0 @@
-# Rlp tests guideline
-
-Rlp can be tested in various ways. It can encode/decode a value or an array of values. Let's start with encoding.
-
-Each operation must have field:
-
-- `operation` - `append`, `append_list`, `append_empty` or `append_raw`
-
-Additionally `append` and `append_raw` must additionally define a `value` field:
-
-- `value` - data
-
-Also `append_raw` and `append_list` requires `len` field
-
-- `len` - integer
-
-### Encoding Test Example
-
-```json
-{
-	"input":
-	[
-		{
-			"operation": "append_list",
-			"len": 2
-		},
-		{
-			"operation": "append",
-			"value": "cat"
-		},
-		{
-			"operation": "append",
-			"value": "dog"
-		}
-	],
-	"output": "0xc88363617183646f67"
-}
-```
-

util/json-tests/json/rlp/stream/bytestring0.json

@@ -1,10 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append",
-			"value": "\u0000"
-		}
-	],
-	"output": "0x00"
-}

util/json-tests/json/rlp/stream/bytestring1.json

@@ -1,10 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append",
-			"value": "\u0001"
-		}
-	],
-	"output": "0x01"
-}

util/json-tests/json/rlp/stream/bytestring7.json

@@ -1,10 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append",
-			"value": "\u007f"
-		}
-	],
-	"output": "0x7f"
-}

util/json-tests/json/rlp/stream/catdog.json

@@ -1,10 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append",
-			"value": "\u0000"
-		}
-	],
-	"output": "0x00"
-}

util/json-tests/json/rlp/stream/empty.json

@@ -1,9 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append_empty"
-		}
-	],
-	"output": "0x80"
-}

util/json-tests/json/rlp/stream/empty_lists.json

@@ -1,38 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append_list",
-			"len": 3
-		},
-		{
-			"operation": "append_list",
-			"len": 0
-		},
-		{
-			"operation": "append_list",
-			"len": 1
-		},
-		{
-			"operation": "append_list",
-			"len": 0
-		},
-		{
-			"operation": "append_list",
-			"len": 2
-		},
-		{
-			"operation": "append_list",
-			"len": 0
-		},
-		{
-			"operation": "append_list",
-			"len": 1
-		},
-		{
-			"operation": "append_list",
-			"len": 0
-		}
-	],
-	"output": "0xc7c0c1c0c3c0c1c0"
-}

util/json-tests/json/rlp/stream/integer.json

@@ -1,10 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append",
-			"value": "0x0400"
-		}
-	],
-	"output": "0x820400"
-}

util/json-tests/json/rlp/stream/list_of_empty_data.json

@@ -1,22 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append_list",
-			"len": 3
-		},
-		{
-			"operation": "append",
-			"value": ""
-		},
-		{
-			"operation": "append",
-			"value": ""
-		},
-		{
-			"operation": "append",
-			"value": ""
-		}
-	],
-	"output": "0xc3808080"
-}

util/json-tests/json/rlp/stream/list_of_empty_data2.json

@@ -1,19 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append_list",
-			"len": 3
-		},
-		{
-			"operation": "append_empty"
-		},
-		{
-			"operation": "append_empty"
-		},
-		{
-			"operation": "append_empty"
-		}
-	],
-	"output": "0xc3808080"
-}

util/json-tests/json/rlp/stream/longlist.json

@@ -1,521 +0,0 @@
-{
-	"input": [
-	{
-		"operation": "append_list",
-		"len": 32
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	},
-	{
-		"operation": "append_list",
-		"len": 3
-	},
-	{
-		"operation": "append",
-		"value": "asdf"
-	},
-	{
-		"operation": "append",
-		"value": "qwer"
-	},
-	{
-		"operation": "append",
-		"value": "zxcv"
-	}],
-	"output": "0xf90200cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376"
-
-}

util/json-tests/json/rlp/stream/longstring.json

@@ -1,10 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "append",
-			"value": "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur mauris magna, suscipit sed vehicula non, iaculis faucibus tortor. Proin suscipit ultricies malesuada. Duis tortor elit, dictum quis tristique eu, ultrices at risus. Morbi a est imperdiet mi ullamcorper aliquet suscipit nec lorem. Aenean quis leo mollis, vulputate elit varius, consequat enim. Nulla ultrices turpis justo, et posuere urna consectetur nec. Proin non convallis metus. Donec tempor ipsum in mauris congue sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Suspendisse convallis sem vel massa faucibus, eget lacinia lacus tempor. Nulla quis ultricies purus. Proin auctor rhoncus nibh condimentum mollis. Aliquam consequat enim at metus luctus, a eleifend purus egestas. Curabitur at nibh metus. Nam bibendum, neque at auctor tristique, lorem libero aliquet arcu, non interdum tellus lectus sit amet eros. Cras rhoncus, metus ac ornare cursus, dolor justo ultrices metus, at ullamcorper volutpat"
-		}
-	],
-	"output": "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"
-}

util/json-tests/json/trie/README.md

@@ -1,35 +0,0 @@
-# Trie tests guideline
-
-Trie test input is an array of operations. Each operation must have 2 fields:
-
-- `operation` - string, either `insert` or `remove`
-- `key` - string, or hex value prefixed with `0x`
-
-And optional field:
-
-- `value`- which is used by `insert` operation
-
-### Example
-
-```json
-{
-	"input": 
-	[
-		{
-			"operation": "insert",
-			"key": "world",
-			"value": "hello"
-		},
-		{
-			"operation": "insert",
-			"key": "0x1234",
-			"value": "ooooops"
-		},
-		{
-			"operation": "remove",
-			"key": "0x1234"
-		}
-	],
-	"output": "0x5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84"
-}
-```

util/json-tests/json/trie/basic.json

@@ -1,11 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "insert",
-			"key": "A",
-			"value": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-		}
-	],
-	"output": "0xd23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab"
-}

util/json-tests/json/trie/branching.json

@@ -1,229 +0,0 @@
-{
-	"input": [
-	{
-		"operation": "insert",
-		"key": "0x04110d816c380812a427968ece99b1c963dfbce6",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x095e7baea6a6c7c4c2dfeb977efac326af552d87",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x0a517d755cebbf66312b30fff713666a9cb917e0",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x24dd378f51adc67a50e339e8031fe9bd4aafab36",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x293f982d000532a7861ab122bdc4bbfd26bf9030",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x2cf5732f017b0cf1b1f13a1478e10239716bf6b5",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x31c640b92c21a1f1465c91070b4b3b4d6854195f",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x37f998764813b136ddf5a754f34063fd03065e36",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x37fa399a749c121f8a15ce77e3d9f9bec8020d7a",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x4f36659fa632310b6ec438dea4085b522a2dd077",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x62c01474f089b07dae603491675dc5b5748f7049",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x729af7294be595a0efd7d891c9e51f89c07950c7",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x83e3e5a16d3b696a0314b30b2534804dd5e11197",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x8703df2417e0d7c59d063caa9583cb10a4d20532",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x8dffcd74e5b5923512916c6a64b502689cfa65e1",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x95a4d7cccb5204733874fa87285a176fe1e9e240",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0x99b2fcba8120bedd048fe79f5262a6690ed38c39",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xa4202b8b8afd5354e3e40a219bdc17f6001bf2cf",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xa9647f4a0a14042d91dc33c0328030a7157c93ae",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xaa6cffe5185732689c18f37a7f86170cb7304c2a",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xaae4a2e3c51c04606dcb3723456e58f3ed214f45",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xc37a43e940dfb5baf581a0b82b351d48305fc885",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xd2571607e241ecf590ed94b12d87c94babe36db6",
-		"value": "something"
-	},
-	{
-		"operation": "insert",
-		"key": "0xf735071cbee190d76b704ce68384fc21e389fbe7",
-		"value": "something"
-	},
-	{
-		"operation": "remove",
-		"key": "0x04110d816c380812a427968ece99b1c963dfbce6"
-	},
-	{
-		"operation": "remove",
-		"key": "0x095e7baea6a6c7c4c2dfeb977efac326af552d87"
-	},
-	{
-		"operation": "remove",
-		"key": "0x0a517d755cebbf66312b30fff713666a9cb917e0"
-	},
-	{
-		"operation": "remove",
-		"key": "0x24dd378f51adc67a50e339e8031fe9bd4aafab36"
-	},
-	{
-		"operation": "remove",
-		"key": "0x293f982d000532a7861ab122bdc4bbfd26bf9030"
-	},
-	{
-		"operation": "remove",
-		"key": "0x2cf5732f017b0cf1b1f13a1478e10239716bf6b5"
-	},
-	{
-		"operation": "remove",
-		"key": "0x31c640b92c21a1f1465c91070b4b3b4d6854195f"
-	},
-	{
-		"operation": "remove",
-		"key": "0x37f998764813b136ddf5a754f34063fd03065e36"
-	},
-	{
-		"operation": "remove",
-		"key": "0x37fa399a749c121f8a15ce77e3d9f9bec8020d7a"
-	},
-	{
-		"operation": "remove",
-		"key": "0x4f36659fa632310b6ec438dea4085b522a2dd077"
-	},
-	{
-		"operation": "remove",
-		"key": "0x62c01474f089b07dae603491675dc5b5748f7049"
-	},
-	{
-		"operation": "remove",
-		"key": "0x729af7294be595a0efd7d891c9e51f89c07950c7"
-	},
-	{
-		"operation": "remove",
-		"key": "0x83e3e5a16d3b696a0314b30b2534804dd5e11197"
-	},
-	{
-		"operation": "remove",
-		"key": "0x8703df2417e0d7c59d063caa9583cb10a4d20532"
-	},
-	{
-		"operation": "remove",
-		"key": "0x8dffcd74e5b5923512916c6a64b502689cfa65e1"
-	},
-	{
-		"operation": "remove",
-		"key": "0x95a4d7cccb5204733874fa87285a176fe1e9e240"
-	},
-	{
-		"operation": "remove",
-		"key": "0x99b2fcba8120bedd048fe79f5262a6690ed38c39"
-	},
-	{
-		"operation": "remove",
-		"key": "0xa4202b8b8afd5354e3e40a219bdc17f6001bf2cf"
-	},
-	{
-		"operation": "remove",
-		"key": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"
-	},
-	{
-		"operation": "remove",
-		"key": "0xa9647f4a0a14042d91dc33c0328030a7157c93ae"
-	},
-	{
-		"operation": "remove",
-		"key": "0xaa6cffe5185732689c18f37a7f86170cb7304c2a"
-	},
-	{
-		"operation": "remove",
-		"key": "0xaae4a2e3c51c04606dcb3723456e58f3ed214f45"
-	},
-	{
-		"operation": "remove",
-		"key": "0xc37a43e940dfb5baf581a0b82b351d48305fc885"
-	},
-	{
-		"operation": "remove",
-		"key": "0xd2571607e241ecf590ed94b12d87c94babe36db6"
-	},
-	{
-		"operation": "remove",
-		"key": "0xf735071cbee190d76b704ce68384fc21e389fbe7"
-	}],
-	"output": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
-}

util/json-tests/json/trie/dogs.json

@@ -1,21 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "insert",
-			"key": "doe",
-			"value": "reindeer"
-		},
-		{
-			"operation": "insert",
-			"key": "dogglesworth",
-			"value": "cat"
-		},
-		{
-			"operation": "insert",
-			"key": "dog",
-			"value": "puppy"
-		}
-	],
-	"output": "0x8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3"
-}

util/json-tests/json/trie/empty.json

@@ -1,4 +0,0 @@
-{
-	"input": [],
-	"output": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
-}

util/json-tests/json/trie/empty_values.json

@@ -1,44 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "insert",
-			"key": "do",
-			"value": "verb"
-		},
-		{
-			"operation": "insert",
-			"key": "ether",
-			"value": "wookiedoo"
-		},
-		{
-			"operation": "insert",
-			"key": "horse",
-			"value": "stallion"
-		},
-		{
-			"operation": "insert",
-			"key": "shaman",
-			"value": "horse"
-		},
-		{
-			"operation": "insert",
-			"key": "doge",
-			"value": "coin"
-		},
-		{
-			"operation": "remove",
-			"key": "ether"
-		},
-		{
-			"operation": "insert",
-			"key": "dog",
-			"value": "puppy"
-		},
-		{
-			"operation": "remove",
-			"key": "shaman"
-		}
-	],
-	"output": "0x5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84"
-}

util/json-tests/json/trie/foo.json

@@ -1,16 +0,0 @@
-{
-	"input":
-	[
-		{
-			"operation": "insert",
-			"key": "foo",
-			"value": "bar"
-		},
-		{
-			"operation": "insert",
-			"key": "food",
-			"value": "bass"
-		}
-	],
-	"output": "0x17beaa1648bafa633cda809c90c04af50fc8aed3cb40d16efbddee6fdf63c4c3"
-}

util/json-tests/json/trie/jeff.json

@@ -1,58 +0,0 @@
-{
-	"input": [
-	{
-		"operation": "insert",
-		"key": "0x0000000000000000000000000000000000000000000000000000000000000045",
-		"value": "0x22b224a1420a802ab51d326e29fa98e34c4f24ea"
-	},
-	{
-		"operation": "insert",
-		"key": "0x0000000000000000000000000000000000000000000000000000000000000046",
-		"value": "0x67706c2076330000000000000000000000000000000000000000000000000000"
-	},
-	{
-		"operation": "insert",
-		"key": "0x0000000000000000000000000000000000000000000000000000001234567890",
-		"value": "0x697c7b8c961b56f675d570498424ac8de1a918f6"
-	},
-	{
-		"operation": "insert",
-		"key": "0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6",
-		"value": "0x1234567890"
-	},
-	{
-		"operation": "insert",
-		"key": "0x0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2",
-		"value": "0x4655474156000000000000000000000000000000000000000000000000000000"
-	},
-	{
-		"operation": "insert",
-		"key": "0x000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1",
-		"value": "0x4e616d6552656700000000000000000000000000000000000000000000000000"
-	},
-	{
-		"operation": "insert",
-		"key": "0x4655474156000000000000000000000000000000000000000000000000000000",
-		"value": "0x7ef9e639e2733cb34e4dfc576d4b23f72db776b2"
-	},
-	{
-		"operation": "insert",
-		"key": "0x4e616d6552656700000000000000000000000000000000000000000000000000",
-		"value": "0xec4f34c97e43fbb2816cfd95e388353c7181dab1"
-	},
-	{
-		"operation": "remove",
-		"key": "0x0000000000000000000000000000000000000000000000000000001234567890"
-	},
-	{
-		"operation": "insert",
-		"key": "0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6",
-		"value": "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000"
-	},
-	{
-		"operation": "insert",
-		"key": "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000",
-		"value": "0x697c7b8c961b56f675d570498424ac8de1a918f6"
-	}],
-	"output": "0x9f6221ebb8efe7cff60a716ecb886e67dd042014be444669f0159d8e68b42100"
-}

util/json-tests/src/lib.rs

@@ -1,82 +0,0 @@
-// 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/>.
-
-extern crate rustc_serialize;
-extern crate glob;
-
-use std::str::from_utf8;
-use std::path::*;
-use std::io::prelude::*;
-use std::fs::File;
-use glob::glob;
-use rustc_serialize::*;
-
-mod util;
-pub mod trie;
-pub mod rlp;
-
-pub trait JsonTest: Sized {
-	type Input;
-	type Output;
-
-	fn new(data: &[u8]) -> Self;
-	fn input(&self) -> Self::Input;
-	fn output(&self) -> Self::Output;
-}
-
-pub struct JsonLoader {
-	json: json::Json
-}
-
-impl JsonTest for JsonLoader {
-	type Input = json::Json;
-	type Output = json::Json;
-
-	fn new(data: &[u8]) -> Self {
-		JsonLoader {
-			json: json::Json::from_str(from_utf8(data).unwrap()).unwrap()
-		}
-	}
-	fn input(&self) -> Self::Input {
-		self.json.as_object().unwrap()["input"].clone()
-	}
-
-	fn output(&self) -> Self::Output {
-		self.json.as_object().unwrap()["output"].clone()
-	}
-}
-
-pub fn execute_test<T, F>(data: &[u8], f: &mut F) where T: JsonTest, F: FnMut(T::Input, T::Output) {
-	let test = T::new(data);
-	f(test.input(), test.output())
-}
-
-pub fn execute_test_from_file<T, F>(path: &Path, f: &mut F) where T: JsonTest, F: FnMut(T::Input, T::Output) {
-	let mut file = File::open(path).unwrap();
-	let mut buffer = vec![];
-	let _  = file.read_to_end(&mut buffer);
-	let test = T::new(&buffer);
-	f(test.input(), test.output())
-}
-
-pub fn execute_tests_from_directory<T, F>(pattern: &str, f: &mut F) where T: JsonTest, F: FnMut(String, T::Input, T::Output) {
-	for path in glob(pattern).unwrap().filter_map(Result::ok) {
-		execute_test_from_file::<T, _>(&path, &mut | input, output | {
-			f(path.to_str().unwrap().to_string(), input, output);
-		});
-	}
-}
-

util/json-tests/src/rlp.rs

@@ -1,68 +0,0 @@
-// 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/>.
-
-//! json rlp tests
-use rustc_serialize::*;
-use super::{JsonTest, JsonLoader};
-use util::*;
-
-pub enum Operation {
-	Append(Vec<u8>),
-	AppendList(usize),
-	AppendRaw(Vec<u8>, usize),
-	AppendEmpty
-}
-
-impl Into<Operation> for json::Json {
-	fn into(self) -> Operation {
-		let obj = self.as_object().unwrap();
-		match obj["operation"].as_string().unwrap().as_ref() {
-			"append" => Operation::Append(hex_or_string(obj["value"].as_string().unwrap())),
-			"append_list" => Operation::AppendList(obj["len"].as_u64().unwrap() as usize),
-			"append_raw" => Operation::AppendRaw(hex_or_string(obj["value"].as_string().unwrap()), obj["len"].as_u64().unwrap() as usize),
-			"append_empty" => Operation::AppendEmpty,
-			other => { panic!("Unsupported opertation: {}", other); }
-		}
-	}
-}
-
-pub struct RlpStreamTest {
-	loader: JsonLoader
-}
-
-impl JsonTest for RlpStreamTest {
-	type Input = Vec<Operation>;
-	type Output = Vec<u8>;
-
-	fn new(data: &[u8]) -> Self {
-		RlpStreamTest {
-			loader: JsonLoader::new(data) 
-		}
-	}
-
-	fn input(&self) -> Self::Input {
-		self.loader.input().as_array().unwrap()
-			.iter()
-			.cloned()
-			.map(|i| i.into())
-			.collect()
-	}
-
-	fn output(&self) -> Self::Output {
-		hex_or_string(self.loader.output().as_string().unwrap())
-	}
-}
-

util/json-tests/src/trie.rs

@@ -1,105 +0,0 @@
-// 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/>.
-
-//! json trie tests
-use std::collections::HashMap;
-use rustc_serialize::*;
-use super::{JsonTest, JsonLoader};
-use util::*;
-
-#[derive(RustcDecodable)]
-struct RawOperation {
-	operation: String,
-	key: String,
-	value: Option<String>
-}
-
-pub enum Operation {
-	Insert(Vec<u8>, Vec<u8>),
-	Remove(Vec<u8>)
-}
-
-impl Into<Operation> for RawOperation {
-	fn into(self) -> Operation {
-		match self.operation.as_ref() {
-			"insert" => Operation::Insert(hex_or_string(&self.key), hex_or_string(&self.value.unwrap())),
-			"remove" => Operation::Remove(hex_or_string(&self.key)),
-			other => panic!("invalid operation type: {}", other)
-		}
-	}
-}
-
-pub struct TrieTest {
-	loader: JsonLoader
-}
-
-impl JsonTest for TrieTest {
-	type Input = Vec<Operation>;
-	type Output = Vec<u8>;
-	
-	fn new(data: &[u8]) -> Self {
-		TrieTest {
-			loader: JsonLoader::new(data) 
-		}
-	}
-
-	fn input(&self) -> Self::Input {
-		let mut decoder = json::Decoder::new(self.loader.input());
-		let raw: Vec<RawOperation> = Decodable::decode(&mut decoder).unwrap();
-		raw.into_iter()
-			.map(|i| i.into())
-			.collect()
-	}
-
-	fn output(&self) -> Self::Output {
-		hex_or_string(self.loader.output().as_string().unwrap())
-	}
-}
-
-pub struct TriehashTest {
-	trietest: TrieTest
-}
-
-impl JsonTest for TriehashTest {
-	type Input = Vec<(Vec<u8>, Vec<u8>)>;
-	type Output = Vec<u8>;
-
-	fn new(data: &[u8]) -> Self {
-		TriehashTest {
-			trietest: TrieTest::new(data)
-		}
-	}
-
-	fn input(&self) -> Self::Input {
-		self.trietest.input()
-			.into_iter()
-			.fold(HashMap::new(), | mut map, o | {
-				match o {
-					Operation::Insert(k, v) => map.insert(k, v),
-					Operation::Remove(k) => map.remove(&k)
-				};
-				map
-			})
-			.into_iter()
-			.map(|p| { p })
-			.collect()
-	}
-
-	fn output(&self) -> Self::Output {
-		self.trietest.output()
-	}
-}
-

util/src/json_aid.rs

@@ -1,154 +0,0 @@
-// 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/>.
-
-use common::*;
-
-/// Remove the `"0x"`, if present, from the left of `s`, returning the remaining slice.
-pub fn clean(s: &str) -> &str {
-	if s.len() >= 2 && &s[0..2] == "0x" {
-		&s[2..]
-	} else {
-		s
-	}
-}
-
-fn u256_from_str(s: &str) -> U256 {
-	if s.len() >= 2 && &s[0..2] == "0x" {
-		U256::from_str(&s[2..]).unwrap_or_else(|_| U256::zero())
-	} else {
-		U256::from_dec_str(s).unwrap_or_else(|_| U256::zero())
-	}
-}
-
-impl FromJson for Bytes {
-	fn from_json(json: &Json) -> Self {
-		match *json {
-			Json::String(ref s) => match s.len() % 2 {
-				0 => FromHex::from_hex(clean(s)).unwrap_or_else(|_| vec![]),
-				_ => FromHex::from_hex(&("0".to_owned() + &(clean(s).to_owned()))[..]).unwrap_or_else(|_| vec![]),
-			},
-			_ => vec![],
-		}
-	}
-}
-
-impl FromJson for BTreeMap<H256, H256> {
-	fn from_json(json: &Json) -> Self {
-		match *json {
-			Json::Object(ref o) => o.iter().map(|(key, value)| (u256_from_str(key).into(), U256::from_json(value).into())).collect(),
-			_ => BTreeMap::new(),
-		}
-	}
-}
-
-impl<T> FromJson for Vec<T> where T: FromJson {
-	fn from_json(json: &Json) -> Self {
-		match *json {
-			Json::Array(ref o) => o.iter().map(|x|T::from_json(x)).collect(),
-			_ => Vec::new(),
-		}
-	}
-}
-
-impl<T> FromJson for Option<T> where T: FromJson {
-	fn from_json(json: &Json) -> Self {
-		match *json {
-			Json::String(ref o) if o.is_empty() => None,
-			Json::Null => None,
-			_ => Some(FromJson::from_json(json)),
-		}
-	}
-}
-
-impl FromJson for u64 {
-	fn from_json(json: &Json) -> Self {
-		U256::from_json(json).low_u64()
-	}
-}
-
-impl FromJson for u32 {
-	fn from_json(json: &Json) -> Self {
-		U256::from_json(json).low_u64() as u32
-	}
-}
-
-impl FromJson for u16 {
-	fn from_json(json: &Json) -> Self {
-		U256::from_json(json).low_u64() as u16
-	}
-}
-
-#[test]
-fn u256_from_json() {
-	let j = Json::from_str("{ \"dec\": \"10\", \"hex\": \"0x0a\", \"int\": 10 }").unwrap();
-
-	let v: U256 = xjson!(&j["dec"]);
-	assert_eq!(U256::from(10), v);
-	let v: U256 = xjson!(&j["hex"]);
-	assert_eq!(U256::from(10), v);
-	let v: U256 = xjson!(&j["int"]);
-	assert_eq!(U256::from(10), v);
-}
-
-#[test]
-fn h256_from_json() {
-	let j = Json::from_str("{ \"with\": \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\", \"without\": \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\" }").unwrap();
-
-	let v: H256 = xjson!(&j["with"]);
-	assert_eq!(H256::from_str("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(), v);
-	let v: H256 = xjson!(&j["without"]);
-	assert_eq!(H256::from_str("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(), v);
-}
-
-#[test]
-fn vec_u256_from_json() {
-	let j = Json::from_str("{ \"array\": [ \"10\", \"0x0a\", 10] }").unwrap();
-
-	let v: Vec<U256> = xjson!(&j["array"]);
-	assert_eq!(vec![U256::from(10); 3], v);
-}
-
-#[test]
-fn vec_h256_from_json() {
-	let j = Json::from_str("{ \"array\": [ \"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\", \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\"] }").unwrap();
-
-	let v: Vec<H256> = xjson!(&j["array"]);
-	assert_eq!(vec![H256::from_str("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap(); 2], v);
-}
-
-#[test]
-fn simple_types() {
-	let j = Json::from_str("{ \"null\": null, \"empty\": \"\", \"int\": 42, \"dec\": \"42\", \"hex\": \"0x2a\" }").unwrap();
-	let v: u16 = xjson!(&j["int"]);
-	assert_eq!(42u16, v);
-	let v: u32 = xjson!(&j["dec"]);
-	assert_eq!(42u32, v);
-	let v: u64 = xjson!(&j["hex"]);
-	assert_eq!(42u64, v);
-}
-
-#[test]
-fn option_types() {
-	let j = Json::from_str("{ \"null\": null, \"empty\": \"\", \"int\": 42, \"dec\": \"42\", \"hex\": \"0x2a\" }").unwrap();
-	let v: Option<u16> = xjson!(&j["int"]);
-	assert_eq!(Some(42u16), v);
-	let v: Option<u16> = xjson!(&j["dec"]);
-	assert_eq!(Some(42u16), v);
-	let v: Option<u16> = xjson!(&j["null"]);
-	assert_eq!(None, v);
-	let v: Option<u16> = xjson!(&j["empty"]);
-	assert_eq!(None, v);
-}

util/src/lib.rs

@@ -131,7 +131,6 @@ pub mod bytes;
 pub mod rlp;
 pub mod misc;
 pub mod using_queue;
-mod json_aid;
 pub mod vector;
 pub mod sha3;
 pub mod hashdb;
@@ -147,7 +146,6 @@ pub mod trie;
 pub mod nibbleslice;
 pub mod nibblevec;
 mod heapsizeof;
-pub mod squeeze;
 pub mod semantic_version;
 pub mod io;
 pub mod network;
@@ -161,7 +159,6 @@ mod timer;
 pub use common::*;
 pub use misc::*;
 pub use using_queue::*;
-pub use json_aid::*;
 pub use rlp::*;
 pub use hashdb::*;
 pub use memorydb::*;
@@ -172,7 +169,6 @@ pub use crypto::*;
 pub use triehash::*;
 pub use trie::*;
 pub use nibbleslice::*;
-pub use squeeze::*;
 pub use semantic_version::*;
 pub use network::*;
 pub use io::*;

util/src/rlp/tests.rs

@@ -14,9 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-extern crate json_tests;
-use self::json_tests::execute_tests_from_directory;
-use self::json_tests::rlp as rlptest;
 use std::{fmt, cmp};
 use std::str::FromStr;
 use rlp;
@@ -340,26 +337,6 @@ fn decode_untrusted_vector_of_vectors_str() {
 	run_decode_tests(tests);
 }
 
-#[test]
-fn test_rlp_json() {
-	println!("Json rlp test: ");
-	execute_tests_from_directory::<rlptest::RlpStreamTest, _>("json-tests/json/rlp/stream/*.json", &mut | file, input, output | {
-		println!("file: {}", file);
-
-		let mut stream = RlpStream::new();
-		for operation in input.into_iter() {
-			match operation {
-				rlptest::Operation::Append(ref v) => stream.append(v),
-				rlptest::Operation::AppendList(len) => stream.begin_list(len),
-				rlptest::Operation::AppendRaw(ref raw, len) => stream.append_raw(raw, len),
-				rlptest::Operation::AppendEmpty => stream.append_empty_data()
-			};
-		}
-
-		assert_eq!(stream.out(), output);
-	});
-}
-
 #[test]
 fn test_decoding_array() {
 	let v = vec![5u16, 2u16];

util/src/squeeze.rs

@@ -1,84 +0,0 @@
-// 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/>.
-
-//! Helper module that should be used to randomly squeeze 
-//! caches to a given size in bytes
-//! 
-//! ```
-//! extern crate heapsize;
-//! extern crate ethcore_util as util;
-//! use std::collections::HashMap;
-//! use std::mem::size_of;
-//! use heapsize::HeapSizeOf;
-//! use util::squeeze::Squeeze;
-//! 
-//! fn main() {
-//!     let initial_size = 60;
-//! 	let mut map: HashMap<u8, u8> = HashMap::with_capacity(initial_size);
-//! 	assert!(map.capacity() >= initial_size);
-//! 	for i in 0..initial_size {
-//! 		map.insert(i as u8, i as u8);
-//! 	}
-//! 	
-//! 	assert_eq!(map.heap_size_of_children(), map.capacity() * 2 * size_of::<u8>());
-//! 	assert_eq!(map.len(), initial_size);
-//! 	let initial_heap_size = map.heap_size_of_children();
-//!
-//! 	// squeeze it to size of key and value
-//! 	map.squeeze(2 * size_of::<u8>());
-//! 	assert_eq!(map.len(), 1);
-//! 	
-//! 	// its likely that heap size was reduced, but we can't be 100% sure
-//! 	assert!(initial_heap_size >= map.heap_size_of_children());
-//! }
-//! ```
-
-use std::collections::HashMap;
-use std::hash::Hash;
-use heapsize::HeapSizeOf;
-
-/// Should be used to squeeze collections to certain size in bytes
-pub trait Squeeze {
-	/// Try to reduce collection size to `size` bytes
-	fn squeeze(&mut self, size: usize);
-}
-
-impl<K, T> Squeeze for HashMap<K, T> where K: Eq + Hash + Clone + HeapSizeOf, T: HeapSizeOf {
-	fn squeeze(&mut self, size: usize) {
-		if self.is_empty() {
-			return
-		}
-		
-		let size_of_entry = self.heap_size_of_children() / self.capacity();
-		let all_entries = size_of_entry * self.len();
-		let mut shrinked_size = all_entries;
-
-		while !self.is_empty() && shrinked_size > size {
-			// could be optimized
-			let key = self.keys().next().unwrap().clone();
-			self.remove(&key);
-			shrinked_size -= size_of_entry;
-		}
-
-		self.shrink_to_fit();
-
-		// if we squeezed something, but not enough, squeeze again
-		if all_entries != shrinked_size && self.heap_size_of_children() > size {
-			self.squeeze(size);
-		}
-	}
-}
-

util/src/trie/triedbmut.rs

@@ -676,8 +676,6 @@ impl<'db> fmt::Debug for TrieDBMut<'db> {
 
 #[cfg(test)]
 mod tests {
-	extern crate json_tests;
-	use self::json_tests::{trie, execute_tests_from_directory};
 	use triehash::*;
 	use hash::*;
 	use hashdb::*;
@@ -858,6 +856,21 @@ mod tests {
 		]));
 	}
 
+	#[test]
+	fn insert_out_of_order() {
+		let mut memdb = MemoryDB::new();
+		let mut root = H256::new();
+		let mut t = TrieDBMut::new(&mut memdb, &mut root);
+		t.insert(&[0xf1u8, 0x23], &[0xf1u8, 0x23]);
+		t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]);
+		t.insert(&[0x81u8, 0x23], &[0x81u8, 0x23]);
+		assert_eq!(*t.root(), trie_root(vec![
+			(vec![0x01u8, 0x23], vec![0x01u8, 0x23]),
+			(vec![0x81u8, 0x23], vec![0x81u8, 0x23]),
+			(vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]),
+		]));
+	}
+
 	#[test]
 	fn insert_value_into_branch_root() {
 		let mut memdb = MemoryDB::new();
@@ -1063,23 +1076,64 @@ mod tests {
 	}
 
 	#[test]
-	fn test_trie_json() {
+	fn branching_test() {
-		println!("Json trie test: ");
+		use std::str::FromStr;
-		execute_tests_from_directory::<trie::TrieTest, _>("json-tests/json/trie/*.json", &mut | file, input, output | {
+		use rustc_serialize::hex::FromHex;
-			println!("file: {}", file);
 
-			let mut memdb = MemoryDB::new();
+		let mut memdb = MemoryDB::new();
-			let mut root = H256::new();
+		let mut root = H256::new();
-			let mut t = TrieDBMut::new(&mut memdb, &mut root);
+		let mut t = TrieDBMut::new(&mut memdb, &mut root);
-			for operation in input.into_iter() {
+		t.insert(&"04110d816c380812a427968ece99b1c963dfbce6".from_hex().unwrap(), b"something");
-				match operation {
+		t.insert(&"095e7baea6a6c7c4c2dfeb977efac326af552d87".from_hex().unwrap(), b"something");
-					trie::Operation::Insert(key, value) => t.insert(&key, &value),
+		t.insert(&"0a517d755cebbf66312b30fff713666a9cb917e0".from_hex().unwrap(), b"something");
-					trie::Operation::Remove(key) => t.remove(&key)
+		t.insert(&"24dd378f51adc67a50e339e8031fe9bd4aafab36".from_hex().unwrap(), b"something");
-				}
+		t.insert(&"293f982d000532a7861ab122bdc4bbfd26bf9030".from_hex().unwrap(), b"something");
-			}
+		t.insert(&"2cf5732f017b0cf1b1f13a1478e10239716bf6b5".from_hex().unwrap(), b"something");
-
+		t.insert(&"31c640b92c21a1f1465c91070b4b3b4d6854195f".from_hex().unwrap(), b"something");
-			assert_eq!(*t.root(), H256::from_slice(&output));
+		t.insert(&"37f998764813b136ddf5a754f34063fd03065e36".from_hex().unwrap(), b"something");
-		});
+		t.insert(&"37fa399a749c121f8a15ce77e3d9f9bec8020d7a".from_hex().unwrap(), b"something");
+		t.insert(&"4f36659fa632310b6ec438dea4085b522a2dd077".from_hex().unwrap(), b"something");
+		t.insert(&"62c01474f089b07dae603491675dc5b5748f7049".from_hex().unwrap(), b"something");
+		t.insert(&"729af7294be595a0efd7d891c9e51f89c07950c7".from_hex().unwrap(), b"something");
+		t.insert(&"83e3e5a16d3b696a0314b30b2534804dd5e11197".from_hex().unwrap(), b"something");
+		t.insert(&"8703df2417e0d7c59d063caa9583cb10a4d20532".from_hex().unwrap(), b"something");
+		t.insert(&"8dffcd74e5b5923512916c6a64b502689cfa65e1".from_hex().unwrap(), b"something");
+		t.insert(&"95a4d7cccb5204733874fa87285a176fe1e9e240".from_hex().unwrap(), b"something");
+		t.insert(&"99b2fcba8120bedd048fe79f5262a6690ed38c39".from_hex().unwrap(), b"something");
+		t.insert(&"a4202b8b8afd5354e3e40a219bdc17f6001bf2cf".from_hex().unwrap(), b"something");
+		t.insert(&"a94f5374fce5edbc8e2a8697c15331677e6ebf0b".from_hex().unwrap(), b"something");
+		t.insert(&"a9647f4a0a14042d91dc33c0328030a7157c93ae".from_hex().unwrap(), b"something");
+		t.insert(&"aa6cffe5185732689c18f37a7f86170cb7304c2a".from_hex().unwrap(), b"something");
+		t.insert(&"aae4a2e3c51c04606dcb3723456e58f3ed214f45".from_hex().unwrap(), b"something");
+		t.insert(&"c37a43e940dfb5baf581a0b82b351d48305fc885".from_hex().unwrap(), b"something");
+		t.insert(&"d2571607e241ecf590ed94b12d87c94babe36db6".from_hex().unwrap(), b"something");
+		t.insert(&"f735071cbee190d76b704ce68384fc21e389fbe7".from_hex().unwrap(), b"something");
+		t.insert(&"04110d816c380812a427968ece99b1c963dfbce6".from_hex().unwrap(), &[]);
+		t.insert(&"095e7baea6a6c7c4c2dfeb977efac326af552d87".from_hex().unwrap(), &[]);
+		t.insert(&"0a517d755cebbf66312b30fff713666a9cb917e0".from_hex().unwrap(), &[]);
+		t.insert(&"24dd378f51adc67a50e339e8031fe9bd4aafab36".from_hex().unwrap(), &[]);
+		t.insert(&"293f982d000532a7861ab122bdc4bbfd26bf9030".from_hex().unwrap(), &[]);
+		t.insert(&"2cf5732f017b0cf1b1f13a1478e10239716bf6b5".from_hex().unwrap(), &[]);
+		t.insert(&"31c640b92c21a1f1465c91070b4b3b4d6854195f".from_hex().unwrap(), &[]);
+		t.insert(&"37f998764813b136ddf5a754f34063fd03065e36".from_hex().unwrap(), &[]);
+		t.insert(&"37fa399a749c121f8a15ce77e3d9f9bec8020d7a".from_hex().unwrap(), &[]);
+		t.insert(&"4f36659fa632310b6ec438dea4085b522a2dd077".from_hex().unwrap(), &[]);
+		t.insert(&"62c01474f089b07dae603491675dc5b5748f7049".from_hex().unwrap(), &[]);
+		t.insert(&"729af7294be595a0efd7d891c9e51f89c07950c7".from_hex().unwrap(), &[]);
+		t.insert(&"83e3e5a16d3b696a0314b30b2534804dd5e11197".from_hex().unwrap(), &[]);
+		t.insert(&"8703df2417e0d7c59d063caa9583cb10a4d20532".from_hex().unwrap(), &[]);
+		t.insert(&"8dffcd74e5b5923512916c6a64b502689cfa65e1".from_hex().unwrap(), &[]);
+		t.insert(&"95a4d7cccb5204733874fa87285a176fe1e9e240".from_hex().unwrap(), &[]);
+		t.insert(&"99b2fcba8120bedd048fe79f5262a6690ed38c39".from_hex().unwrap(), &[]);
+		t.insert(&"a4202b8b8afd5354e3e40a219bdc17f6001bf2cf".from_hex().unwrap(), &[]);
+		t.insert(&"a94f5374fce5edbc8e2a8697c15331677e6ebf0b".from_hex().unwrap(), &[]);
+		t.insert(&"a9647f4a0a14042d91dc33c0328030a7157c93ae".from_hex().unwrap(), &[]);
+		t.insert(&"aa6cffe5185732689c18f37a7f86170cb7304c2a".from_hex().unwrap(), &[]);
+		t.insert(&"aae4a2e3c51c04606dcb3723456e58f3ed214f45".from_hex().unwrap(), &[]);
+		t.insert(&"c37a43e940dfb5baf581a0b82b351d48305fc885".from_hex().unwrap(), &[]);
+		t.insert(&"d2571607e241ecf590ed94b12d87c94babe36db6".from_hex().unwrap(), &[]);
+		t.insert(&"f735071cbee190d76b704ce68384fc21e389fbe7".from_hex().unwrap(), &[]);
+		assert_eq!(*t.root(), H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap());
 	}
 
 	#[test]

util/src/triehash.rs

@@ -46,7 +46,8 @@ pub fn ordered_trie_root(input: Vec<Vec<u8>>) -> H256 {
 		// optimize it later
 		.into_iter()
 		.enumerate()
-		.fold(BTreeMap::new(), | mut acc, (i, vec) | { acc.insert(rlp::encode(&i).to_vec(), vec); acc })
+		.map(|(i, vec)| (rlp::encode(&i).to_vec(), vec))
+		.collect::<BTreeMap<_, _>>()
 		// then move them to a vector
 		.into_iter()
 		.map(|(k, v)| (as_nibbles(&k), v) )
@@ -78,10 +79,7 @@ pub fn trie_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
 	let gen_input = input
 		// first put elements into btree to sort them and to remove duplicates
 		.into_iter()
-		.fold(BTreeMap::new(), | mut acc, (k, v) | {
+		.collect::<BTreeMap<_, _>>()
-			acc.insert(k, v);
-			acc
-		})
 		// then move them to a vector
 		.into_iter()
 		.map(|(k, v)| (as_nibbles(&k), v) )
@@ -97,7 +95,7 @@ pub fn trie_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
 /// use std::str::FromStr;
 /// use util::triehash::*;
 /// use util::hash::*;
-/// 
+///
 /// fn main() {
 /// 	let v = vec![
 /// 		(From::from("doe"), From::from("reindeer")),
@@ -113,10 +111,8 @@ pub fn sec_trie_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
 	let gen_input = input
 		// first put elements into btree to sort them and to remove duplicates
 		.into_iter()
-		.fold(BTreeMap::new(), | mut acc, (k, v) | {
+		.map(|(k, v)| (k.sha3().to_vec(), v))
-			acc.insert(k.sha3().to_vec(), v);
+		.collect::<BTreeMap<_, _>>()
-			acc
-		})
 		// then move them to a vector
 		.into_iter()
 		.map(|(k, v)| (as_nibbles(&k), v) )
@@ -324,10 +320,16 @@ fn test_hex_prefix_encode() {
 
 #[cfg(test)]
 mod tests {
-	extern crate json_tests;
+	use std::str::FromStr;
-	use self::json_tests::*;
+	use hash::H256;
-	use hash::*;
+	use super::trie_root;
-	use triehash::*;
+
+	#[test]
+	fn simple_test() {
+		assert_eq!(trie_root(vec![
+			(b"A".to_vec(), b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_vec())
+		]), H256::from_str("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab").unwrap());
+	}
 
 	#[test]
 	fn test_triehash_out_of_order() {
@@ -343,11 +345,4 @@ mod tests {
 		]));
 	}
 
-	#[test]
-	fn test_triehash_json() {
-		execute_tests_from_directory::<trie::TriehashTest, _>("json-tests/json/trie/*.json", &mut | file, input, output | {
-			println!("file: {}, output: {:?}", file, output);
-			assert_eq!(trie_root(input), H256::from_slice(&output));
-		});
-	}
 }