Support HashMap and similar types in the macros contains_each! and is_contained_in!.

This extends the functionality just introduced to `unordered_elements_are!` to the other two macros in the same module.

This also adds explicit macro rules for empty arguments, which might not otherwise work properly with the new macro rules.

PiperOrigin-RevId: 523633992

Author: hovinenb

googletest/src/matchers/unordered_elements_are_matcher.rs

@@ -127,6 +127,16 @@ macro_rules! unordered_elements_are {
 /// The actual value must be a container implementing [`IntoIterator`]. This
 /// includes standard containers, slices (when dereferenced) and arrays.
 ///
+/// This can also match against [`HashMap`][std::collections::HashMap] and
+/// similar collections. The arguments are a sequence of pairs of matchers
+/// corresponding to the keys and their respective values.
+///
+/// ```
+/// let value: HashMap<u32, &'static str> =
+///     HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+/// verify_that!(value, contains_each![(eq(2), eq("Two")), (eq(1), eq("One"))])
+/// ```
+///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
 ///
@@ -151,6 +161,31 @@ macro_rules! unordered_elements_are {
 /// [`Vec`]: https://doc.rust-lang.org/std/vec/struct.Vec.html
 #[macro_export]
 macro_rules! contains_each {
+    ($(,)?) => {{
+        #[cfg(google3)]
+        use $crate::internal::{UnorderedElementsAreMatcher, Requirements};
+        #[cfg(not(google3))]
+        use $crate::matchers::unordered_elements_are_matcher::internal::{
+            UnorderedElementsAreMatcher, Requirements
+        };
+        UnorderedElementsAreMatcher::new([], Requirements::Superset)
+    }};
+
+    // TODO: Consider an alternative map-like syntax here similar to that used in
+    // https://crates.io/crates/maplit.
+    ($(($key_matcher:expr, $value_matcher:expr)),* $(,)?) => {{
+        #[cfg(google3)]
+        use $crate::internal::{UnorderedElementsOfMapAreMatcher, Requirements};
+        #[cfg(not(google3))]
+        use $crate::matchers::unordered_elements_are_matcher::internal::{
+            UnorderedElementsOfMapAreMatcher, Requirements
+        };
+        UnorderedElementsOfMapAreMatcher::new(
+            [$((&$key_matcher, &$value_matcher)),*],
+            Requirements::Superset
+        )
+    }};
+
     ($($matcher:expr),* $(,)?) => {{
         #[cfg(google3)]
         use $crate::internal::{UnorderedElementsAreMatcher, Requirements};
@@ -185,6 +220,18 @@ macro_rules! contains_each {
 /// The actual value must be a container implementing [`IntoIterator`]. This
 /// includes standard containers, slices (when dereferenced) and arrays.
 ///
+/// This can also match against [`HashMap`][std::collections::HashMap] and
+/// similar collections. The arguments are a sequence of pairs of matchers
+/// corresponding to the keys and their respective values.
+///
+/// ```
+/// let value: HashMap<u32, &'static str> = HashMap::from_iter([(1, "One"), (2, "Two")]);
+/// verify_that!(
+///     value,
+///     is_contained_in![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))]
+/// )
+/// ```
+///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
 ///
@@ -209,6 +256,31 @@ macro_rules! contains_each {
 /// [`Vec`]: https://doc.rust-lang.org/std/vec/struct.Vec.html
 #[macro_export]
 macro_rules! is_contained_in {
+    ($(,)?) => {{
+        #[cfg(google3)]
+        use $crate::internal::{UnorderedElementsAreMatcher, Requirements};
+        #[cfg(not(google3))]
+        use $crate::matchers::unordered_elements_are_matcher::internal::{
+            UnorderedElementsAreMatcher, Requirements
+        };
+        UnorderedElementsAreMatcher::new([], Requirements::Subset)
+    }};
+
+    // TODO: Consider an alternative map-like syntax here similar to that used in
+    // https://crates.io/crates/maplit.
+    ($(($key_matcher:expr, $value_matcher:expr)),* $(,)?) => {{
+        #[cfg(google3)]
+        use $crate::internal::{UnorderedElementsOfMapAreMatcher, Requirements};
+        #[cfg(not(google3))]
+        use $crate::matchers::unordered_elements_are_matcher::internal::{
+            UnorderedElementsOfMapAreMatcher, Requirements
+        };
+        UnorderedElementsOfMapAreMatcher::new(
+            [$((&$key_matcher, &$value_matcher)),*],
+            Requirements::Subset
+        )
+    }};
+
     ($($matcher:expr),* $(,)?) => {{
         #[cfg(google3)]
         use $crate::internal::{UnorderedElementsAreMatcher, Requirements};

googletest/tests/unordered_elements_are_matcher_test.rs

@@ -26,6 +26,18 @@ use matchers::{
 use matchers::{contains_each, is_contained_in, unordered_elements_are};
 use std::collections::HashMap;
 
+#[google_test]
+fn unordered_elements_are_matches_empty_vector() -> Result<()> {
+    let value: Vec<u32> = vec![];
+    verify_that!(value, unordered_elements_are![])
+}
+
+#[google_test]
+fn unordered_elements_are_matches_empty_vector_with_trailing_comma() -> Result<()> {
+    let value: Vec<u32> = vec![];
+    verify_that!(value, unordered_elements_are![,])
+}
+
 #[google_test]
 fn unordered_elements_are_matches_vector() -> Result<()> {
     let value = vec![1, 2, 3];
@@ -250,11 +262,35 @@ fn contains_each_supports_trailing_comma() -> Result<()> {
     verify_that!(vec![2, 3, 4], contains_each!(eq(2), eq(3), eq(4),))
 }
 
+#[google_test]
+fn contains_each_matches_hash_map() -> Result<()> {
+    let value: HashMap<u32, &'static str> =
+        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    verify_that!(value, contains_each![(eq(2), eq("Two")), (eq(1), eq("One"))])
+}
+
+#[google_test]
+fn contains_each_matches_hash_map_with_trailing_comma() -> Result<()> {
+    let value: HashMap<u32, &'static str> =
+        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    verify_that!(value, contains_each![(eq(2), eq("Two")), (eq(1), eq("One")),])
+}
+
 #[google_test]
 fn contains_each_matches_when_no_matchers_present() -> Result<()> {
     verify_that!(vec![2, 3, 4], contains_each!())
 }
 
+#[google_test]
+fn contains_each_matches_when_no_matchers_present_and_trailing_comma() -> Result<()> {
+    verify_that!(vec![2, 3, 4], contains_each!(,))
+}
+
+#[google_test]
+fn contains_each_matches_when_list_is_empty_and_no_matchers_present() -> Result<()> {
+    verify_that!(Vec::<u32>::new(), contains_each!())
+}
+
 #[google_test]
 fn contains_each_matches_when_excess_elements_present() -> Result<()> {
     verify_that!(vec![1, 2, 3, 4], contains_each!(eq(2), eq(3), eq(4)))
@@ -302,6 +338,18 @@ fn contains_each_explains_mismatch_due_to_no_graph_matching_found() -> Result<()
     ))
 }
 
+#[google_test]
+fn is_contained_in_matches_with_empty_vector() -> Result<()> {
+    let value: Vec<u32> = vec![];
+    verify_that!(value, is_contained_in!())
+}
+
+#[google_test]
+fn is_contained_in_matches_with_empty_vector_and_trailing_comma() -> Result<()> {
+    let value: Vec<u32> = vec![];
+    verify_that!(value, is_contained_in!(,))
+}
+
 #[google_test]
 fn is_contained_in_matches_when_one_to_one_correspondence_present() -> Result<()> {
     verify_that!(vec![2, 3, 4], is_contained_in!(eq(2), eq(3), eq(4)))
@@ -312,6 +360,24 @@ fn is_contained_supports_trailing_comma() -> Result<()> {
     verify_that!(vec![2, 3, 4], is_contained_in!(eq(2), eq(3), eq(4),))
 }
 
+#[google_test]
+fn is_contained_in_matches_hash_map() -> Result<()> {
+    let value: HashMap<u32, &'static str> = HashMap::from_iter([(1, "One"), (2, "Two")]);
+    verify_that!(
+        value,
+        is_contained_in![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))]
+    )
+}
+
+#[google_test]
+fn is_contained_in_matches_hash_map_with_trailing_comma() -> Result<()> {
+    let value: HashMap<u32, &'static str> = HashMap::from_iter([(1, "One"), (2, "Two")]);
+    verify_that!(
+        value,
+        is_contained_in![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three")),]
+    )
+}
+
 #[google_test]
 fn is_contained_in_matches_when_container_is_empty() -> Result<()> {
     verify_that!(vec![], is_contained_in!(eq(2), eq(3), eq(4)))