Make the #[gtest] macro tolerate user-declared std and core modules

PiperOrigin-RevId: 665225837

Author: gribozavr

googletest_macro/src/lib.rs

@@ -75,15 +75,17 @@ pub fn gtest(
     let mut parsed_fn = parse_macro_input!(input as ItemFn);
     let attrs = parsed_fn.attrs.drain(..).collect::<Vec<_>>();
     let (mut sig, block) = (parsed_fn.sig, parsed_fn.block);
-    let (outer_return_type, trailer) =
-        if attrs.iter().any(|attr| attr.path().is_ident("should_panic")) {
-            (quote! { () }, quote! { .unwrap(); })
-        } else {
-            (
-                quote! { std::result::Result<(), googletest::internal::test_outcome::TestFailure> },
-                quote! {},
-            )
-        };
+    let (outer_return_type, trailer) = if attrs
+        .iter()
+        .any(|attr| attr.path().is_ident("should_panic"))
+    {
+        (quote! { () }, quote! { .unwrap(); })
+    } else {
+        (
+            quote! { ::std::result::Result<(), googletest::internal::test_outcome::TestFailure> },
+            quote! {},
+        )
+    };
     let output_type = match sig.output.clone() {
         ReturnType::Type(_, output_type) => Some(output_type),
         ReturnType::Default => None,

integration_tests/Cargo.toml

@@ -399,3 +399,8 @@ test = false
 name = "verify_predicate_with_failure_as_method_in_submodule"
 path = "src/verify_predicate_with_failure_as_method_in_submodule.rs"
 test = false
+
+[[bin]]
+name = "macro_hygiene"
+path = "src/macro_hygiene.rs"
+test = false

integration_tests/src/integration_tests.rs

@@ -1834,6 +1834,48 @@ mod tests {
         expect_that!(123, eq(123));
     }
 
+    #[gtest]
+    fn macros_are_hygenic() -> Result<()> {
+        let output = run_external_process_in_tests_directory("macro_hygiene")?;
+
+        verify_that!(
+            output,
+            all!(
+                contains_substring("test tests::verify_that_works ... ok"),
+                contains_substring("test tests::verify_pred_works ... ok"),
+                contains_substring("test tests::fail_works ... FAILED"),
+                contains_substring("test tests::succeed_works ... ok"),
+                contains_substring("test tests::add_failure_works ... FAILED"),
+                contains_substring("test tests::add_failure_at_works ... FAILED"),
+                contains_substring("test tests::verify_true_works ... ok"),
+                contains_substring("test tests::expect_true_works ... ok"),
+                contains_substring("test tests::verify_false_works ... ok"),
+                contains_substring("test tests::expect_false_works ... ok"),
+                contains_substring("test tests::verify_eq_works ... ok"),
+                contains_substring("test tests::expect_eq_works ... ok"),
+                contains_substring("test tests::verify_ne_works ... ok"),
+                contains_substring("test tests::expect_ne_works ... ok"),
+                contains_substring("test tests::verify_lt_works ... ok"),
+                contains_substring("test tests::expect_lt_works ... ok"),
+                contains_substring("test tests::verify_le_works ... ok"),
+                contains_substring("test tests::expect_le_works ... ok"),
+                contains_substring("test tests::verify_gt_works ... ok"),
+                contains_substring("test tests::expect_gt_works ... ok"),
+                contains_substring("test tests::verify_ge_works ... ok"),
+                contains_substring("test tests::expect_ge_works ... ok"),
+                contains_substring("test tests::verify_float_eq_works ... ok"),
+                contains_substring("test tests::expect_float_eq_works ... ok"),
+                contains_substring("test tests::verify_near_works ... ok"),
+                contains_substring("test tests::expect_near_works ... ok"),
+                contains_substring("test tests::assert_that_works ... ok"),
+                contains_substring("test tests::assert_pred_works ... ok"),
+                contains_substring("test tests::expect_that_works ... ok"),
+                contains_substring("test tests::expect_pred_works ... ok"),
+                contains_substring("test result: FAILED. 27 passed; 3 failed;")
+            )
+        )
+    }
+
     fn run_external_process_in_tests_directory_with_args(
         name: &'static str,
         args: &[&'static str],

integration_tests/src/macro_hygiene.rs

@@ -0,0 +1,183 @@
+// 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() {}
+
+// Shadow important modules that the macros use.
+mod std {}
+mod ctor {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::prelude::*;
+
+    #[gtest]
+    fn verify_that_works() -> Result<()> {
+        verify_that!(2 + 2, eq(4))
+    }
+
+    #[gtest]
+    fn verify_pred_works() -> Result<()> {
+        fn pred() -> bool {
+            true
+        }
+        verify_pred!(pred())
+    }
+
+    #[gtest]
+    fn fail_works() -> Result<()> {
+        fail!()
+    }
+
+    #[gtest]
+    fn succeed_works() {
+        succeed!();
+    }
+
+    #[gtest]
+    fn add_failure_works() {
+        add_failure!("message");
+    }
+
+    #[gtest]
+    fn add_failure_at_works() {
+        add_failure_at!("hello.rs", 12, 34, "message");
+    }
+
+    #[gtest]
+    fn verify_true_works() -> Result<()> {
+        verify_true!(true)
+    }
+
+    #[gtest]
+    fn expect_true_works() {
+        expect_true!(true);
+    }
+
+    #[gtest]
+    fn verify_false_works() -> Result<()> {
+        verify_false!(false)
+    }
+
+    #[gtest]
+    fn expect_false_works() {
+        expect_false!(false);
+    }
+
+    #[gtest]
+    fn verify_eq_works() -> Result<()> {
+        verify_eq!(2 + 2, 4)
+    }
+
+    #[gtest]
+    fn expect_eq_works() {
+        expect_eq!(2 + 2, 4);
+    }
+
+    #[gtest]
+    fn verify_ne_works() -> Result<()> {
+        verify_ne!(2 + 2, 5)
+    }
+
+    #[gtest]
+    fn expect_ne_works() {
+        expect_ne!(2 + 2, 5);
+    }
+
+    #[gtest]
+    fn verify_lt_works() -> Result<()> {
+        verify_lt!(2 + 2, 5)
+    }
+
+    #[gtest]
+    fn expect_lt_works() {
+        expect_lt!(2 + 2, 5);
+    }
+
+    #[gtest]
+    fn verify_le_works() -> Result<()> {
+        verify_le!(2 + 2, 4)
+    }
+
+    #[gtest]
+    fn expect_le_works() {
+        expect_le!(2 + 2, 4);
+    }
+
+    #[gtest]
+    fn verify_gt_works() -> Result<()> {
+        verify_gt!(2 + 2, 3)
+    }
+
+    #[gtest]
+    fn expect_gt_works() {
+        expect_gt!(2 + 2, 3);
+    }
+
+    #[gtest]
+    fn verify_ge_works() -> Result<()> {
+        verify_ge!(2 + 2, 4)
+    }
+
+    #[gtest]
+    fn expect_ge_works() {
+        expect_ge!(2 + 2, 4);
+    }
+
+    #[gtest]
+    fn verify_float_eq_works() -> Result<()> {
+        verify_float_eq!(1.0, 1.0)
+    }
+
+    #[gtest]
+    fn expect_float_eq_works() {
+        expect_float_eq!(1.0, 1.0);
+    }
+
+    #[gtest]
+    fn verify_near_works() -> Result<()> {
+        verify_near!(42.0, 42.001, 0.1)
+    }
+
+    #[gtest]
+    fn expect_near_works() {
+        expect_near!(42.0, 42.001, 0.1);
+    }
+
+    #[gtest]
+    fn assert_that_works() {
+        assert_that!(2 + 2, eq(4));
+    }
+
+    #[gtest]
+    fn assert_pred_works() {
+        fn pred() -> bool {
+            true
+        }
+        assert_pred!(pred());
+    }
+
+    #[gtest]
+    fn expect_that_works() {
+        expect_that!(2 + 2, eq(4));
+    }
+
+    #[gtest]
+    fn expect_pred_works() {
+        fn pred() -> bool {
+            true
+        }
+        expect_pred!(pred());
+    }
+}

run_integration_tests.sh

@@ -96,6 +96,7 @@ INTEGRATION_TEST_BINARIES=(
   "two_non_fatal_failures"
   "verify_predicate_with_failure"
   "verify_predicate_with_failure_as_method_in_submodule"
+  "macro_hygiene"
 )
 
 cargo build