Merge pull request #237 from google:omitted_elements_are

PiperOrigin-RevId: 542872969

Author: copybara-github

googletest/src/assertions.rs

@@ -52,8 +52,30 @@
 /// # verify_that!(should_fail(), err(displays_as(contains_substring("Expected: is equal to 123"))))
 /// #     .unwrap();
 /// ```
+///
+/// This macro has special support for matching against container. Namely:
+///   * `verify_that!(actual, [m1, m2, ...])` is equivalent to
+///     `verify_that!(actual, elements_are![m1, m2, ...])`
+///   * `verify_that!(actual, {m1, m2, ...})` is equivalent to
+///     `verify_that!(actual, unordered_elements_are![m1, m2, ...])`
 #[macro_export]
 macro_rules! verify_that {
+    ($actual:expr, [$($expecteds:expr),+]) => {
+        $crate::assertions::internal::check_matcher(
+            &$actual,
+            $crate::elements_are![$($expecteds),+],
+            stringify!($actual),
+            $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
+        )
+    };
+    ($actual:expr, {$($expecteds:expr),+}) => {
+        $crate::assertions::internal::check_matcher(
+            &$actual,
+            $crate::unordered_elements_are![$($expecteds),+],
+            stringify!($actual),
+            $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
+        )
+    };
     ($actual:expr, $expected:expr) => {
         $crate::assertions::internal::check_matcher(
             &$actual,

googletest/src/matchers/elements_are_matcher.rs

@@ -39,6 +39,32 @@
 /// #    .unwrap();
 /// ```
 ///
+/// This can also be omitted in [`verify_that!`] macros and replaced with square
+/// brackets.
+///
+/// ```
+/// # use googletest::prelude::*;
+///  verify_that!(vec![1, 2], [eq(1), eq(2)])
+/// #     .unwrap();
+/// ```
+///
+/// Note: This behavior is only possible in [`verify_that!`] macros. In any
+/// other cases, it is still necessary to use the
+/// [`elements_are!`][crate::elements_are] macro.
+///
+/// ```compile_fail
+/// # use googletest::prelude::*;
+/// verify_that!(vec![vec![1,2], vec![3]], [[eq(1), eq(2)], [eq(3)]])
+/// # .unwrap();
+/// ```
+///
+/// Use this instead:
+/// ```
+/// # use googletest::prelude::*;
+/// verify_that!(vec![vec![1,2], vec![3]], [elements_are![eq(1), eq(2)], elements_are![eq(3)]])
+/// # .unwrap();
+/// ```
+///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
 ///

googletest/src/matchers/unordered_elements_are_matcher.rs

@@ -61,6 +61,33 @@
 /// #     .unwrap();
 /// ```
 ///
+/// This can also be omitted in [`verify_that!`] macros and replaced with curly
+/// brackets.
+///
+/// ```
+/// # use googletest::prelude::*;
+///  verify_that!(vec![1, 2], {eq(2), eq(1)})
+/// #     .unwrap();
+/// ```
+///
+/// Note: This behavior is only possible in [`verify_that!`] macros. In any
+/// other cases, it is still necessary to use the
+/// [`unordered_elements_are!`][crate::unordered_elements_are] macro.
+///
+/// ```compile_fail
+/// # use googletest::prelude::*;
+/// verify_that!(vec![vec![1,2], vec![3]], {{eq(2), eq(1)}, {eq(3)}})
+/// # .unwrap();
+/// ```
+///
+/// Use this instead:
+/// ```
+/// # use googletest::prelude::*;
+/// verify_that!(vec![vec![1,2], vec![3]],
+///   {unordered_elements_are![eq(2), eq(1)], unordered_elements_are![eq(3)]})
+/// # .unwrap();
+/// ```
+///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
 ///

googletest/tests/elements_are_matcher_test.rs

@@ -118,3 +118,8 @@ fn create_matcher() -> impl Matcher<ActualT = Vec<i32>> {
 fn elements_are_works_when_matcher_is_created_in_subroutine() -> Result<()> {
     verify_that!(vec![1], create_matcher())
 }
+
+#[test]
+fn elements_are_implicitly_called() -> Result<()> {
+    verify_that!(vec![1, 2, 3], [eq(1), eq(2), eq(3)])
+}

googletest/tests/unordered_elements_are_matcher_test.rs

@@ -35,6 +35,12 @@ fn unordered_elements_are_matches_vector() -> Result<()> {
     verify_that!(value, unordered_elements_are![eq(1), eq(2), eq(3)])
 }
 
+#[test]
+fn unordered_elements_are_omitted() -> Result<()> {
+    let value = vec![1, 2, 3];
+    verify_that!(value, {eq(3), eq(2), eq(1)})
+}
+
 #[test]
 fn unordered_elements_are_matches_slice() -> Result<()> {
     let value = vec![1, 2, 3];

integration_tests/src/integration_tests.rs

@@ -26,6 +26,16 @@ mod tests {
         verify_that!(value, eq(2))
     }
 
+    #[test]
+    fn should_pass_with_omitted_elements_are() -> Result<()> {
+        verify_that!(vec![1, 2], [eq(1), eq(2)])
+    }
+
+    #[test]
+    fn should_pass_with_omitted_unordered_elements_are() -> Result<()> {
+        verify_that!(vec![1, 2], {eq(2), eq(1)})
+    }
+
     #[googletest::google_test]
     fn should_pass_with_google_test() -> Result<()> {
         let value = 2;