Introduce a macro expect_pred.

This expands to verify_pred!(...).and_log_failure() and is analogous to GoogleTest's EXPECT_PRED* family of macros. It serves the same function as the previously introduced expect_that macro and completes this API surface.

PiperOrigin-RevId: 503417665

Author: hovinenb

googletest/Cargo.toml

@@ -61,6 +61,11 @@ name = "expect_that_failure"
 path = "integration_tests/expect_that_failure.rs"
 test = false
 
+[[bin]]
+name = "expect_pred_failure"
+path = "integration_tests/expect_pred_failure.rs"
+test = false
+
 [[bin]]
 name = "failure_due_to_fail_macro"
 path = "integration_tests/failure_due_to_fail_macro.rs"
@@ -101,6 +106,11 @@ name = "simple_assertion_failure_with_assert_that"
 path = "integration_tests/simple_assertion_failure_with_assert_that.rs"
 test = false
 
+[[bin]]
+name = "two_expect_pred_failures"
+path = "integration_tests/two_expect_pred_failures.rs"
+test = false
+
 [[bin]]
 name = "two_expect_that_failures"
 path = "integration_tests/two_expect_that_failures.rs"

googletest/integration_tests/expect_pred_failure.rs

@@ -0,0 +1,32 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::{expect_pred, google_test, Result};
+
+    #[google_test]
+    fn verify_predicate_with_failure() -> Result<()> {
+        let a = 1;
+        let b = 2;
+        expect_pred!(eq_predicate(a, b));
+        Ok(())
+    }
+
+    fn eq_predicate(a: i32, b: i32) -> bool {
+        a == b
+    }
+}

googletest/integration_tests/integration_tests.rs

@@ -19,8 +19,8 @@ mod tests {
     #[cfg(not(google3))]
     use googletest::{all, matchers};
     use googletest::{
-        assert_that, expect_that, google_test, verify_pred, verify_that, GoogleTestSupport,
-        MapErrorToTestFailure, Result,
+        assert_that, expect_pred, expect_that, google_test, verify_pred, verify_that,
+        GoogleTestSupport, MapErrorToTestFailure, Result,
     };
     #[cfg(google3)]
     use matchers::all;
@@ -249,6 +249,12 @@ Actual: 2, which isn't equal to 3
         a == b
     }
 
+    #[google_test]
+    fn should_verify_predicate_with_success_using_expect_pred() -> Result<()> {
+        expect_pred!(eq_predicate(1, 1));
+        Ok(())
+    }
+
     #[google_test]
     fn verify_pred_should_fail_test_on_failure() -> Result<()> {
         let status =
@@ -281,6 +287,13 @@ eq_predicate(a, b) was false with
         verify_that!(status.success(), eq(false))
     }
 
+    #[google_test]
+    fn expect_pred_should_fail_test_on_failure() -> Result<()> {
+        let status = run_external_process("expect_pred_failure").status().err_to_test_failure()?;
+
+        verify_that!(status.success(), eq(false))
+    }
+
     #[google_test]
     fn assert_pred_should_output_correct_failure_message() -> Result<()> {
         let output = run_external_process_in_tests_directory("assert_predicate_with_failure")?;
@@ -297,6 +310,38 @@ eq_predicate(a, b) was false with
         )
     }
 
+    #[google_test]
+    fn expect_pred_should_output_correct_failure_message() -> Result<()> {
+        let output = run_external_process_in_tests_directory("expect_pred_failure")?;
+
+        verify_that!(
+            output,
+            contains_substring(
+                "\
+eq_predicate(a, b) was false with
+  a = 1,
+  b = 2
+"
+            )
+        )
+    }
+
+    #[google_test]
+    fn expect_pred_should_output_failure_message_for_second_failure() -> Result<()> {
+        let output = run_external_process_in_tests_directory("two_expect_pred_failures")?;
+
+        verify_that!(
+            output,
+            contains_substring(
+                "\
+eq_predicate(a, b) was false with
+  a = 3,
+  b = 4
+"
+            )
+        )
+    }
+
     #[google_test]
     fn should_verify_predicate_in_a_submodule() -> Result<()> {
         verify_pred!(submodule::eq_predicate_in_submodule(1, 1))

googletest/integration_tests/two_expect_pred_failures.rs

@@ -0,0 +1,35 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::{expect_pred, google_test, Result};
+
+    #[google_test]
+    fn verify_predicate_with_failure() -> Result<()> {
+        let a = 1;
+        let b = 2;
+        expect_pred!(eq_predicate(a, b));
+        let a = 3;
+        let b = 4;
+        expect_pred!(eq_predicate(a, b));
+        Ok(())
+    }
+
+    fn eq_predicate(a: i32, b: i32) -> bool {
+        a == b
+    }
+}

googletest/src/assertions.rs

@@ -263,6 +263,30 @@ macro_rules! expect_that {
     }};
 }
 
+/// Asserts that the given predicate applied to the given arguments returns
+/// true, failing the test but continuing execution if not.
+///
+/// This is a *non-fatal* predicate assertion: the test
+/// continues execution in the event of assertion failure.
+///
+/// This can only be invoked inside tests with the
+/// [`google_test`][crate::google_test] attribute. The assertion must occur in
+/// the same thread as that running the test itself.
+///
+/// Invoking this macro is equivalent to using
+/// [`and_log_failure`](crate::GoogleTestSupport::and_log_failure) as follows:
+///
+/// ```rust
+/// verify_pred!(predicate(...)).and_log_failure()
+/// ```
+#[macro_export]
+macro_rules! expect_pred {
+    ($($content:tt)*) => {{
+        use $crate::GoogleTestSupport;
+        $crate::verify_pred!($($content)*).and_log_failure();
+    }};
+}
+
 /// Functions for use only by the procedural macros in this module.
 ///
 /// **For internal use only. API stablility is not guaranteed!**

run_integration_tests.sh

@@ -27,6 +27,7 @@ INTEGRATION_TEST_BINARIES=(
   "assert_predicate_with_failure"
   "assertion_failure_in_subroutine"
   "custom_error_message"
+  "expect_pred_failure"
   "expect_that_failure"
   "failure_due_to_fail_macro"
   "failure_due_to_fail_macro_with_empty_message"
@@ -36,6 +37,7 @@ INTEGRATION_TEST_BINARIES=(
   "non_fatal_failure_in_subroutine"
   "simple_assertion_failure"
   "simple_assertion_failure_with_assert_that"
+  "two_expect_pred_failures"
   "two_expect_that_failures"
   "two_non_fatal_failures"
   "verify_predicate_with_failure"