Use the displays_as matcher when asserting on the output of Matcher::describe in tests.

Many existing tests assert directly on the output of `Matcher::describe`, which is currently a `String`. This return type will change to a `Description` in the future. In order that the tests do not have to be modified when that is changed, this changes them to wrap the existing matcher in `displays_as`. That has no effect on the current assertion, but will cause the `Display::fmt` method to be invoked on the output in the future.

Author: hovinen

googletest/src/matchers/all_matcher.rs

@@ -163,12 +163,12 @@ mod tests {
 
         verify_that!(
             matcher.describe(MatcherResult::Match),
-            eq(indoc!(
+            displays_as(eq(indoc!(
                 "
                 has all the following properties:
                   * starts with prefix \"A\"
                   * ends with suffix \"string\""
-            ))
+            )))
         )
     }
 
@@ -177,7 +177,10 @@ mod tests {
         let first_matcher = starts_with("A");
         let matcher: internal::AllMatcher<String, 1> = all!(first_matcher);
 
-        verify_that!(matcher.describe(MatcherResult::Match), eq("starts with prefix \"A\""))
+        verify_that!(
+            matcher.describe(MatcherResult::Match),
+            displays_as(eq("starts with prefix \"A\""))
+        )
     }
 
     #[test]

googletest/src/matchers/any_matcher.rs

@@ -157,12 +157,12 @@ mod tests {
 
         verify_that!(
             matcher.describe(MatcherResult::Match),
-            eq(indoc!(
+            displays_as(eq(indoc!(
                 "
                 has at least one of the following properties:
                   * starts with prefix \"A\"
                   * ends with suffix \"string\""
-            ))
+            )))
         )
     }
 
@@ -171,7 +171,10 @@ mod tests {
         let first_matcher = starts_with("A");
         let matcher: internal::AnyMatcher<String, 1> = any!(first_matcher);
 
-        verify_that!(matcher.describe(MatcherResult::Match), eq("starts with prefix \"A\""))
+        verify_that!(
+            matcher.describe(MatcherResult::Match),
+            displays_as(eq("starts with prefix \"A\""))
+        )
     }
 
     #[test]

googletest/src/matchers/contains_matcher.rs

@@ -233,7 +233,7 @@ mod tests {
 
         verify_that!(
             Matcher::describe(&matcher, MatcherResult::Match),
-            eq("contains at least one element which is equal to 1")
+            displays_as(eq("contains at least one element which is equal to 1"))
         )
     }
 
@@ -243,7 +243,7 @@ mod tests {
 
         verify_that!(
             Matcher::describe(&matcher, MatcherResult::Match),
-            eq("contains n elements which is equal to 1\n  where n is equal to 2")
+            displays_as(eq("contains n elements which is equal to 1\n  where n is equal to 2"))
         )
     }
 

googletest/src/matchers/contains_regex_matcher.rs

@@ -142,7 +142,7 @@ mod tests {
 
         verify_that!(
             Matcher::describe(&matcher, MatcherResult::Match),
-            eq("contains the regular expression \"\\n\"")
+            displays_as(eq("contains the regular expression \"\\n\""))
         )
     }
 }

googletest/src/matchers/err_matcher.rs

@@ -139,6 +139,9 @@ mod tests {
             phantom_t: Default::default(),
             phantom_e: Default::default(),
         };
-        verify_that!(matcher.describe(MatcherResult::Match), eq("is an error which is equal to 1"))
+        verify_that!(
+            matcher.describe(MatcherResult::Match),
+            displays_as(eq("is an error which is equal to 1"))
+        )
     }
 }

googletest/src/matchers/gt_matcher.rs

@@ -175,14 +175,17 @@ mod tests {
 
     #[test]
     fn gt_describe_matches() -> Result<()> {
-        verify_that!(gt::<i32, i32>(232).describe(MatcherResult::Match), eq("is greater than 232"))
+        verify_that!(
+            gt::<i32, i32>(232).describe(MatcherResult::Match),
+            displays_as(eq("is greater than 232"))
+        )
     }
 
     #[test]
     fn gt_describe_does_not_match() -> Result<()> {
         verify_that!(
             gt::<i32, i32>(232).describe(MatcherResult::NoMatch),
-            eq("is less than or equal to 232")
+            displays_as(eq("is less than or equal to 232"))
         )
     }
 

googletest/src/matchers/is_encoded_string_matcher.rs

@@ -129,7 +129,7 @@ mod tests {
 
         verify_that!(
             matcher.describe(MatcherResult::Match),
-            eq("is a UTF-8 encoded string which is equal to \"A string\"")
+            displays_as(eq("is a UTF-8 encoded string which is equal to \"A string\""))
         )
     }
 
@@ -139,7 +139,7 @@ mod tests {
 
         verify_that!(
             matcher.describe(MatcherResult::NoMatch),
-            eq("is not a UTF-8 encoded string which is equal to \"A string\"")
+            displays_as(eq("is not a UTF-8 encoded string which is equal to \"A string\""))
         )
     }
 
@@ -149,15 +149,15 @@ mod tests {
 
         verify_that!(
             explanation,
-            eq("which is a UTF-8 encoded string which is equal to \"A string\"")
+            displays_as(eq("which is a UTF-8 encoded string which is equal to \"A string\""))
         )
     }
 
     #[test]
     fn has_correct_explanation_when_byte_array_is_not_utf8_encoded() -> Result<()> {
         let explanation = is_utf8_string(eq("A string")).explain_match(&&[192, 128, 0, 64]);
 
-        verify_that!(explanation, starts_with("which is not a UTF-8 encoded string: "))
+        verify_that!(explanation, displays_as(starts_with("which is not a UTF-8 encoded string: ")))
     }
 
     #[test]
@@ -167,7 +167,7 @@ mod tests {
 
         verify_that!(
             explanation,
-            eq("which is a UTF-8 encoded string which isn't equal to \"A string\"")
+            displays_as(eq("which is a UTF-8 encoded string which isn't equal to \"A string\""))
         )
     }
 }

googletest/src/matchers/matches_regex_matcher.rs

@@ -204,7 +204,7 @@ mod tests {
 
         verify_that!(
             Matcher::describe(&matcher, MatcherResult::Match),
-            eq("matches the regular expression \"\\n\"")
+            displays_as(eq("matches the regular expression \"\\n\""))
         )
     }
 }

googletest/src/matchers/ok_matcher.rs

@@ -144,7 +144,7 @@ mod tests {
         };
         verify_that!(
             matcher.describe(MatcherResult::Match),
-            eq("is a success containing a value, which is equal to 1")
+            displays_as(eq("is a success containing a value, which is equal to 1"))
         )
     }
 }

googletest/src/matchers/some_matcher.rs

@@ -127,15 +127,15 @@ mod tests {
     fn some_describe_matches() -> Result<()> {
         verify_that!(
             some(eq(1)).describe(MatcherResult::Match),
-            eq("has a value which is equal to 1")
+            displays_as(eq("has a value which is equal to 1"))
         )
     }
 
     #[test]
     fn some_describe_does_not_match() -> Result<()> {
         verify_that!(
             some(eq(1)).describe(MatcherResult::NoMatch),
-            eq("is None or has a value which isn't equal to 1")
+            displays_as(eq("is None or has a value which isn't equal to 1"))
         )
     }