feat: Add support for '#[should_panic]' macro

Author: skogseth

crates/libtest2/src/lib.rs

@@ -61,6 +61,7 @@ pub mod _private {
 
     pub use crate::_main_parse as main_parse;
     pub use crate::_parse_ignore as parse_ignore;
+    pub use crate::_run_test as run_test;
     pub use crate::_test_parse as test_parse;
     pub use crate::case::DynCase;
 }

crates/libtest2/src/macros.rs

@@ -28,29 +28,52 @@ macro_rules! _test_parse {
     // Recursively handle attributes:
 
     // Edge condition (no more attributes to parse)
-    (continue: name=$name:ident body=[$($item:tt)*] attrs=[] $(ignore=$ignore:tt)?) => {
+    (continue: name=$name:ident body=[$($item:tt)*] attrs=[] $(ignore=$ignore:tt)? $(should_panic=$should_panic:tt)?) => {
         $crate::_private::test_parse!(break:
             name=$name
             body=[$($item)*]
             $(ignore=$ignore)?
+            $(should_panic=$should_panic)?
         );
     };
     // Process `#[ignore]` macro (NOTE: This will only match if an `#[ignore]` macro has not already been parsed)
-    (continue: name=$name:ident body=[$($item:tt)*] attrs=[#[ignore $(= $reason:literal)?] $(#[$($attr:tt)+])*]) => {
+    (continue: name=$name:ident body=[$($item:tt)*] attrs=[#[ignore $(= $reason:literal)?] $(#[$($attr:tt)+])*] $(should_panic=$should_panic:tt)?) => {
         $crate::_private::test_parse!(continue:
             name=$name
             body=[$($item)*]
             attrs=[$(#[$($attr)*])*]
             ignore=[$($reason)?]
+            $(should_panic=$should_panic)?
+        );
+    };
+    // Process `#[should_panic]` macro (NOTE: This will only match if `#[should_panic]` macro has not already been parsed)
+    (continue: name=$name:ident body=[$($item:tt)*] attrs=[#[should_panic $(= $expected:literal)?] $(#[$($attr:tt)+])*] $(ignore=$ignore:tt)?) => {
+        $crate::_private::test_parse!(continue:
+            name=$name
+            body=[$($item)*]
+            attrs=[$(#[$($attr)*])*]
+            $(ignore=$ignore)?
+            should_panic=[$($expected)?]
+        );
+    };
+    // Process `#[should_panic(expected = "..")]` macro (NOTE: Same as branch above)
+    (continue: name=$name:ident body=[$($item:tt)*] attrs=[#[should_panic(expected = $expected:literal)] $(#[$($attr:tt)+])*] $(ignore=$ignore:tt)?) => {
+        $crate::_private::test_parse!(continue:
+            name=$name
+            body=[$($item)*]
+            attrs=[$(#[$($attr)*])*]
+            $(ignore=$ignore)?
+            should_panic=[$expected]
         );
     };
     // Discard unknown attributes
-    (continue: name=$name:ident body=[$($item:tt)*] attrs=[#[$($unknown_attr:tt)+] $(#[$($attr:tt)+])*] $(ignore=$ignore:tt)?) => {
+    (continue: name=$name:ident body=[$($item:tt)*] attrs=[#[$($unknown_attr:tt)+] $(#[$($attr:tt)+])*] $(ignore=$ignore:tt)? $(should_panic=$should_panic:tt)?) => {
         $crate::_private::test_parse!(continue:
             name=$name
             body=[$($item)*]
             attrs=[$(#[$($attr)*])*]
             $(ignore=$ignore)?
+            $(should_panic=$should_panic)?
         );
     };
 
@@ -83,13 +106,12 @@ macro_rules! _test_parse {
                 )?
 
                 use $crate::IntoRunResult;
-                let result = run(context);
+                let result = $crate::_private::run_test!(context, $($should_panic)?);
                 IntoRunResult::into_run_result(result)
             }
         }
     };
 }
-
 #[macro_export]
 macro_rules! _parse_ignore {
     ($context:expr, [$reason:literal]) => {
@@ -99,3 +121,80 @@ macro_rules! _parse_ignore {
         $context.ignore()
     };
 }
+
+#[macro_export]
+macro_rules! _run_test {
+    ($context:expr, [$($expected:literal)?]) => {
+        $crate::assert_panic!(run($context), $($expected)?)
+    };
+    ($context:expr $(,)?) => {{
+        run($context)
+    }};
+}
+
+#[macro_export]
+macro_rules! assert_panic {
+    ($f:expr, $expected:literal $(,)?) => {
+        match ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| $f)) {
+            // The test should have panicked, but didn't.
+            ::std::result::Result::Ok(_) => {
+                // TODO: Rust includes the source file location here, consider doing the same?
+                ::std::result::Result::Err($crate::RunError::fail("test did not panic as expected"))
+            }
+
+            // The test panicked, as expected.
+            ::std::result::Result::Err(payload) => {
+                // The `panic` information is just an `Any` object representing the
+                // value the panic was invoked with. For most panics (which use
+                // `panic!` like `println!`), this is either `&str` or `String`.
+                let maybe_panic_str = payload
+                    .downcast_ref::<::std::string::String>()
+                    .map(|s| s.as_str())
+                    .or_else(|| payload.downcast_ref::<&str>().copied());
+
+                // Enforce `$expected` to be a string literal
+                let expected: &'static str = $expected;
+
+                // Check the panic message against the expected message.
+                match maybe_panic_str {
+                    ::std::option::Option::Some(panic_str) if panic_str.contains(expected) => {
+                        ::std::result::Result::Ok(())
+                    }
+
+                    ::std::option::Option::Some(panic_str) => {
+                        let error_msg = ::std::format!(
+                            r#"panic did not contain expected string
+      panic message: {panic_str:?}
+ expected substring: {expected:?}"#
+                        );
+
+                        ::std::result::Result::Err($crate::RunError::fail(error_msg))
+                    }
+
+                    ::std::option::Option::None => {
+                        let type_id = (*payload).type_id();
+                        let error_msg = ::std::format!(
+                            r#"expected panic with string value,
+ found non-string value: `{type_id:?}`
+     expected substring: {expected:?}"#,
+                        );
+
+                        ::std::result::Result::Err($crate::RunError::fail(error_msg))
+                    }
+                }
+            }
+        }
+    };
+    ($f:expr $(,)?) => {
+        match ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| $f)) {
+            // The test should have panicked, but didn't.
+            ::std::result::Result::Ok(_) => {
+                // TODO: Rust includes the source file location here, consider doing the same?
+                ::std::result::Result::Err($crate::RunError::fail("test did not panic as expected"))
+            }
+
+            // The test panicked, as expected.
+            ::std::result::Result::Err(_) => Ok(()),
+        }
+    };
+}