Use pretty-print to display the actual value in test assertion failure messages.

This makes the output much easier to understand when the actual value consists of a complex data structure with a lot of nesting. Previously, everything was packed into a single line. Pretty-print enforces newlines after every field as well as indentation reflecting the data structure.

This change also fixes several clippy warnings which surfaced in the same files affected by the above modifications.

PiperOrigin-RevId: 505619168

Author: hovinenb

googletest/integration_tests/integration_tests.rs

@@ -24,7 +24,7 @@ mod tests {
     };
     #[cfg(google3)]
     use matchers::all;
-    use matchers::{contains_regex, contains_substring, eq, not};
+    use matchers::{anything, contains_regex, contains_substring, displays_as, eq, err, not};
     use std::process::Command;
 
     #[google_test]
@@ -466,6 +466,29 @@ Actual: 1, which isn't equal to 2
         verify_that!(1, eq(2))
     }
 
+    #[google_test]
+    fn failure_message_uses_pretty_print_for_actual_value() -> Result<()> {
+        #[derive(Debug)]
+        #[allow(unused)]
+        struct NontrivialStruct {
+            a: i32,
+            b: i32,
+        }
+        let value = NontrivialStruct { a: 1, b: 2 };
+        let failed_assertion_result = verify_that!(value, not(anything()));
+
+        verify_that!(
+            failed_assertion_result,
+            err(displays_as(contains_substring(
+                "\
+Actual: NontrivialStruct {
+    a: 1,
+    b: 2,
+}"
+            )))
+        )
+    }
+
     fn run_external_process_in_tests_directory(name: &'static str) -> Result<String> {
         let mut command = run_external_process(name);
         let std::process::Output { stdout, .. } = command.output()?;

googletest/src/matcher.rs

@@ -61,7 +61,7 @@ pub(crate) fn create_assertion_failure<T: Debug + ?Sized>(
     TestAssertionFailure::create(format!(
         "Value of: {}\n\
              Expected: {}\n\
-             Actual: {:?}, {}\n\
+             Actual: {:#?}, {}\n\
              {}",
         actual_expr,
         matcher.describe(MatcherResult::Matches),

googletest/src/matchers/container_eq_matcher.rs

@@ -140,7 +140,7 @@ impl<const N: usize> Matcher<Vec<String>> for ContainerEqMatcher<[&str; N]> {
                 return MatcherResult::DoesNotMatch;
             }
         }
-        return MatcherResult::Matches;
+        MatcherResult::Matches
     }
 
     fn explain_match(&self, actual: &Vec<String>) -> MatchExplanation {
@@ -170,20 +170,14 @@ where
     where
         for<'a> &'a ActualT: IntoIterator<Item = &'a T>,
     {
-        self.expected
-            .into_iter()
-            .filter(|i| actual.into_iter().find(|j| j == i).is_none())
-            .collect()
+        self.expected.into_iter().filter(|&i| !actual.into_iter().any(|j| j == i)).collect()
     }
 
     fn get_unexpected_items<'a, ActualT: ?Sized>(&self, actual: &'a ActualT) -> Vec<&'a T>
     where
         for<'b> &'b ActualT: IntoIterator<Item = &'b T>,
     {
-        actual
-            .into_iter()
-            .filter(|i| self.expected.into_iter().find(|j| j == i).is_none())
-            .collect()
+        actual.into_iter().filter(|&i| !self.expected.into_iter().any(|j| j == i)).collect()
     }
 }
 
@@ -205,8 +199,7 @@ fn build_explanation<T: Debug, U: Debug>(missing: Vec<T>, unexpected: Vec<U>) ->
             unexpected[0]
         )),
         (0, _) => MatchExplanation::create(format!(
-            "which contains the unexpected elements {:?}",
-            unexpected
+            "which contains the unexpected elements {unexpected:?}",
         )),
         (1, 0) => {
             MatchExplanation::create(format!("which is missing the element {:?}", missing[0]))
@@ -216,17 +209,16 @@ fn build_explanation<T: Debug, U: Debug>(missing: Vec<T>, unexpected: Vec<U>) ->
             missing[0], unexpected[0]
         )),
         (1, _) => MatchExplanation::create(format!(
-            "which is missing the element {:?} and contains the unexpected elements {:?}",
-            missing[0], unexpected
+            "which is missing the element {:?} and contains the unexpected elements {unexpected:?}",
+            missing[0]
         )),
-        (_, 0) => MatchExplanation::create(format!("which is missing the elements {:?}", missing)),
+        (_, 0) => MatchExplanation::create(format!("which is missing the elements {missing:?}")),
         (_, 1) => MatchExplanation::create(format!(
-            "which is missing the elements {:?} and contains the unexpected element {:?}",
-            missing, unexpected[0]
+            "which is missing the elements {missing:?} and contains the unexpected element {:?}",
+            unexpected[0]
         )),
         (_, _) => MatchExplanation::create(format!(
-            "which is missing the elements {:?} and contains the unexpected elements {:?}",
-            missing, unexpected
+            "which is missing the elements {missing:?} and contains the unexpected elements {unexpected:?}",
         )),
     }
 }
@@ -281,9 +273,15 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![1, 3, 2]\n\
-                Expected: is equal to [1, 2, 3]\n\
-                Actual: [1, 3, 2], which contains all the elements"
+                "\
+Value of: vec![1, 3, 2]
+Expected: is equal to [1, 2, 3]
+Actual: [
+    1,
+    3,
+    2,
+], which contains all the elements
+"
             )))
         )
     }

googletest/src/matchers/each_matcher.rs

@@ -81,24 +81,22 @@ where
         if non_matching_elements.len() == 1 {
             let (idx, element, explanation) = non_matching_elements.remove(0);
             return MatchExplanation::create(format!(
-                "whose element #{} is {:?}, {}",
-                idx, element, explanation
+                "whose element #{idx} is {element:?}, {explanation}"
             ));
         }
 
         let failed_indexes = non_matching_elements
             .iter()
-            .map(|&(idx, _, _)| format!("#{}", idx))
+            .map(|&(idx, _, _)| format!("#{idx}"))
             .collect::<Vec<_>>()
             .join(", ");
         let element_explanations = non_matching_elements
             .iter()
-            .map(|&(_, element, ref explanation)| format!("{:?}, {}", element, explanation))
+            .map(|&(_, element, ref explanation)| format!("{element:?}, {explanation}"))
             .collect::<Vec<_>>()
             .join("\n");
         MatchExplanation::create(format!(
-            "whose elements {} don't match\n{}",
-            failed_indexes, element_explanations
+            "whose elements {failed_indexes} don't match\n{element_explanations}"
         ))
     }
 
@@ -177,9 +175,15 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![0, 2, 3]\n\
-                Expected: only contains elements that is greater than 0\n\
-                Actual: [0, 2, 3], whose element #0 is 0, which is less than or equal to 0"
+                "\
+Value of: vec![0, 2, 3]
+Expected: only contains elements that is greater than 0\n\
+Actual: [
+    0,
+    2,
+    3,
+], whose element #0 is 0, which is less than or equal to 0
+"
             )))
         )
     }
@@ -191,9 +195,15 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![1, 0, 3]\n\
-                Expected: only contains elements that is greater than 0\n\
-                Actual: [1, 0, 3], whose element #1 is 0, which is less than or equal to 0"
+                "\
+Value of: vec![1, 0, 3]
+Expected: only contains elements that is greater than 0
+Actual: [
+    1,
+    0,
+    3,
+], whose element #1 is 0, which is less than or equal to 0
+"
             )))
         )
     }
@@ -205,11 +215,17 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![0, 1, 3]\n\
-                Expected: only contains elements that is greater than 1\n\
-                Actual: [0, 1, 3], whose elements #0, #1 don't match\n\
-                0, which is less than or equal to 1\n\
-                1, which is less than or equal to 1"
+                "\
+Value of: vec![0, 1, 3]
+Expected: only contains elements that is greater than 1
+Actual: [
+    0,
+    1,
+    3,
+], whose elements #0, #1 don't match
+0, which is less than or equal to 1
+1, which is less than or equal to 1
+"
             )))
         )
     }
@@ -220,9 +236,19 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![vec! [1, 2], vec! [1]]\n\
-                Expected: only contains elements that only contains elements that is equal to 1\n\
-                Actual: [[1, 2], [1]], whose element #0 is [1, 2], whose element #1 is 2, which isn't equal to 1"
+                "\
+Value of: vec![vec! [1, 2], vec! [1]]
+Expected: only contains elements that only contains elements that is equal to 1
+Actual: [
+    [
+        1,
+        2,
+    ],
+    [
+        1,
+    ],
+], whose element #0 is [1, 2], whose element #1 is 2, which isn't equal to 1
+"
             )))
         )
     }

googletest/src/matchers/elements_are_matcher.rs

@@ -148,12 +148,18 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![1, 4, 3]\n\
-                Expected: has elements:\n\
-                is equal to 1\n\
-                is equal to 2\n\
-                is equal to 3\n\
-                Actual: [1, 4, 3], whose element #1 is 4, which isn't equal to 2"
+                "\
+Value of: vec![1, 4, 3]
+Expected: has elements:
+is equal to 1
+is equal to 2
+is equal to 3
+Actual: [
+    1,
+    4,
+    3,
+], whose element #1 is 4, which isn't equal to 2
+"
             )))
         )
     }

googletest/src/matchers/err_matcher.rs

@@ -114,9 +114,13 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: Err::<i32, i32>(1)\n\
-                 Expected: is an error containing a value, which is equal to 2\n\
-                 Actual: Err(1), which is an error containing 1, which isn't equal to 2"
+                "\
+Value of: Err::<i32, i32>(1)
+Expected: is an error containing a value, which is equal to 2
+Actual: Err(
+    1,
+), which is an error containing 1, which isn't equal to 2
+"
             )))
         )
     }

googletest/src/matchers/gt_matcher.rs

@@ -122,9 +122,10 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: 481\n\
-                Expected: is greater than 632\n\
-                Actual: 481"
+                "\
+Value of: 481
+Expected: is greater than 632
+Actual: 481"
             )))
         )
     }
@@ -136,9 +137,15 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: vec![19, 23, 11]\n\
-                Expected: only contains elements that is greater than 15\n\
-                Actual: [19, 23, 11], whose element #2 is 11, which is less than or equal to 15"
+                "\
+Value of: vec![19, 23, 11]\n\
+Expected: only contains elements that is greater than 15\n\
+Actual: [
+    19,
+    23,
+    11,
+], whose element #2 is 11, which is less than or equal to 15
+"
             )))
         )
     }

googletest/src/matchers/has_entry_matcher.rs

@@ -135,9 +135,13 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: HashMap::from([(0, 0)])\n\
-            Expected: contains key 1, which value is equal to 0\n\
-            Actual: {0: 0}, which doesn't contain key 1"
+                "\
+Value of: HashMap::from([(0, 0)])
+Expected: contains key 1, which value is equal to 0
+Actual: {
+    0: 0,
+}, which doesn't contain key 1
+"
             )))
         )
     }
@@ -149,9 +153,13 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: HashMap::from([(0, 0)])\n\
-            Expected: contains key 0, which value is equal to 1\n\
-            Actual: {0: 0}, which contains key 0, but is mapped to value 0, which isn't equal to 1"
+                "\
+Value of: HashMap::from([(0, 0)])
+Expected: contains key 0, which value is equal to 1
+Actual: {
+    0: 0,
+}, which contains key 0, but is mapped to value 0, which isn't equal to 1
+"
             )))
         )
     }

googletest/src/matchers/matches_pattern.rs

@@ -460,9 +460,13 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: actual\n\
-                Expected: has field `a_field`, which is equal to 234\n\
-                Actual: AStruct { a_field: 123 }, which has field `a_field`, which isn't equal to 234"
+                "\
+Value of: actual
+Expected: has field `a_field`, which is equal to 234
+Actual: AStruct {
+    a_field: 123,
+}, which has field `a_field`, which isn't equal to 234
+"
             )))
         )
     }
@@ -483,11 +487,16 @@ mod tests {
         verify_that!(
             result,
             err(displays_as(contains_substring(
-                "Value of: actual\n\
-                Expected: has field `a_field`, which is equal to 234 and\n\
-                has field `another_field`, which is equal to 123\n\
-                Actual: AStruct { a_field: 123, another_field: 234 }, which has field `a_field`, which isn't equal to 234 AND\n\
-                which has field `another_field`, which isn't equal to 123"
+                "\
+Value of: actual
+Expected: has field `a_field`, which is equal to 234 and
+has field `another_field`, which is equal to 123
+Actual: AStruct {
+    a_field: 123,
+    another_field: 234,
+}, which has field `a_field`, which isn't equal to 234 AND
+which has field `another_field`, which isn't equal to 123
+"
             )))
         )
     }