Easier debugging output for nibbleslice.

src/nibbleslice.rs

@@ -1,5 +1,6 @@
 //! Nibble-orientated view onto byte-slice, allowing nibble-precision offsets.
 use std::cmp::*;
+use std::fmt;
 use bytes::*;
 
 /// Nibble-orientated view onto byte-slice, allowing nibble-precision offsets.
@@ -25,7 +26,7 @@ use bytes::*;
 ///   assert_eq!(n2.mid(3).common_prefix(&n1), 3);
 /// }
 /// ```
-#[derive(Debug, Copy, Clone, Eq, Ord)]
+#[derive(Copy, Clone, Eq, Ord)]
 pub struct NibbleSlice<'a> {
 	data: &'a [u8],
 	offset: usize,
@@ -122,6 +123,15 @@ impl<'a> PartialOrd for NibbleSlice<'a> {
 	}
 }
 
+impl<'a> fmt::Debug for NibbleSlice<'a> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		for i in 0..self.len() {
+			try!(write!(f, "{:01x}", i));
+		}
+		Ok(())
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::NibbleSlice;

src/trie.rs

@@ -332,12 +332,14 @@ mod tests {
 	fn playpen() {
 		env_logger::init().unwrap();
 
+		let big_value = b"00000000000000000000000000000000";
+
 		let mut t = TrieDB::new_memory();
-		t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]);
-		t.insert(&[], &[0x0]);
+		t.insert(&[0x01u8, 0x23], big_value);
+		t.insert(&[0x11u8, 0x23], big_value);
 		assert_eq!(*t.root(), trie_root(vec![
-			(vec![], vec![0x0]),
-			(vec![0x01u8, 0x23], vec![0x01u8, 0x23]),
+			(vec![0x01u8, 0x23], big_value.to_vec()),
+			(vec![0x11u8, 0x23], big_value.to_vec())
 		]));
 	}
 
@@ -386,4 +388,66 @@ mod tests {
 			(vec![0xf1u8, 0x23], vec![0xf1u8, 0x23]),
 		]));
 	}
+
+	#[test]
+	fn insert_value_into_branch_root() {
+		let mut t = TrieDB::new_memory();
+		t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]);
+		t.insert(&[], &[0x0]);
+		assert_eq!(*t.root(), trie_root(vec![
+			(vec![], vec![0x0]),
+			(vec![0x01u8, 0x23], vec![0x01u8, 0x23]),
+		]));
+	}
+
+	#[test]
+	fn insert_split_leaf() {
+		let mut t = TrieDB::new_memory();
+		t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]);
+		t.insert(&[0x01u8, 0x34], &[0x01u8, 0x34]);
+		assert_eq!(*t.root(), trie_root(vec![
+			(vec![0x01u8, 0x23], vec![0x01u8, 0x23]),
+			(vec![0x01u8, 0x34], vec![0x01u8, 0x34]),
+		]));
+	}
+
+	#[test]
+	fn insert_split_extenstion() {
+		let mut t = TrieDB::new_memory();
+		t.insert(&[0x01, 0x23, 0x45], &[0x01]);
+		t.insert(&[0x01, 0xf3, 0x45], &[0x02]);
+		t.insert(&[0x01, 0xf3, 0xf5], &[0x03]);
+		assert_eq!(*t.root(), trie_root(vec![
+			(vec![0x01, 0x23, 0x45], vec![0x01]),
+			(vec![0x01, 0xf3, 0x45], vec![0x02]),
+			(vec![0x01, 0xf3, 0xf5], vec![0x03]),
+		]));
+	}
+
+	#[test]
+	fn insert_big_value() {
+		let big_value0 = b"00000000000000000000000000000000";
+		let big_value1 = b"11111111111111111111111111111111";
+
+		let mut t = TrieDB::new_memory();
+		t.insert(&[0x01u8, 0x23], big_value0);
+		t.insert(&[0x11u8, 0x23], big_value1);
+		assert_eq!(*t.root(), trie_root(vec![
+			(vec![0x01u8, 0x23], big_value0.to_vec()),
+			(vec![0x11u8, 0x23], big_value1.to_vec())
+		]));
+	}
+
+	#[test]
+	fn insert_duplicate_value() {
+		let big_value = b"00000000000000000000000000000000";
+
+		let mut t = TrieDB::new_memory();
+		t.insert(&[0x01u8, 0x23], big_value);
+		t.insert(&[0x11u8, 0x23], big_value);
+		assert_eq!(*t.root(), trie_root(vec![
+			(vec![0x01u8, 0x23], big_value.to_vec()),
+			(vec![0x11u8, 0x23], big_value.to_vec())
+		]));
+	}
 }