Merge pull request #408 from filecoin-project/feat/fuzz-cleanup

Cleanup fuzz test naming and add equivalence AMT test

Author: Kubuxu

fvm/src/system_actor.rs

@@ -1,10 +1,9 @@
 use anyhow::Context;
 use cid::Cid;
-use serde::{Deserialize, Serialize};
-
 use fvm_shared::address::Address;
 use fvm_shared::blockstore::{Blockstore, CborStore};
 use fvm_shared::encoding::Cbor;
+use serde::{Deserialize, Serialize};
 
 use crate::kernel::{ClassifyResult, Result};
 use crate::state_tree::{ActorState, StateTree};

ipld/amt/fuzz/Cargo.toml

@@ -11,20 +11,26 @@ cargo-fuzz = true
 [dependencies]
 libfuzzer-sys = "0.3"
 arbitrary = { version = "0.4", features = ["derive"] }
-ahash = "0.6"
+ahash = "0.7.6"
+itertools = "0.10.3"
 
-[dependencies.fvm_ipld_amt]
-path = ".."
+cid = { version = "0.8.2", default-features = false, features = ["serde-codec"] }
 
-[dependencies.fvm_shared]
-path = "../../../shared"
+fvm_ipld_amt = { path = ".."}
+fvm_shared = { path = "../../../shared" }
 
 # Prevent this from interfering with workspaces
 [workspace]
 members = ["."]
 
 [[bin]]
-name = "amt_fuzz"
-path = "fuzz_targets/amt_fuzz.rs"
+name = "simple"
+path = "fuzz_targets/simple.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "equivalence"
+path = "fuzz_targets/equivalence.rs"
 test = false
 doc = false

ipld/amt/fuzz/fuzz_targets/equivalence.rs

@@ -0,0 +1,68 @@
+// Copyright 2019-2022 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+#![no_main]
+use arbitrary::Arbitrary;
+use fvm_ipld_amt::{Amt, MAX_INDEX};
+use libfuzzer_sys::fuzz_target;
+use cid::Cid;
+use itertools::Itertools;
+
+
+#[derive(Debug, Arbitrary)]
+struct Operation {
+    idx: u64,
+    method: Method,
+}
+
+#[derive(Debug, Arbitrary)]
+enum Method {
+    Insert(u64),
+    Remove,
+    Get,
+}
+
+fn execute(ops: Vec<Operation>) -> (Cid, ahash::AHashMap<u64, u64>) {
+    let db = fvm_shared::blockstore::MemoryBlockstore::default();
+    let mut amt = Amt::new(&db);
+    let mut elements = ahash::AHashMap::new();
+
+    for (i, Operation { idx, method }) in ops.into_iter().enumerate() {
+        if idx > MAX_INDEX {
+            continue;
+        }
+
+        match method {
+            Method::Insert(v) => {
+                elements.insert(idx, v);
+                amt.set(idx, v).unwrap();
+            }
+            Method::Remove => {
+                let el = elements.remove(&idx);
+                let amt_deleted = amt.delete(idx).unwrap();
+                assert_eq!(amt_deleted, el, "step {}", i);
+            }
+            Method::Get => {
+                let ev = elements.get(&idx);
+                let av = amt.get(idx).unwrap();
+                assert_eq!(av, ev, "step {}", i);
+            }
+        }
+    }
+    (amt.flush().unwrap(), elements)
+}
+
+// Verifies that AMT created by this order of operations results in the same CID as
+// AMT created by minimal number of operations required.
+// The aim is to verify lack of past memory in the AMT structures.
+// AMT with same elements should have the same CID, regardless of their past.
+fuzz_target!(|ops: Vec<Operation>| {
+    let (res_cid, m) = execute(ops);
+
+    let simplified_ops = m.iter().sorted_by_key(|(_, v)| *v).map(|(k ,v)| {
+        Operation{idx: *k, method: Method::Insert(*v)}
+    }).collect();
+
+    let (simplified_cid, _) = execute(simplified_ops);
+    assert_eq!(res_cid, simplified_cid)
+});

ipld/amt/fuzz/fuzz_targets/amt_fuzz.rs renamed to ipld/amt/fuzz/fuzz_targets/simple.rs

@@ -11,18 +11,18 @@ cargo-fuzz = true
 [dependencies]
 libfuzzer-sys = "0.3"
 arbitrary = { version = "0.4", features = ["derive"] }
-ahash = "0.6"
+ahash = "0.7.6"
+
+fvm_ipld_hamt = { path = ".." }
 fvm_shared = { path = "../../../shared" }
 
-[dependencies.fvm_ipld_hamt]
-path = ".."
 
 # Prevent this from interfering with workspaces
 [workspace]
 members = ["."]
 
 [[bin]]
-name = "hamt_fuzz"
-path = "fuzz_targets/hamt_fuzz.rs"
+name = "simple"
+path = "fuzz_targets/simple.rs"
 test = false
 doc = false