Support up to three containers in the pointwise! matcher.

This allows the caller to specify up to three containers to supply values to a lambda expression which generates a matcher:

```
verify_that!(value, pointwise!(near, [1.0, 2.0, 3.0], [0.01, 0.0001, 0.0001]))?;
verify_that!(value, pointwise!(|v, t, u| near(v, t * u), [1.0, 2.0, 3.0], [0.01, 0.001, 0.0001], [0.5, 0.5, 1.0]))?;
```

The limit of three was chosen because it's highly uncommon for a (function) matcher to have more than three parameters.

PiperOrigin-RevId: 524003958

Author: hovinenb

googletest/src/matchers/pointwise_matcher.rs

@@ -36,6 +36,28 @@
 /// verify_that!(value, pointwise!(|v| near(v, 0.001), [1.0, 2.0, 3.0]))?;
 /// ```
 ///
+/// One can pass up to three containers to supply arguments to the function
+/// creating the matcher:
+///
+/// ```
+/// let value = vec![1.00001, 2.000001, 3.00001];
+/// verify_that!(value, pointwise!(|v, t| near(v, t), [1.0, 2.0, 3.0], [0.001, 0.0001, 0.01]))?;
+/// verify_that!(value, pointwise!(near, [1.0, 2.0, 3.0], [0.001, 0.0001, 0.01]))?; // Same as above
+/// verify_that!(
+///     value,
+///     pointwise!(
+///         |v, t, u| near(v, t * u),
+///         [1.0, 2.0, 3.0],
+///         [0.001, 0.0001, 0.01],
+///         [0.5, 0.5, 1.0]
+///     )
+/// )?;
+/// ```
+///
+/// When using `pointwise!` with multiple containers, the caller must ensure
+/// that all of the containers have the same size. This matcher does not check
+/// whether the sizes match.
+///
 /// The actual value must be a container implementing [`IntoIterator`]. This
 /// includes standard containers, slices (when dereferenced) and arrays.
 ///
@@ -63,12 +85,40 @@
 #[macro_export]
 macro_rules! pointwise {
     ($matcher:expr, $container:expr) => {{
-            #[cfg(google3)]
-            use $crate::internal::PointwiseMatcher;
-            #[cfg(not(google3))]
-            use $crate::matchers::pointwise_matcher::internal::PointwiseMatcher;
-            PointwiseMatcher::new($container.into_iter().map($matcher).collect())
-        }};
+        #[cfg(google3)]
+        use $crate::internal::PointwiseMatcher;
+        #[cfg(not(google3))]
+        use $crate::matchers::pointwise_matcher::internal::PointwiseMatcher;
+        PointwiseMatcher::new($container.into_iter().map($matcher).collect())
+    }};
+
+    ($matcher:expr, $left_container:expr, $right_container:expr) => {{
+        #[cfg(google3)]
+        use $crate::internal::PointwiseMatcher;
+        #[cfg(not(google3))]
+        use $crate::matchers::pointwise_matcher::internal::PointwiseMatcher;
+        PointwiseMatcher::new(
+            $left_container
+                .into_iter()
+                .zip($right_container.into_iter())
+                .map(|(l, r)| $matcher(l, r))
+                .collect(),
+        )
+    }};
+
+    ($matcher:expr, $left_container:expr, $middle_container:expr, $right_container:expr) => {{
+        #[cfg(google3)]
+        use $crate::internal::PointwiseMatcher;
+        #[cfg(not(google3))]
+        use $crate::matchers::pointwise_matcher::internal::PointwiseMatcher;
+        PointwiseMatcher::new(
+            $left_container
+                .into_iter()
+                .zip($right_container.into_iter().zip($middle_container.into_iter()))
+                .map(|(l, (m, r))| $matcher(l, m, r))
+                .collect(),
+        )
+    }};
 }
 
 /// Module for use only by the procedural macros in this module.

googletest/tests/pointwise_matcher_test.rs

@@ -172,3 +172,18 @@ fn pointwise_matches_single_element_with_lambda_expression_with_extra_value() ->
     let value = vec![1.00001f32];
     verify_that!(value, pointwise!(|v| near(v, 0.0001), vec![1.0]))
 }
+
+#[google_test]
+fn pointwise_matches_single_element_with_two_containers() -> Result<()> {
+    let value = vec![1.00001f32];
+    verify_that!(value, pointwise!(near, vec![1.0], vec![0.0001]))
+}
+
+#[google_test]
+fn pointwise_matches_single_element_with_three_containers() -> Result<()> {
+    let value = vec![1.00001f32];
+    verify_that!(
+        value,
+        pointwise!(|v, t, u| near(v, t * u), vec![1.0f32], vec![0.0001f32], vec![0.5f32])
+    )
+}