Add feature backtrace

.github/workflows/rust.yml

@@ -46,6 +46,12 @@ jobs:
         run: cd proptest && cargo build --verbose
       - name: Run tests
         run: cd proptest && cargo test --verbose
+      - name: Run tests handle-panics
+        run: cd proptest && cargo test --verbose --features handle-panics
+      - name: Run tests backtrace
+        run: cd proptest && cargo test --verbose --features backtrace
+      - name: Run tests handle-panics+backtrace
+        run: cd proptest && cargo test --verbose --features "handle-panics backtrace"
       - name: Build coverage no-default-features
         if: ${{ matrix.build == 'stable' }}
         env:

proptest/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - When running persisted regressions, the most recently added regression is now run first.
 - Added `handle-panics` feature which enables catching panics raised in tests and turning them into failures
+- Added `backtrace` feature which enables capturing backtraces for both test failures and panics,
+  if `handle-panics` feature is enabled
 
 ## 1.5.0
 

proptest/Cargo.toml

@@ -62,6 +62,11 @@ bit-set = ["dep:bit-set", "dep:bit-vec"]
 # In particular, hides all intermediate panics flowing into stderr during shrink phase
 handle-panics = ["std"]
 
+# Enables gathering of failure backtraces
+# * when test failure is reported via `prop_assert_*` macro
+# * when normal assertion fails or panic fires, if `handle-panics` feature is enabled too
+backtrace = ["std"]
+
 [dependencies]
 bitflags = "2"
 unarray = "0.1.4"
@@ -123,5 +128,6 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dev-dependencies]
+assert_matches = "1.5.0"
 regex = "1.0"
 trybuild = "=1.0.0"

proptest/src/arbitrary/_alloc/collections.rs

@@ -19,6 +19,7 @@ use crate::std_facade::{
     binary_heap, btree_map, btree_set, fmt, linked_list, vec, vec_deque, Arc,
     BTreeMap, BTreeSet, BinaryHeap, Box, LinkedList, Rc, Vec, VecDeque,
 };
+#[cfg(feature = "std")]
 use core::hash::Hash;
 use core::ops::{Bound, RangeInclusive};
 

proptest/src/sugar.rs

@@ -751,10 +751,11 @@ macro_rules! prop_assert {
 
     ($cond:expr, $($fmt:tt)*) => {
         if !$cond {
-            let message = format!($($fmt)*);
-            let message = format!("{} at {}:{}", message, file!(), line!());
             return ::core::result::Result::Err(
-                $crate::test_runner::TestCaseError::fail(message));
+                $crate::test_runner::TestCaseError::fail(
+                    $crate::test_runner::Reason::with_location_and_backtrace(format!($($fmt)*))
+                )
+            );
         }
     };
 }

proptest/src/test_runner/backtrace.rs

@@ -0,0 +1,135 @@
+//-
+// Copyright 2024
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::fmt;
+/// Holds test failure backtrace, if captured
+///
+/// If feature `backtrace` is disabled, it's a zero-sized struct with no logic
+///
+/// If `backtrace` is enabled, attempts to capture backtrace using `std::backtrace::Backtrace` -
+/// if requested
+#[derive(Clone, Default)]
+pub struct Backtrace(internal::Backtrace);
+
+impl Backtrace {
+    /// Creates empty backtrace object
+    ///
+    /// Used when client code doesn't care
+    pub fn empty() -> Self {
+        Self(internal::Backtrace::empty())
+    }
+    /// Tells whether there's backtrace captured
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+    /// Attempts to capture backtrace - but only if `backtrace` feature is enabled
+    #[inline(always)]
+    pub fn capture() -> Self {
+        Self(internal::Backtrace::capture())
+    }
+}
+
+impl fmt::Debug for Backtrace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl fmt::Display for Backtrace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+#[cfg(feature = "backtrace")]
+mod internal {
+    use core::fmt;
+    use std::backtrace as bt;
+    use std::sync::Arc;
+
+    // `std::backtrace::Backtrace` isn't `Clone`, so we have
+    // to use `Arc` to also maintain `Send + Sync`
+    #[derive(Clone, Default)]
+    pub struct Backtrace(Option<Arc<bt::Backtrace>>);
+
+    impl Backtrace {
+        pub fn empty() -> Self {
+            Self(None)
+        }
+
+        pub fn is_empty(&self) -> bool {
+            self.0.is_none()
+        }
+
+        #[inline(always)]
+        pub fn capture() -> Self {
+            let bt = bt::Backtrace::capture();
+            // Store only if we have backtrace
+            if bt.status() == bt::BacktraceStatus::Captured {
+                Self(Some(Arc::new(bt)))
+            } else {
+                Self(None)
+            }
+        }
+    }
+
+    impl fmt::Debug for Backtrace {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            if let Some(ref arc) = self.0 {
+                fmt::Debug::fmt(arc.as_ref(), f)
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    impl fmt::Display for Backtrace {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            if let Some(ref arc) = self.0 {
+                fmt::Display::fmt(arc.as_ref(), f)
+            } else {
+                Ok(())
+            }
+        }
+    }
+}
+
+#[cfg(not(feature = "backtrace"))]
+mod internal {
+    use core::fmt;
+
+    #[derive(Clone, Default)]
+    pub struct Backtrace;
+
+    impl Backtrace {
+        pub fn empty() -> Self {
+            Self
+        }
+
+        pub fn is_empty(&self) -> bool {
+            true
+        }
+
+        pub fn capture() -> Self {
+            Self
+        }
+    }
+
+    impl fmt::Debug for Backtrace {
+        fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
+            Ok(())
+        }
+    }
+
+    impl fmt::Display for Backtrace {
+        fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
+            Ok(())
+        }
+    }
+}

proptest/src/test_runner/errors.rs

@@ -86,7 +86,9 @@ impl fmt::Display for TestCaseError {
             TestCaseError::Reject(ref whence) => {
                 write!(f, "Input rejected at {}", whence)
             }
-            TestCaseError::Fail(ref why) => write!(f, "Case failed: {}", why),
+            TestCaseError::Fail(ref why) => {
+                write!(f, "Case failed: {}", why.display_detailed())
+            }
         }
     }
 }
@@ -115,7 +117,7 @@ impl<T: fmt::Debug> fmt::Display for TestError<T> {
         match *self {
             TestError::Abort(ref why) => write!(f, "Test aborted: {}", why),
             TestError::Fail(ref why, ref what) => {
-                writeln!(f, "Test failed: {}.", why)?;
+                writeln!(f, "Test failed: {}", why.display_detailed())?;
                 write!(f, "minimal failing input: {:#?}", what)
             }
         }

proptest/src/test_runner/mod.rs

@@ -12,6 +12,7 @@
 //! You do not normally need to access things in this module directly except
 //! when implementing new low-level strategies.
 
+mod backtrace;
 mod config;
 mod errors;
 mod failure_persistence;
@@ -21,6 +22,7 @@ mod replay;
 mod result_cache;
 mod rng;
 mod runner;
+#[cfg(feature = "handle-panics")]
 mod scoped_panic_hook;
 
 pub use self::config::*;