Initial model testing using quickcheck

Author: Kristoffer Ström

Cargo.lock

@@ -160,6 +160,8 @@ warp = "0.3.7"
 flate2 = "1.0.35"
 prometheus = "0.13.4"
 ctor = "0.2"
+quickcheck = "1.0.3"
+rand = "0.8"
 
 libc = { version = "0.2.161" }
 lazy_static = "1.4.0"

Cargo.toml

@@ -45,6 +45,9 @@ hash-db = { version = "0.15.2", optional = true }
 triehash = { version = "0.8.4", optional = true }
 flate2 = { workspace = true, optional = true }
 
+quickcheck = { workspace = true }
+rand = { workspace = true }
+
 [features]
 benchmark-utils = ["dep:hash-db", "dep:triehash", "dep:flate2"]
 
@@ -69,4 +72,3 @@ harness = false
 [[bench]]
 name = "trie_do_bench"
 harness = false
-

crates/eth-sparse-mpt/Cargo.toml

@@ -15,6 +15,8 @@ use reth_provider::{
     StateCommitmentProvider,
 };
 
+pub mod model_test;
+
 #[cfg(any(test, feature = "benchmark-utils"))]
 pub mod test_utils;
 pub mod utils;

crates/eth-sparse-mpt/src/lib.rs

@@ -0,0 +1,69 @@
+use crate::v2::trie::Trie;
+use quickcheck::{quickcheck, Arbitrary, Gen};
+use std::collections::HashMap;
+
+// The maximum key size. keeping it relatively
+// small increases the chance of multiple
+// operations being executed against the same
+// key, which will tease out more bugs.
+const KEY_SPACE: u8 = 16;
+
+#[derive(Clone, Debug)]
+enum Op {
+    Insert(Vec<u8>, Vec<u8>),
+    Get(Vec<u8>),
+}
+
+trait ChooseNonempty {
+    fn one_of<'a, T>(&'a mut self, entries: &'a [T]) -> &'a T;
+}
+
+impl ChooseNonempty for Gen {
+    fn one_of<'a, T>(&'a mut self, entries: &'a [T]) -> &'a T {
+        self.choose(entries).expect("empty list in choose nonempty")
+    }
+}
+
+// Arbitrary lets you create randomized instances
+// of types that you're interested in testing
+// properties with. QuickCheck will look for
+// this trait for things that are the arguments
+// to properties that it is testing.
+impl Arbitrary for Op {
+    fn arbitrary(g: &mut Gen) -> Self {
+        // pick a random key to perform an operation on
+        let key = g
+            .one_of(&["key00", "key01", "odd", "key010"])
+            .as_bytes()
+            .to_owned();
+
+        if *g.one_of(&[true, false]) {
+            Op::Insert(key, "value".into())
+        } else {
+            Op::Get(key)
+        }
+    }
+}
+
+quickcheck! {
+    fn model_test_v2(ops: Vec<Op>) -> bool {
+        let mut model = HashMap::new();
+        let mut implementation = Trie::new_empty();
+
+        for op in ops {
+            match op {
+                Op::Insert(k, v) => {
+                    implementation.insert(k.as_slice(), v.as_slice());
+                    model.insert(k, v);
+                }
+                Op::Get(k) => {
+                    // if implementation.get(&k) != model.get(&k).map(AsRef::as_ref) {
+                    //     return false;
+                    // }
+                }
+            }
+        }
+
+        true
+    }
+}

crates/eth-sparse-mpt/src/model_test.rs

@@ -361,6 +361,66 @@ impl Trie {
         self.delete_nibbles_key(&n)
     }
 
+    pub fn get(&mut self, key: &[u8]) -> Option<&[u8]> {
+        let n = Nibbles::unpack(key);
+        self.get_nibbles_key(&n)
+    }
+
+    pub fn get_nibbles_key(&mut self, nibbles_key: &Nibbles) -> Option<&[u8]> {
+        let get_key = nibbles_key.as_slice();
+        self.walk_path.clear();
+
+        let mut current_node = 0;
+        let mut path_walked = 0;
+
+        loop {
+            let node = self.nodes.get(current_node)?;
+
+            match node {
+                DiffTrieNode::Branch { children } => {
+                    // deleting from branch, key not found
+                    if get_key.len() == path_walked {
+                        return None;
+                    }
+
+                    let children = *children;
+
+                    let n = get_key[path_walked];
+                    self.walk_path.push((current_node, n));
+                    path_walked += 1;
+
+                    if let Some(child_ptr) = self.branch_node_children[children][n as usize] {
+                        current_node = child_ptr.local_ptr()?;
+                        continue;
+                    } else {
+                        return None;
+                    }
+                }
+                DiffTrieNode::Extension { key, next_node } => {
+                    let key = key.clone();
+                    let next_node = *next_node;
+
+                    if get_key[path_walked..].starts_with(&self.keys[key.clone()]) {
+                        self.walk_path.push((current_node, 0));
+                        path_walked += key.len();
+                        current_node = next_node.local_ptr()?;
+                        continue;
+                    }
+
+                    return None;
+                }
+                DiffTrieNode::Leaf { key, value } => {
+                    if self.keys[key.clone()] == get_key[path_walked..] {
+                        self.walk_path.push((current_node, 0));
+                        return Some(b"test");
+                    }
+                    return None;
+                }
+                DiffTrieNode::Null => return None,
+            }
+        }
+    }
+
     pub fn delete_nibbles_key(
         &mut self,
         nibbles_key: &Nibbles,