Use Description in other matchers.

PiperOrigin-RevId: 515576928

Author: bjacotg

googletest/src/matchers/all_matcher.rs

@@ -57,9 +57,13 @@ pub mod internal {
     use crate as googletest;
     #[cfg(google3)]
     use anything_matcher::anything;
+    #[cfg(google3)]
+    use description::Description;
     use googletest::matcher::{MatchExplanation, Matcher, MatcherResult};
     #[cfg(not(google3))]
     use googletest::matchers::anything;
+    #[cfg(not(google3))]
+    use googletest::matchers::description::Description;
     use std::fmt::Debug;
 
     /// A matcher which matches an input value matched by all matchers in the
@@ -105,8 +109,12 @@ pub mod internal {
                             matches!(component.matches(actual), MatcherResult::DoesNotMatch)
                         })
                         .map(|component| format!("{}", component.explain_match(actual)))
-                        .collect::<Vec<_>>();
-                    MatchExplanation::create(failures.join(" AND\n"))
+                        .collect::<Description>();
+                    if failures.len() == 1 {
+                        MatchExplanation::create(format!("{}", failures))
+                    } else {
+                        MatchExplanation::create(format!("\n{}", failures.bullet_list().indent()))
+                    }
                 }
             }
         }
@@ -115,12 +123,22 @@ pub mod internal {
             match N {
                 0 => anything::<T>().describe(matcher_result),
                 1 => self.components[0].describe(matcher_result),
-                _ => self
-                    .components
-                    .iter()
-                    .map(|m| m.describe(matcher_result))
-                    .collect::<Vec<_>>()
-                    .join(matcher_result.pick(" and\n", " or\n")),
+                _ => {
+                    let properties = self
+                        .components
+                        .iter()
+                        .map(|m| m.describe(matcher_result))
+                        .collect::<Description>()
+                        .bullet_list()
+                        .indent();
+                    format!(
+                        "{}:\n{properties}",
+                        matcher_result.pick(
+                            "has all the following properties",
+                            "has at least one of the following properties"
+                        )
+                    )
+                }
             }
         }
     }
@@ -138,7 +156,8 @@ mod tests {
         matcher::{Matcher, MatcherResult},
         verify_that, Result,
     };
-    use matchers::{contains_substring, displays_as, ends_with, eq, not, starts_with};
+    use indoc::indoc;
+    use matchers::{contains_substring, displays_as, ends_with, eq, err, not, starts_with};
 
     #[google_test]
     fn matches_any_value_when_list_is_empty() -> Result<()> {
@@ -181,7 +200,12 @@ mod tests {
 
         verify_that!(
             matcher.describe(MatcherResult::Matches),
-            eq("starts with prefix \"A\" and\nends with suffix \"string\"")
+            eq(indoc!(
+                "
+                has all the following properties:
+                  * starts with prefix \"A\"
+                  * ends with suffix \"string\""
+            ))
         )
     }
 
@@ -222,7 +246,7 @@ mod tests {
         verify_that!(
             all!(starts_with("One"), starts_with("Two")).explain_match("Three"),
             displays_as(eq(
-                "which does not start with \"One\" AND\nwhich does not start with \"Two\""
+                "\n  * which does not start with \"One\"\n  * which does not start with \"Two\""
             ))
         )
     }
@@ -231,4 +255,24 @@ mod tests {
     fn mismatch_description_empty_matcher() -> Result<()> {
         verify_that!(all!().explain_match("Three"), displays_as(eq("which is anything")))
     }
+
+    #[google_test]
+    fn all_multiple_failed_assertions() -> Result<()> {
+        let result = verify_that!(4, all![eq(1), eq(2), eq(3)]);
+        verify_that!(
+            result,
+            err(displays_as(contains_substring(indoc!(
+                "
+                Value of: 4
+                Expected: has all the following properties:
+                  * is equal to 1
+                  * is equal to 2
+                  * is equal to 3
+                Actual: 4, 
+                  * which isn't equal to 1
+                  * which isn't equal to 2
+                  * which isn't equal to 3"
+            ))))
+        )
+    }
 }

googletest/src/matchers/each_matcher.rs

@@ -14,7 +14,11 @@
 
 #[cfg(not(google3))]
 use crate as googletest;
+#[cfg(google3)]
+use description::Description;
 use googletest::matcher::{MatchExplanation, Matcher, MatcherResult};
+#[cfg(not(google3))]
+use googletest::matchers::description::Description;
 use std::fmt::Debug;
 
 /// Matches a container all of whose elements are matched by the matcher
@@ -81,7 +85,7 @@ where
         if non_matching_elements.len() == 1 {
             let (idx, element, explanation) = non_matching_elements.remove(0);
             return MatchExplanation::create(format!(
-                "whose element #{idx} is {element:#?}, {explanation}"
+                "whose element #{idx} is {element:?}, {explanation}"
             ));
         }
 
@@ -92,9 +96,9 @@ where
             .join(", ");
         let element_explanations = non_matching_elements
             .iter()
-            .map(|&(_, element, ref explanation)| format!("{element:#?}, {explanation}"))
-            .collect::<Vec<_>>()
-            .join("\n");
+            .map(|&(_, element, ref explanation)| format!("{element:?}, {explanation}"))
+            .collect::<Description>()
+            .indent();
         MatchExplanation::create(format!(
             "whose elements {failed_indexes} don't match\n{element_explanations}"
         ))
@@ -123,6 +127,7 @@ mod tests {
     #[cfg(not(google3))]
     use googletest::matchers;
     use googletest::{google_test, verify_that, Result};
+    use indoc::indoc;
     use matchers::{contains_substring, displays_as, eq, err, gt, not};
     use std::collections::HashSet;
 
@@ -174,17 +179,16 @@ mod tests {
 
         verify_that!(
             result,
-            err(displays_as(contains_substring(
-                "\
-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
-"
-            )))
+            err(displays_as(contains_substring(indoc!(
+                "
+                Value of: vec![0, 2, 3]
+                Expected: only contains elements that is greater than 0
+                Actual: [
+                    0,
+                    2,
+                    3,
+                ], whose element #0 is 0, which is less than or equal to 0"
+            ))))
         )
     }
 
@@ -194,17 +198,16 @@ Actual: [
 
         verify_that!(
             result,
-            err(displays_as(contains_substring(
-                "\
-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
-"
-            )))
+            err(displays_as(contains_substring(indoc!(
+                "
+                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"
+            ))))
         )
     }
 
@@ -214,19 +217,18 @@ Actual: [
 
         verify_that!(
             result,
-            err(displays_as(contains_substring(
-                "\
-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
-"
-            )))
+            err(displays_as(contains_substring(indoc!(
+                "
+                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"
+            ))))
         )
     }
     #[google_test]
@@ -235,24 +237,20 @@ Actual: [
 
         verify_that!(
             result,
-            err(displays_as(contains_substring(
-                "\
-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
-"
-            )))
+            err(displays_as(contains_substring(indoc!(
+                "
+                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/matches_pattern.rs

@@ -379,6 +379,7 @@ mod tests {
     #[cfg(not(google3))]
     use googletest::matchers;
     use googletest::{google_test, verify_that, Result};
+    use indoc::indoc;
     use matchers::{contains_substring, displays_as, eq, err, not};
 
     #[google_test]
@@ -509,21 +510,21 @@ Actual: AStruct {
             actual,
             matches_pattern!(AStruct { a_field: eq(234), another_field: eq(123) })
         );
-        // TODO(bjacotg) Improve this error message. The format is not obvious.
         verify_that!(
             result,
-            err(displays_as(contains_substring(
-                "\
-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
-"
-            )))
+            err(displays_as(contains_substring(indoc!(
+                "
+                Value of: actual
+                Expected: has all the following properties:
+                  * has field `a_field`, which is equal to 234
+                  * 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
+                  * which has field `another_field`, which isn't equal to 123"
+            ))))
         )
     }