Relax trait bound restrictions for more flexible use of match_matrix.

This relaxes the earlier type constraint of requiring the `actual` collection to be `Copy` or `Debug`.  The main reason this was done was to use the `count_elements` method, but this can be avoided by building the graph with nested `map` uses instead.

The main benefit is to allow the `MatchMatrix` to accept a wider class of inputs, which can be helpful in the definition of new matchers.  A simliar relaxation is done to `get_explanation`, which also doesn't depend on it.

We also add a unit test to exercise the basic construction of the graph and expose some private functions to the crate in anticipation of its use in new matchers.

PiperOrigin-RevId: 707632959

Author: Googler

googletest/src/matcher_support/match_matrix.rs

@@ -90,25 +90,21 @@ pub mod internal {
     }
 
     impl MatchMatrix {
-        pub(crate) fn generate<
-            'a,
-            T: Debug + Copy + 'a,
-            ContainerT: Debug + Copy + IntoIterator<Item = T>,
-        >(
-            actual: ContainerT,
+        pub(crate) fn generate<'a, T: Debug + Copy + 'a>(
+            actual: impl IntoIterator<Item = T>,
             expected: &[Box<dyn Matcher<T> + 'a>],
         ) -> Self {
             let expected_len = expected.len();
-            let mut matrix = MatchMatrix {
-                graph: vec![vec![MatcherResult::NoMatch; expected_len]; count_elements(actual)],
-                expected_len,
-            };
-            for (actual_idx, actual) in actual.into_iter().enumerate() {
-                for (expected_idx, expected) in expected.iter().enumerate() {
-                    matrix.graph[actual_idx][expected_idx] = expected.matches(actual);
-                }
-            }
-            matrix
+            let graph = actual
+                .into_iter()
+                .map(|actual| {
+                    expected
+                        .iter()
+                        .map(|expected_matcher| expected_matcher.matches(actual))
+                        .collect()
+                })
+                .collect();
+            MatchMatrix { graph, expected_len }
         }
 
         pub(crate) fn is_match_for(&self, requirements: Requirements) -> bool {
@@ -430,34 +426,30 @@ pub mod internal {
             self.get_unmatched_expected().is_empty()
         }
 
-        fn get_matches(&self) -> impl Iterator<Item = (usize, usize)> + '_ {
+        pub(crate) fn get_matches(&self) -> impl Iterator<Item = (usize, usize)> + '_ {
             self.actual_match.iter().enumerate().filter_map(|(actual_idx, maybe_expected_idx)| {
                 maybe_expected_idx.map(|expected_idx| (actual_idx, expected_idx))
             })
         }
 
-        fn get_unmatched_actual(&self) -> impl Iterator<Item = usize> + '_ {
+        pub(crate) fn get_unmatched_actual(&self) -> impl Iterator<Item = usize> + '_ {
             self.actual_match
                 .iter()
                 .enumerate()
                 .filter(|&(_, o)| o.is_none())
                 .map(|(actual_idx, _)| actual_idx)
         }
 
-        fn get_unmatched_expected(&self) -> Vec<usize> {
+        pub(crate) fn get_unmatched_expected(&self) -> Vec<usize> {
             let matched_expected: HashSet<_> = self.actual_match.iter().flatten().collect();
             (0..self.expected_len)
                 .filter(|expected_idx| !matched_expected.contains(expected_idx))
                 .collect()
         }
 
-        pub(crate) fn get_explanation<
-            'a,
-            T: Debug + Copy,
-            ContainerT: Debug + Copy + IntoIterator<Item = T>,
-        >(
+        pub(crate) fn get_explanation<'a, T: Debug + Copy>(
             &self,
-            actual: ContainerT,
+            actual: impl IntoIterator<Item = T>,
             expected: &[Box<dyn Matcher<T> + 'a>],
             requirements: Requirements,
         ) -> Option<Description> {
@@ -499,4 +491,28 @@ pub mod internal {
             ).into())
         }
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use crate::prelude::*;
+
+        #[test]
+        fn match_matrix_generate() {
+            let actual = vec![1, 2, 3, 4];
+            let expected: Vec<Box<dyn Matcher<i32>>> =
+                vec![Box::new(eq(1)), Box::new(eq(2)), Box::new(eq(3))];
+            let matrix = MatchMatrix::generate(actual, &expected);
+
+            assert_eq!(
+                matrix.graph,
+                vec![
+                    vec![true.into(), false.into(), false.into()],
+                    vec![false.into(), true.into(), false.into()],
+                    vec![false.into(), false.into(), true.into()],
+                    vec![false.into(), false.into(), false.into()],
+                ]
+            );
+        }
+    }
 }