From ec8c1cb5f9e0bb435770df9a56d25d6a3a2b05a4 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Sat, 27 Feb 2016 15:49:44 +0100
Subject: [PATCH] Make "random" trie tests fully determinate.

---
 util/src/trie/standardmap.rs | 25 +++++++++++-----
 util/src/trie/triedbmut.rs   | 58 ++++++++++++------------------------
 2 files changed, 37 insertions(+), 46 deletions(-)

diff --git a/util/src/trie/standardmap.rs b/util/src/trie/standardmap.rs
index 98a5ae0f0..b7f3a9500 100644
--- a/util/src/trie/standardmap.rs
+++ b/util/src/trie/standardmap.rs
@@ -20,6 +20,7 @@ extern crate rand;
 use bytes::*;
 use sha3::*;
 use hash::*;
+use rlp::encode;
 
 /// Alphabet to use when creating words for insertion into tries.
 pub enum Alphabet {
@@ -39,6 +40,8 @@ pub enum ValueMode {
 	Mirror,
 	/// Randomly (50:50) 1 or 32 byte randomly string.
 	Random,
+	/// RLP-encoded index.
+	Index,
 }
 
 /// Standard test map for profiling tries.
@@ -89,19 +92,27 @@ impl StandardMap {
 
 	/// Create the standard map (set of keys and values) for the object's fields.
 	pub fn make(&self) -> Vec<(Bytes, Bytes)> {
+		self.make_with(&mut H256::new())
+	}
+
+	/// Create the standard map (set of keys and values) for the object's fields, using the given seed.
+	pub fn make_with(&self, seed: &mut H256) -> Vec<(Bytes, Bytes)> {
 		let low = b"abcdef";
 		let mid = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
 
 		let mut d: Vec<(Bytes, Bytes)> = Vec::new();
-		let mut seed = H256::new();
-		for _ in 0..self.count {
+		for index in 0..self.count {
 			let k = match self.alphabet {
-				Alphabet::All => Self::random_bytes(self.min_key, self.journal_key, &mut seed),
-				Alphabet::Low => Self::random_word(low, self.min_key, self.journal_key, &mut seed),
-				Alphabet::Mid => Self::random_word(mid, self.min_key, self.journal_key, &mut seed),
-				Alphabet::Custom(ref a) => Self::random_word(&a, self.min_key, self.journal_key, &mut seed),
+				Alphabet::All => Self::random_bytes(self.min_key, self.journal_key, seed),
+				Alphabet::Low => Self::random_word(low, self.min_key, self.journal_key, seed),
+				Alphabet::Mid => Self::random_word(mid, self.min_key, self.journal_key, seed),
+				Alphabet::Custom(ref a) => Self::random_word(&a, self.min_key, self.journal_key, seed),
+			};
+			let v = match self.value_mode {
+				ValueMode::Mirror => k.clone(),
+				ValueMode::Random => Self::random_value(seed),
+				ValueMode::Index => encode(&index).to_vec(),
 			};
-			let v = match self.value_mode { ValueMode::Mirror => k.clone(), ValueMode::Random => Self::random_value(&mut seed) };
 			d.push((k, v))
 		}
 		d
diff --git a/util/src/trie/triedbmut.rs b/util/src/trie/triedbmut.rs
index 2b4567264..829c1e518 100644
--- a/util/src/trie/triedbmut.rs
+++ b/util/src/trie/triedbmut.rs
@@ -687,31 +687,10 @@ mod tests {
 	use super::*;
 	use nibbleslice::*;
 	use rlp::*;
-	use rand::random;
-	use std::collections::HashSet;
-	use bytes::{ToPretty,Bytes,Populatable};
+	use bytes::ToPretty;
 	use super::super::node::*;
 	use super::super::trietraits::*;
-
-	fn random_key(alphabet: &[u8], min_count: usize, journal_count: usize) -> Vec<u8> {
-		let mut ret: Vec<u8> = Vec::new();
-		let r = min_count + if journal_count > 0 {random::<usize>() % journal_count} else {0};
-		for _ in 0..r {
-			ret.push(alphabet[random::<usize>() % alphabet.len()]);
-		}
-		ret
-	}
-	
-	fn random_value_indexed(j: usize) -> Bytes {
-		match random::<usize>() % 2 {
-			0 => encode(&j).to_vec(),
-			_ => {
-				let mut h = H256::new();
-				h.as_slice_mut()[31] = j as u8;
-				encode(&h).to_vec()
-			},
-		}
-	}
+	use super::super::standardmap::*;
 
 	fn populate_trie<'db>(db: &'db mut HashDB, root: &'db mut H256, v: &[(Vec<u8>, Vec<u8>)]) -> TrieDBMut<'db> {
 		let mut t = TrieDBMut::new(db, root);
@@ -756,20 +735,18 @@ mod tests {
 		};*/
 //		panic!();
 
+		let mut seed = H256::new();
 		for test_i in 0..1 {
 			if test_i % 50 == 0 {
 				debug!("{:?} of 10000 stress tests done", test_i);
 			}
-			let mut x: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
-			let mut got: HashSet<Vec<u8>> = HashSet::new();
-			let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
-			for j in 0..100usize {
-				let key = random_key(alphabet, 5, 0);
-				if !got.contains(&key) {
-					x.push((key.clone(), random_value_indexed(j)));
-					got.insert(key);
-				}
-			}
+			let x = StandardMap {
+				alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()),
+				min_key: 5,
+				journal_key: 0,
+				value_mode: ValueMode::Index,
+				count: 100,
+			}.make_with(&mut seed);
 
 			let real = trie_root(x.clone());
 			let mut memdb = MemoryDB::new();
@@ -1049,13 +1026,16 @@ mod tests {
 
 	#[test]
 	fn stress() {
+		let mut seed = H256::new();
 		for _ in 0..50 {
-			let mut x: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
-			let alphabet = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";
-			for j in 0..4u32 {
-				let key = random_key(alphabet, 5, 1);
-				x.push((key, encode(&j).to_vec()));
-			}
+			let x = StandardMap {
+				alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()),
+				min_key: 5,
+				journal_key: 0,
+				value_mode: ValueMode::Index,
+				count: 4,
+			}.make_with(&mut seed);
+
 			let real = trie_root(x.clone());
 			let mut memdb = MemoryDB::new();
 			let mut root = H256::new();