Fix support for async tests with googletest::test.

Previously, an async test annotated with `googletest::test` would not compile because the test content was put in an ordinary closure. Any uses of `.await` inside that closure would generate a compiler error.

This changes the `googletest::test` macro implementation to detect that the test is async and adjust the generation accordingly. If the test is async, then no closure is generated, but the test content is placed in an async block.

Unfortunately, there does not appear to be a single way to cover both the sync and async cases currently, as explained in the code comments.

A further refinement of this approach could possibly address #4.

PiperOrigin-RevId: 524774676

Author: hovinenb

googletest/Cargo.toml

@@ -40,6 +40,7 @@ regex = "1.6.0"
 anyhow = { version = "1.0.70", optional = true }
 indoc = { version = "2", optional = true }
 rstest = { version = "0.17.0", optional = true }
+tokio = { version = "1", optional = true, features = ["time", "macros", "rt"] }
 
 [dev-dependencies]
 indoc = "2"
@@ -60,6 +61,12 @@ name = "assertion_failure_in_subroutine"
 path = "integration_tests/assertion_failure_in_subroutine.rs"
 test = false
 
+[[bin]]
+name = "async_test_with_expect_that"
+path = "integration_tests/async_test_with_expect_that.rs"
+test = false
+required_features = ["tokio"]
+
 [[bin]]
 name = "custom_error_message"
 path = "integration_tests/custom_error_message.rs"

googletest/integration_tests/async_test_with_expect_that.rs

@@ -0,0 +1,42 @@
+// Copyright 2023 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() {}
+
+#[deny(warnings)]
+#[cfg(test)]
+mod tests {
+    #[cfg(not(google3))]
+    use googletest::matchers;
+    use googletest::{expect_that, verify_that, Result};
+    use matchers::eq;
+    use std::time::Duration;
+    use tokio::time::sleep;
+
+    #[googletest::test]
+    #[tokio::test]
+    async fn async_test_failure_with_non_fatal_assertion() -> Result<()> {
+        sleep(Duration::from_millis(1)).await;
+        expect_that!(2, eq(3));
+        Ok(())
+    }
+
+    #[googletest::test]
+    #[tokio::test]
+    async fn async_test_failure_with_fatal_assertion() -> Result<()> {
+        sleep(Duration::from_millis(1)).await;
+        verify_that!(3, eq(4))?;
+        Ok(())
+    }
+}

googletest/integration_tests/integration_tests.rs

@@ -19,8 +19,8 @@ mod tests {
     #[cfg(not(google3))]
     use googletest::{all, matchers, matchers::str_matcher};
     use googletest::{
-        assert_that, expect_pred, expect_that, test, verify_pred, verify_that,
-        GoogleTestSupport, Result,
+        assert_that, expect_pred, expect_that, test, verify_pred, verify_that, GoogleTestSupport,
+        Result,
     };
     use indoc::indoc;
     #[cfg(google3)]
@@ -495,7 +495,24 @@ mod tests {
         )
     }
 
-    #[cfg(feature = "anyhow")]
+    #[test]
+    fn async_test_with_google_test_runs_correctly() -> Result<()> {
+        let output = run_external_process_in_tests_directory("async_test_with_expect_that")?;
+
+        expect_that!(
+            output,
+            contains_substring("tests::async_test_failure_with_non_fatal_assertion ... FAILED")
+                .times(eq(1))
+        );
+        expect_that!(
+            output,
+            contains_substring("tests::async_test_failure_with_fatal_assertion ... FAILED")
+                .times(eq(1))
+        );
+        expect_that!(output, contains_substring("Expected: is equal to 3"));
+        verify_that!(output, contains_substring("Expected: is equal to 4"))
+    }
+
     #[test]
     fn test_can_return_anyhow_generated_error() -> Result<()> {
         let output = run_external_process_in_tests_directory("test_returning_anyhow_error")?;

googletest_macro/src/lib.rs

@@ -64,13 +64,37 @@ pub fn test(
         }.into();
     };
     sig.output = ReturnType::Default;
+    let (maybe_closure, invocation) = if sig.asyncness.is_some() {
+        (
+            // In the async case, the ? operator returns from the *block* rather than the
+            // surrounding function. So we just put the test content in an async block. Async
+            // closures are still unstable (see https://github.com/rust-lang/rust/issues/62290),
+            // so we can't use the same solution as the sync case below.
+            quote! {},
+            quote! {
+                async { #block }.await
+            },
+        )
+    } else {
+        (
+            // In the sync case, the ? operator returns from the surrounding function. So we must
+            // create a separate closure from which the ? operator can return in order to capture
+            // the output.
+            quote! {
+                let test = move || #block;
+            },
+            quote! {
+                test()
+            },
+        )
+    };
     let function = quote! {
         #(#attrs)*
         #sig -> std::result::Result<(), ()> {
-            let test = move || #block;
+            #maybe_closure
             use googletest::internal::test_outcome::TestOutcome;
             TestOutcome::init_current_test_outcome();
-            let result: #output_type = test();
+            let result: #output_type = #invocation;
             TestOutcome::close_current_test_outcome(result)
         }
     };

run_integration_tests.sh

@@ -26,6 +26,7 @@ INTEGRATION_TEST_BINARIES=(
   "integration_tests"
   "assert_predicate_with_failure"
   "assertion_failure_in_subroutine"
+  "async_test_with_expect_that"
   "custom_error_message"
   "expect_pred_failure"
   "expect_that_failure"
@@ -48,6 +49,6 @@ INTEGRATION_TEST_BINARIES=(
 
 cargo build
 for binary in ${INTEGRATION_TEST_BINARIES[@]}; do
-  cargo rustc -p googletest --bin $binary --features anyhow,indoc,rstest -- --test
+  cargo rustc -p googletest --bin $binary --features anyhow,indoc,rstest,tokio -- --test
 done
 ./target/debug/integration_tests