Remove the dependency of elements_are! on HasSize.

HasSize is annoying because it can only be implemented for a priori known types. This change eliminates that dependency by having the matcher check whether the actual and expected values have matching sizes through inspection of the iterator used for matching rather than up front.

This introduces a new type ZippedIterator, which is almost identical to std::iter::Zip except that:

  * It contains an additional field which indicates whether the two input iterators had different sizes, and
  * It otherwise only implements the bare minimum functionality required by its caller and the Iterator trait.

Using this, the matcher can check whether a size mismatch was detected after the full iteration and fail the test in that case.

In particular, this makes elements_are! actually work with slices, e.g., from calling as_slice() on a Vec. Previously that would fail because (1) the slice must be dereferenced when passed as an actual value to verify_that! and (2) the resulting dereferenced type cannot implement HasSize.

PiperOrigin-RevId: 515585610

Author: hovinenb

googletest/src/matchers/elements_are_matcher.rs

@@ -26,9 +26,14 @@
 /// verify_that!(vec![1, 2, 3], elements_are![eq(1), anything(), gt(0).and(lt(123))])
 /// ```
 ///
-/// The actual value must be a container implementing [`IntoIterator`] and
-/// [`HasSize`][crate::matchers::has_size::HasSize]. This includes all common
-/// containers in the Rust standard library.
+/// The actual value must be a container implementing [`IntoIterator`]. This
+/// includes standard containers, slices (when dereferenced) and arrays.
+///
+/// ```
+/// let vector = vec![1, 2, 3];
+/// let slice = vector.as_slice();
+/// verify_that!(*slice, elements_are![eq(1), anything(), gt(0).and(lt(123))])
+/// ```
 ///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
@@ -59,16 +64,16 @@ macro_rules! elements_are {
 pub mod internal {
     #[cfg(not(google3))]
     use crate as googletest;
+    #[cfg(not(google3))]
+    use crate::matchers::zipped_iterator::zip;
     #[cfg(google3)]
     use description::Description;
     use googletest::matcher::{MatchExplanation, Matcher, MatcherResult};
     #[cfg(not(google3))]
     use googletest::matchers::description::Description;
-    #[cfg(not(google3))]
-    use googletest::matchers::has_size::HasSize;
-    #[cfg(google3)]
-    use has_size::HasSize;
     use std::fmt::Debug;
+    #[cfg(google3)]
+    use zipped_iterator::zip;
 
     /// This struct is meant to be used only by the macro `elements_are!`.
     ///
@@ -88,38 +93,47 @@ pub mod internal {
         }
     }
 
-    impl<'a, T: Debug, ContainerT: Debug + HasSize> Matcher<ContainerT> for ElementsAre<'a, T>
+    impl<'a, T: Debug, ContainerT: Debug + ?Sized> Matcher<ContainerT> for ElementsAre<'a, T>
     where
         for<'b> &'b ContainerT: IntoIterator<Item = &'b T>,
     {
         fn matches(&self, actual: &ContainerT) -> MatcherResult {
-            if actual.size() != self.elements.len() {
-                return MatcherResult::DoesNotMatch;
-            }
-            for (a, e) in actual.into_iter().zip(self.elements) {
+            let mut zipped_iterator = zip(actual.into_iter(), self.elements.iter());
+            for (a, e) in zipped_iterator.by_ref() {
                 if matches!(e.matches(a), MatcherResult::DoesNotMatch) {
                     return MatcherResult::DoesNotMatch;
                 }
             }
-            MatcherResult::Matches
+            if !zipped_iterator.has_size_mismatch() {
+                MatcherResult::Matches
+            } else {
+                MatcherResult::DoesNotMatch
+            }
         }
 
         fn explain_match(&self, actual: &ContainerT) -> MatchExplanation {
-            if actual.size() != self.elements.len() {
-                return MatchExplanation::create(format!("whose size is {}", actual.size(),));
+            let actual_iterator = actual.into_iter();
+            // TODO(b/271570144): This is a lower bound and not an actual value, so fix it
+            // to use the real number of elements in actual.
+            let actual_size = actual_iterator.size_hint().0;
+            let mut zipped_iterator = zip(actual_iterator, self.elements.iter());
+            let mut mismatches = Vec::new();
+            for (idx, (a, e)) in zipped_iterator.by_ref().enumerate() {
+                if matches!(e.matches(a), MatcherResult::DoesNotMatch) {
+                    mismatches.push(format!("element #{idx} is {a:?}, {}", e.explain_match(a)));
+                }
             }
-            let mismatches = actual
-                .into_iter()
-                .zip(self.elements)
-                .enumerate()
-                .filter(|&(_, (a, e))| matches!(e.matches(a), MatcherResult::DoesNotMatch))
-                .map(|(idx, (a, e))| format!("element #{idx} is {a:?}, {}", e.explain_match(a)))
-                .collect::<Description>();
             if mismatches.is_empty() {
-                MatchExplanation::create("whose elements all match".to_string())
+                if !zipped_iterator.has_size_mismatch() {
+                    MatchExplanation::create("whose elements all match".to_string())
+                } else {
+                    MatchExplanation::create(format!("whose size is {}", actual_size))
+                }
             } else if mismatches.len() == 1 {
+                let mismatches = mismatches.into_iter().collect::<Description>();
                 MatchExplanation::create(format!("where {mismatches}"))
             } else {
+                let mismatches = mismatches.into_iter().collect::<Description>();
                 MatchExplanation::create(format!("where:\n{}", mismatches.bullet_list().indent()))
             }
         }
@@ -159,8 +173,9 @@ mod tests {
 
     #[google_test]
     fn elements_are_matches_slice() -> Result<()> {
-        let value = &[1, 2, 3];
-        verify_that!(*value, elements_are![eq(1), eq(2), eq(3)])
+        let value = vec![1, 2, 3];
+        let slice = value.as_slice();
+        verify_that!(*slice, elements_are![eq(1), eq(2), eq(3)])
     }
 
     #[google_test]

googletest/src/matchers/mod.rs

@@ -88,6 +88,8 @@ pub mod superset_of_matcher;
 pub mod tuple_matcher;
 #[cfg(not(google3))]
 pub mod unordered_elements_are_matcher;
+#[cfg(not(google3))]
+pub mod zipped_iterator;
 
 #[cfg(google3)]
 pub use all_matcher::all;

googletest/src/matchers/zipped_iterator.rs

@@ -0,0 +1,53 @@
+/// Zips up two iterators into a single iterator of pairs.
+///
+/// This is identical to [`Iterator::zip`] except that this version allows the
+/// caller to determine whether the two iterators had mismatching sizes using
+/// the method [`ZippedIterator::has_size_mismatch`].
+///
+/// [`Iterator::zip`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.zip
+pub(crate) fn zip<I1, I2>(left: I1, right: I2) -> ZippedIterator<I1, I2> {
+    ZippedIterator { left, right, has_size_mismatch: false }
+}
+
+/// An iterator over pairs of the elements of two constituent iterators, which
+/// keeps track of whether the two iterators have the same size.
+///
+/// This is identical to [`Zip`] except that it allows the caller to determine
+/// whether the two iterators had mismatching sizes using the method
+/// [`ZippedIterator::has_size_mismatch`].
+///
+/// [`Zip`]: https://doc.rust-lang.org/std/iter/struct.Zip.html
+pub(crate) struct ZippedIterator<I1, I2> {
+    left: I1,
+    right: I2,
+    has_size_mismatch: bool,
+}
+
+impl<I1, I2> ZippedIterator<I1, I2> {
+    /// Returns whether a mismatch in the two sizes of the two iterators was
+    /// detected during iteration.
+    ///
+    /// This returns `true` if and only if, at some previous call to
+    /// [`Iterator::next`] on this instance, one of the constituent iterators
+    /// had a next element and the other did not.
+    ///
+    /// [`Iterator::next`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
+    pub(crate) fn has_size_mismatch(&self) -> bool {
+        self.has_size_mismatch
+    }
+}
+
+impl<I1: Iterator, I2: Iterator> Iterator for ZippedIterator<I1, I2> {
+    type Item = (I1::Item, I2::Item);
+
+    fn next(&mut self) -> Option<(I1::Item, I2::Item)> {
+        match (self.left.next(), self.right.next()) {
+            (Some(v1), Some(v2)) => Some((v1, v2)),
+            (None, None) => None,
+            _ => {
+                self.has_size_mismatch = true;
+                None
+            }
+        }
+    }
+}