Rename the atribute macro google_test to just test.

This changes the canonical way to use the attribute macro from:

```
#[google_test]
fn should_work() -> Result<()> {...}
```

to

```
#[googletest::test]
fn should_work() -> Result<()> {...}
```

This is more in line with other test libraries such as Tokio et al., and aligns with the expectations of libraries like rstest; see https://github.com/la10736/rstest#inject-test-attribute. Thus the test will not be registered twice even if `#[googletest::test]` appears after `#[rstest]`. In particular, this addresses the remainder of #77.

This also adjusts the generated output of `#[googletest::test]` to refer explicitly to `::core::prelude::v1::test`, so that it still compiles when the test directly imports `googletest::test`.

Since this is a potentially more serious breaking change, the name `googletest::google_test` is retained as an alias for `googletest::test`. So it is not necessary to port existing downstream uses of the library.

PiperOrigin-RevId: 524774178

Author: hovinenb

README.md

@@ -182,15 +182,13 @@ failed, but execution continues until the test completes or otherwise aborts.
 This is analogous to the `EXPECT_*` family of macros in GoogleTest.
 
 To make a non-fatal assertion, use the macro [`expect_that!`]. The test must
-also be marked with [`google_test`] instead of the Rust-standard `#[test]`. It
-must return [`Result<()>`].
+also be marked with [`googletest::test`] instead of the Rust-standard `#[test]`.
+It must return [`Result<()>`].
 
 ```rust
-use googletest::{
-    expect_that, google_test, matchers::eq, Result
-};
+use googletest::{expect_that, matchers::eq, Result};
 
-#[google_test]
+#[googletest::test]
 fn more_than_one_failure() -> Result<()> {
     let value = 2;
     expect_that!(value, eq(3));  // Just marks the test as having failed.
@@ -201,12 +199,12 @@ fn more_than_one_failure() -> Result<()> {
 
 ### Interoperability
 
-You can use the `#[google_test]` macro together with many other libraries such
-as [rstest](https://crates.io/crates/rstest). Just apply both attribute macros
-to the test:
+You can use the `#[googletest::test]` macro together with many other libraries
+such as [rstest](https://crates.io/crates/rstest). Just apply both attribute
+macros to the test:
 
 ```rust
-#[google_test]
+#[googletest::test]
 #[rstest]
 #[case(1)]
 #[case(2)]
@@ -216,16 +214,16 @@ fn rstest_works_with_google_test(#[case] value: u32) -> Result<()> {
 }
 ```
 
-Make sure to put `#[google_test]` *before* `#[rstest]`. Otherwise the annotated
-test will run twice, since both macros will attempt to register a test with the
-Rust test harness.
+Make sure to put `#[googletest::test]` *before* `#[rstest]`. Otherwise the
+annotated test will run twice, since both macros will attempt to register a test
+with the Rust test harness.
 
 The macro also works together with
 [async tests with Tokio](https://docs.rs/tokio/latest/tokio/attr.test.html) in
 the same way:
 
 ```rust
-#[google_test]
+#[googletest::test]
 #[tokio::test]
 async fn should_work_with_tokio() -> Result<()> {
     verify_that!(3, gt(0))
@@ -289,7 +287,7 @@ to this project.
 [`expect_pred!`]: https://docs.rs/googletest/*/googletest/macro.expect_pred.html
 [`expect_that!`]: https://docs.rs/googletest/*/googletest/macro.expect_that.html
 [`fail!`]: https://docs.rs/googletest/*/googletest/macro.fail.html
-[`google_test`]: https://docs.rs/googletest/*/googletest/attr.google_test.html
+[`googletest::test`]: https://docs.rs/googletest/*/googletest/attr.test.html
 [`matches_pattern!`]: https://docs.rs/googletest/*/googletest/macro.matches_pattern.html
 [`verify_pred!`]: https://docs.rs/googletest/*/googletest/macro.verify_pred.html
 [`verify_that!`]: https://docs.rs/googletest/*/googletest/macro.verify_that.html

googletest/integration_tests/google_test_with_rstest.rs

@@ -14,49 +14,49 @@
 
 fn main() {}
 
-// Mixing rstest and google_test should not result in any compiler warnings. The
+// Mixing rstest and googletest::test should not result in any compiler warnings. The
 // fact that this successfully compiles is part of the test.
 #[deny(warnings)]
 #[cfg(test)]
 mod tests {
     #[cfg(not(google3))]
     use googletest::matchers;
-    use googletest::{google_test, verify_that, Result};
+    use googletest::{verify_that, Result};
     use matchers::eq;
     use rstest::rstest;
 
     #[rstest]
-    #[google_test]
+    #[googletest::test]
     fn test_should_work_with_rstest_first() -> Result<()> {
         verify_that!(1, eq(1))
     }
 
     #[rstest::rstest]
-    #[google_test]
+    #[googletest::test]
     fn test_should_work_with_qualified_rstest_first() -> Result<()> {
         verify_that!(1, eq(1))
     }
 
-    #[google_test]
+    #[googletest::test]
     #[rstest]
     fn test_should_work_with_rstest_second() -> Result<()> {
         verify_that!(1, eq(1))
     }
 
-    #[google_test]
+    #[googletest::test]
     #[rstest::rstest]
     fn test_should_work_with_qualified_rstest_second() -> Result<()> {
         verify_that!(1, eq(1))
     }
 
     #[rstest]
     #[case(1)]
-    #[google_test]
+    #[googletest::test]
     fn paramterised_test_should_work_with_rstest_first(#[case] value: u32) -> Result<()> {
         verify_that!(value, eq(value))
     }
 
-    #[google_test]
+    #[googletest::test]
     #[rstest]
     #[case(1)]
     fn paramterised_test_should_work_with_rstest_second(#[case] value: u32) -> Result<()> {
@@ -67,13 +67,13 @@ mod tests {
         pub use rstest::rstest as test;
     }
 
-    #[google_test]
+    #[googletest::test]
     #[submodule::test]
     fn test_should_work_with_qualified_test_annotation() -> Result<()> {
         verify_that!(1, eq(1))
     }
 
-    #[google_test]
+    #[googletest::test]
     #[test]
     fn test_should_work_with_second_test_annotation() -> Result<()> {
         verify_that!(1, eq(1))