tests: re-enable comparisons of the loan_live_at relation

Also, add a descriptive message if the `assert_equal` helper fails its assertions.

Author: lqd

src/test.rs

@@ -17,8 +17,7 @@ use std::path::Path;
 fn test_facts(all_facts: &AllFacts, algorithms: &[Algorithm]) {
     let naive = Output::compute(all_facts, Algorithm::Naive, true);
 
-    // Check that the "naive errors" are a subset of the "insensitive
-    // ones".
+    // Check that the "naive errors" are a subset of the "insensitive ones".
     let insensitive = Output::compute(all_facts, Algorithm::LocationInsensitive, false);
     for (naive_point, naive_loans) in &naive.errors {
         match insensitive.errors.get(&naive_point) {
@@ -77,18 +76,37 @@ fn test_facts(all_facts: &AllFacts, algorithms: &[Algorithm]) {
     for &optimized_algorithm in algorithms {
         println!("Algorithm {:?}", optimized_algorithm);
         let opt = Output::compute(all_facts, optimized_algorithm, true);
-        // TMP: until we reach our correctness goals, deactivate some comparisons between variants
-        // assert_equal(&naive.loan_live_at, &opt.loan_live_at);
-        assert_equal(&naive.errors, &opt.errors);
-        assert_equal(&naive.subset_errors, &opt.subset_errors);
-        assert_equal(&naive.move_errors, &opt.move_errors);
+        assert_equal(
+            &naive.loan_live_at,
+            &opt.loan_live_at,
+            "naive vs opt loan_live_at",
+        );
+        assert_equal(&naive.errors, &opt.errors, "naive vs opt errors");
+        assert_equal(
+            &naive.subset_errors,
+            &opt.subset_errors,
+            "naive vs opt subset_errors",
+        );
+        assert_equal(
+            &naive.move_errors,
+            &opt.move_errors,
+            "naive vs opt move_errors",
+        );
     }
 
     // The hybrid algorithm gets the same errors as the naive version
     let opt = Output::compute(all_facts, Algorithm::Hybrid, true);
-    assert_equal(&naive.errors, &opt.errors);
-    assert_equal(&naive.subset_errors, &opt.subset_errors);
-    assert_equal(&naive.move_errors, &opt.move_errors);
+    assert_equal(&naive.errors, &opt.errors, "naive vs hybrid errors");
+    assert_equal(
+        &naive.subset_errors,
+        &opt.subset_errors,
+        "naive vs hybrid subset_errors",
+    );
+    assert_equal(
+        &naive.move_errors,
+        &opt.move_errors,
+        "naive vs hybrid move_errors",
+    );
 }
 
 fn test_fn(dir_name: &str, fn_name: &str, algorithm: Algorithm) -> Result<(), Box<dyn Error>> {
@@ -155,7 +173,7 @@ fn test_insensitive_errors() -> Result<(), Box<dyn Error>> {
     expected.insert(Point::from(24), vec![Loan::from(1)]);
     expected.insert(Point::from(50), vec![Loan::from(2)]);
 
-    assert_equal(&insensitive.errors, &expected);
+    assert_equal(&insensitive.errors, &expected, "insensitive errors");
     Ok(())
 }
 

src/test_util.rs

@@ -8,21 +8,21 @@ use crate::intern::InternerTables;
 use crate::program::parse_from_program;
 
 /// Test that two values are equal, with a better error than `assert_eq`
-pub fn assert_equal<A>(expected_value: &A, actual_value: &A)
+pub fn assert_equal<A>(expected_value: &A, actual_value: &A, message: &str)
 where
     A: ?Sized + Debug + Eq,
 {
     // First check that they have the same debug text. This produces a better error.
     let expected_text = format!("{:#?}", expected_value);
-    assert_expected_debug(&expected_text, actual_value);
+    assert_expected_debug(&expected_text, actual_value, message);
 
     // Then check that they are `eq` too, for good measure.
     assert_eq!(expected_value, actual_value);
 }
 
 /// Test that the debug output of `actual_value` is as expected. Gives
 /// a nice diff if things fail.
-pub fn assert_expected_debug<A>(expected_text: &str, actual_value: &A)
+pub fn assert_expected_debug<A>(expected_text: &str, actual_value: &A, message: &str)
 where
     A: ?Sized + Debug,
 {
@@ -47,7 +47,7 @@ where
         }
     }
 
-    panic!("debug comparison failed");
+    panic!("debug comparison failed: {}", message);
 }
 
 /// Builder for fact checking assertions
@@ -92,9 +92,13 @@ pub(crate) fn assert_checkers_match(checker_a: &FactChecker, checker_b: &FactChe
 }
 
 pub(crate) fn assert_outputs_match(output_a: &Output<LocalFacts>, output_b: &Output<LocalFacts>) {
-    assert_equal(&output_a.errors, &output_b.errors);
-    assert_equal(&output_a.subset_errors, &output_b.subset_errors);
-    assert_equal(&output_a.move_errors, &output_b.move_errors);
+    assert_equal(&output_a.errors, &output_b.errors, "errors");
+    assert_equal(
+        &output_a.subset_errors,
+        &output_b.subset_errors,
+        "subset_errors",
+    );
+    assert_equal(&output_a.move_errors, &output_b.move_errors, "move_errors");
 }
 
 impl FactChecker {