Move some tests of UnorderedElementsOfMapAreMatcher into the unit tests of the module matchers::unordered_elements_are_matcher.

These tests exercise some of the more internal aspects of the matcher rather than using `verify_that!` with the matcher itself. Because of the type inference issues such use creates, it is more convenient to locate these tests in the unit tests rather than integration tests. This will become particularly apparent in a follow-up change which modifies the `Matcher` trait to use an associated type rather than a type parameter.

PiperOrigin-RevId: 527874814

Author: hovinenb

googletest/src/matchers/unordered_elements_are_matcher.rs

@@ -1056,3 +1056,67 @@ pub mod internal {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::matcher::Matcher;
+    #[cfg(not(google3))]
+    use crate::matchers;
+    #[cfg(not(google3))]
+    use crate::unordered_elements_are;
+    use crate::{matcher::MatcherResult, verify_that, Result};
+    use indoc::indoc;
+    use matchers::{anything, contains_regex, contains_substring, displays_as, eq, AndMatcherExt};
+    use std::collections::HashMap;
+
+    #[test]
+    fn has_correct_description_for_map() -> Result<()> {
+        // UnorderedElementsAreMatcher maintains references to the matchers, so the
+        // constituent matchers must live longer. Inside a verify_that! macro, the
+        // compiler takes care of that, but when the matcher is created separately,
+        // we must create the constitute matchers separately so that they
+        // aren't dropped too early.
+        let matchers = ((eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three")));
+        let matcher = unordered_elements_are![
+            (matchers.0.0, matchers.0.1),
+            (matchers.1.0, matchers.1.1),
+            (matchers.2.0, matchers.2.1)
+        ];
+        verify_that!(
+            Matcher::<HashMap<i32, &str>>::describe(&matcher, MatcherResult::Matches),
+            eq(indoc!(
+                "
+                contains elements matching in any order:
+                  is equal to 2 => is equal to \"Two\"
+                  is equal to 1 => is equal to \"One\"
+                  is equal to 3 => is equal to \"Three\""
+            ))
+        )
+    }
+
+    #[test]
+    fn unordered_elements_are_description_no_full_match_with_map() -> Result<()> {
+        // UnorderedElementsAreMatcher maintains references to the matchers, so the
+        // constituent matchers must live longer. Inside a verify_that! macro, the
+        // compiler takes care of that, but when the matcher is created separately,
+        // we must create the constitute matchers separately so that they
+        // aren't dropped too early.
+        let matchers = ((anything(), eq(1)), (anything(), eq(2)), (anything(), eq(2)));
+        let matcher = unordered_elements_are![
+            (matchers.0.0, matchers.0.1),
+            (matchers.1.0, matchers.1.1),
+            (matchers.2.0, matchers.2.1),
+        ];
+        let value: HashMap<u32, u32> = HashMap::from_iter([(0, 1), (1, 1), (2, 2)]);
+        verify_that!(
+            matcher.explain_match(&value),
+            displays_as(contains_regex(
+                "Actual element 2 => 2 at index [0-2] matched expected element `is anything` => `is equal to 2` at index [0-2]."
+            )).and(displays_as(contains_regex(
+                "Actual element [0-1] => [0-1] at index [0-2] did not match any remaining expected element."
+            ))).and(displays_as(contains_substring(
+                "Expected element `is anything` => `is equal to 2` at index 2 did not match any remaining actual element."
+            )))
+        )
+    }
+}

googletest/tests/unordered_elements_are_matcher_test.rs

@@ -17,13 +17,11 @@ use googletest::matcher::Matcher;
 use googletest::matchers;
 #[cfg(not(google3))]
 use googletest::{contains_each, is_contained_in, unordered_elements_are};
-use googletest::{google_test, matcher::MatcherResult, verify_that, Result};
+use googletest::{google_test, verify_that, Result};
 use indoc::indoc;
-use matchers::{
-    anything, contains_regex, contains_substring, displays_as, eq, err, ge, not, AndMatcherExt,
-};
 #[cfg(google3)]
 use matchers::{contains_each, is_contained_in, unordered_elements_are};
+use matchers::{contains_substring, displays_as, eq, err, ge, not};
 use std::collections::HashMap;
 
 #[google_test]
@@ -150,31 +148,6 @@ fn unordered_elements_are_description_mismatch() -> Result<()> {
     )
 }
 
-#[google_test]
-fn has_correct_description_for_map() -> Result<()> {
-    // UnorderedElementsAreMatcher maintains references to the matchers, so the
-    // constituent matchers must live longer. Inside a verify_that! macro, the
-    // compiler takes care of that, but when the matcher is created separately,
-    // we must create the constitute matchers separately so that they
-    // aren't dropped too early.
-    let matchers = ((eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three")));
-    let matcher = unordered_elements_are![
-        (matchers.0.0, matchers.0.1),
-        (matchers.1.0, matchers.1.1),
-        (matchers.2.0, matchers.2.1)
-    ];
-    verify_that!(
-        Matcher::<HashMap<u32, &'static str>>::describe(&matcher, MatcherResult::Matches),
-        eq(indoc!(
-            "
-                contains elements matching in any order:
-                  is equal to 2 => is equal to \"Two\"
-                  is equal to 1 => is equal to \"One\"
-                  is equal to 3 => is equal to \"Three\""
-        ))
-    )
-}
-
 #[google_test]
 fn unordered_elements_are_matches_unordered() -> Result<()> {
     let value = vec![1, 2];
@@ -210,32 +183,6 @@ fn unordered_elements_are_description_no_full_match() -> Result<()> {
     )
 }
 
-#[google_test]
-fn unordered_elements_are_description_no_full_match_with_map() -> Result<()> {
-    // UnorderedElementsAreMatcher maintains references to the matchers, so the
-    // constituent matchers must live longer. Inside a verify_that! macro, the
-    // compiler takes care of that, but when the matcher is created separately,
-    // we must create the constitute matchers separately so that they
-    // aren't dropped too early.
-    let matchers = ((anything(), eq(1)), (anything(), eq(2)), (anything(), eq(2)));
-    let matcher = unordered_elements_are![
-        (matchers.0.0, matchers.0.1),
-        (matchers.1.0, matchers.1.1),
-        (matchers.2.0, matchers.2.1),
-    ];
-    let value: HashMap<u32, u32> = HashMap::from_iter([(0, 1), (1, 1), (2, 2)]);
-    verify_that!(
-        matcher.explain_match(&value),
-        displays_as(contains_regex(
-            "Actual element 2 => 2 at index [0-2] matched expected element `is anything` => `is equal to 2` at index [0-2]."
-        )).and(displays_as(contains_regex(
-            "Actual element [0-1] => [0-1] at index [0-2] did not match any remaining expected element."
-        ))).and(displays_as(contains_substring(
-            "Expected element `is anything` => `is equal to 2` at index 2 did not match any remaining actual element."
-        )))
-    )
-}
-
 #[google_test]
 fn unordered_elements_are_unmatchable_expected_description_mismatch() -> Result<()> {
     verify_that!(