PUBLIC: add_failure_at!() macro implementation for non fatal failure in tests

This is the rust equivalent for[]
used to generate **non-fatal** failures at invocation location marking the
tests as failed but allowing function execution to **continue**.

In order to use this the test must have `#[googletest::test]` attribute.

PiperOrigin-RevId: 625949442

Author: satylogin

googletest/src/assertions.rs

@@ -291,7 +291,7 @@ macro_rules! verify_pred {
 /// [`and_log_failure`](crate::GoogleTestSupport::and_log_failure).
 #[macro_export]
 macro_rules! fail {
-    ($($message:expr),+) => {{
+    ($($message:expr),+ $(,)?) => {{
         $crate::assertions::internal::create_fail_result(
             format!($($message),*),
             file!(),
@@ -325,7 +325,7 @@ macro_rules! fail {
 /// ```
 #[macro_export]
 macro_rules! succeed {
-    ($($message:expr),+) => {{
+    ($($message:expr),+ $(,)?) => {{
         println!(
             "{}\n{}",
             format!($($message),*),
@@ -368,7 +368,7 @@ macro_rules! succeed {
 /// ```
 #[macro_export]
 macro_rules! add_failure {
-    ($($message:expr),+) => {{
+    ($($message:expr),+ $(,)?) => {{
         use $crate::GoogleTestSupport;
         $crate::assertions::internal::create_fail_result(
             format!($($message),*),
@@ -383,6 +383,57 @@ macro_rules! add_failure {
     };
 }
 
+/// Generates a failure at specified location marking the test as failed but
+/// continue execution.
+///
+/// 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.
+///
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[googletest::test]
+/// fn should_fail_but_not_abort() {
+///     add_failure_at!("src/my_file.rs", 32, 12);
+/// }
+/// ```
+///
+/// One may include formatted arguments in the failure message:
+///
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[googletest::test]
+/// fn should_fail_but_not_abort() {
+///     add_failure_at!(
+///         "src/my_file.rs",
+///         32,
+///         12,
+///         "I am just a fake test: {}", "a fake test indeed",
+///     );
+/// }
+/// ```
+#[macro_export]
+macro_rules! add_failure_at {
+    ($file:expr, $line:expr, $column:expr, $($message:expr),+ $(,)?) => {{
+        use $crate::GoogleTestSupport;
+        $crate::assertions::internal::create_fail_result(
+            format!($($message),*),
+            $file,
+            $line,
+            $column,
+        ).and_log_failure();
+    }};
+
+    ($file:expr, $line:expr, $column:expr $(,)?) => {
+        add_failure_at!($file, $line, $column, "Failed")
+    };
+}
+
 /// Matches the given value against the given matcher, panicking if it does not
 /// match.
 ///

googletest/src/lib.rs

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

integration_tests/Cargo.toml

@@ -125,6 +125,26 @@ name = "add_failure_macro_needs_googletest_attribute"
 path = "src/add_failure_macro_needs_googletest_attribute.rs"
 test = false
 
+[[bin]]
+name = "add_failure_at_macro_causes_failure_but_continues_execution"
+path = "src/add_failure_at_macro_causes_failure_but_continues_execution.rs"
+test = false
+
+[[bin]]
+name = "add_failure_at_macro_allows_empty_message"
+path = "src/add_failure_at_macro_allows_empty_message.rs"
+test = false
+
+[[bin]]
+name = "add_failure_at_macro_allows_formatted_arguments"
+path = "src/add_failure_at_macro_allows_formatted_arguments.rs"
+test = false
+
+[[bin]]
+name = "add_failure_at_macro_needs_googletest_attribute"
+path = "src/add_failure_at_macro_needs_googletest_attribute.rs"
+test = false
+
 [[bin]]
 name = "failure_due_to_returned_error"
 path = "src/failure_due_to_returned_error.rs"

integration_tests/src/add_failure_at_macro_allows_empty_message.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_but_not_abort() {
+        add_failure_at!("my_file.rs", 1, 1,);
+    }
+}

integration_tests/src/add_failure_at_macro_allows_formatted_arguments.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_but_not_abort() {
+        let argument = "An argument";
+        add_failure_at!("my_file.rs", 1, 1, "Failure message with argument: {argument}");
+    }
+}

integration_tests/src/add_failure_at_macro_causes_failure_but_continues_execution.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_but_not_abort() {
+        add_failure_at!("first_file.rs", 32, 12, "First failure",);
+        add_failure_at!("second_file.rs", 32, 12, "Second failure");
+    }
+}

integration_tests/src/add_failure_at_macro_needs_googletest_attribute.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() {
+        add_failure_at!("file.rs", 1, 1);
+    }
+}

integration_tests/src/integration_tests.rs

@@ -658,6 +658,55 @@ mod tests {
         verify_that!(output, contains_regex("Did you annotate the test with googletest::test?"))
     }
 
+    #[googletest::test]
+    fn add_failure_at_macro_causes_failure_but_continues_execution() -> Result<()> {
+        let output = run_external_process_in_tests_directory(
+            "add_failure_at_macro_causes_failure_but_continues_execution",
+        )?;
+
+        expect_that!(
+            output,
+            contains_regex(indoc! {"
+                First failure
+                  at .*first_file.rs:32:12
+                "})
+        );
+        expect_that!(
+            output,
+            contains_regex(indoc! {"
+                Second failure
+                  at .*second_file.rs:32:12
+                "})
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn add_failure_at_macro_allows_empty_message() -> Result<()> {
+        let output =
+            run_external_process_in_tests_directory("add_failure_at_macro_allows_empty_message")?;
+
+        verify_that!(output, contains_regex("Failed"))
+    }
+
+    #[test]
+    fn add_failure_at_macro_allows_formatted_arguments() -> Result<()> {
+        let output = run_external_process_in_tests_directory(
+            "add_failure_at_macro_allows_formatted_arguments",
+        )?;
+
+        verify_that!(output, contains_regex("Failure message with argument: An argument"))
+    }
+
+    #[test]
+    fn add_failure_at_macro_needs_googletest_attribute() -> Result<()> {
+        let output = run_external_process_in_tests_directory(
+            "add_failure_at_macro_needs_googletest_attribute",
+        )?;
+
+        verify_that!(output, contains_regex("Did you annotate the test with googletest::test?"))
+    }
+
     #[test]
     fn test_using_normal_test_attribute_macro_formats_failure_message_correctly() -> Result<()> {
         let result = should_display_error_correctly_without_google_test_macro();

run_integration_tests.sh

@@ -42,6 +42,10 @@ INTEGRATION_TEST_BINARIES=(
   "add_failure_macro_allows_empty_message"
   "add_failure_macro_allows_formatted_arguments"
   "add_failure_macro_needs_googletest_attribute"
+  "add_failure_at_macro_causes_failure_but_continues_execution"
+  "add_failure_at_macro_allows_empty_message"
+  "add_failure_at_macro_allows_formatted_arguments"
+  "add_failure_at_macro_needs_googletest_attribute"
   "fatal_and_non_fatal_failure"
   "first_failure_aborts"
   "google_test_with_rstest"