Better support the creation of a diff between actual and expected values with the ends_with matcher.

This uses the new `Prefix` mode in `edit_list` to skip the lines preceding the expected suffix. To do this, `StrMatcher` reverses the lines of the actual and expected values before creating the edit list, then restores the correct order from the output.

This approach has the side effect that the order in which the actual and expected lines are shown in the diff is the reverse of that used in the `eq` and `starts_with` matcher. It is unlikely that this difference will have any real consequence for the user, so I am leaving it as is.

PiperOrigin-RevId: 540859950

Author: hovinenb

googletest/src/matchers/eq_matcher.rs

@@ -119,6 +119,15 @@ impl<A: Debug + ?Sized, T: PartialEq<A> + Debug> Matcher for EqMatcher<A, T> {
     }
 }
 
+/// Returns a string describing how the expected and actual lines differ.
+///
+/// This is included in a match explanation for [`EqMatcher`] and
+/// [`crate::matchers::str_matcher::StrMatcher`].
+///
+/// If the actual value has at most two lines, or the two differ by more than
+/// the maximum edit distance, then this returns the empty string. If the two
+/// are equal, it returns a simple statement that they are equal. Otherwise,
+/// this constructs a unified diff view of the actual and expected values.
 pub(super) fn create_diff(
     expected_debug: &str,
     actual_debug: &str,
@@ -138,6 +147,37 @@ pub(super) fn create_diff(
     }
 }
 
+/// Returns a string describing how the expected and actual differ after
+/// reversing the lines in each.
+///
+/// This is similar to [`create_diff`] except that it first reverses the lines
+/// in both the expected and actual values, then reverses the constructed edit
+/// list. When `diff_mode` is [`edit_distance::Mode::Prefix`], this becomes a
+/// diff of the suffix for use by [`ends_with`][crate::matchers::ends_with].
+pub(super) fn create_diff_reversed(
+    expected_debug: &str,
+    actual_debug: &str,
+    diff_mode: edit_distance::Mode,
+) -> Cow<'static, str> {
+    if actual_debug.lines().count() < 2 {
+        // If the actual debug is only one line, then there is no point in doing a
+        // line-by-line diff.
+        return "".into();
+    }
+    let mut actual_lines_reversed = actual_debug.lines().collect::<Vec<_>>();
+    let mut expected_lines_reversed = expected_debug.lines().collect::<Vec<_>>();
+    actual_lines_reversed.reverse();
+    expected_lines_reversed.reverse();
+    match edit_distance::edit_list(actual_lines_reversed, expected_lines_reversed, diff_mode) {
+        edit_distance::Difference::Equal => "No difference found between debug strings.".into(),
+        edit_distance::Difference::Editable(mut edit_list) => {
+            edit_list.reverse();
+            format!("\nDifference:{}", edit_list_summary(&edit_list)).into()
+        }
+        edit_distance::Difference::Unrelated => "".into(),
+    }
+}
+
 fn edit_list_summary(edit_list: &[edit_distance::Edit<&str>]) -> String {
     let mut summary = String::new();
     // Use to collect common line and compress them.

googletest/src/matchers/str_matcher.rs

@@ -17,7 +17,7 @@ use crate::{
     matcher_support::edit_distance,
     matchers::{
         eq_deref_of_matcher::EqDerefOfMatcher,
-        eq_matcher::{create_diff, EqMatcher},
+        eq_matcher::{create_diff, create_diff_reversed, EqMatcher},
     },
 };
 use std::borrow::Cow;
@@ -402,7 +402,7 @@ impl MatchMode {
         // TODO(b/286515736): Once supported, only MatchMode::Equals should map to
         // Mode::Exact.
         match self {
-            MatchMode::StartsWith => edit_distance::Mode::Prefix,
+            MatchMode::StartsWith | MatchMode::EndsWith => edit_distance::Mode::Prefix,
             _ => edit_distance::Mode::Exact,
         }
     }
@@ -540,10 +540,14 @@ impl Configuration {
             return default_explanation;
         }
 
-        format!(
-            "{default_explanation}\n{}",
-            create_diff(expected, actual, self.mode.to_diff_mode())
-        )
+        let diff = match self.mode {
+            MatchMode::Equals | MatchMode::StartsWith | MatchMode::Contains => {
+                create_diff(expected, actual, self.mode.to_diff_mode())
+            }
+            MatchMode::EndsWith => create_diff_reversed(expected, actual, self.mode.to_diff_mode()),
+        };
+
+        format!("{default_explanation}\n{diff}",)
     }
 
     fn ignoring_leading_whitespace(self) -> Self {
@@ -1033,6 +1037,7 @@ mod tests {
             result,
             err(displays_as(contains_substring(indoc!(
                 "
+                    Difference:
                      First line
                     +Second line
                     -Second lines
@@ -1042,6 +1047,41 @@ mod tests {
         )
     }
 
+    #[test]
+    fn match_explanation_for_ends_with_ignores_leading_lines_in_actual_string() -> Result<()> {
+        let result = verify_that!(
+            indoc!(
+                "
+                    First line
+                    Second line
+                    Third line
+                    Fourth line
+                "
+            ),
+            ends_with(indoc!(
+                "
+                    Second line
+                    Third lines
+                    Fourth line
+                "
+            ))
+        );
+
+        verify_that!(
+            result,
+            err(displays_as(contains_substring(indoc!(
+                "
+                    Difference:
+                    <---- remaining lines omitted ---->
+                     Second line
+                    -Third lines
+                    +Third line
+                     Fourth line
+                "
+            ))))
+        )
+    }
+
     #[test]
     fn match_explanation_for_eq_does_not_ignore_trailing_lines_in_actual_string() -> Result<()> {
         let result = verify_that!(