Add support for Error Types that Don't Implement std::error::Error.

Author: frozenlib

Cargo.toml

@@ -27,3 +27,4 @@ structmeta = "0.3.0"
 proptest = "1.6.0"
 trybuild = "1.0.96"
 tokio = { version = "1.38.0", features = ["rt-multi-thread"] }
+anyhow = "1.0.97"

src/proptest_fn.rs

@@ -50,7 +50,8 @@ pub fn build_proptest(attr: TokenStream, mut item_fn: ItemFn) -> Result<TokenStr
                     let #f = move || -> #ty {
                         #block
                     };
-                    ::std::result::Result::map_err(#f(), ::std::convert::Into::<TestCaseError>::into)?;
+                    ::std::result::Result::map_err(#f(),
+                        |e| ::proptest::test_runner::TestCaseError::fail(::std::string::ToString::to_string(&e)))?;
                 })
             }
         }
@@ -168,7 +169,8 @@ impl Async {
                 body = quote! { #block };
                 output_type = quote!(#ty);
                 ret_expr = quote! {
-                    ::std::result::Result::map_err(ret, ::std::convert::Into::<TestCaseError>::into)?
+                    ::std::result::Result::map_err(ret,
+                        |e| ::proptest::test_runner::TestCaseError::fail(::std::string::ToString::to_string(&e)))?
                 };
             }
         }

tests/proptest_fn.rs

@@ -123,6 +123,12 @@ struct NotImplError1;
 #[derive(Debug)]
 struct CustomError(#[allow(dead_code)] TestCaseError);
 
+impl CustomError {
+    fn new() -> Self {
+        CustomError(TestCaseError::fail("Custom"))
+    }
+}
+
 impl std::error::Error for CustomError {}
 impl std::fmt::Display for CustomError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -145,9 +151,9 @@ impl From<NotImplError1> for CustomError {
     }
 }
 
-macro_rules! prop_assert2 {
+macro_rules! prop_assert_custom {
     ($cond:expr) => {
-        prop_assert2!($cond, concat!("assertion failed: ", stringify!($cond)))
+        prop_assert_custom!($cond, concat!("assertion failed: ", stringify!($cond)))
     };
     ($cond:expr, $($fmt:tt)*) => {
         if !$cond {
@@ -160,58 +166,128 @@ macro_rules! prop_assert2 {
 
 #[proptest]
 fn custom_error_ok(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
-    prop_assert2!(x < 10);
+    prop_assert_custom!(x < 10);
     not_impl_error_ok()?;
     Ok(())
 }
+#[proptest(async = "tokio")]
+async fn custom_error_ok_async(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
+    prop_assert_custom!(x < 10);
+    not_impl_error_ok()?;
+    yield_now().await;
+    Ok(())
+}
 
 #[should_panic]
 #[proptest]
-fn custom_error_ok_prop_assesrt_fail(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
-    prop_assert2!(x >= 10);
+fn custom_error_prop_assesrt_fail(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
+    prop_assert_custom!(x >= 10);
     Ok(())
 }
 
 #[proptest]
 #[should_panic]
 fn custom_error_err(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
-    prop_assert2!(x < 10);
+    prop_assert_custom!(x < 10);
     not_impl_error_err()?;
     Ok(())
 }
 
+#[proptest(async = "tokio")]
+#[should_panic]
+async fn custom_error_err_async(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
+    prop_assert_custom!(x < 10);
+    not_impl_error_err()?;
+    yield_now().await;
+    Ok(())
+}
+
 #[proptest]
 fn custom_error_ok_2(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
-    prop_assert2!(x < 10);
+    prop_assert_custom!(x < 10);
     not_impl_error_ok()?;
     not_impl_error_ok_1()?;
     Ok(())
 }
 
+fn not_impl_error_ok() -> Result<(), NotImplError0> {
+    Ok(())
+}
+fn not_impl_error_err() -> Result<(), NotImplError0> {
+    Err(NotImplError0)
+}
+
+fn not_impl_error_ok_1() -> Result<(), NotImplError1> {
+    Ok(())
+}
+
+macro_rules! prop_assert_anyhow {
+    ($cond:expr) => {
+        prop_assert_anyhow!($cond, concat!("assertion failed: ", stringify!($cond)))
+    };
+    ($cond:expr, $($fmt:tt)*) => {
+        if !$cond {
+            anyhow::bail!("{} at {}:{}", format!($($fmt)*), file!(), line!());
+        }
+    };
+}
+
+#[proptest]
+fn anyhow_result_ok(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x < 10);
+    Ok(())
+}
+
 #[proptest(async = "tokio")]
-async fn custom_error_async_ok(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
-    prop_assert2!(x < 10);
-    not_impl_error_ok()?;
+async fn anyhow_result_ok_async(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x < 10);
     yield_now().await;
     Ok(())
 }
 
+#[proptest]
+#[should_panic]
+fn anyhow_result_prop_assert_fail(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x >= 10);
+    Ok(())
+}
+
 #[proptest(async = "tokio")]
 #[should_panic]
-async fn custom_error_async_err(#[strategy(1..10u8)] x: u8) -> Result<(), CustomError> {
-    prop_assert2!(x < 10);
-    not_impl_error_err()?;
+async fn anyhow_result_prop_assert_fail_async(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x >= 10);
     yield_now().await;
     Ok(())
 }
 
-fn not_impl_error_ok() -> Result<(), NotImplError0> {
+#[proptest]
+#[should_panic]
+fn anyhow_result_err(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x < 10);
+    Err(CustomError::new())?;
     Ok(())
 }
-fn not_impl_error_err() -> Result<(), NotImplError0> {
-    Err(NotImplError0)
-}
 
-fn not_impl_error_ok_1() -> Result<(), NotImplError1> {
+#[proptest(async = "tokio")]
+#[should_panic]
+async fn anyhow_result_err_async(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x < 10);
+    Err(CustomError::new())?;
+    yield_now().await;
     Ok(())
 }
+
+#[proptest]
+#[should_panic]
+fn anyhow_result_bail(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x < 10);
+    anyhow::bail!("error");
+}
+
+#[proptest(async = "tokio")]
+#[should_panic]
+async fn anyhow_result_bail_async(#[strategy(1..10u8)] x: u8) -> anyhow::Result<()> {
+    prop_assert_anyhow!(x < 10);
+    yield_now().await;
+    anyhow::bail!("error");
+}