Merge pull request #20 from os-checker/tests-diff

Chore: Simplify testing for proofs and snapshots folders

Author: zjp-CN

.github/workflows/test.yml

@@ -0,0 +1,14 @@
+name: Run Tests
+
+on:
+  push:
+    branches: 
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run tests
+        run: cargo test -- --nocapture

src/functions/mod.rs

@@ -52,7 +52,7 @@ pub struct Function {
     /// Raw function string, including name, signature, and body.
     func: String,
     /// Recursive fnction calls inside the body.
-    /// This set has insertion order, which is nice to check out call contexts.
+    /// The elements are sorted by file path and fn source code to keep hash value stable.
     callees: IndexSet<Instance>,
 }
 

src/functions/serialization.rs

@@ -19,7 +19,7 @@ pub struct SerFunction {
     attrs: Vec<String>,
     /// Raw function string, including name, signature, and body.
     func: String,
-    /// Recursive fnction calls inside the body.
+    /// Recursive function calls inside the proof.
     callees: Vec<Callee>,
 }
 

src/lib.rs

@@ -24,13 +24,3 @@ pub struct Callee {
     pub file: String,
     pub func: String,
 }
-
-impl SerFunction {
-    /// Even though callees are in insertion order, to make them easy to check,
-    /// sort by file and function.
-    pub fn callee_sorted_by_file_func(&self) -> Vec<[&str; 2]> {
-        let mut callees: Vec<_> = self.callees.iter().collect();
-        callees.sort_by(|a, b| (&a.file, &a.func).cmp(&(&b.file, &b.func)));
-        callees.into_iter().map(|c| [&*c.file, &*c.func]).collect()
-    }
-}

tests/compare.rs

@@ -0,0 +1,47 @@
+use distributed_verification::SerFunction;
+use std::fs::{copy, remove_file};
+
+mod utils;
+use utils::{assert_eq, cmd, expect_file};
+
+fn get(text: &str, start: &str) -> SerFunction {
+    let json = &text[text.find("[\n").unwrap()..];
+    let v: Vec<SerFunction> = serde_json::from_str(json).unwrap();
+    v.into_iter().find(|f| f.func.starts_with(start)).unwrap()
+}
+
+const COMPARE: &str = "tests/compare";
+
+fn compare(tmp: &str, v_file: &[&str], f: &str) {
+    let len = v_file.len();
+    assert!(len > 1);
+    let tmp = format!("{COMPARE}/{tmp}.rs");
+
+    let mut v_func = vec![];
+    for ele in v_file {
+        copy(format!("{COMPARE}/{ele}.rs"), &tmp).unwrap();
+        let text = cmd(&[&tmp]);
+        expect_file![format!("./snapshots/{ele}.json")].assert_eq(&text);
+        v_func.push(get(&text, f));
+    }
+
+    remove_file(tmp).unwrap();
+
+    // For the same proof (w.r.t same path and body),
+    // the hash value must be the same.
+    for i in 0..len - 1 {
+        for j in 1..len {
+            assert_eq!(
+                v_func[i].hash, v_func[j].hash,
+                "Hash values are not equal: {} ≠ {}",
+                v_file[i], v_file[j]
+            );
+        }
+    }
+}
+
+#[test]
+fn test_compare() {
+    compare("proof", &["proof1", "proof2"], "pub fn f()");
+    compare("contract", &["contract1", "contract2"], "pub fn f()");
+}

tests/proofs.rs

@@ -0,0 +1,32 @@
+mod utils;
+use utils::*;
+
+#[test]
+fn test_proofs() -> eyre::Result<()> {
+    let mut proofs = vec![];
+    for entry in std::fs::read_dir("tests/proofs")? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_file()
+            && path.extension().and_then(|ext| Some(ext.to_str()? == "rs")).unwrap_or(false)
+        {
+            proofs.push(path);
+        }
+    }
+
+    expect![[r#"
+        [
+            "tests/proofs/standard_proofs_with_contracts.rs",
+            "tests/proofs/standard_proofs.rs",
+        ]
+    "#]]
+    .assert_debug_eq(&proofs);
+
+    for path in &proofs {
+        let file_stem = path.file_stem().and_then(|f| f.to_str()).unwrap();
+        let json = cmd(&[&format!("tests/proofs/{file_stem}.rs")]);
+        expect_file![format!("./snapshots/{file_stem}.json")].assert_eq(&json);
+    }
+
+    Ok(())
+}

tests/standard_proofs.rs renamed to tests/proofs/standard_proofs.rs

@@ -1,18 +1,18 @@
 [
   {
-    "hash": "42109808322873561223875447740690337681",
+    "hash": "46975737574545431849805961234274153517",
     "def_id": "DefId { id: 1, name: \"verify::standard_proof_empty\" }",
-    "file": "tests/standard_proofs.rs",
+    "file": "tests/proofs/standard_proofs.rs",
     "attrs": [
       "#[kanitool::proof]"
     ],
     "func": "fn standard_proof_empty() {}",
     "callees": []
   },
   {
-    "hash": "119935654822495658609677948466451012436",
+    "hash": "154269283551974763216917429380903124467",
     "def_id": "DefId { id: 0, name: \"verify::standard_proof\" }",
-    "file": "tests/standard_proofs.rs",
+    "file": "tests/proofs/standard_proofs.rs",
     "attrs": [
       "#[kanitool::proof]"
     ],
@@ -51,9 +51,9 @@
     ]
   },
   {
-    "hash": "353125589356689115114026576863231049982",
+    "hash": "58801092890548413495612860413695445693",
     "def_id": "DefId { id: 2, name: \"verify::recursive_callees\" }",
-    "file": "tests/standard_proofs.rs",
+    "file": "tests/proofs/standard_proofs.rs",
     "attrs": [
       "#[kanitool::proof]"
     ],
@@ -596,12 +596,12 @@
       },
       {
         "def_id": "DefId { id: 4, name: \"m::func1\" }",
-        "file": "tests/standard_proofs.rs",
+        "file": "tests/proofs/standard_proofs.rs",
         "func": "pub fn func1() {\n        let _a = \"\".trim();\n    }"
       },
       {
         "def_id": "DefId { id: 3, name: \"top_level\" }",
-        "file": "tests/standard_proofs.rs",
+        "file": "tests/proofs/standard_proofs.rs",
         "func": "pub fn top_level() {\n    m::func1();\n}"
       }
     ]