refactor(tests): improve assertion error messages

Author: mkovaxx

crates/anodized-core/src/test_util.rs

@@ -21,65 +21,75 @@ impl Parse for ConditionClosure {
 }
 
 pub fn assert_contract_eq(left: &Contract, right: &Contract) {
-    assert_conditions_eq(&left.requires, &right.requires, "requires");
-    assert_conditions_eq(&left.maintains, &right.maintains, "maintains");
-    assert_condition_closures_eq(&left.ensures, &right.ensures, "ensures");
+    assert_slice_eq(
+        &left.requires,
+        &right.requires,
+        "requires",
+        &assert_condition_eq,
+    );
+    assert_slice_eq(
+        &left.maintains,
+        &right.maintains,
+        "maintains",
+        &assert_condition_eq,
+    );
+    assert_slice_eq(
+        &left.ensures,
+        &right.ensures,
+        "ensures",
+        &assert_condition_closure_eq,
+    );
 }
 
-fn assert_conditions_eq(left: &[Condition], right: &[Condition], clause_name: &str) {
+fn assert_slice_eq<T, F>(left: &[T], right: &[T], item_name: &str, assert_item_eq: F)
+where
+    F: Fn(&T, &T, &str),
+{
     assert_eq!(
         left.len(),
         right.len(),
-        "number of {} clauses do not match",
-        clause_name
+        "number of `{}` items do not match",
+        item_name
     );
 
     for (i, (left_item, right_item)) in left.iter().zip(right.iter()).enumerate() {
-        assert_eq!(
-            left_item.cfg.to_token_stream().to_string(),
-            right_item.cfg.to_token_stream().to_string(),
-            "{} clause #{} cfg does not match",
-            clause_name,
-            i + 1
-        );
-
-        assert_eq!(
-            left_item.expr.to_token_stream().to_string(),
-            right_item.expr.to_token_stream().to_string(),
-            "{} clause #{} does not match",
-            clause_name,
-            i + 1
-        );
+        let msg_prefix = format!("`{}` items at index {}, ", item_name, i);
+        assert_item_eq(left_item, right_item, &msg_prefix);
     }
 }
 
-fn assert_condition_closures_eq(
-    left: &[ConditionClosure],
-    right: &[ConditionClosure],
-    clause_name: &str,
-) {
+fn assert_condition_eq(left: &Condition, right: &Condition, msg_prefix: &str) {
     assert_eq!(
-        left.len(),
-        right.len(),
-        "number of {} clauses do not match",
-        clause_name
+        left.expr.to_token_stream().to_string(),
+        right.expr.to_token_stream().to_string(),
+        "{}`expr` does not match",
+        msg_prefix
     );
 
-    for (i, (left_item, right_item)) in left.iter().zip(right.iter()).enumerate() {
-        assert_eq!(
-            left_item.cfg.to_token_stream().to_string(),
-            right_item.cfg.to_token_stream().to_string(),
-            "{} clause #{} cfg does not match",
-            clause_name,
-            i + 1
-        );
+    assert_eq!(
+        left.cfg.to_token_stream().to_string(),
+        right.cfg.to_token_stream().to_string(),
+        "{}`cfg` does not match",
+        msg_prefix
+    );
+}
 
-        assert_eq!(
-            left_item.closure.to_token_stream().to_string(),
-            right_item.closure.to_token_stream().to_string(),
-            "{} clause #{} does not match",
-            clause_name,
-            i + 1
-        );
-    }
+fn assert_condition_closure_eq(
+    left: &ConditionClosure,
+    right: &ConditionClosure,
+    msg_prefix: &str,
+) {
+    assert_eq!(
+        left.closure.to_token_stream().to_string(),
+        right.closure.to_token_stream().to_string(),
+        "{}`closure` does not match",
+        msg_prefix
+    );
+
+    assert_eq!(
+        left.cfg.to_token_stream().to_string(),
+        right.cfg.to_token_stream().to_string(),
+        "{}`cfg` does not match",
+        msg_prefix
+    );
 }