Restructure eq_matcher::create_diff so that it only returns the report on the difference between the strings and not the entire match explanation.

Previously, the method `EqMatcher::explain_match` would defer entirely to `eq_matcher::create_diff`. This made `eq_matcher::create_diff` unusable for `StrMatcher`, where it is intended also to be used. This restructures the function to be reusable by focusing on just the difference between the two input strings.

This also replaces the text "Debug diff" in the match explanation output with "Difference", which should be clearer.

This also adds a parameter to allow the caller to specify the edit distance mode, which will be needed by `StrMatcher`.

PiperOrigin-RevId: 533479136

Author: hovinenb

googletest/src/matcher_support/edit_distance.rs

@@ -105,15 +105,17 @@ pub(crate) fn edit_list<T: Distance + Copy>(
 }
 
 /// Controls how `right` should match `left`.
-#[allow(dead_code)]
 pub(crate) enum Mode {
     /// `right` is fully matching `left`
     FullMatch,
     /// `right` should match the beginning of `left`
+    #[allow(unused)]
     StartsWith,
     /// `right` should match the end of `left`
+    #[allow(unused)]
     EndsWith,
     /// `right` should be contained in `left`
+    #[allow(unused)]
     Contains,
 }
 

googletest/src/matchers/eq_deref_of_matcher.rs

@@ -12,8 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::matcher::{Matcher, MatcherResult};
-use crate::matchers::eq_matcher::create_diff;
+use crate::{
+    matcher::{Matcher, MatcherResult},
+    matcher_support::edit_distance,
+    matchers::eq_matcher::create_diff,
+};
 use std::{fmt::Debug, marker::PhantomData, ops::Deref};
 
 /// Matches a value equal (in the sense of `==`) to the dereferenced value of
@@ -82,10 +85,14 @@ where
     }
 
     fn explain_match(&self, actual: &ActualT) -> String {
-        create_diff(
-            &format!("{:#?}", self.expected.deref()),
-            &format!("{:#?}", actual),
+        format!(
+            "which {}{}",
             &self.describe(self.matches(actual)),
+            create_diff(
+                &format!("{:#?}", self.expected.deref()),
+                &format!("{:#?}", actual),
+                edit_distance::Mode::FullMatch,
+            )
         )
     }
 }
@@ -132,7 +139,7 @@ mod tests {
             r#"
             Actual: Strukt { int: 123, string: "something" },
               which isn't equal to Strukt { int: 321, string: "someone" }
-            Debug diff:
+            Difference:
              Strukt {
             +    int: 123,
             -    int: 321,

googletest/src/matchers/eq_matcher.rs

@@ -14,7 +14,7 @@
 
 use crate::matcher::{Matcher, MatcherResult};
 use crate::matcher_support::edit_distance;
-use std::{fmt::Debug, marker::PhantomData};
+use std::{borrow::Cow, fmt::Debug, marker::PhantomData};
 
 /// Matches a value equal (in the sense of `==`) to `expected`.
 ///
@@ -95,31 +95,35 @@ impl<A: Debug + ?Sized, T: PartialEq<A> + Debug> Matcher for EqMatcher<A, T> {
     }
 
     fn explain_match(&self, actual: &A) -> String {
-        create_diff(
-            &format!("{:#?}", self.expected),
-            &format!("{:#?}", actual),
+        format!(
+            "which {}{}",
             &self.describe(self.matches(actual)),
+            create_diff(
+                &format!("{:#?}", self.expected),
+                &format!("{:#?}", actual),
+                edit_distance::Mode::FullMatch,
+            )
         )
     }
 }
 
-pub(super) fn create_diff(expected_debug: &str, actual_debug: &str, description: &str) -> String {
+pub(super) fn create_diff(
+    expected_debug: &str,
+    actual_debug: &str,
+    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 format!("which {description}",);
+        return "".into();
     }
-    let edit_list = edit_distance::edit_list(
-        actual_debug.lines(),
-        expected_debug.lines(),
-        edit_distance::Mode::FullMatch,
-    );
+    let edit_list = edit_distance::edit_list(actual_debug.lines(), expected_debug.lines(), mode);
 
     if edit_list.is_empty() {
-        return format!("which {description}\nNo difference found between debug strings.",);
+        return "No difference found between debug strings.".into();
     }
 
-    format!("which {description}\nDebug diff:{}", edit_list_summary(&edit_list))
+    format!("\nDifference:{}", edit_list_summary(&edit_list)).into()
 }
 
 fn edit_list_summary(edit_list: &[edit_distance::Edit<&str>]) -> String {
@@ -197,7 +201,7 @@ mod tests {
             r#"
             Actual: Strukt { int: 123, string: "something" },
               which isn't equal to Strukt { int: 321, string: "someone" }
-            Debug diff:
+            Difference:
              Strukt {
             +    int: 123,
             -    int: 321,
@@ -219,7 +223,7 @@ mod tests {
             Expected: is equal to [1, 3, 4]
             Actual: [1, 2, 3],
               which isn't equal to [1, 3, 4]
-            Debug diff:
+            Difference:
              [
                  1,
             +    2,
@@ -241,7 +245,7 @@ mod tests {
             Expected: is equal to [1, 3, 5]
             Actual: [1, 2, 3, 4, 5],
               which isn't equal to [1, 3, 5]
-            Debug diff:
+            Difference:
              [
                  1,
             +    2,