diff options
Diffstat (limited to 'third_party/rust/failure_derive/tests')
5 files changed, 283 insertions, 0 deletions
diff --git a/third_party/rust/failure_derive/tests/backtrace.rs b/third_party/rust/failure_derive/tests/backtrace.rs new file mode 100644 index 0000000000..a307184112 --- /dev/null +++ b/third_party/rust/failure_derive/tests/backtrace.rs @@ -0,0 +1,64 @@ +extern crate failure; +#[macro_use] +extern crate failure_derive; + +use failure::{Backtrace, Fail}; + +#[derive(Fail, Debug)] +#[fail(display = "Error code: {}", code)] +struct BacktraceError { + backtrace: Backtrace, + code: u32, +} + +#[test] +fn backtrace_error() { + let err = BacktraceError { + backtrace: Backtrace::new(), + code: 7, + }; + let s = format!("{}", err); + assert_eq!(&s[..], "Error code: 7"); + assert!(err.backtrace().is_some()); +} + +#[derive(Fail, Debug)] +#[fail(display = "An error has occurred.")] +struct BacktraceTupleError(Backtrace); + +#[test] +fn backtrace_tuple_error() { + let err = BacktraceTupleError(Backtrace::new()); + let s = format!("{}", err); + assert_eq!(&s[..], "An error has occurred."); + assert!(err.backtrace().is_some()); +} + +#[derive(Fail, Debug)] +enum BacktraceEnumError { + #[fail(display = "Error code: {}", code)] + StructVariant { code: i32, backtrace: Backtrace }, + #[fail(display = "Error: {}", _0)] + TupleVariant(&'static str, Backtrace), + #[fail(display = "An error has occurred.")] + UnitVariant, +} + +#[test] +fn backtrace_enum_error() { + let err = BacktraceEnumError::StructVariant { + code: 2, + backtrace: Backtrace::new(), + }; + let s = format!("{}", err); + assert_eq!(&s[..], "Error code: 2"); + assert!(err.backtrace().is_some()); + let err = BacktraceEnumError::TupleVariant("foobar", Backtrace::new()); + let s = format!("{}", err); + assert_eq!(&s[..], "Error: foobar"); + assert!(err.backtrace().is_some()); + let err = BacktraceEnumError::UnitVariant; + let s = format!("{}", err); + assert_eq!(&s[..], "An error has occurred."); + assert!(err.backtrace().is_none()); +} diff --git a/third_party/rust/failure_derive/tests/custom_type_bounds.rs b/third_party/rust/failure_derive/tests/custom_type_bounds.rs new file mode 100644 index 0000000000..fd1c8b975b --- /dev/null +++ b/third_party/rust/failure_derive/tests/custom_type_bounds.rs @@ -0,0 +1,45 @@ +#[macro_use] +extern crate failure; + +use std::fmt::Debug; + +use failure::Fail; + +#[derive(Debug, Fail)] +#[fail(display = "An error has occurred.")] +pub struct UnboundedGenericTupleError<T: 'static + Debug + Send + Sync>(T); + +#[test] +fn unbounded_generic_tuple_error() { + let s = format!("{}", UnboundedGenericTupleError(())); + assert_eq!(&s[..], "An error has occurred."); +} + +#[derive(Debug, Fail)] +#[fail(display = "An error has occurred: {}", _0)] +pub struct FailBoundsGenericTupleError<T: Fail>(T); + +#[test] +fn fail_bounds_generic_tuple_error() { + let error = FailBoundsGenericTupleError(UnboundedGenericTupleError(())); + let s = format!("{}", error); + assert_eq!(&s[..], "An error has occurred: An error has occurred."); +} + +pub trait NoDisplay: 'static + Debug + Send + Sync {} + +impl NoDisplay for &'static str {} + +#[derive(Debug, Fail)] +#[fail(display = "An error has occurred: {:?}", _0)] +pub struct CustomBoundsGenericTupleError<T: NoDisplay>(T); + +#[test] +fn custom_bounds_generic_tuple_error() { + let error = CustomBoundsGenericTupleError("more details unavailable."); + let s = format!("{}", error); + assert_eq!( + &s[..], + "An error has occurred: \"more details unavailable.\"" + ); +} diff --git a/third_party/rust/failure_derive/tests/no_derive_display.rs b/third_party/rust/failure_derive/tests/no_derive_display.rs new file mode 100644 index 0000000000..20eeb308c2 --- /dev/null +++ b/third_party/rust/failure_derive/tests/no_derive_display.rs @@ -0,0 +1,21 @@ +extern crate failure; +#[macro_use] +extern crate failure_derive; + +use failure::Fail; +use std::fmt::{self, Display}; + +#[derive(Debug, Fail)] +struct Foo; + +impl Display for Foo { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("An error occurred.") + } +} + +#[test] +fn handwritten_display() { + assert!(Foo.cause().is_none()); + assert_eq!(&format!("{}", Foo)[..], "An error occurred."); +} diff --git a/third_party/rust/failure_derive/tests/tests.rs b/third_party/rust/failure_derive/tests/tests.rs new file mode 100644 index 0000000000..4e73255ef3 --- /dev/null +++ b/third_party/rust/failure_derive/tests/tests.rs @@ -0,0 +1,55 @@ +extern crate failure; +#[macro_use] +extern crate failure_derive; + +#[derive(Fail, Debug)] +#[fail(display = "An error has occurred.")] +struct UnitError; + +#[test] +fn unit_struct() { + let s = format!("{}", UnitError); + assert_eq!(&s[..], "An error has occurred."); +} + +#[derive(Fail, Debug)] +#[fail(display = "Error code: {}", code)] +struct RecordError { + code: u32, +} + +#[test] +fn record_struct() { + let s = format!("{}", RecordError { code: 0 }); + assert_eq!(&s[..], "Error code: 0"); +} + +#[derive(Fail, Debug)] +#[fail(display = "Error code: {}", _0)] +struct TupleError(i32); + +#[test] +fn tuple_struct() { + let s = format!("{}", TupleError(2)); + assert_eq!(&s[..], "Error code: 2"); +} + +#[derive(Fail, Debug)] +enum EnumError { + #[fail(display = "Error code: {}", code)] + StructVariant { code: i32 }, + #[fail(display = "Error: {}", _0)] + TupleVariant(&'static str), + #[fail(display = "An error has occurred.")] + UnitVariant, +} + +#[test] +fn enum_error() { + let s = format!("{}", EnumError::StructVariant { code: 2 }); + assert_eq!(&s[..], "Error code: 2"); + let s = format!("{}", EnumError::TupleVariant("foobar")); + assert_eq!(&s[..], "Error: foobar"); + let s = format!("{}", EnumError::UnitVariant); + assert_eq!(&s[..], "An error has occurred."); +} diff --git a/third_party/rust/failure_derive/tests/wraps.rs b/third_party/rust/failure_derive/tests/wraps.rs new file mode 100644 index 0000000000..9144325cad --- /dev/null +++ b/third_party/rust/failure_derive/tests/wraps.rs @@ -0,0 +1,98 @@ +extern crate failure; +#[macro_use] +extern crate failure_derive; + +use std::fmt; +use std::io; + +use failure::{Backtrace, Fail}; + +#[derive(Fail, Debug)] +#[fail(display = "An error has occurred: {}", inner)] +struct WrapError { + #[fail(cause)] + inner: io::Error, +} + +#[test] +fn wrap_error() { + let inner = io::Error::from_raw_os_error(98); + let err = WrapError { inner }; + assert!(err + .cause() + .and_then(|err| err.downcast_ref::<io::Error>()) + .is_some()); +} + +#[derive(Fail, Debug)] +#[fail(display = "An error has occurred: {}", _0)] +struct WrapTupleError(#[fail(cause)] io::Error); + +#[test] +fn wrap_tuple_error() { + let io_error = io::Error::from_raw_os_error(98); + let err: WrapTupleError = WrapTupleError(io_error); + assert!(err + .cause() + .and_then(|err| err.downcast_ref::<io::Error>()) + .is_some()); +} + +#[derive(Fail, Debug)] +#[fail(display = "An error has occurred: {}", inner)] +struct WrapBacktraceError { + #[fail(cause)] + inner: io::Error, + backtrace: Backtrace, +} + +#[test] +fn wrap_backtrace_error() { + let inner = io::Error::from_raw_os_error(98); + let err: WrapBacktraceError = WrapBacktraceError { + inner, + backtrace: Backtrace::new(), + }; + assert!(err + .cause() + .and_then(|err| err.downcast_ref::<io::Error>()) + .is_some()); + assert!(err.backtrace().is_some()); + assert!(err.backtrace().unwrap().is_empty()); + assert!(err.backtrace().unwrap().to_string().trim().is_empty()); +} + +#[derive(Fail, Debug)] +enum WrapEnumError { + #[fail(display = "An error has occurred: {}", _0)] + Io(#[fail(cause)] io::Error), + #[fail(display = "An error has occurred: {}", inner)] + Fmt { + #[fail(cause)] + inner: fmt::Error, + backtrace: Backtrace, + }, +} + +#[test] +fn wrap_enum_error() { + let io_error = io::Error::from_raw_os_error(98); + let err: WrapEnumError = WrapEnumError::Io(io_error); + assert!(err + .cause() + .and_then(|err| err.downcast_ref::<io::Error>()) + .is_some()); + assert!(err.backtrace().is_none()); + let fmt_error = fmt::Error::default(); + let err: WrapEnumError = WrapEnumError::Fmt { + inner: fmt_error, + backtrace: Backtrace::new(), + }; + assert!(err + .cause() + .and_then(|err| err.downcast_ref::<fmt::Error>()) + .is_some()); + assert!(err.backtrace().is_some()); + assert!(err.backtrace().unwrap().is_empty()); + assert!(err.backtrace().unwrap().to_string().trim().is_empty()); +} |