138 lines
3.1 KiB
Rust
138 lines
3.1 KiB
Rust
use {
|
|
crate::utils::errorfmt::ErrorFmt,
|
|
std::{
|
|
error::Error,
|
|
fmt::{Debug, Display, Formatter},
|
|
},
|
|
};
|
|
|
|
pub type TestResult<T = ()> = Result<T, TestError>;
|
|
|
|
pub struct TestError {
|
|
error: Box<dyn Error + 'static>,
|
|
source: Option<Box<TestError>>,
|
|
}
|
|
|
|
impl TestError {
|
|
pub fn new<D: Display + 'static>(d: D) -> Self {
|
|
Self {
|
|
error: Box::new(DisplayError { msg: d }),
|
|
source: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct DisplayError<T: Display> {
|
|
msg: T,
|
|
}
|
|
|
|
impl<T: Display> Debug for DisplayError<T> {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
Display::fmt(&self.msg, f)
|
|
}
|
|
}
|
|
|
|
impl<T: Display> Display for DisplayError<T> {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
Display::fmt(&self.msg, f)
|
|
}
|
|
}
|
|
|
|
impl<T: Display> Error for DisplayError<T> {}
|
|
|
|
impl Debug for TestError {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("TestError")
|
|
.field("error", &self.error)
|
|
.field("source", &self.source)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
impl Display for TestError {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
let mut e_prev = self;
|
|
let mut e_opt = Some(self);
|
|
let mut first = true;
|
|
while let Some(e) = e_opt {
|
|
if first {
|
|
write!(f, "{}", e.error)?;
|
|
first = false;
|
|
} else {
|
|
write!(f, ": {}", e.error)?;
|
|
}
|
|
e_prev = e;
|
|
e_opt = e.source.as_deref();
|
|
}
|
|
if let Some(e) = e_prev.error.source() {
|
|
write!(f, ": ")?;
|
|
ErrorFmt(e).fmt(f)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<T: Error + 'static> From<T> for TestError {
|
|
fn from(error: T) -> Self {
|
|
Self {
|
|
error: Box::new(error),
|
|
source: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait TestErrorExt {
|
|
type Context;
|
|
|
|
fn with_context<T, F>(self, f: F) -> Self::Context
|
|
where
|
|
T: Display + 'static,
|
|
F: FnOnce() -> T;
|
|
}
|
|
|
|
impl<T, E> TestErrorExt for Result<T, E>
|
|
where
|
|
E: StdError,
|
|
{
|
|
type Context = Result<T, TestError>;
|
|
|
|
fn with_context<D, F>(self, f: F) -> Self::Context
|
|
where
|
|
D: Display + 'static,
|
|
F: FnOnce() -> D,
|
|
{
|
|
match self {
|
|
Ok(v) => Ok(v),
|
|
Err(e) => Err(e.with_context(f())),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait StdError: 'static {
|
|
fn with_context<D: Display + 'static>(self, d: D) -> TestError;
|
|
}
|
|
|
|
impl<E: Error + 'static> StdError for E {
|
|
fn with_context<D: Display + 'static>(self, d: D) -> TestError {
|
|
TestError {
|
|
error: Box::new(DisplayError { msg: d }),
|
|
source: Some(Box::new(self.into())),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl StdError for TestError {
|
|
fn with_context<D: Display + 'static>(self, d: D) -> TestError {
|
|
TestError {
|
|
error: Box::new(DisplayError { msg: d }),
|
|
source: Some(Box::new(self)),
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! bail {
|
|
($($tt:tt)*) => {{
|
|
let msg = format!($($tt)*);
|
|
return Err(crate::it::test_error::TestError::new(msg));
|
|
}}
|
|
}
|