Improve the output of actual value in test assertion failures.

This makes two changes:
 * If the total length of the (non-pretty-printed) debug output of the actual value is less than 60, then the non-pretty-printed output is used. Otherwise, the output is pretty-printed as before. This means that short, structured values like `Some(123)` will no longer be printed with newlines. This should reduce visual clutter and make the actual values easier to read.
 * The match explanation is now separated from the actual value by a newline and is indented. This visually separates the explanation from the actual value, making it easier to distinguish the two.

To support this visual separation, it was also necessary to enhance `Description` to support indenting all but the first line. Otherwise, the `all` matcher would have output multiple entries with the first one indented extra spaces like this:

```
Actual: [1, 2, 3],
    * First explanation
  * Second explanation
  * Third explanation
```

I replaced the boolean field `indented` with a enum representing the indentation mode and cleaned a few things up in the implementation along the way.

This also increases the use of indoc throughout the unit tests, making them easier to read.

PiperOrigin-RevId: 532034798

Author: hovinenb

googletest/Cargo.toml

@@ -58,6 +58,11 @@ name = "assertion_failure_in_subroutine"
 path = "integration_tests/assertion_failure_in_subroutine.rs"
 test = false
 
+[[bin]]
+name = "assertion_failures_with_short_structured_actual_values"
+path = "integration_tests/assertion_failures_with_short_structured_actual_values.rs"
+test = false
+
 [[bin]]
 name = "async_test_with_expect_that"
 path = "integration_tests/async_test_with_expect_that.rs"

googletest/integration_tests/assertion_failures_with_short_structured_actual_values.rs

@@ -0,0 +1,37 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::prelude::*;
+
+    #[test]
+    fn should_fail_with_option_value() -> Result<()> {
+        verify_that!(Some(1), some(eq(2)))
+    }
+
+    #[test]
+    fn should_fail_with_result_ok_value() -> Result<()> {
+        let value: std::result::Result<i32, ()> = Ok(1);
+        verify_that!(value, ok(eq(2)))
+    }
+
+    #[test]
+    fn should_fail_with_result_err_value() -> Result<()> {
+        let value: std::result::Result<(), i32> = Err(1);
+        verify_that!(value, err(eq(2)))
+    }
+}

googletest/integration_tests/integration_tests.rs

@@ -76,7 +76,8 @@ mod tests {
             contains_regex(indoc! {"
                 Value of: value
                 Expected: is equal to 3
-                Actual: 2, which isn't equal to 3
+                Actual: 2,
+                  which isn't equal to 3
                   at .*googletest/integration_tests/simple_assertion_failure.rs:[0-9]+:9"})
         )
     }
@@ -91,7 +92,8 @@ mod tests {
             contains_regex(indoc! {"
                 Value of: value
                 Expected: is equal to 3
-                Actual: 2, which isn't equal to 3
+                Actual: 2,
+                  which isn't equal to 3
                   at .*googletest/integration_tests/simple_assertion_failure_with_assert_that.rs:[0-9]+:9
                 "})
         )
@@ -106,7 +108,8 @@ mod tests {
             contains_regex(indoc! {"
                 Value of: value
                 Expected: is equal to 3
-                Actual: 2, which isn't equal to 3
+                Actual: 2,
+                  which isn't equal to 3
                   at .*googletest/integration_tests/expect_that_failure.rs:[0-9]+:9
                 "})
         )
@@ -122,12 +125,49 @@ mod tests {
             contains_regex(indoc! {"
                 Value of: value
                 Expected: is equal to 4
-                Actual: 2, which isn't equal to 4
+                Actual: 2,
+                  which isn't equal to 4
                   at .*googletest/integration_tests/two_expect_that_failures.rs:[0-9]+:9
                 "})
         )
     }
 
+    #[googletest::test]
+    fn should_output_failure_message_with_simple_structured_value() -> Result<()> {
+        let output = run_external_process_in_tests_directory(
+            "assertion_failures_with_short_structured_actual_values",
+        )?;
+
+        expect_that!(
+            output,
+            contains_substring(indoc! {"
+                Value of: Some(1)
+                Expected: has a value which is equal to 2
+                Actual: Some(1),
+                  which has a value which isn't equal to 2
+            "})
+        );
+        expect_that!(
+            output,
+            contains_substring(indoc! {"
+                Value of: value
+                Expected: is a success containing a value, which is equal to 2
+                Actual: Ok(1),
+                  which is a success which isn't equal to 2
+            "})
+        );
+        expect_that!(
+            output,
+            contains_substring(indoc! {"
+                Value of: value
+                Expected: is an error which is equal to 2
+                Actual: Err(1),
+                  which is an error which isn't equal to 2
+            "})
+        );
+        Ok(())
+    }
+
     #[test]
     fn should_fail_due_to_assertion_failure_in_subroutine() -> Result<()> {
         let status = run_external_process("simple_assertion_failure").status()?;
@@ -158,11 +198,13 @@ mod tests {
             all!(
                 contains_substring(indoc! {"
                     Expected: is equal to 3
-                    Actual: 2, which isn't equal to 3
+                    Actual: 2,
+                      which isn't equal to 3
                     "}),
                 contains_substring(indoc! {"
                     Expected: is equal to 4
-                    Actual: 2, which isn't equal to 4
+                    Actual: 2,
+                      which isn't equal to 4
                     "})
             )
         )
@@ -176,7 +218,8 @@ mod tests {
             output,
             not(contains_substring(indoc! {"
                 Expected: is equal to 4
-                Actual: 2, which isn't equal to 4
+                Actual: 2,
+                  which isn't equal to 4
                 "}))
         )
     }
@@ -189,7 +232,8 @@ mod tests {
             output,
             contains_substring(indoc! {"
                 Expected: is equal to 3
-                Actual: 2, which isn't equal to 3
+                Actual: 2,
+                  which isn't equal to 3
                 "})
         )
     }
@@ -424,7 +468,8 @@ mod tests {
             contains_substring(indoc! {"
                 Value of: 1
                 Expected: is equal to 2
-                Actual: 1, which isn't equal to 2
+                Actual: 1,
+                  which isn't equal to 2
                 "})
         )
     }
@@ -435,23 +480,23 @@ mod tests {
     }
 
     #[test]
-    fn failure_message_uses_pretty_print_for_actual_value() -> Result<()> {
+    fn failure_message_uses_pretty_print_for_actual_value_when_long_enough() -> Result<()> {
         #[derive(Debug)]
         #[allow(unused)]
         struct NontrivialStruct {
-            a: i32,
-            b: i32,
+            a: &'static str,
+            b: &'static str,
         }
-        let value = NontrivialStruct { a: 1, b: 2 };
+        let value = NontrivialStruct { a: "A long enough string", b: "Another long enough string" };
         let failed_assertion_result = verify_that!(value, not(anything()));
 
         verify_that!(
             failed_assertion_result,
-            err(displays_as(contains_substring(indoc! {"
+            err(displays_as(contains_substring(indoc! {r#"
                 Actual: NontrivialStruct {
-                    a: 1,
-                    b: 2,
-                }"})))
+                    a: "A long enough string",
+                    b: "Another long enough string",
+                }"#})))
         )
     }
 

googletest/src/matcher.rs

@@ -197,6 +197,10 @@ pub trait Matcher {
     }
 }
 
+/// Any actual value whose debug length is greater than this value will be
+/// pretty-printed. Otherwise, it will have normal debug output formatting.
+const PRETTY_PRINT_LENGTH_THRESHOLD: usize = 60;
+
 /// Constructs a [`TestAssertionFailure`] reporting that the given `matcher`
 /// does not match the value `actual`.
 ///
@@ -208,16 +212,21 @@ pub(crate) fn create_assertion_failure<T: Debug + ?Sized>(
     actual_expr: &'static str,
     source_location: SourceLocation,
 ) -> TestAssertionFailure {
+    let actual_formatted = format!("{actual:?}");
+    let actual_formatted = if actual_formatted.len() > PRETTY_PRINT_LENGTH_THRESHOLD {
+        format!("{actual:#?}")
+    } else {
+        actual_formatted
+    };
     TestAssertionFailure::create(format!(
-        "Value of: {}\n\
-             Expected: {}\n\
-             Actual: {:#?}, {}\n\
-             {}",
-        actual_expr,
+        "\
+Value of: {actual_expr}
+Expected: {}
+Actual: {actual_formatted},
+  {}
+{source_location}",
         matcher.describe(MatcherResult::Matches),
-        actual,
         matcher.explain_match(actual),
-        source_location,
     ))
 }