Rename into_test_result to or_fail

This name is shorter and aligns with the existing `or_` methods
on `Option` and `Result`. It reads more clearly when used in
situations like `let error = my_result.err().or_fail()?;`

This CL also removes IntoTestResult's generic parameter.
All types that implement IntoTestResult do so for only one particular
output type, so the generic parameter is unnecessary.

NOTE: this is a backwards-incompatible change.
PiperOrigin-RevId: 712700561

Author: cramertj

googletest/crate_docs.md

@@ -475,8 +475,8 @@ fn test_png_image_dimensions() -> googletest::Result<()> {
 ```
 
 If your setup function returns `Option<T>` or `std::result::Result<T, E>` where
-`E: !std::error::Error`, then you can convert these types with `into_test_result()`
-from the `IntoTestResult` extension trait.
+`E: !std::error::Error`, then you can convert these types with `or_fail()`
+from the `OrFail` extension trait.
 
 ```
 # use googletest::prelude::*;
@@ -494,7 +494,7 @@ impl PngImage {
 # */
 fn test_png_image_binary() -> googletest::Result<()> {
   // Arrange
-  let png_image = PngImage::new_from_binary(&PNG_BINARY).into_test_result()?;
+  let png_image = PngImage::new_from_binary(&PNG_BINARY).or_fail()?;
   /* ... */
   # Ok(())
 }
@@ -511,7 +511,7 @@ impl PngImage {
 # */
 fn test_png_from_cache() -> googletest::Result<()> {
   // Arrange
-  let png_image = PngImage::new_from_cache(123).into_test_result()?;
+  let png_image = PngImage::new_from_cache(123).or_fail()?;
   /* ... */
   # Ok(())
 }
@@ -528,6 +528,6 @@ GoogleTest assertion failures into Proptest
 through the `?` operator.
 
 [`and_log_failure()`]: GoogleTestSupport::and_log_failure
-[`into_test_result()`]: IntoTestResult::into_test_result
+[`or_fail()`]: OrFail::or_fail
 [`Matcher`]: matcher::Matcher
 [`MatcherBase`]: matcher::MatcherBase

googletest/src/lib.rs

@@ -53,7 +53,7 @@ pub mod prelude {
     pub use super::matchers::*;
     pub use super::verify_current_test_outcome;
     pub use super::GoogleTestSupport;
-    pub use super::IntoTestResult;
+    pub use super::OrFail;
     pub use super::Result;
     // Assert macros
     pub use super::{
@@ -238,8 +238,8 @@ impl<T> GoogleTestSupport for std::result::Result<T, TestAssertionFailure> {
     }
 }
 
-/// Provides an extension method for converting an arbitrary type into a
-/// [`Result`].
+/// Provides an extension method for converting an arbitrary type into
+/// `googletest`'s [`Result`] type.
 ///
 /// A type can implement this trait to provide an easy way to return immediately
 /// from a test in conjunction with the `?` operator. This is useful for
@@ -252,41 +252,48 @@ impl<T> GoogleTestSupport for std::result::Result<T, TestAssertionFailure> {
 /// ```ignore
 /// #[test]
 /// fn should_work() -> googletest::Result<()> {
-///     let value = something_which_can_fail().into_test_result()?;
-///     let value = something_which_can_fail_with_option().into_test_result()?;
+///     let value = something_which_can_fail().or_fail()?;
+///     let value = something_which_can_fail_with_option().or_fail()?;
 ///     ...
 /// }
 ///
 /// fn something_which_can_fail() -> std::result::Result<T, String> { ... }
 /// fn something_which_can_fail_with_option() -> Option<T> { ... }
 /// ```
-pub trait IntoTestResult<T> {
-    /// Converts this instance into a [`Result`].
+pub trait OrFail {
+    /// The success type of the test result.
+    type Output;
+
+    /// Converts a value into a [`Result`] containing
+    /// either the [`Self::Output`] type or a [`TestAssertionFailure`].
     ///
-    /// Typically, the `Self` type is itself an implementation of the
-    /// [`std::ops::Try`] trait. This method should then map the `Residual`
-    /// variant to a [`TestAssertionFailure`] and leave the `Output` variant
-    /// unchanged.
-    fn into_test_result(self) -> Result<T>;
+    /// The most frequently used implementations convert
+    /// `Result<T, E>` into `Result<T, TestAssertionFailure>` and
+    /// `Option<T>` into `Result<T, TestAssertionFailure>`.
+    fn or_fail(self) -> Result<Self::Output>;
 }
 
-impl<T, E: std::fmt::Debug> IntoTestResult<T> for std::result::Result<T, E> {
+impl<T, E: std::fmt::Debug> OrFail for std::result::Result<T, E> {
+    type Output = T;
+
     #[track_caller]
-    fn into_test_result(self) -> std::result::Result<T, TestAssertionFailure> {
+    fn or_fail(self) -> std::result::Result<T, TestAssertionFailure> {
         match self {
             Ok(t) => Ok(t),
             Err(e) => Err(TestAssertionFailure::create(format!("{e:?}"))),
         }
     }
 }
 
-impl<T> IntoTestResult<T> for Option<T> {
+impl<T> OrFail for Option<T> {
+    type Output = T;
+
     #[track_caller]
-    fn into_test_result(self) -> std::result::Result<T, TestAssertionFailure> {
+    fn or_fail(self) -> std::result::Result<T, TestAssertionFailure> {
         match self {
             Some(t) => Ok(t),
             None => Err(TestAssertionFailure::create(format!(
-                "called `Option::into_test_result()` on a `Option::<{}>::None` value",
+                "called `Option::or_fail()` on a `Option::<{}>::None` value",
                 std::any::type_name::<T>()
             ))),
         }

googletest/tests/proptest_integration_test.rs

@@ -20,11 +20,11 @@ use proptest::test_runner::{Config, TestRunner};
 #[test]
 fn numbers_are_greater_than_zero() -> Result<()> {
     let mut runner = TestRunner::new(Config::default());
-    runner.run(&(1..100i32), |v| Ok(verify_that!(v, gt(0))?)).into_test_result()
+    runner.run(&(1..100i32), |v| Ok(verify_that!(v, gt(0))?)).or_fail()
 }
 
 #[test]
 fn strings_are_nonempty() -> Result<()> {
     let mut runner = TestRunner::new(Config::default());
-    runner.run(&"[a-zA-Z0-9]+", |v| Ok(verify_that!(v, not(eq("")))?)).into_test_result()
+    runner.run(&"[a-zA-Z0-9]+", |v| Ok(verify_that!(v, not(eq("")))?)).or_fail()
 }

integration_tests/src/integration_tests.rs

@@ -1790,9 +1790,7 @@ mod tests {
         verify_that!(
             output,
             all![
-                contains_substring(
-                    "called `Option::into_test_result()` on a `Option::<()>::None` value"
-                ),
+                contains_substring("called `Option::or_fail()` on a `Option::<()>::None` value"),
                 contains_substring("test_returning_option.rs:23")
             ]
         )

integration_tests/src/test_returning_anyhow_error.rs

@@ -20,7 +20,7 @@ mod tests {
 
     #[test]
     fn should_fail_due_to_error_in_subroutine() -> Result<()> {
-        returns_anyhow_error().into_test_result()?;
+        returns_anyhow_error().or_fail()?;
         Ok(())
     }
 

integration_tests/src/test_returning_option.rs

@@ -20,7 +20,7 @@ mod tests {
 
     #[test]
     fn should_fail_due_to_none_in_subroutine() -> Result<()> {
-        returns_option().into_test_result()?;
+        returns_option().or_fail()?;
         Ok(())
     }
 

integration_tests/src/test_returning_string_error.rs

@@ -20,7 +20,7 @@ mod tests {
 
     #[test]
     fn should_fail_due_to_error_in_subroutine() -> Result<()> {
-        returns_string_error().into_test_result()?;
+        returns_string_error().or_fail()?;
         Ok(())
     }