Improve support for displaying the diff between actual and expected values in the contains_substring matcher.

In contrast with `starts_with` and `ends_with`, there is no anchor to identify where to start matching the substring with the actual value. Any method to find such an anchor in general would require using a maximum edit distance equal to the sum of the lengths of the inputs. The resulting algorithm would have quadratic running time in the input length, which is too expensive.

For this reason, this implementation makes a "best effort" attempt using the existing maximum edit length and exact matching. The `edit_list` implementation has a new mode `Contains` which compresses the prefix and suffix in the actual value to `Edit::AdditionalLeft`. If the total number of lines in the actual value not in the substring already exceed the maximum edit distance, then the diff output will not be shown.

The practical effect of this change is that the lines of the actual value preceding and succeeding the substring are now compressed to the string `<---- remaining lines omitted ---->`.

PiperOrigin-RevId: 540904195

Author: hovinenb

googletest/src/matcher_support/edit_distance.rs

@@ -61,6 +61,7 @@ pub(crate) enum Edit<T> {
 }
 
 /// Controls the termination condition of [`edit_list`].
+#[derive(Clone, Copy)]
 pub(crate) enum Mode {
     /// Indicates that the two arguments are intended to be equal.
     ///
@@ -73,6 +74,15 @@ pub(crate) enum Mode {
     /// Any additional parts of `left` after the prefix `right` are omitted from
     /// the output.
     Prefix,
+
+    /// Similar to [`Mode::Prefix`], except it is also assumed that `left` has
+    /// some number of initial lines which should not be in the output.
+    ///
+    /// Any initial [`Edit::ExtraLeft`] entries are replaced with
+    /// [`Edit::AdditionalLeft`] in the edit list. If the first entry which is
+    /// not an [`Edit::Extraleft`] is [`Edit::ExtraRight`], then the last
+    /// [`Edit::ExtraLeft`] is left in the output.
+    Contains,
 }
 
 /// Computes the edit list of `left` and `right`.
@@ -163,6 +173,9 @@ pub(crate) fn edit_list<T: PartialEq + Copy>(
             // If we have exhausted both inputs, we are done.
             if left_endpoint == left.len() && right_endpoint == right.len() {
                 return if path.edits.iter().any(|v| !matches!(v, Edit::Both(_))) {
+                    if matches!(mode, Mode::Contains) {
+                        compress_prefix_and_suffix(&mut path.edits);
+                    }
                     Difference::Editable(path.edits)
                 } else {
                     Difference::Equal
@@ -213,6 +226,30 @@ fn index_of_k(k: i32, k_min: i32) -> usize {
     ((k - k_min) / 2) as usize
 }
 
+fn compress_prefix_and_suffix<T>(edits: &mut Vec<Edit<T>>) {
+    if let Some(mut first_non_extra_left_edit) =
+        edits.iter().position(|e| !matches!(e, Edit::ExtraLeft(_)))
+    {
+        if first_non_extra_left_edit > 1
+            && matches!(edits[first_non_extra_left_edit], Edit::ExtraRight(_))
+        {
+            first_non_extra_left_edit -= 1;
+        }
+        edits.splice(..first_non_extra_left_edit, [Edit::AdditionalLeft]);
+    }
+
+    if let Some(mut last_non_extra_left_edit) =
+        edits.iter().rposition(|e| !matches!(e, Edit::ExtraLeft(_)))
+    {
+        if last_non_extra_left_edit < edits.len() - 1
+            && matches!(edits[last_non_extra_left_edit], Edit::ExtraRight(_))
+        {
+            last_non_extra_left_edit += 1;
+        }
+        edits.splice(last_non_extra_left_edit + 1.., [Edit::AdditionalLeft]);
+    }
+}
+
 #[derive(Clone)]
 struct Path<T: Clone> {
     left_endpoint: usize,

googletest/src/matchers/str_matcher.rs

@@ -399,11 +399,10 @@ enum MatchMode {
 
 impl MatchMode {
     fn to_diff_mode(&self) -> edit_distance::Mode {
-        // TODO(b/286515736): Once supported, only MatchMode::Equals should map to
-        // Mode::Exact.
         match self {
             MatchMode::StartsWith | MatchMode::EndsWith => edit_distance::Mode::Prefix,
-            _ => edit_distance::Mode::Exact,
+            MatchMode::Contains => edit_distance::Mode::Contains,
+            MatchMode::Equals => edit_distance::Mode::Exact,
         }
     }
 }
@@ -542,6 +541,9 @@ impl Configuration {
 
         let diff = match self.mode {
             MatchMode::Equals | MatchMode::StartsWith | MatchMode::Contains => {
+                // TODO(b/287632452): Also consider improving the output in MatchMode::Contains
+                // when the substring begins or ends in the middle of a line of the actual
+                // value.
                 create_diff(expected, actual, self.mode.to_diff_mode())
             }
             MatchMode::EndsWith => create_diff_reversed(expected, actual, self.mode.to_diff_mode()),
@@ -1082,6 +1084,85 @@ mod tests {
         )
     }
 
+    #[test]
+    fn match_explanation_for_contains_substring_ignores_outer_lines_in_actual_string() -> Result<()>
+    {
+        let result = verify_that!(
+            indoc!(
+                "
+                    First line
+                    Second line
+                    Third line
+                    Fourth line
+                    Fifth line
+                "
+            ),
+            contains_substring(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
+                    <---- remaining lines omitted ---->
+                "
+            ))))
+        )
+    }
+
+    #[test]
+    fn match_explanation_for_contains_substring_shows_diff_when_first_and_last_line_are_incomplete()
+    -> Result<()> {
+        let result = verify_that!(
+            indoc!(
+                "
+                    First line
+                    Second line
+                    Third line
+                    Fourth line
+                    Fifth line
+                "
+            ),
+            contains_substring(indoc!(
+                "
+                    line
+                    Third line
+                    Foorth line
+                    Fifth"
+            ))
+        );
+
+        verify_that!(
+            result,
+            err(displays_as(contains_substring(indoc!(
+                "
+                    Difference:
+                    <---- remaining lines omitted ---->
+                    -line
+                    +Second line
+                     Third line
+                    -Foorth line
+                    +Fourth line
+                    -Fifth
+                    +Fifth line
+                    <---- remaining lines omitted ---->
+                "
+            ))))
+        )
+    }
+
     #[test]
     fn match_explanation_for_eq_does_not_ignore_trailing_lines_in_actual_string() -> Result<()> {
         let result = verify_that!(