PUBLIC: True boolean conditions macros

Adding rust flavours for:[]
* `verify_true`: check if the given expression is true and returns `Result`.
* `assert_true`: **panics** if the expression evaluates to false.
* `expect_true`: **logs** failure and **continues** execution if expression evaluates to false.

PiperOrigin-RevId: 632437788

Author: satylogin

googletest/src/assertions.rs

@@ -434,6 +434,95 @@ macro_rules! add_failure_at {
     };
 }
 
+/// Verify if the condition evaluates to true and returns `Result`.
+///
+/// Evaluates to `Result::Ok(())` if the condition is true and
+/// `Result::Err(TestAssertionFailure)` if it evaluates to false. The caller
+/// must then decide how to handle the `Err` variant. It has a few options:
+///   * Abort the current function with the `?` operator. This requires that the
+///     function return a suitable `Result`.
+///   * Log the failure and continue by calling the method `and_log_failure`.
+///
+/// Of course, one can also use all other standard methods on `Result`.
+///
+/// **Invoking this macro by itself does not cause a test failure to be recorded
+/// or output.** The resulting `Result` must be handled as described above to
+/// cause the test to be recorded as a failure.
+///
+/// Example:
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[test]
+/// fn should_fail() -> Result<()> {
+///     verify_true!(2 + 2 == 5)
+/// }
+/// ```
+#[macro_export]
+macro_rules! verify_true {
+    ($condition:expr) => {{
+        use $crate::assertions::internal::Subject;
+        ($condition).check(
+            $crate::matchers::eq(true),
+            stringify!($condition),
+            $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
+        )
+    }};
+}
+
+/// Assert if the condition evaluates to true and panics if false.
+///
+/// This is the same as calling `and_log_failure` on [`verify_true`] macro
+/// Result.
+///
+/// This can only be invoked inside tests with the
+/// [`googletest::test`][crate::test] attribute. The failure must be generated
+/// in the same thread as that running the thread itself.
+///
+/// Example:
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[googletest::test]
+/// fn should_fail() {
+///     assert_true!(2 + 2 == 5);
+/// }
+/// ```
+#[macro_export]
+macro_rules! assert_true {
+    ($condition:expr) => {
+        verify_true!($condition).and_log_failure()
+    };
+}
+
+/// Marks test as failed and continue execution if the expression evaluates to
+/// false.
+///
+/// This is a **not-fatal** failure. The test continues execution even after the
+/// macro execution.
+///
+/// This can only be invoked inside tests with the
+/// [`googletest::test`][crate::test] attribute. The failure must be generated
+/// in the same thread as that running the thread itself.
+///
+/// Example:
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[googletest::test]
+/// fn should_fail() {
+///     expect_true!(2 + 2 == 5);
+///     println!("This will print");
+/// }
+/// ```
+#[macro_export]
+macro_rules! expect_true {
+    ($condition:expr) => {{
+        use $crate::GoogleTestSupport;
+        verify_true!($condition).and_log_failure()
+    }};
+}
+
 /// Matches the given value against the given matcher, panicking if it does not
 /// match.
 ///

googletest/src/lib.rs

@@ -50,8 +50,8 @@ pub mod prelude {
     pub use super::Result;
     // Assert macros
     pub use super::{
-        add_failure, add_failure_at, assert_that, expect_pred, expect_that, fail, succeed,
-        verify_pred, verify_that,
+        add_failure, add_failure_at, assert_that, assert_true, expect_pred, expect_that,
+        expect_true, fail, succeed, verify_pred, verify_that, verify_true,
     };
 }
 

integration_tests/Cargo.toml

@@ -145,6 +145,21 @@ name = "add_failure_at_macro_needs_googletest_attribute"
 path = "src/add_failure_at_macro_needs_googletest_attribute.rs"
 test = false
 
+[[bin]]
+name = "verify_true_macro_on_false_condition"
+path = "src/verify_true_macro_on_false_condition.rs"
+test = false
+
+[[bin]]
+name = "assert_true_macro_on_false_condition_panics"
+path = "src/assert_true_macro_on_false_condition_panics.rs"
+test = false
+
+[[bin]]
+name = "expect_true_macro_on_false_condition_fails_test_and_continues"
+path = "src/expect_true_macro_on_false_condition_fails_test_and_continues.rs"
+test = false
+
 [[bin]]
 name = "failure_due_to_returned_error"
 path = "src/failure_due_to_returned_error.rs"

integration_tests/src/assert_true_macro_on_false_condition_panics.rs

@@ -0,0 +1,25 @@
+// Copyright 2024 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::prelude::*;
+
+    #[googletest::test]
+    fn should_fail() {
+        assert_true!(2 + 2 == 5);
+    }
+}

integration_tests/src/expect_true_macro_on_false_condition_fails_test_and_continues.rs

@@ -0,0 +1,26 @@
+// Copyright 2024 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::prelude::*;
+
+    #[googletest::test]
+    fn should_fail() {
+        expect_true!(2 + 2 == 5);
+        println!("This will print");
+    }
+}

integration_tests/src/integration_tests.rs

@@ -707,6 +707,76 @@ mod tests {
         verify_that!(output, contains_regex("Did you annotate the test with googletest::test?"))
     }
 
+    #[test]
+    fn verify_true_when_true_returns_ok() {
+        assert!(verify_true!("test" == "test").is_ok())
+    }
+
+    #[test]
+    fn verify_true_when_false_returns_err() {
+        assert!(verify_true!(2 + 2 == 5).is_err())
+    }
+
+    #[googletest::test]
+    fn verify_true_macro_on_false_condition_logs_error_when_handled() -> Result<()> {
+        let output =
+            run_external_process_in_tests_directory("verify_true_macro_on_false_condition")?;
+
+        verify_that!(
+            output,
+            contains_regex(indoc! {"
+                Expected: is equal to true
+                Actual: false,
+                  which isn't equal to true
+                  at .*verify_true_macro_on_false_condition.rs:23:9
+                "})
+        )
+    }
+
+    #[googletest::test]
+    fn assert_true_macro_on_true_condition_does_nothing() {
+        assert_true!(2 + 2 == 4);
+    }
+
+    #[googletest::test]
+    fn assert_true_macro_on_false_condition_panics() -> Result<()> {
+        let output =
+            run_external_process_in_tests_directory("assert_true_macro_on_false_condition_panics")?;
+
+        verify_that!(
+            output,
+            contains_regex(indoc! {"
+                Expected: is equal to true
+                Actual: false,
+                  which isn't equal to true
+                  at .*assert_true_macro_on_false_condition_panics.rs:23:9
+                "})
+        )
+    }
+
+    #[googletest::test]
+    fn expect_true_macro_on_true_condition_does_nothing() {
+        expect_true!(2 + 2 == 4)
+    }
+
+    #[googletest::test]
+    fn expect_true_macro_on_false_condition_fails_test_and_continues() -> Result<()> {
+        let output = run_external_process_in_tests_directory(
+            "expect_true_macro_on_false_condition_fails_test_and_continues",
+        )?;
+
+        expect_that!(
+            output,
+            contains_regex(indoc! {"
+                Expected: is equal to true
+                Actual: false,
+                  which isn't equal to true
+                  at .*expect_true_macro_on_false_condition_fails_test_and_continues.rs:23:9
+                "})
+        );
+        verify_that!(output, contains_regex("This will print"))
+    }
+
     #[test]
     fn test_using_normal_test_attribute_macro_formats_failure_message_correctly() -> Result<()> {
         let result = should_display_error_correctly_without_google_test_macro();

integration_tests/src/verify_true_macro_on_false_condition.rs

@@ -0,0 +1,25 @@
+// Copyright 2024 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::prelude::*;
+
+    #[test]
+    fn should_fail() -> Result<()> {
+        verify_true!(2 + 2 == 5)
+    }
+}

run_integration_tests.sh

@@ -46,6 +46,9 @@ INTEGRATION_TEST_BINARIES=(
   "add_failure_at_macro_allows_empty_message"
   "add_failure_at_macro_allows_formatted_arguments"
   "add_failure_at_macro_needs_googletest_attribute"
+  "verify_true_macro_on_false_condition"
+  "assert_true_macro_on_false_condition_panics"
+  "expect_true_macro_on_false_condition_fails_test_and_continues"
   "fatal_and_non_fatal_failure"
   "first_failure_aborts"
   "google_test_with_rstest"