Merge pull request #36 from os-checker/testing

test: Check all hash values are unique

Author: zjp-CN

src/functions/serialization.rs

@@ -32,11 +32,9 @@ impl SerFunction {
         let mut hasher = StableHasher::<SipHasher128>::new();
         func.with_hasher(&mut hasher);
         hasher.write_length_prefix(attrs.len());
-        attrs.iter().for_each(|a| hasher.write_str(a));
+        attrs.iter().for_each(|attr| hasher.write_str(attr));
         hasher.write_length_prefix(callees.len());
-        callees.iter().for_each(|c| {
-            c.func.with_hasher(&mut hasher);
-        });
+        callees.iter().for_each(|callee| callee.func.with_hasher(&mut hasher));
         let Hash128(hash) = hasher.finish();
 
         SerFunction { hash, def_id, attrs, func, callees }

src/functions/utils.rs

@@ -31,6 +31,7 @@ pub struct SourceCode {
 
 impl SourceCode {
     pub fn with_hasher(&self, hasher: &mut StableHasher<SipHasher128>) {
+        hasher.write_str(&self.file);
         hasher.write_str(&self.src);
         match &self.before_expansion {
             Some(text) => {

tests/compare.rs

@@ -1,8 +1,7 @@
-use distributed_verification::SerFunction;
 use std::fs::{copy, remove_file};
 
 mod utils;
-use utils::{assert_eq, cmd, expect_file};
+use utils::{assert_eq, *};
 
 fn get(text: &str, start: &str) -> SerFunction {
     let json = &text[text.find("[\n").unwrap()..];

tests/proofs.rs

@@ -1,10 +1,12 @@
+use indexmap::IndexMap;
+use std::path::{Path, PathBuf};
+
 mod utils;
-use utils::*;
+use utils::{assert_eq, *};
 
-#[test]
-fn test_proofs() -> eyre::Result<()> {
+fn get_proofs(dir: &str) -> Result<Vec<PathBuf>> {
     let mut proofs = vec![];
-    for entry in std::fs::read_dir("tests/proofs")? {
+    for entry in std::fs::read_dir(dir)? {
         let entry = entry?;
         let path = entry.path();
         if path.is_file()
@@ -13,8 +15,35 @@ fn test_proofs() -> eyre::Result<()> {
             proofs.push(path);
         }
     }
-
     proofs.sort();
+    Ok(proofs)
+}
+
+fn assert_unique_hash(proofs: &[PathBuf], v_json: &[Vec<SerFunction>]) {
+    let mut map = IndexMap::<&str, Vec<(&Path, &str)>>::new();
+    for (v, proof) in v_json.iter().zip(proofs) {
+        for json in v {
+            let def_id = &*json.def_id;
+            let item = (&**proof, def_id);
+            map.entry(&json.hash)
+                .and_modify(|v_item| v_item.push(item))
+                .or_insert_with(|| vec![item]);
+        }
+    }
+    for (hash, v_item) in &map {
+        let v_item_len = v_item.len();
+        assert_eq!(
+            v_item_len, 1,
+            "{hash} should only correspond to single item, but \
+             {v_item_len} items have the hash value:\n{v_item:?}",
+        );
+    }
+}
+
+#[test]
+fn test_proofs() -> Result<()> {
+    let proofs = get_proofs("tests/proofs")?;
+
     expect![[r#"
         [
             "tests/proofs/ad_hoc.rs",
@@ -26,12 +55,41 @@ fn test_proofs() -> eyre::Result<()> {
     "#]]
     .assert_debug_eq(&proofs);
 
+    let mut v_json = Vec::<Vec<SerFunction>>::with_capacity(proofs.len());
+    for path in &proofs {
+        let file_stem = path.file_stem().and_then(|f| f.to_str()).unwrap();
+        let text = cmd(&[&format!("tests/proofs/{file_stem}.rs")]);
+        expect_file![format!("./snapshots/{file_stem}.json")].assert_eq(&text);
+        v_json.push(serde_json::from_str(&text).unwrap());
+    }
+
+    assert_unique_hash(&proofs, &v_json);
+    Ok(())
+}
+
+#[test]
+fn test_compare() -> Result<()> {
+    let proofs = get_proofs("tests/compare")?;
+
+    expect![[r#"
+        [
+            "tests/compare/contract1.rs",
+            "tests/compare/contract2.rs",
+            "tests/compare/proof1.rs",
+            "tests/compare/proof2.rs",
+        ]
+    "#]]
+    .assert_debug_eq(&proofs);
+
+    let mut v_json = Vec::<Vec<SerFunction>>::with_capacity(proofs.len());
     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);
+        let text = cmd(&[&format!("tests/compare/{file_stem}.rs")]);
+        // NOTE: don't write text to json file, since compare.rs write it in a different way
+        v_json.push(serde_json::from_str(&text).unwrap());
     }
 
+    assert_unique_hash(&proofs, &v_json);
     Ok(())
 }
 

tests/snapshots/ad_hoc.json

@@ -1,6 +1,6 @@
 [
   {
-    "hash": "10655023569148153324449981413843532452",
+    "hash": "240402353946165679413432703131261523692",
     "def_id": "DefId { id: 0, name: \"adhoc::callee_defined_in_proof\" }",
     "attrs": [
       "#[kanitool::proof]"
@@ -30,7 +30,7 @@
     ]
   },
   {
-    "hash": "79774297860844392025388862955799835958",
+    "hash": "910297032864347757816118745588521867089",
     "def_id": "DefId { id: 2, name: \"adhoc::closure_in_proof\" }",
     "attrs": [
       "#[kanitool::proof]"
@@ -60,7 +60,7 @@
     ]
   },
   {
-    "hash": "1291521982426130649016479097978635423963",
+    "hash": "210930681113882741614289248380189671885",
     "def_id": "DefId { id: 5, name: \"adhoc::proof_in_fn_item::proof\" }",
     "attrs": [
       "#[kanitool::proof]"

tests/snapshots/contract1.json

@@ -1,6 +1,6 @@
 [
   {
-    "hash": "142480961098313829086739331134333133873",
+    "hash": "767709965873040961211552770308306929266",
     "def_id": "DefId { id: 13, name: \"verify::f\" }",
     "attrs": [
       "#[kanitool::proof]"

tests/snapshots/contract2.json

@@ -1,6 +1,6 @@
 [
   {
-    "hash": "142480961098313829086739331134333133873",
+    "hash": "767709965873040961211552770308306929266",
     "def_id": "DefId { id: 13, name: \"verify::f\" }",
     "attrs": [
       "#[kanitool::proof]"

tests/snapshots/gen_by_macros.json

@@ -1,6 +1,6 @@
 [
   {
-    "hash": "975053280399656902416947254920631190028",
+    "hash": "11523848083194292978283464977531584378",
     "def_id": "DefId { id: 0, name: \"verify::proof1\" }",
     "attrs": [
       "#[kanitool::proof]"
@@ -62,7 +62,7 @@
     ]
   },
   {
-    "hash": "236593704829635227314040469354864202296",
+    "hash": "1149667103326042736912034193006744676464",
     "def_id": "DefId { id: 1, name: \"verify::proof2\" }",
     "attrs": [
       "#[kanitool::proof]"
@@ -124,7 +124,7 @@
     ]
   },
   {
-    "hash": "5474537339301642838978910224697845004",
+    "hash": "181931886334719422625983948383201250208",
     "def_id": "DefId { id: 2, name: \"verify::proof3\" }",
     "attrs": [
       "#[kanitool::proof]"

tests/snapshots/proof1.json

@@ -1,6 +1,6 @@
 [
   {
-    "hash": "327831672023728938116624563073238276451",
+    "hash": "876433099390387370318218200145590989814",
     "def_id": "DefId { id: 0, name: \"verify::f\" }",
     "attrs": [
       "#[kanitool::proof]"

tests/snapshots/proof2.json

@@ -1,6 +1,6 @@
 [
   {
-    "hash": "327831672023728938116624563073238276451",
+    "hash": "876433099390387370318218200145590989814",
     "def_id": "DefId { id: 0, name: \"verify::f\" }",
     "attrs": [
       "#[kanitool::proof]"
@@ -22,7 +22,7 @@
     ]
   },
   {
-    "hash": "588068929243813241914251336986802616528",
+    "hash": "47211252920145052832965334366253119118",
     "def_id": "DefId { id: 1, name: \"verify::g\" }",
     "attrs": [
       "#[kanitool::proof]"