diff --git a/json-tests/json/.DS_Store b/json-tests/json/.DS_Store
new file mode 100644
index 000000000..5ddc63de7
Binary files /dev/null and b/json-tests/json/.DS_Store differ
diff --git a/json-tests/json/rlp/README.md b/json-tests/json/rlp/README.md
new file mode 100644
index 000000000..ab8b01020
--- /dev/null
+++ b/json-tests/json/rlp/README.md
@@ -0,0 +1,39 @@
+# 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"
+}
+```
+
diff --git a/json-tests/json/rlp/stream/bytestring0.json b/json-tests/json/rlp/stream/bytestring0.json
new file mode 100644
index 000000000..2cfd89b2c
--- /dev/null
+++ b/json-tests/json/rlp/stream/bytestring0.json
@@ -0,0 +1,10 @@
+{
+	"input":
+	[
+		{
+			"operation": "append",
+			"value": "\u0000"
+		}
+	],
+	"output": "0x00"
+}
diff --git a/json-tests/json/rlp/stream/bytestring1.json b/json-tests/json/rlp/stream/bytestring1.json
new file mode 100644
index 000000000..b14699f7a
--- /dev/null
+++ b/json-tests/json/rlp/stream/bytestring1.json
@@ -0,0 +1,10 @@
+{
+	"input":
+	[
+		{
+			"operation": "append",
+			"value": "\u0001"
+		}
+	],
+	"output": "0x01"
+}
diff --git a/json-tests/json/rlp/stream/bytestring7.json b/json-tests/json/rlp/stream/bytestring7.json
new file mode 100644
index 000000000..672050297
--- /dev/null
+++ b/json-tests/json/rlp/stream/bytestring7.json
@@ -0,0 +1,10 @@
+{
+	"input":
+	[
+		{
+			"operation": "append",
+			"value": "\u007f"
+		}
+	],
+	"output": "0x7f"
+}
diff --git a/json-tests/json/rlp/stream/catdog.json b/json-tests/json/rlp/stream/catdog.json
new file mode 100644
index 000000000..2cfd89b2c
--- /dev/null
+++ b/json-tests/json/rlp/stream/catdog.json
@@ -0,0 +1,10 @@
+{
+	"input":
+	[
+		{
+			"operation": "append",
+			"value": "\u0000"
+		}
+	],
+	"output": "0x00"
+}
diff --git a/json-tests/json/rlp/stream/empty.json b/json-tests/json/rlp/stream/empty.json
new file mode 100644
index 000000000..19cbf4185
--- /dev/null
+++ b/json-tests/json/rlp/stream/empty.json
@@ -0,0 +1,9 @@
+{
+	"input":
+	[
+		{
+			"operation": "append_empty"
+		}
+	],
+	"output": "0x80"
+}
diff --git a/json-tests/json/rlp/stream/empty_lists.json b/json-tests/json/rlp/stream/empty_lists.json
new file mode 100644
index 000000000..5ac649c2c
--- /dev/null
+++ b/json-tests/json/rlp/stream/empty_lists.json
@@ -0,0 +1,38 @@
+{
+	"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"
+}
diff --git a/json-tests/json/rlp/stream/integer.json b/json-tests/json/rlp/stream/integer.json
new file mode 100644
index 000000000..1effa4a1e
--- /dev/null
+++ b/json-tests/json/rlp/stream/integer.json
@@ -0,0 +1,10 @@
+{
+	"input":
+	[
+		{
+			"operation": "append",
+			"value": "0x0400"
+		}
+	],
+	"output": "0x820400"
+}
diff --git a/json-tests/json/rlp/stream/list_of_empty_data.json b/json-tests/json/rlp/stream/list_of_empty_data.json
new file mode 100644
index 000000000..c5b898f25
--- /dev/null
+++ b/json-tests/json/rlp/stream/list_of_empty_data.json
@@ -0,0 +1,22 @@
+{
+	"input":
+	[
+		{
+			"operation": "append_list",
+			"len": 3
+		},
+		{
+			"operation": "append",
+			"value": ""
+		},
+		{
+			"operation": "append",
+			"value": ""
+		},
+		{
+			"operation": "append",
+			"value": ""
+		}
+	],
+	"output": "0xc3808080"
+}
diff --git a/json-tests/json/rlp/stream/list_of_empty_data2.json b/json-tests/json/rlp/stream/list_of_empty_data2.json
new file mode 100644
index 000000000..76043af91
--- /dev/null
+++ b/json-tests/json/rlp/stream/list_of_empty_data2.json
@@ -0,0 +1,19 @@
+{
+	"input":
+	[
+		{
+			"operation": "append_list",
+			"len": 3
+		},
+		{
+			"operation": "append_empty"
+		},
+		{
+			"operation": "append_empty"
+		},
+		{
+			"operation": "append_empty"
+		}
+	],
+	"output": "0xc3808080"
+}
diff --git a/json-tests/json/rlp/stream/longlist.json b/json-tests/json/rlp/stream/longlist.json
new file mode 100644
index 000000000..4054d9c26
--- /dev/null
+++ b/json-tests/json/rlp/stream/longlist.json
@@ -0,0 +1,521 @@
+{
+	"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"
+
+}
\ No newline at end of file
diff --git a/json-tests/json/rlp/stream/longstring.json b/json-tests/json/rlp/stream/longstring.json
new file mode 100644
index 000000000..42b9aa2e0
--- /dev/null
+++ b/json-tests/json/rlp/stream/longstring.json
@@ -0,0 +1,10 @@
+{
+	"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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"
+}
diff --git a/json-tests/src/lib.rs b/json-tests/src/lib.rs
index 8a800e8f9..0fb1b091a 100644
--- a/json-tests/src/lib.rs
+++ b/json-tests/src/lib.rs
@@ -8,7 +8,9 @@ use std::fs::File;
 use glob::glob;
 use rustc_serialize::*;
 
+mod util;
 pub mod trie;
+pub mod rlp;
 
 pub trait JsonTest: Sized {
 	type Input;
diff --git a/json-tests/src/rlp.rs b/json-tests/src/rlp.rs
new file mode 100644
index 000000000..bf6131b5b
--- /dev/null
+++ b/json-tests/src/rlp.rs
@@ -0,0 +1,52 @@
+//! 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())
+	}
+}
+
diff --git a/json-tests/src/trie.rs b/json-tests/src/trie.rs
index 827bf8c9a..bc65e9db9 100644
--- a/json-tests/src/trie.rs
+++ b/json-tests/src/trie.rs
@@ -1,27 +1,12 @@
 //! json trie tests
 use std::collections::HashMap;
 use rustc_serialize::*;
-use rustc_serialize::hex::FromHex;
 use super::{JsonTest, JsonLoader};
-
-enum OperationType {
-	Insert,
-	Remove
-}
-
-impl Decodable for OperationType {
-	fn decode<D>(d: &mut D) -> Result<OperationType, D::Error> where D: Decoder {
-		match try!(String::decode(d)).as_ref() {
-			"insert" => Ok(OperationType::Insert),
-			"remove" => Ok(OperationType::Remove),
-			other => panic!("invalid operation type: {}", other)
-		}
-	}
-}
+use util::*;
 
 #[derive(RustcDecodable)]
 struct RawOperation {
-	operation: OperationType,
+	operation: String,
 	key: String,
 	value: Option<String>
 }
@@ -31,18 +16,12 @@ pub enum Operation {
 	Remove(Vec<u8>)
 }
 
-fn hex_or_string(s: &str) -> Vec<u8> {
-	match s.starts_with("0x") {
-		true => s[2..].from_hex().unwrap(),
-		false => From::from(s)
-	}
-}
-
 impl Into<Operation> for RawOperation {
 	fn into(self) -> Operation {
-		match self.operation {
-			OperationType::Insert => Operation::Insert(hex_or_string(&self.key), hex_or_string(&self.value.unwrap())),
-			OperationType::Remove => Operation::Remove(hex_or_string(&self.key))
+		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)
 		}
 	}
 }
diff --git a/json-tests/src/util.rs b/json-tests/src/util.rs
new file mode 100644
index 000000000..f9d1e4eab
--- /dev/null
+++ b/json-tests/src/util.rs
@@ -0,0 +1,8 @@
+use rustc_serialize::hex::FromHex;
+
+pub fn hex_or_string(s: &str) -> Vec<u8> {
+	match s.starts_with("0x") {
+		true => s[2..].from_hex().unwrap(),
+		false => From::from(s)
+	}
+}
diff --git a/src/rlp.rs b/src/rlp.rs
index b875e61c5..a7543aae5 100644
--- a/src/rlp.rs
+++ b/src/rlp.rs
@@ -1099,6 +1099,9 @@ impl Encoder for BasicEncoder {
 
 #[cfg(test)]
 mod tests {
+	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;
@@ -1257,7 +1260,7 @@ mod tests {
 		run_encode_tests(tests);
 	}
 
-	/// Vec<u8> is treated as a single value
+	/// Vec<u8> (Bytes) is treated as a single value
 	#[test]
 	fn encode_vector_u8() {
 		let tests = vec![
@@ -1293,60 +1296,6 @@ mod tests {
 		run_encode_tests(tests);
 	}
 
-	#[test]
-	fn encode_bytes() {
-		let vec = vec![0u8];
-		let slice: &[u8] = &vec;
-		let res = rlp::encode(&slice);
-		assert_eq!(res, vec![0u8]);
-	}
-
-	#[test]
-	fn rlp_stream() {
-		let mut stream = RlpStream::new_list(2);
-		stream.append(&"cat").append(&"dog");
-		let out = stream.out();
-		assert_eq!(out,
-				   vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
-	}
-
-	#[test]
-	fn rlp_stream_list() {
-		let mut stream = RlpStream::new_list(3);
-		stream.append_list(0);
-		stream.append_list(1).append_list(0);
-		stream.append_list(2).append_list(0).append_list(1).append_list(0);
-		let out = stream.out();
-		assert_eq!(out, vec![0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0]);
-	}
-
-	#[test]
-	fn rlp_stream_list2() {
-		let mut stream = RlpStream::new();
-		stream.append_list(17);
-		for _ in 0..17 {
-			stream.append(&"");
-		}
-		let out = stream.out();
-		assert_eq!(out, vec![0xd1, 0x80, 0x80, 0x80, 0x80, 0x80,
-							 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-							 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]);
-	}
-
-	#[test]
-	fn rlp_stream_list3() {
-		let mut stream = RlpStream::new();
-		stream.append_list(17);
-
-		let mut res = vec![0xf8, 0x44];
-		for _ in 0..17 {
-			stream.append(&"aaa");
-			res.extend(vec![0x83, b'a', b'a', b'a']);
-		}
-		let out = stream.out();
-		assert_eq!(out, res);
-	}
-
 	struct DTestPair<T>(T, Vec<u8>) where T: rlp::Decodable + fmt::Debug + cmp::Eq;
 
 	fn run_decode_tests<T>(tests: Vec<DTestPair<T>>) where T: rlp::Decodable + fmt::Debug + cmp::Eq {
@@ -1356,7 +1305,7 @@ mod tests {
 		}
 	}
 
-	/// Vec<u8> is treated as a single value
+	/// Vec<u8> (Bytes) is treated as a single value
 	#[test]
 	fn decode_vector_u8() {
 		let tests = vec![
@@ -1472,29 +1421,23 @@ mod tests {
 	}
 
 	#[test]
-	fn test_view() {
-		struct View<'a> {
-			bytes: &'a [u8]
-		}
+	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);
 
-		impl <'a, 'view> View<'a> where 'a: 'view {
-			fn new(bytes: &'a [u8]) -> View<'a> {
-				View {
-					bytes: bytes
-				}
+			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.append_list(len),
+					rlptest::Operation::AppendRaw(ref raw, len) => stream.append_raw(raw, len),
+					rlptest::Operation::AppendEmpty => stream.append_empty_data()
+				};
 			}
 
-			fn offset(&'view self, len: usize) -> View<'a> {
-				View::new(&self.bytes[len..])
-			}
-
-			fn data(&'view self) -> &'a [u8] {
-				self.bytes
-			}
-		}
-
-		let data = vec![0, 1, 2, 3];
-		let view = View::new(&data);
-		let _data_slice = view.offset(1).data();
+			assert_eq!(stream.out(), output);
+		});
 	}
+
 }
diff --git a/src/trie.rs b/src/trie.rs
index 3d825c707..9b31545db 100644
--- a/src/trie.rs
+++ b/src/trie.rs
@@ -793,8 +793,7 @@ impl Trie for TrieDB {
 #[cfg(test)]
 mod tests {
 	extern crate json_tests;
-	use self::json_tests::*;
-	use rustc_serialize::hex::FromHex;
+	use self::json_tests::{trie, execute_tests_from_directory};
 	use triehash::*;
 	use hash::*;
 	use super::*;
@@ -1023,24 +1022,6 @@ mod tests {
 		//assert!(false);
 	}
 
-	fn test_all(v: Vec<(Vec<u8>, Vec<u8>)>) {
-		let mut t = TrieDB::new_memory();
-		
-		for i in 0..v.len() {
-			let key: &[u8]= &v[i].0;
-			let val: &[u8] = &v[i].1;
-			t.insert(&key, &val);
-		}
-
-// 		trace!("{:?}", t);
-//		println!("{:?}", t);
-
-		// check lifetime
-//		let _q = t.at(&[b'd', b'o']).unwrap();
-
-		assert_eq!(*t.root(), trie_root(v));
-	}
-
 	fn random_key() -> Vec<u8> {
 		let chars = b"abcdefgrstuvwABCDEFGRSTUVW";
 		let mut ret: Vec<u8> = Vec::new();
@@ -1095,52 +1076,6 @@ mod tests {
 		t
 	}
 
-	#[test]
-	fn test_at_dog() {
-		env_logger::init().ok();
-		let v = vec![
-			(From::from("do"), From::from("verb")),
-			(From::from("dog"), From::from("puppy")),
-			(From::from("doge"), From::from("coin")),
-			(From::from("horse"), From::from("stallion")),
-		];
-
-		test_all(v);
-	}
-
-	#[test]
-	fn test_more_data() {
-		let v = vec![
-		
-			("0000000000000000000000000000000000000000000000000000000000000045".from_hex().unwrap(), 
-			 "22b224a1420a802ab51d326e29fa98e34c4f24ea".from_hex().unwrap()),
-
-			("0000000000000000000000000000000000000000000000000000000000000046".from_hex().unwrap(),
-			 "67706c2076330000000000000000000000000000000000000000000000000000".from_hex().unwrap()),
-
-			("000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap(),
-			 "6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap()),
-
-			("0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap(),
-			 "4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap()),
-
-			("000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap(),
-			 "4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap()),
-
-			("4655474156000000000000000000000000000000000000000000000000000000".from_hex().unwrap(),
-			 "7ef9e639e2733cb34e4dfc576d4b23f72db776b2".from_hex().unwrap()),
-
-			("4e616d6552656700000000000000000000000000000000000000000000000000".from_hex().unwrap(),
-			 "ec4f34c97e43fbb2816cfd95e388353c7181dab1".from_hex().unwrap()),
-
-			("6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000".from_hex().unwrap(),
-			 "697c7b8c961b56f675d570498424ac8de1a918f6".from_hex().unwrap())
-
-		];
-
-		test_all(v);
-	}
-
 	#[test]
 	fn test_trie_json() {
 		println!("Json trie test: ");