Apply auto_eq to all matcher.

Author: bjacotg

googletest/src/matchers/all_matcher.rs

@@ -50,21 +50,33 @@
 /// ```
 ///
 /// Assertion failure messages are not guaranteed to be identical, however.
+///
+///  If an inner matcher is `eq(...)`, it can be omitted:
+///
+/// ```
+/// # use googletest::prelude::*;
+///
+/// verify_that!(123, all![123, lt(1000), gt(100)])
+/// #     .unwrap();
+/// ```
 #[macro_export]
 #[doc(hidden)]
 macro_rules! __all {
     ($(,)?) => {{
         $crate::matchers::anything()
     }} ;
     ($matcher:expr $(,)?) => {{
-        $matcher
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        auto_eq!($matcher)
     }};
     ($head:expr, $head2:expr $(,)?) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::ConjunctionMatcher::new($head, $head2)
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        $crate::matchers::__internal_unstable_do_not_depend_on_these::ConjunctionMatcher::new(auto_eq!($head), auto_eq!($head2))
     }};
     ($head:expr, $head2:expr, $($tail:expr),+ $(,)?) => {{
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
         $crate::__all![
-            $crate::matchers::__internal_unstable_do_not_depend_on_these::ConjunctionMatcher::new($head, $head2),
+            $crate::matchers::__internal_unstable_do_not_depend_on_these::ConjunctionMatcher::new(auto_eq!($head), auto_eq!($head2)),
             $($tail),+
         ]
     }}
@@ -127,4 +139,9 @@ mod tests {
             displays_as(eq("which does not start with \"Another\""))
         )
     }
+
+    #[test]
+    fn all_with_auto_eq() -> Result<()> {
+        verify_that!(42, all![eq(42), 42, lt(100)])
+    }
 }

googletest/src/matchers/any_matcher.rs

@@ -52,21 +52,33 @@
 /// ```
 ///
 /// Assertion failure messages are not guaranteed to be identical, however.
+///
+///  If an inner matcher is `eq(...)`, it can be omitted:
+///
+/// ```
+/// # use googletest::prelude::*;
+///
+/// verify_that!(123, any![lt(1), 123, gt(1000)])
+/// #     .unwrap();
+/// ```
 #[macro_export]
 #[doc(hidden)]
 macro_rules! __any {
     ($(,)?) => {{
         $crate::matchers::not($crate::matchers::anything())
     }} ;
     ($matcher:expr $(,)?) => {{
-        $matcher
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        auto_eq!($matcher)
     }};
     ($head:expr, $head2:expr $(,)?) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::DisjunctionMatcher::new($head, $head2)
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        $crate::matchers::__internal_unstable_do_not_depend_on_these::DisjunctionMatcher::new(auto_eq!($head), auto_eq!($head2))
     }};
     ($head:expr, $head2:expr, $($tail:expr),+ $(,)?) => {{
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
         $crate::__any![
-            $crate::matchers::__internal_unstable_do_not_depend_on_these::DisjunctionMatcher::new($head, $head2),
+            $crate::matchers::__internal_unstable_do_not_depend_on_these::DisjunctionMatcher::new(auto_eq!($head), auto_eq!($head2)),
             $($tail),+
         ]
     }}
@@ -134,4 +146,9 @@ mod tests {
     fn empty_any_matcher_never_matches() -> Result<()> {
         verify_that!(123, not(any![]))
     }
+
+    #[test]
+    fn any_with_auto_eq() -> Result<()> {
+        verify_that!(42, any![1, 2, 42, gt(123)])
+    }
 }

googletest/src/matchers/elements_are_matcher.rs

@@ -65,6 +65,15 @@
 /// # .unwrap();
 /// ```
 ///
+///  If an inner matcher is `eq(...)`, it can be omitted:
+///
+/// ```
+/// # use googletest::prelude::*;
+///
+/// verify_that!(vec![1,2,3], elements_are![&1, lt(&1000), gt(&1)])
+/// #     .unwrap();
+/// ```
+///
 /// Do not use this with unordered containers, since that will lead to flaky
 /// tests. Use
 /// [`unordered_elements_are!`][crate::matchers::unordered_elements_are]
@@ -79,7 +88,8 @@
 macro_rules! __elements_are {
     ($($matcher:expr),* $(,)?) => {{
         use $crate::matchers::__internal_unstable_do_not_depend_on_these::ElementsAre;
-        ElementsAre::new(vec![$(Box::new($matcher)),*])
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        ElementsAre::new(vec![$(Box::new(auto_eq!($matcher))),*])
     }}
 }
 

googletest/src/matchers/unordered_elements_are_matcher.rs

@@ -73,6 +73,15 @@
 /// # .unwrap();
 /// ```
 ///
+///  If an inner matcher is `eq(...)`, it can be omitted:
+///
+/// ```
+/// # use googletest::prelude::*;
+///
+/// verify_that!(vec![1,2,3], unordered_elements_are![lt(&2), gt(&1), &3])
+/// #     .unwrap();
+/// ```
+///
 /// The matcher proceeds in three stages:
 ///
 /// 1. It first checks whether the actual value is of the right size to possibly
@@ -109,7 +118,8 @@ macro_rules! __unordered_elements_are {
         use $crate::matchers::__internal_unstable_do_not_depend_on_these::{
             UnorderedElementsAreMatcher, Requirements
         };
-        UnorderedElementsAreMatcher::new([$(Box::new($matcher)),*], Requirements::PerfectMatch)
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        UnorderedElementsAreMatcher::new([$(Box::new(auto_eq!($matcher))),*], Requirements::PerfectMatch)
     }};
 }
 
@@ -153,6 +163,15 @@ macro_rules! __unordered_elements_are {
 /// The actual value must be a container such as a `&Vec`, an array, or a
 /// slice. More precisely, the actual value must implement [`IntoIterator`].
 ///
+///  If an inner matcher is `eq(...)`, it can be omitted:
+///
+/// ```
+/// # use googletest::prelude::*;
+///
+/// verify_that!(vec![1,2,3], contains_each![lt(&2), &3])
+/// #     .unwrap();
+/// ```
+///
 /// The matcher proceeds in three stages:
 ///
 /// 1. It first checks whether the actual value is large enough to possibly be
@@ -183,10 +202,11 @@ macro_rules! __contains_each {
     }};
 
     ($($matcher:expr),* $(,)?) => {{
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
         use $crate::matchers::__internal_unstable_do_not_depend_on_these::{
             UnorderedElementsAreMatcher, Requirements
         };
-        UnorderedElementsAreMatcher::new([$(Box::new($matcher)),*], Requirements::Superset)
+        UnorderedElementsAreMatcher::new([$(Box::new(auto_eq!($matcher))),*], Requirements::Superset)
     }}
 }
 
@@ -231,6 +251,15 @@ macro_rules! __contains_each {
 /// The actual value must be a container such as a `&Vec`, an array, or a slice.
 /// More precisely, the actual value must implement [`IntoIterator`].
 ///
+///  If an inner matcher is `eq(...)`, it can be omitted:
+///
+/// ```
+/// # use googletest::prelude::*;
+///
+/// verify_that!(vec![1,2,3], is_contained_in![lt(&2), &3, &4, gt(&0)])
+/// #     .unwrap();
+/// ```
+///
 /// The matcher proceeds in three stages:
 ///
 /// 1. It first checks whether the actual value is too large to possibly be
@@ -264,7 +293,8 @@ macro_rules! __is_contained_in {
         use $crate::matchers::__internal_unstable_do_not_depend_on_these::{
             UnorderedElementsAreMatcher, Requirements
         };
-        UnorderedElementsAreMatcher::new([$(Box::new($matcher)),*], Requirements::Subset)
+        use $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq;
+        UnorderedElementsAreMatcher::new([$(Box::new(auto_eq!($matcher))),*], Requirements::Subset)
     }}
 }
 

googletest/tests/elements_are_matcher_test.rs

@@ -139,3 +139,8 @@ fn elements_are_works_when_matcher_is_created_in_subroutine() -> Result<()> {
 fn elements_are_implicitly_called() -> Result<()> {
     verify_that!(vec![1, 2, 3], [eq(&1), eq(&2), eq(&3)])
 }
+
+#[test]
+fn elements_are_with_auto_eq() -> Result<()> {
+    verify_that!(vec![1, 2, 3], [&1, &2, lt(&43)])
+}

googletest/tests/unordered_elements_are_matcher_test.rs

@@ -448,3 +448,18 @@ fn is_contained_in_explains_mismatch_due_to_no_graph_matching_found() -> Result<
               Expected element `is greater than or equal to 3` at index 1 did not match any remaining actual element."))
     ))
 }
+
+#[test]
+fn unordered_elements_are_with_auto_eq() -> Result<()> {
+    verify_that!(vec![3, 4, 2], unordered_elements_are![&2, &3, &4])
+}
+
+#[test]
+fn contains_each_with_auto_eq() -> Result<()> {
+    verify_that!(vec![3, 4, 2], contains_each![&2, &4])
+}
+
+#[test]
+fn is_contained_in_with_auto_eq() -> Result<()> {
+    verify_that!(vec![3, 4, 2], is_contained_in![&1, &2, &3, &4])
+}