Add support for sequences (ordered and unordered) for assert_that.

This adds the other patterns necessary for `assert_that!` to work with ordered and unordered sequences.

PiperOrigin-RevId: 695781813

Author: Googler

googletest/src/assertions.rs

@@ -1308,6 +1308,59 @@ macro_rules! expect_near {
 /// equivalent to `ASSERT_THAT`, use [`verify_that!`] with the `?` operator.
 #[macro_export]
 macro_rules! assert_that {
+    // specialized to sequence:
+    ($actual:expr, [ $($expected:expr),* ] $(,)?) => {
+        match $crate::verify_that!($actual, [ $($expected),* ]) {
+            Ok(_) => {}
+            Err(e) => {
+                // The extra newline before the assertion failure message makes the failure a
+                // bit easier to read when there's some generic boilerplate from the panic.
+                panic!("\n{}", e);
+            }
+        }
+    };
+
+    // specialized to unordered sequence
+    ($actual:expr, { $($expected:expr),* } $(,)?) => {
+        match $crate::verify_that!($actual, { $($expected),* }) {
+            Ok(_) => {}
+            Err(e) => {
+                // The extra newline before the assertion failure message makes the failure a
+                // bit easier to read when there's some generic boilerplate from the panic.
+                panic!("\n{}", e);
+            }
+        }
+    };
+
+    // w/ format args, specialized to sequence:
+    ($actual:expr, [ $($expected:expr),* ], $($format_args:expr),* $(,)?) => {
+        match $crate::verify_that!($actual, [ $($expected),* ])
+            .with_failure_message(|| format!($($format_args),*))
+        {
+            Ok(_) => {}
+            Err(e) => {
+                // The extra newline before the assertion failure message makes the failure a
+                // bit easier to read when there's some generic boilerplate from the panic.
+                panic!("\n{}", e);
+            }
+        }
+    };
+
+    // w/ format args, specialized to unordered sequence:
+    ($actual:expr, { $($expected:expr),* }, $($format_args:expr),* $(,)?) => {
+        match $crate::verify_that!($actual, { $($expected),* })
+            .with_failure_message(|| format!($($format_args),*))
+        {
+            Ok(_) => {}
+            Err(e) => {
+                // The extra newline before the assertion failure message makes the failure a
+                // bit easier to read when there's some generic boilerplate from the panic.
+                panic!("\n{}", e);
+            }
+        }
+    };
+
+    // general case:
     ($actual:expr, $expected:expr $(,)?) => {
         match $crate::verify_that!($actual, $expected) {
             Ok(_) => {}
@@ -1319,6 +1372,7 @@ macro_rules! assert_that {
         }
     };
 
+    // w/ format args, general case:
     ($actual:expr, $expected:expr, $($format_args:expr),* $(,)?) => {
         match $crate::verify_that!($actual, $expected)
             .with_failure_message(|| format!($($format_args),*))

integration_tests/src/integration_tests.rs

@@ -71,6 +71,26 @@ mod tests {
         assert_that!(value, eq(2), "A custom error message",);
     }
 
+    #[gtest]
+    fn assert_that_supports_element_sequences() {
+        assert_that!(vec![1, 2], [eq(&1), eq(&2)]);
+    }
+
+    #[gtest]
+    fn assert_that_supports_unordered_element_sequences() {
+        assert_that!(vec![1, 2], {eq(&2), eq(&1)});
+    }
+
+    #[gtest]
+    fn assert_that_supports_ordered_element_sequences_with_format_string() {
+        assert_that!(vec![1, 2], [eq(&1), eq(&2)], "A custom error message");
+    }
+
+    #[gtest]
+    fn assert_that_supports_unordered_element_sequences_with_format_string() {
+        assert_that!(vec![1, 2], {eq(&2), eq(&1)}, "A custom error message");
+    }
+
     #[gtest]
     fn should_pass_with_expect_that() -> Result<()> {
         let value = 2;