From 54c97ae0a97144b79381a51f4a595e9b07e551d1 Mon Sep 17 00:00:00 2001 From: Mattia Penati Date: Fri, 5 Aug 2022 13:29:06 +0200 Subject: [PATCH] Functions replaced with macros for better error messages --- src/assert_err.rs | 23 +++---- src/assert_ge.rs | 16 ++--- src/assert_gt.rs | 15 +++-- src/assert_le.rs | 16 ++--- src/assert_lt.rs | 15 +++-- src/assert_matches.rs | 13 ++-- src/assert_none.rs | 23 +++---- src/assert_ok.rs | 23 +++---- src/assert_pending.rs | 23 +++---- src/assert_ready.rs | 23 +++---- src/assert_ready_err.rs | 23 +++---- src/assert_ready_ok.rs | 23 +++---- src/assert_some.rs | 23 +++---- src/panicking.rs | 134 +++++++++++++++++++++------------------- 14 files changed, 179 insertions(+), 214 deletions(-) diff --git a/src/assert_err.rs b/src/assert_err.rs index 8cb0cd2..4af776f 100644 --- a/src/assert_err.rs +++ b/src/assert_err.rs @@ -4,25 +4,20 @@ macro_rules! assert_err { ($cond:expr $(,)?) => { match $cond { Err(err) => err, - ok @ Ok(_) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Err(..)`"), - $crate::panicking::Value::Ref(&ok), - None, - ); - } + ok @ Ok(_) => $crate::assert_failed!( + $crate::panicking::Msg("`Err(..)`"), + $crate::panicking::Ref(&ok), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { Err(err) => err, - ok @ Ok(_) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Err(..)`"), - $crate::panicking::Value::Ref(&ok), - Some(format_args!($($arg)+)), - ); - } + ok @ Ok(_) => $crate::assert_failed!( + $crate::panicking::Msg("`Err(..)`"), + $crate::panicking::Ref(&ok), + $($arg)+ + ), } }; } diff --git a/src/assert_ge.rs b/src/assert_ge.rs index 8a96b6d..8e6de5e 100644 --- a/src/assert_ge.rs +++ b/src/assert_ge.rs @@ -3,22 +3,21 @@ macro_rules! assert_ge { ($left:expr, $right:expr $(,)?) => { match (&$left, &$right) { - (left, right) if !(*left >= *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left >= *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::GreaterEqual, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - None, + $crate::panicking::Ref(right), ), _ => {} } }; ($left:expr, $right:expr, $($arg:tt)+) => { match (&$left, &$right) { - (left, right) if !(*left >= *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left >= *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::GreaterEqual, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - Some(format_args!($($arg)+)), + $crate::panicking::Ref(right), + $($arg)+ ), _ => {} } @@ -54,5 +53,6 @@ mod tests { #[test] fn check_assert_ge_pass() { assert_ge!(2, 1); + assert_ge!(2, 2); } } diff --git a/src/assert_gt.rs b/src/assert_gt.rs index 86d3973..3001b78 100644 --- a/src/assert_gt.rs +++ b/src/assert_gt.rs @@ -3,22 +3,21 @@ macro_rules! assert_gt { ($left:expr, $right:expr $(,)?) => { match (&$left, &$right) { - (left, right) if !(*left > *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left > *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::Greater, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - None, + $crate::panicking::Ref(right), ), _ => {} } }; ($left:expr, $right:expr, $($arg:tt)+) => { match (&$left, &$right) { - (left, right) if !(*left > *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left > *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::Greater, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - Some(format_args!($($arg)+)), + $crate::panicking::Ref(right), + $($arg)+ ), _ => {} } diff --git a/src/assert_le.rs b/src/assert_le.rs index 6686ebb..9d82431 100644 --- a/src/assert_le.rs +++ b/src/assert_le.rs @@ -3,22 +3,21 @@ macro_rules! assert_le { ($left:expr, $right:expr $(,)?) => { match (&$left, &$right) { - (left, right) if !(*left <= *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left <= *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::LessEqual, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - None, + $crate::panicking::Ref(right), ), _ => {} } }; ($left:expr, $right:expr, $($arg:tt)+) => { match (&$left, &$right) { - (left, right) if !(*left <= *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left <= *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::LessEqual, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - Some(format_args!($($arg)+)), + $crate::panicking::Ref(right), + $($arg)+ ), _ => {} } @@ -54,5 +53,6 @@ mod tests { #[test] fn check_assert_le_pass() { assert_le!(1, 2); + assert_le!(2, 2); } } diff --git a/src/assert_lt.rs b/src/assert_lt.rs index 9eea42a..3ccea8c 100644 --- a/src/assert_lt.rs +++ b/src/assert_lt.rs @@ -3,22 +3,21 @@ macro_rules! assert_lt { ($left:expr, $right:expr $(,)?) => { match (&$left, &$right) { - (left, right) if !(*left <= *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left < *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::Less, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - None, + $crate::panicking::Ref(right), ), _ => {} } }; ($left:expr, $right:expr, $($arg:tt)+) => { match (&$left, &$right) { - (left, right) if !(*left <= *right) => $crate::panicking::assert_comparison_failed( + (left, right) if !(*left < *right) => $crate::assert_comparison_failed!( + $crate::panicking::Ref(left), $crate::panicking::Comparison::Less, - $crate::panicking::Value::Ref(left), - $crate::panicking::Value::Ref(right), - Some(format_args!($($arg)+)), + $crate::panicking::Ref(right), + $($arg)+ ), _ => {} } diff --git a/src/assert_matches.rs b/src/assert_matches.rs index ffc4eff..8527440 100644 --- a/src/assert_matches.rs +++ b/src/assert_matches.rs @@ -4,20 +4,19 @@ macro_rules! assert_matches { ($expression:expr, $($pattern:pat_param)|+ $(if $guard:expr)? $(,)?) => { match $expression { $($pattern)|+ $(if $guard)? => {}, - other => $crate::panicking::assert_matches_failed( - $crate::panicking::Value::Ref(&other), + other => $crate::assert_matches_failed!( + $crate::panicking::Ref(&other), stringify!($($pattern)|+ $(if $guard)?), - None, - ) + ), } }; ($expression:expr, $($pattern:pat_param)|+ $(if $guard:expr)?, $($arg:tt)+) => { match $expression { $($pattern)|+ $(if $guard)? => {}, - other => $crate::panicking::assert_matches_failed( - $crate::panicking::Value::Ref(&other), + other => $crate::assert_matches_failed!( + $crate::panicking::Ref(&other), stringify!($($pattern)|+ $(if $guard)?), - Some(format_args!($($arg)+)), + $($arg)+ ) } }; diff --git a/src/assert_none.rs b/src/assert_none.rs index 10148a4..5c85647 100644 --- a/src/assert_none.rs +++ b/src/assert_none.rs @@ -4,25 +4,20 @@ macro_rules! assert_none { ($cond:expr $(,)?) => { match $cond { none @ None => none, - some @ Some(_) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Ref(&None), - $crate::panicking::Value::Ref(&some), - None, - ); - } + some @ Some(_) => $crate::assert_failed!( + $crate::panicking::Msg("`None`"), + $crate::panicking::Ref(&some), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { none @ None => none, - value @ Some(_) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Ref(&None), - $crate::panicking::Value::Ref(&value), - Some(format_args!($($arg)+)), - ); - } + some @ Some(_) => $crate::assert_failed!( + $crate::panicking::Msg("`None`"), + $crate::panicking::Ref(&some), + $($arg)+ + ), } }; } diff --git a/src/assert_ok.rs b/src/assert_ok.rs index c24a7cd..1d75853 100644 --- a/src/assert_ok.rs +++ b/src/assert_ok.rs @@ -4,25 +4,20 @@ macro_rules! assert_ok { ($cond:expr $(,)?) => { match $cond { Ok(value) => value, - err @ Err(..) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ok(..)`"), - $crate::panicking::Value::Ref(&err), - None, - ); - } + err @ Err(..) => $crate::assert_failed!( + $crate::panicking::Msg("`Ok(..)`"), + $crate::panicking::Ref(&err), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { Ok(value) => value, - err @ Err(..) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ok(..)`"), - $crate::panicking::Value::Ref(&err), - Some(format_args!($($arg)+)), - ); - } + err @ Err(..) => $crate::assert_failed!( + $crate::panicking::Msg("`Ok(..)`"), + $crate::panicking::Ref(&err), + $($arg)+ + ), } }; } diff --git a/src/assert_pending.rs b/src/assert_pending.rs index 5137d6d..51f0894 100644 --- a/src/assert_pending.rs +++ b/src/assert_pending.rs @@ -6,25 +6,20 @@ macro_rules! assert_pending { ($cond:expr $(,)?) => { match $cond { pending @ core::task::Poll::Pending => pending, - ready @ core::task::Poll::Ready(_) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Ref(&core::task::Poll::Pending), - $crate::panicking::Value::Ref(&ready), - None, - ); - } + ready @ core::task::Poll::Ready(_) => $crate::assert_failed!( + $crate::panicking::Msg("`Pending`"), + $crate::panicking::Ref(&ready), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { pending @ core::task::Poll::Pending => pending, - ready @ core::task::Poll::Ready(_) => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Ref(&core::task::Poll::Pending), - $crate::panicking::Value::Ref(&ready), - Some(format_args!($($arg)+)), - ); - } + ready @ core::task::Poll::Ready(_) => $crate::assert_failed!( + $crate::panicking::Msg("`Pending`"), + $crate::panicking::Ref(&ready), + $($arg)+ + ), } }; } diff --git a/src/assert_ready.rs b/src/assert_ready.rs index fe4ce27..ce0f25e 100644 --- a/src/assert_ready.rs +++ b/src/assert_ready.rs @@ -6,25 +6,20 @@ macro_rules! assert_ready { ($cond:expr $(,)?) => { match $cond { core::task::Poll::Ready(t) => t, - pending @ core::task::Poll::Pending => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ready(..)`"), - $crate::panicking::Value::Ref(&pending), - None, - ); - } + pending @ core::task::Poll::Pending => $crate::assert_failed!( + $crate::panicking::Msg("`Ready(..)`"), + $crate::panicking::Ref(&pending), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { core::task::Poll::Ready(t) => t, - pending @ core::task::Poll::Pending => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ready(..)`"), - $crate::panicking::Value::Ref(&pending), - Some(format_args!($($arg)+)), - ); - } + pending @ core::task::Poll::Pending => $crate::assert_failed!( + $crate::panicking::Msg("`Ready(..)`"), + $crate::panicking::Ref(&pending), + $($arg)+ + ), } }; } diff --git a/src/assert_ready_err.rs b/src/assert_ready_err.rs index 02abe86..eaf827b 100644 --- a/src/assert_ready_err.rs +++ b/src/assert_ready_err.rs @@ -6,25 +6,20 @@ macro_rules! assert_ready_err { ($cond:expr $(,)?) => { match $cond { core::task::Poll::Ready(Err(err)) => err, - poll => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ready(Err(..))`"), - $crate::panicking::Value::Ref(&poll), - None, - ); - } + poll => $crate::assert_failed!( + $crate::panicking::Msg("`Ready(Err(..))`"), + $crate::panicking::Ref(&poll), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { core::task::Poll::Ready(Err(err)) => err, - poll => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ready(Err(..))`"), - $crate::panicking::Value::Ref(&poll), - Some(format_args!($($arg)+)), - ); - } + poll => $crate::assert_failed!( + $crate::panicking::Msg("`Ready(Err(..))`"), + $crate::panicking::Ref(&poll), + $($arg)+ + ), } }; } diff --git a/src/assert_ready_ok.rs b/src/assert_ready_ok.rs index d774594..e572c35 100644 --- a/src/assert_ready_ok.rs +++ b/src/assert_ready_ok.rs @@ -6,25 +6,20 @@ macro_rules! assert_ready_ok { ($cond:expr $(,)?) => { match $cond { core::task::Poll::Ready(Ok(ok)) => ok, - poll => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ready(Ok(..))`"), - $crate::panicking::Value::Ref(&poll), - None, - ); - } + poll => $crate::assert_failed!( + $crate::panicking::Msg("`Ready(Ok(..))`"), + $crate::panicking::Ref(&poll), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { core::task::Poll::Ready(Ok(ok)) => ok, - poll => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Ready(Ok(..))`"), - $crate::panicking::Value::Ref(&poll), - Some(format_args!($($arg)+)), - ); - } + poll => $crate::assert_failed!( + $crate::panicking::Msg("`Ready(Ok(..))`"), + $crate::panicking::Ref(&poll), + $($arg)+ + ), } }; } diff --git a/src/assert_some.rs b/src/assert_some.rs index 510e901..afd2f86 100644 --- a/src/assert_some.rs +++ b/src/assert_some.rs @@ -4,25 +4,20 @@ macro_rules! assert_some { ($cond:expr $(,)?) => { match $cond { Some(value) => value, - none @ None => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Some(..)`"), - $crate::panicking::Value::Ref(&none), - None, - ); - } + none @ None => $crate::assert_failed!( + $crate::panicking::Msg("`Some(..)`"), + $crate::panicking::Ref(&none), + ), } }; ($cond:expr, $($arg:tt)+) => { match $cond { Some(value) => value, - none @ None => { - $crate::panicking::assert_failed( - $crate::panicking::Value::Str("`Some(..)`"), - $crate::panicking::Value::Ref(&none), - Some(format_args!($($arg)+)), - ); - } + none @ None => $crate::assert_failed!( + $crate::panicking::Msg("`Some(..)`"), + $crate::panicking::Ref(&none), + $($arg)+ + ), } }; } diff --git a/src/panicking.rs b/src/panicking.rs index 5a6f57b..7cc41cb 100644 --- a/src/panicking.rs +++ b/src/panicking.rs @@ -14,54 +14,26 @@ impl<'a, T: fmt::Debug> fmt::Debug for Value<'a, T> { } } } - -/// Internal function for `assert_*!` macros. #[doc(hidden)] -pub fn assert_failed( - expected: Value<'_, T>, - unexpected: Value<'_, T>, - args: Option>, -) -> ! +pub struct Ref<'a, T>(pub &'a T); + +impl<'a, T> fmt::Debug for Ref<'a, T> where T: fmt::Debug, { - match args { - Some(args) => core::panic!( - "assertion failed: expected {:?}, got {:?}\n{}", - expected, - unexpected, - args, - ), - None => core::panic!( - "assertion failed: expected {:?}, got {:?}", - expected, - unexpected, - ), + #[inline(always)] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "`{:?}`", self.0) } } -/// Internal function for `assert_matches!` macro. #[doc(hidden)] -pub fn assert_matches_failed( - unexpected: Value<'_, T>, - variants: &'static str, - args: Option>, -) -> ! -where - T: fmt::Debug, -{ - match args { - Some(args) => core::panic!( - "assertion failed: expression does not match any of the given variants, got {:?}\nvariants: `{}`\n{}", - unexpected, - variants, - args, - ), - None => core::panic!( - "assertion failed: expression does not match any of the given variants, got {:?}\nvariants: `{}`", - unexpected, - variants, - ), +pub struct Msg(pub &'static str); + +impl fmt::Debug for Msg { + #[inline(always)] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.0) } } @@ -84,31 +56,67 @@ impl fmt::Display for Comparison { } } +/// Internal macro for `assert_*!` macros. +#[doc(hidden)] +#[macro_export] +macro_rules! assert_failed { + ($expected:expr, $unexpected:expr, $($arg:tt)+) => { + core::panic!( + "assertion failed: expected {:?}, got {:?}\n{}", + $expected, + $unexpected, + core::format_args!($($arg)+) + ) + }; + ($expected:expr, $unexpected:expr $(,)?) => { + core::panic!( + "assertion failed: expected {:?}, got {:?}", + $expected, + $unexpected + ) + }; +} + +/// Internal function for `assert_matches!` macro. +#[doc(hidden)] +#[macro_export] +macro_rules! assert_matches_failed { + ($unexpected:expr, $variants:expr, $($arg:tt)+) => { + core::panic!( + "assertion failed: expression does not match any of the given variants, got {:?}\nvariants: `{}`\n{}", + $unexpected, + $variants, + core::format_args!($($arg)+) + ) + }; + ($unexpected:expr, $variants:expr $(,)?) => { + core::panic!( + "assertion failed: expression does not match any of the given variants, got {:?}\nvariants: `{}`", + $unexpected, + $variants, + ) + }; +} + /// Internal function for `assert_*` comparison macros. #[doc(hidden)] -pub fn assert_comparison_failed( - cmp: Comparison, - left: Value<'_, L>, - right: Value<'_, R>, - args: Option>, -) -> ! -where - L: fmt::Debug, - R: fmt::Debug, -{ - match args { - Some(args) => core::panic!( +#[macro_export] +macro_rules! assert_comparison_failed { + ($left:expr, $cmp:expr, $right:expr, $($arg:tt)+) => { + core::panic!( "assertion failed: left {} right\n left: {:?}\nright: {:?}\n{}", - cmp, - left, - right, - args, - ), - None => core::panic!( + $cmp, + $left, + $right, + core::format_args!($($arg)+) + ) + }; + ($left:expr, $cmp:expr, $right:expr $(,)?) => { + core::panic!( "assertion failed: left {} right\n left: {:?}\nright: {:?}", - cmp, - left, - right, - ), - } + $cmp, + $left, + $right, + ) + }; }