test: add proptests for LruCache

Author: obycode

Cargo.lock

@@ -1,14 +1,25 @@
 [package]
 name = "stacks-common"
 version = "0.0.1"
-authors = [ "Jude Nelson <[email protected]>",
-            "Aaron Blankstein <[email protected]>",
-            "Ludo Galabru <[email protected]>" ]
+authors = [
+    "Jude Nelson <[email protected]>",
+    "Aaron Blankstein <[email protected]>",
+    "Ludo Galabru <[email protected]>",
+]
 license = "GPLv3"
 homepage = "https://github.com/blockstack/stacks-blockchain"
 repository = "https://github.com/blockstack/stacks-blockchain"
 description = "Common modules for blockstack_lib, libclarity"
-keywords = [ "stacks", "stx", "bitcoin", "crypto", "blockstack", "decentralized", "dapps", "blockchain" ]
+keywords = [
+    "stacks",
+    "stx",
+    "bitcoin",
+    "crypto",
+    "blockstack",
+    "decentralized",
+    "dapps",
+    "blockchain",
+]
 readme = "README.md"
 resolver = "2"
 edition = "2021"
@@ -25,7 +36,7 @@ serde_derive = "1"
 sha3 = "0.10.1"
 ripemd = "0.1.1"
 lazy_static = "1.4.0"
-slog = { version = "2.5.2", features = [ "max_level_trace" ] }
+slog = { version = "2.5.2", features = ["max_level_trace"] }
 slog-term = "2.6.0"
 slog-json = { version = "2.3.0", optional = true }
 chrono = "0.4.19"
@@ -37,7 +48,12 @@ rusqlite = { workspace = true, optional = true }
 nix = "0.23"
 
 [target.'cfg(windows)'.dependencies]
-winapi = { version = "0.3", features = ["consoleapi", "handleapi", "synchapi", "winbase"] }
+winapi = { version = "0.3", features = [
+    "consoleapi",
+    "handleapi",
+    "synchapi",
+    "winbase",
+] }
 
 [target.'cfg(windows)'.dev-dependencies]
 winapi = { version = "0.3", features = ["fileapi", "processenv", "winnt"] }
@@ -63,6 +79,7 @@ features = ["std"]
 
 [dev-dependencies]
 rand_core = { workspace = true }
+proptest = "1.6.0"
 
 [features]
 default = ["developer-mode"]

stacks-common/Cargo.toml

@@ -305,3 +305,85 @@ mod tests {
         assert_eq!(flushed, [(3, 3), (2, 2)]);
     }
 }
+
+#[cfg(test)]
+mod property_tests {
+    use proptest::prelude::*;
+
+    use super::*;
+
+    #[derive(Debug, Clone)]
+    enum CacheOp {
+        Insert(u32),
+        Get(u32),
+        InsertClean(u32),
+        Flush,
+    }
+
+    prop_compose! {
+        fn arbitrary_op()(op_type in 0..4, value in 0..100u32) -> CacheOp {
+            match op_type {
+                0 => CacheOp::Insert(value),
+                1 => CacheOp::Get(value),
+                2 => CacheOp::InsertClean(value),
+                _ => CacheOp::Flush,
+            }
+        }
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(1_000_000))]
+
+        #[test]
+        fn doesnt_crash_with_random_operations(ops in prop::collection::vec(arbitrary_op(), 1..1000)) {
+            let mut cache = LruCache::new(10);
+            for op in ops {
+                match op {
+                    CacheOp::Insert(v) => { cache.insert(v, v); }
+                    CacheOp::Get(v) => { cache.get(&v); }
+                    CacheOp::InsertClean(v) => { cache.insert_clean(v, v); }
+                    CacheOp::Flush => { cache.flush(|_, _| Ok::<(), ()>(())).unwrap(); }
+                }
+            }
+        }
+
+        #[test]
+        fn maintains_size_invariant(ops in prop::collection::vec(0..100u32, 1..1000)) {
+            let capacity = 10;
+            let mut cache = LruCache::new(capacity);
+            for op in ops {
+                cache.insert(op, op);
+                prop_assert!(cache.cache.len() <= capacity);
+                prop_assert!(cache.order.len() <= capacity);
+            }
+        }
+
+        #[test]
+        fn maintains_lru_order(ops in prop::collection::vec(arbitrary_op(), 1..1000)) {
+            let mut cache = LruCache::new(10);
+            for op in ops {
+                match op {
+                    CacheOp::Insert(v) => { cache.insert(v, v); }
+                    CacheOp::Get(v) => { cache.get(&v); }
+                    CacheOp::InsertClean(v) => { cache.insert_clean(v, v); }
+                    CacheOp::Flush => { cache.flush(|_, _| Ok::<(), ()>(())).unwrap(); }
+                }
+                // Verify linked list integrity
+                if !cache.order.is_empty() {
+                    let mut curr = cache.head;
+                    let mut count = 0;
+                    while curr != cache.capacity {
+                        if count >= cache.order.len() {
+                            prop_assert!(false, "Linked list cycle detected");
+                        }
+                        if cache.order[curr].next != cache.capacity {
+                            prop_assert_eq!(cache.order[cache.order[curr].next].prev, curr);
+                        }
+                        curr = cache.order[curr].next;
+                        count += 1;
+                    }
+                }
+            }
+        }
+    }
+}