diff options
Diffstat (limited to 'vendor/derive_more/tests')
36 files changed, 4515 insertions, 0 deletions
diff --git a/vendor/derive_more/tests/add.rs b/vendor/derive_more/tests/add.rs new file mode 100644 index 000000000..f9ec5a77f --- /dev/null +++ b/vendor/derive_more/tests/add.rs @@ -0,0 +1,23 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +#[derive(Add)] +struct MyInts(i32, i32); + +#[derive(Add)] +struct Point2D { + x: i32, + y: i32, +} + +#[derive(Add)] +enum MixedInts { + SmallInt(i32), + BigInt(i64), + TwoSmallInts(i32, i32), + NamedSmallInts { x: i32, y: i32 }, + UnsignedOne(u32), + UnsignedTwo(u32), + Unit, +} diff --git a/vendor/derive_more/tests/add_assign.rs b/vendor/derive_more/tests/add_assign.rs new file mode 100644 index 000000000..32681787c --- /dev/null +++ b/vendor/derive_more/tests/add_assign.rs @@ -0,0 +1,12 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +#[derive(AddAssign)] +struct MyInts(i32, i32); + +#[derive(AddAssign)] +struct Point2D { + x: i32, + y: i32, +} diff --git a/vendor/derive_more/tests/as_mut.rs b/vendor/derive_more/tests/as_mut.rs new file mode 100644 index 000000000..e074f8b02 --- /dev/null +++ b/vendor/derive_more/tests/as_mut.rs @@ -0,0 +1,108 @@ +#![allow(dead_code)] + +#[macro_use] +extern crate derive_more; + +use std::path::PathBuf; +use std::ptr; + +#[derive(AsMut)] +struct SingleFieldTuple(String); + +#[test] +fn single_field_tuple() { + let mut item = SingleFieldTuple(String::from("test")); + + assert!(ptr::eq(&mut item.0, item.as_mut())); +} + +#[derive(AsMut)] +#[as_mut(forward)] +struct SingleFieldForward(Vec<i32>); + +#[test] +fn single_field_forward() { + let mut item = SingleFieldForward(vec![]); + let _: &mut [i32] = (&mut item).as_mut(); +} + +#[derive(AsMut)] +struct SingleFieldStruct { + first: String, +} + +#[test] +fn single_field_struct() { + let mut item = SingleFieldStruct { + first: String::from("test"), + }; + + assert!(ptr::eq(&mut item.first, item.as_mut())); +} + +#[derive(AsMut)] +struct MultiFieldTuple(#[as_mut] String, #[as_mut] PathBuf, Vec<usize>); + +#[test] +fn multi_field_tuple() { + let mut item = MultiFieldTuple(String::from("test"), PathBuf::new(), vec![]); + + assert!(ptr::eq(&mut item.0, item.as_mut())); + assert!(ptr::eq(&mut item.1, item.as_mut())); +} + +#[derive(AsMut)] +struct MultiFieldStruct { + #[as_mut] + first: String, + #[as_mut] + second: PathBuf, + third: Vec<usize>, +} + +#[test] +fn multi_field_struct() { + let mut item = MultiFieldStruct { + first: String::from("test"), + second: PathBuf::new(), + third: vec![], + }; + + assert!(ptr::eq(&mut item.first, item.as_mut())); + assert!(ptr::eq(&mut item.second, item.as_mut())); +} + +#[derive(AsMut)] +struct SingleFieldGenericStruct<T> { + first: T, +} + +#[test] +fn single_field_generic_struct() { + let mut item = SingleFieldGenericStruct { + first: String::from("test"), + }; + + assert!(ptr::eq(&mut item.first, item.as_mut())); +} + +#[derive(AsMut)] +struct MultiFieldGenericStruct<T> { + #[as_mut] + first: Vec<T>, + #[as_mut] + second: PathBuf, + third: Vec<usize>, +} + +#[test] +fn multi_field_generic_struct() { + let mut item = MultiFieldGenericStruct { + first: b"test".to_vec(), + second: PathBuf::new(), + third: vec![], + }; + + assert!(ptr::eq(&mut item.first, item.as_mut())); + assert!(ptr::eq(&mut item.second, item.as_mut())); +} diff --git a/vendor/derive_more/tests/as_ref.rs b/vendor/derive_more/tests/as_ref.rs new file mode 100644 index 000000000..1e355d28f --- /dev/null +++ b/vendor/derive_more/tests/as_ref.rs @@ -0,0 +1,108 @@ +#![allow(dead_code)] + +#[macro_use] +extern crate derive_more; + +use std::path::PathBuf; +use std::ptr; + +#[derive(AsRef)] +struct SingleFieldTuple(String); + +#[test] +fn single_field_tuple() { + let item = SingleFieldTuple(String::from("test")); + + assert!(ptr::eq(&item.0, item.as_ref())); +} + +#[derive(AsRef)] +#[as_ref(forward)] +struct SingleFieldForward(Vec<i32>); + +#[test] +fn single_field_forward() { + let item = SingleFieldForward(vec![]); + let _: &[i32] = (&item).as_ref(); +} + +#[derive(AsRef)] +struct SingleFieldStruct { + first: String, +} + +#[test] +fn single_field_struct() { + let item = SingleFieldStruct { + first: String::from("test"), + }; + + assert!(ptr::eq(&item.first, item.as_ref())); +} + +#[derive(AsRef)] +struct MultiFieldTuple(#[as_ref] String, #[as_ref] PathBuf, Vec<usize>); + +#[test] +fn multi_field_tuple() { + let item = MultiFieldTuple(String::from("test"), PathBuf::new(), vec![]); + + assert!(ptr::eq(&item.0, item.as_ref())); + assert!(ptr::eq(&item.1, item.as_ref())); +} + +#[derive(AsRef)] +struct MultiFieldStruct { + #[as_ref] + first: String, + #[as_ref] + second: PathBuf, + third: Vec<usize>, +} + +#[test] +fn multi_field_struct() { + let item = MultiFieldStruct { + first: String::from("test"), + second: PathBuf::new(), + third: vec![], + }; + + assert!(ptr::eq(&item.first, item.as_ref())); + assert!(ptr::eq(&item.second, item.as_ref())); +} + +#[derive(AsRef)] +struct SingleFieldGenericStruct<T> { + first: T, +} + +#[test] +fn single_field_generic_struct() { + let item = SingleFieldGenericStruct { + first: String::from("test"), + }; + + assert!(ptr::eq(&item.first, item.as_ref())); +} + +#[derive(AsRef)] +struct MultiFieldGenericStruct<T, U> { + #[as_ref] + first: Vec<T>, + #[as_ref] + second: [U; 2], + third: Vec<usize>, +} + +#[test] +fn multi_field_generic_struct() { + let item = MultiFieldGenericStruct { + first: b"test".to_vec(), + second: [0i32, 1i32], + third: vec![], + }; + + assert!(ptr::eq(&item.first, item.as_ref())); + assert!(ptr::eq(&item.second, item.as_ref())); +} diff --git a/vendor/derive_more/tests/boats_display_derive.rs b/vendor/derive_more/tests/boats_display_derive.rs new file mode 100644 index 000000000..b64f75df8 --- /dev/null +++ b/vendor/derive_more/tests/boats_display_derive.rs @@ -0,0 +1,57 @@ +// The following code is from https://github.com/withoutboats/display_derive/blob/232a32ee19e262aacbd2c93be5b4ce9e89a5fc30/tests/tests.rs +// Written by without boats originally + +#[macro_use] +extern crate derive_more; + +#[derive(Display)] +#[display(fmt = "An error has occurred.")] +struct UnitError; + +#[test] +fn unit_struct() { + let s = format!("{}", UnitError); + assert_eq!(&s[..], "An error has occurred."); +} + +#[derive(Display)] +#[display(fmt = "Error code: {}", code)] +struct RecordError { + code: u32, +} + +#[test] +fn record_struct() { + let s = format!("{}", RecordError { code: 0 }); + assert_eq!(&s[..], "Error code: 0"); +} + +#[derive(Display)] +#[display(fmt = "Error code: {}", _0)] +struct TupleError(i32); + +#[test] +fn tuple_struct() { + let s = format!("{}", TupleError(2)); + assert_eq!(&s[..], "Error code: 2"); +} + +#[derive(Display)] +enum EnumError { + #[display(fmt = "Error code: {}", code)] + StructVariant { code: i32 }, + #[display(fmt = "Error: {}", _0)] + TupleVariant(&'static str), + #[display(fmt = "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/vendor/derive_more/tests/constructor.rs b/vendor/derive_more/tests/constructor.rs new file mode 100644 index 000000000..07fddb883 --- /dev/null +++ b/vendor/derive_more/tests/constructor.rs @@ -0,0 +1,21 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +#[derive(Constructor)] +struct EmptyTuple(); + +#[derive(Constructor)] +struct EmptyStruct {} + +#[derive(Constructor)] +struct EmptyUnit; + +#[derive(Constructor)] +struct MyInts(i32, i32); + +#[derive(Constructor)] +struct Point2D { + x: i32, + y: i32, +} diff --git a/vendor/derive_more/tests/deref.rs b/vendor/derive_more/tests/deref.rs new file mode 100644 index 000000000..8227f88f9 --- /dev/null +++ b/vendor/derive_more/tests/deref.rs @@ -0,0 +1,68 @@ +#![allow(dead_code, unused_imports)] +#[macro_use] +extern crate derive_more; + +#[derive(Deref)] +#[deref(forward)] +struct MyBoxedInt(Box<i32>); + +#[derive(Deref)] +#[deref(forward)] +struct NumRef<'a> { + num: &'a i32, +} + +#[derive(Deref)] +struct NumRef2<'a> { + #[deref(forward)] + num: &'a i32, + useless: bool, +} + +#[derive(Deref)] +#[deref(forward)] +struct NumRef3<'a> { + num: &'a i32, + #[deref(ignore)] + useless: bool, +} + +#[derive(Deref)] +struct MyInt(i32); + +#[derive(Deref)] +struct Point1D { + x: i32, +} + +#[derive(Deref)] +struct Point1D2 { + x: i32, + #[deref(ignore)] + useless: bool, +} + +#[derive(Deref)] +struct CoolVec { + cool: bool, + #[deref] + vec: Vec<i32>, +} + +#[derive(Deref)] +struct GenericVec<T>(Vec<T>); + +#[test] +fn deref_generic() { + let gv = GenericVec(Vec::<i32>::new()); + assert!(gv.is_empty()) +} + +#[derive(Deref)] +struct GenericBox<T>(#[deref(forward)] Box<T>); + +#[test] +fn deref_generic_forward() { + let boxed = GenericBox(Box::new(1i32)); + assert_eq!(*boxed, 1i32); +} diff --git a/vendor/derive_more/tests/deref_mut.rs b/vendor/derive_more/tests/deref_mut.rs new file mode 100644 index 000000000..51a95e4f2 --- /dev/null +++ b/vendor/derive_more/tests/deref_mut.rs @@ -0,0 +1,124 @@ +#![allow(dead_code, unused_imports)] +#[macro_use] +extern crate derive_more; + +#[derive(DerefMut)] +#[deref_mut(forward)] +struct MyBoxedInt(Box<i32>); +// Deref implementation is needed for DerefMut +impl ::core::ops::Deref for MyBoxedInt { + type Target = <Box<i32> as ::core::ops::Deref>::Target; + #[inline] + fn deref(&self) -> &Self::Target { + <Box<i32> as ::core::ops::Deref>::deref(&self.0) + } +} + +#[derive(DerefMut)] +struct NumRef<'a> { + #[deref_mut(forward)] + num: &'a mut i32, +} +// Deref implementation is needed for DerefMut +impl<'a> ::core::ops::Deref for NumRef<'a> { + type Target = <&'a mut i32 as ::core::ops::Deref>::Target; + #[inline] + fn deref(&self) -> &Self::Target { + <&'a mut i32 as ::core::ops::Deref>::deref(&self.num) + } +} + +#[derive(DerefMut)] +#[deref_mut(forward)] +struct NumRef2<'a> { + num: &'a mut i32, + #[deref_mut(ignore)] + useless: bool, +} + +// Deref implementation is needed for DerefMut +impl<'a> ::core::ops::Deref for NumRef2<'a> { + type Target = <&'a mut i32 as ::core::ops::Deref>::Target; + #[inline] + fn deref(&self) -> &Self::Target { + <&'a mut i32 as ::core::ops::Deref>::deref(&self.num) + } +} + +#[derive(DerefMut)] +struct MyInt(i32); + +// Deref implementation is needed for DerefMutToInner +impl ::core::ops::Deref for MyInt { + type Target = i32; + #[inline] + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +#[derive(DerefMut)] +struct Point1D { + x: i32, +} + +// Deref implementation is needed for DerefMutToInner +impl ::core::ops::Deref for Point1D { + type Target = i32; + #[inline] + fn deref(&self) -> &Self::Target { + &self.x + } +} + +#[derive(DerefMut)] +struct CoolVec { + cool: bool, + #[deref_mut] + vec: Vec<i32>, +} +impl ::core::ops::Deref for CoolVec { + type Target = Vec<i32>; + #[inline] + fn deref(&self) -> &Self::Target { + &self.vec + } +} + +#[derive(DerefMut)] +struct GenericVec<T>(Vec<T>); + +impl<T> ::core::ops::Deref for GenericVec<T> { + type Target = Vec<T>; + #[inline] + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +#[test] +fn deref_mut_generic() { + let mut gv = GenericVec::<i32>(vec![42]); + assert!(gv.get_mut(0).is_some()); +} + +#[derive(DerefMut)] +struct GenericBox<T>(#[deref_mut(forward)] Box<T>); + +impl<T> ::core::ops::Deref for GenericBox<T> +where + Box<T>: ::core::ops::Deref, +{ + type Target = <Box<T> as ::core::ops::Deref>::Target; + #[inline] + fn deref(&self) -> &Self::Target { + <Box<T> as ::core::ops::Deref>::deref(&self.0) + } +} + +#[test] +fn deref_mut_generic_forward() { + let mut boxed = GenericBox(Box::new(1i32)); + *boxed = 3; + assert_eq!(*boxed, 3i32); +} diff --git a/vendor/derive_more/tests/display.rs b/vendor/derive_more/tests/display.rs new file mode 100644 index 000000000..fae596b84 --- /dev/null +++ b/vendor/derive_more/tests/display.rs @@ -0,0 +1,429 @@ +#![allow(dead_code, unused_imports)] +#[macro_use] +extern crate derive_more; + +use std::path::PathBuf; + +// Here just to make sure that this doesn't conflict with +// the derives in some way +use std::fmt::Binary; + +#[derive(Display, Octal, Binary)] +struct MyInt(i32); + +#[derive(UpperHex)] +enum IntEnum { + U8(u8), + I8(i8), +} + +#[derive(Display)] +#[display(fmt = "({}, {})", x, y)] +struct Point2D { + x: i32, + y: i32, +} + +#[derive(Display)] +#[display(fmt = "{}", "self.sign()")] +struct PositiveOrNegative { + x: i32, +} + +impl PositiveOrNegative { + fn sign(&self) -> &str { + if self.x >= 0 { + "Positive" + } else { + "Negative" + } + } +} + +#[derive(Display)] +#[display(fmt = "{}", message)] +struct Error { + message: &'static str, + backtrace: (), +} + +impl Error { + fn new(message: &'static str) -> Self { + Self { + message, + backtrace: (), + } + } +} + +#[derive(Display)] +enum E { + Uint(u32), + #[display(fmt = "I am B {:b}", i)] + Binary { + i: i8, + }, + #[display(fmt = "I am C {}", "_0.display()")] + Path(PathBuf), +} + +#[derive(Display)] +#[display(fmt = "Java EE")] +enum EE { + A, + B, +} + +#[derive(Display)] +#[display(fmt = "Hello there!")] +union U { + i: u32, +} + +#[derive(Octal)] +#[octal(fmt = "7")] +struct S; + +#[derive(UpperHex)] +#[upper_hex(fmt = "UpperHex")] +struct UH; + +#[derive(DebugCustom)] +#[debug(fmt = "MyDebug")] +struct D; + +#[derive(Display)] +struct Unit; + +#[derive(Display)] +struct UnitStruct {} + +#[derive(Display)] +enum EmptyEnum {} + +#[derive(Display)] +#[display(fmt = "Generic")] +struct Generic<T>(T); + +#[derive(Display)] +#[display(fmt = "Here's a prefix for {} and a suffix")] +enum Affix { + A(u32), + #[display(fmt = "{} -- {}", wat, stuff)] + B { + wat: String, + stuff: bool, + }, +} + +#[derive(Debug, Display)] +#[display(fmt = "{:?}", self)] +struct DebugStructAsDisplay; + +#[test] +fn check_display() { + assert_eq!(MyInt(-2).to_string(), "-2"); + assert_eq!(format!("{:b}", MyInt(9)), "1001"); + assert_eq!(format!("{:#b}", MyInt(9)), "0b1001"); + assert_eq!(format!("{:o}", MyInt(9)), "11"); + assert_eq!(format!("{:X}", IntEnum::I8(-1)), "FF"); + assert_eq!(format!("{:#X}", IntEnum::U8(255)), "0xFF"); + assert_eq!(Point2D { x: 3, y: 4 }.to_string(), "(3, 4)"); + assert_eq!(PositiveOrNegative { x: 123 }.to_string(), "Positive"); + assert_eq!(PositiveOrNegative { x: 0 }.to_string(), "Positive"); + assert_eq!(PositiveOrNegative { x: -465 }.to_string(), "Negative"); + assert_eq!(Error::new("Error").to_string(), "Error"); + assert_eq!(E::Uint(2).to_string(), "2"); + assert_eq!(E::Binary { i: -2 }.to_string(), "I am B 11111110"); + assert_eq!(E::Path("abc".into()).to_string(), "I am C abc"); + assert_eq!(EE::A.to_string(), "Java EE"); + assert_eq!(EE::B.to_string(), "Java EE"); + assert_eq!(U { i: 2 }.to_string(), "Hello there!"); + assert_eq!(format!("{:o}", S), "7"); + assert_eq!(format!("{:X}", UH), "UpperHex"); + assert_eq!(format!("{:?}", D), "MyDebug"); + assert_eq!(Unit.to_string(), "Unit"); + assert_eq!(UnitStruct {}.to_string(), "UnitStruct"); + assert_eq!(Generic(()).to_string(), "Generic"); + assert_eq!( + Affix::A(2).to_string(), + "Here's a prefix for 2 and a suffix" + ); + assert_eq!( + Affix::B { + wat: "things".to_owned(), + stuff: false, + } + .to_string(), + "Here's a prefix for things -- false and a suffix" + ); + assert_eq!(DebugStructAsDisplay.to_string(), "DebugStructAsDisplay"); +} + +mod generic { + #[derive(Display)] + #[display(fmt = "Generic {}", field)] + struct NamedGenericStruct<T> { + field: T, + } + #[test] + fn named_generic_struct() { + assert_eq!(NamedGenericStruct { field: 1 }.to_string(), "Generic 1"); + } + + #[derive(Display)] + struct AutoNamedGenericStruct<T> { + field: T, + } + #[test] + fn auto_named_generic_struct() { + assert_eq!(AutoNamedGenericStruct { field: 1 }.to_string(), "1"); + } + + #[derive(Display)] + #[display(fmt = "Generic {}", "_0")] + struct UnnamedGenericStruct<T>(T); + #[test] + fn unnamed_generic_struct() { + assert_eq!(UnnamedGenericStruct(2).to_string(), "Generic 2"); + } + + #[derive(Display)] + struct AutoUnnamedGenericStruct<T>(T); + #[test] + fn auto_unnamed_generic_struct() { + assert_eq!(AutoUnnamedGenericStruct(2).to_string(), "2"); + } + + #[derive(Display)] + enum GenericEnum<A, B> { + #[display(fmt = "Gen::A {}", field)] + A { field: A }, + #[display(fmt = "Gen::B {}", "_0")] + B(B), + } + #[test] + fn generic_enum() { + assert_eq!(GenericEnum::A::<_, u8> { field: 1 }.to_string(), "Gen::A 1"); + assert_eq!(GenericEnum::B::<u8, _>(2).to_string(), "Gen::B 2"); + } + + #[derive(Display)] + enum AutoGenericEnum<A, B> { + A { field: A }, + B(B), + } + #[test] + fn auto_generic_enum() { + assert_eq!(AutoGenericEnum::A::<_, u8> { field: 1 }.to_string(), "1"); + assert_eq!(AutoGenericEnum::B::<u8, _>(2).to_string(), "2"); + } + + #[derive(Display)] + #[display(fmt = "{} {} <-> {0:o} {1:#x} <-> {0:?} {1:X?}", a, b)] + struct MultiTraitNamedGenericStruct<A, B> { + a: A, + b: B, + } + #[test] + fn multi_trait_named_generic_struct() { + let s = MultiTraitNamedGenericStruct { a: 8u8, b: 255 }; + assert_eq!(s.to_string(), "8 255 <-> 10 0xff <-> 8 FF"); + } + + #[derive(Display)] + #[display(fmt = "{} {} {{}} {0:o} {1:#x} - {0:>4?} {1:^4X?}", "_0", "_1")] + struct MultiTraitUnnamedGenericStruct<A, B>(A, B); + #[test] + fn multi_trait_unnamed_generic_struct() { + let s = MultiTraitUnnamedGenericStruct(8u8, 255); + assert_eq!(s.to_string(), "8 255 {} 10 0xff - 8 FF "); + } + + #[derive(Display)] + #[display(fmt = "{}", "3 * 4")] + struct UnusedGenericStruct<T>(T); + #[test] + fn unused_generic_struct() { + let s = UnusedGenericStruct(()); + assert_eq!(s.to_string(), "12"); + } + + mod associated_type_field_enumerator { + use super::*; + + trait Trait { + type Type; + } + + struct Struct; + + impl Trait for Struct { + type Type = i32; + } + + #[test] + fn auto_generic_named_struct_associated() { + #[derive(Display)] + struct AutoGenericNamedStructAssociated<T: Trait> { + field: <T as Trait>::Type, + } + + let s = AutoGenericNamedStructAssociated::<Struct> { field: 10 }; + assert_eq!(s.to_string(), "10"); + } + + #[test] + fn auto_generic_unnamed_struct_associated() { + #[derive(Display)] + struct AutoGenericUnnamedStructAssociated<T: Trait>(<T as Trait>::Type); + + let s = AutoGenericUnnamedStructAssociated::<Struct>(10); + assert_eq!(s.to_string(), "10"); + } + + #[test] + fn auto_generic_enum_associated() { + #[derive(Display)] + enum AutoGenericEnumAssociated<T: Trait> { + Enumerator(<T as Trait>::Type), + } + + let e = AutoGenericEnumAssociated::<Struct>::Enumerator(10); + assert_eq!(e.to_string(), "10"); + } + } + + mod complex_type_field_enumerator { + use super::*; + + #[derive(Display)] + struct Struct<T>(T); + + #[test] + fn auto_generic_named_struct_complex() { + #[derive(Display)] + struct AutoGenericNamedStructComplex<T> { + field: Struct<T>, + } + + let s = AutoGenericNamedStructComplex { field: Struct(10) }; + assert_eq!(s.to_string(), "10"); + } + + #[test] + fn auto_generic_unnamed_struct_complex() { + #[derive(Display)] + struct AutoGenericUnnamedStructComplex<T>(Struct<T>); + + let s = AutoGenericUnnamedStructComplex(Struct(10)); + assert_eq!(s.to_string(), "10"); + } + + #[test] + fn auto_generic_enum_complex() { + #[derive(Display)] + enum AutoGenericEnumComplex<T> { + Enumerator(Struct<T>), + } + + let e = AutoGenericEnumComplex::Enumerator(Struct(10)); + assert_eq!(e.to_string(), "10") + } + } + + mod reference { + use super::*; + + #[test] + fn auto_generic_reference() { + #[derive(Display)] + struct AutoGenericReference<'a, T>(&'a T); + + let s = AutoGenericReference(&10); + assert_eq!(s.to_string(), "10"); + } + + #[test] + fn auto_generic_static_reference() { + #[derive(Display)] + struct AutoGenericStaticReference<T: 'static>(&'static T); + + let s = AutoGenericStaticReference(&10); + assert_eq!(s.to_string(), "10"); + } + } + + mod indirect { + use super::*; + + #[derive(Display)] + struct Struct<T>(T); + + #[test] + fn auto_generic_indirect() { + #[derive(Display)] + struct AutoGenericIndirect<T: 'static>(Struct<&'static T>); + + const V: i32 = 10; + let s = AutoGenericIndirect(Struct(&V)); + assert_eq!(s.to_string(), "10"); + } + } + + mod bound { + use super::*; + + #[test] + fn simple() { + #[derive(Display)] + #[display(fmt = "{} {}", _0, _1)] + struct Struct<T1, T2>(T1, T2); + + let s = Struct(10, 20); + assert_eq!(s.to_string(), "10 20"); + } + + #[test] + fn redundant() { + #[derive(Display)] + #[display(bound = "T1: ::core::fmt::Display, T2: ::core::fmt::Display")] + #[display(fmt = "{} {}", _0, _1)] + struct Struct<T1, T2>(T1, T2); + + let s = Struct(10, 20); + assert_eq!(s.to_string(), "10 20"); + } + + #[test] + fn complex() { + trait Trait1 { + fn function1(&self) -> &'static str; + } + + trait Trait2 { + fn function2(&self) -> &'static str; + } + + impl Trait1 for i32 { + fn function1(&self) -> &'static str { + "WHAT" + } + } + + impl Trait2 for i32 { + fn function2(&self) -> &'static str { + "EVER" + } + } + + #[derive(Display)] + #[display(bound = "T1: Trait1 + Trait2, T2: Trait1 + Trait2")] + #[display(fmt = "{} {} {} {}", "_0.function1()", _0, "_1.function2()", _1)] + struct Struct<T1, T2>(T1, T2); + + let s = Struct(10, 20); + assert_eq!(s.to_string(), "WHAT 10 EVER 20"); + } + } +} diff --git a/vendor/derive_more/tests/error/derives_for_enums_with_source.rs b/vendor/derive_more/tests/error/derives_for_enums_with_source.rs new file mode 100644 index 000000000..2513ab60c --- /dev/null +++ b/vendor/derive_more/tests/error/derives_for_enums_with_source.rs @@ -0,0 +1,249 @@ +use super::*; + +derive_display!(TestErr); +#[derive(Debug, Error)] +enum TestErr { + Unit, + NamedImplicitNoSource { + field: i32, + }, + NamedImplicitSource { + source: SimpleErr, + field: i32, + }, + NamedExplicitNoSource { + #[error(not(source))] + source: SimpleErr, + field: i32, + }, + NamedExplicitSource { + #[error(source)] + explicit_source: SimpleErr, + field: i32, + }, + NamedExplicitNoSourceRedundant { + #[error(not(source))] + field: i32, + }, + NamedExplicitSourceRedundant { + #[error(source)] + source: SimpleErr, + field: i32, + }, + NamedExplicitSuppressesImplicit { + source: i32, + #[error(source)] + field: SimpleErr, + }, + UnnamedImplicitNoSource(i32, i32), + UnnamedImplicitSource(SimpleErr), + UnnamedExplicitNoSource(#[error(not(source))] SimpleErr), + UnnamedExplicitSource(#[error(source)] SimpleErr, i32), + UnnamedExplicitNoSourceRedundant( + #[error(not(source))] i32, + #[error(not(source))] i32, + ), + UnnamedExplicitSourceRedundant(#[error(source)] SimpleErr), + NamedIgnore { + #[error(ignore)] + source: SimpleErr, + field: i32, + }, + UnnamedIgnore(#[error(ignore)] SimpleErr), + NamedIgnoreRedundant { + #[error(ignore)] + field: i32, + }, + UnnamedIgnoreRedundant(#[error(ignore)] i32, #[error(ignore)] i32), + #[error(ignore)] + NamedVariantIgnore { + source: SimpleErr, + field: i32, + }, + #[error(ignore)] + UnnamedVariantIgnore(SimpleErr), + #[error(ignore)] + NamedVariantIgnoreRedundant { + field: i32, + }, + #[error(ignore)] + UnnamedVariantIgnoreRedundant(i32, i32), +} + +#[test] +fn unit() { + assert!(TestErr::Unit.source().is_none()); +} + +#[test] +fn named_implicit_no_source() { + let err = TestErr::NamedImplicitNoSource { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn named_implicit_source() { + let err = TestErr::NamedImplicitSource { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source() { + let err = TestErr::NamedExplicitNoSource { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_none()); +} + +#[test] +fn named_explicit_source() { + let err = TestErr::NamedExplicitSource { + explicit_source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source_redundant() { + let err = TestErr::NamedExplicitNoSourceRedundant { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn named_explicit_source_redundant() { + let err = TestErr::NamedExplicitSourceRedundant { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_suppresses_implicit() { + let err = TestErr::NamedExplicitSuppressesImplicit { + source: 0, + field: SimpleErr, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_implicit_no_source() { + assert!(TestErr::UnnamedImplicitNoSource(0, 0).source().is_none()); +} + +#[test] +fn unnamed_implicit_source() { + let err = TestErr::UnnamedImplicitSource(SimpleErr); + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source() { + let err = TestErr::UnnamedExplicitNoSource(SimpleErr); + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_explicit_source() { + let err = TestErr::UnnamedExplicitSource(SimpleErr, 0); + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source_redundant() { + let err = TestErr::UnnamedExplicitNoSourceRedundant(0, 0); + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_explicit_source_redundant() { + let err = TestErr::UnnamedExplicitSourceRedundant(SimpleErr); + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_ignore() { + let err = TestErr::NamedIgnore { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_ignore() { + let err = TestErr::UnnamedIgnore(SimpleErr); + + assert!(err.source().is_none()); +} + +#[test] +fn named_ignore_redundant() { + let err = TestErr::NamedIgnoreRedundant { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_ignore_redundant() { + let err = TestErr::UnnamedIgnoreRedundant(0, 0); + + assert!(err.source().is_none()); +} + +#[test] +fn named_variant_ignore() { + let err = TestErr::NamedVariantIgnore { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_variant_ignore() { + let err = TestErr::UnnamedVariantIgnore(SimpleErr); + + assert!(err.source().is_none()) +} + +#[test] +fn named_variant_ignore_redundant() { + let err = TestErr::NamedVariantIgnoreRedundant { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_variant_ignore_redundant() { + let err = TestErr::UnnamedVariantIgnoreRedundant(0, 0); + + assert!(err.source().is_none()) +} diff --git a/vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs b/vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs new file mode 100644 index 000000000..92f3b3ae9 --- /dev/null +++ b/vendor/derive_more/tests/error/derives_for_generic_enums_with_source.rs @@ -0,0 +1,248 @@ +use super::*; + +derive_display!(TestErr, T, E); +#[derive(Debug, Error)] +enum TestErr<E, T> { + Unit, + NamedImplicitNoSource { + field: T, + }, + NamedImplicitSource { + source: E, + field: T, + }, + NamedExplicitNoSource { + #[error(not(source))] + source: E, + field: T, + }, + NamedExplicitSource { + #[error(source)] + explicit_source: E, + field: T, + }, + NamedExplicitNoSourceRedundant { + #[error(not(source))] + field: T, + }, + NamedExplicitSourceRedundant { + #[error(source)] + source: E, + field: T, + }, + NamedExplicitSuppressesImplicit { + source: T, + #[error(source)] + field: E, + }, + UnnamedImplicitNoSource(T, T), + UnnamedImplicitSource(E), + UnnamedExplicitNoSource(#[error(not(source))] E), + UnnamedExplicitSource(#[error(source)] E, T), + UnnamedExplicitNoSourceRedundant(#[error(not(source))] T, #[error(not(source))] T), + UnnamedExplicitSourceRedundant(#[error(source)] E), + NamedIgnore { + #[error(ignore)] + source: E, + field: T, + }, + UnnamedIgnore(#[error(ignore)] E), + NamedIgnoreRedundant { + #[error(ignore)] + field: T, + }, + UnnamedIgnoreRedundant(#[error(ignore)] T, #[error(ignore)] T), + #[error(ignore)] + NamedVariantIgnore { + source: E, + field: T, + }, + #[error(ignore)] + UnnamedVariantIgnore(E), + #[error(ignore)] + NamedVariantIgnoreRedundant { + field: T, + }, + #[error(ignore)] + UnnamedVariantIgnoreRedundant(T, T), +} + +#[test] +fn unit() { + assert!(TestErr::<SimpleErr, i32>::Unit.source().is_none()); +} + +#[test] +fn named_implicit_no_source() { + let err = TestErr::<SimpleErr, _>::NamedImplicitNoSource { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn named_implicit_source() { + let err = TestErr::NamedImplicitSource { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source() { + let err = TestErr::NamedExplicitNoSource { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_none()); +} + +#[test] +fn named_explicit_source() { + let err = TestErr::NamedExplicitSource { + explicit_source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source_redundant() { + let err = TestErr::<SimpleErr, _>::NamedExplicitNoSourceRedundant { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn named_explicit_source_redundant() { + let err = TestErr::NamedExplicitSourceRedundant { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_suppresses_implicit() { + let err = TestErr::NamedExplicitSuppressesImplicit { + source: 0, + field: SimpleErr, + }; + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_implicit_no_source() { + let err = TestErr::<SimpleErr, _>::UnnamedImplicitNoSource(0, 0); + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_implicit_source() { + let err = TestErr::<_, i32>::UnnamedImplicitSource(SimpleErr); + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source() { + let err = TestErr::<_, i32>::UnnamedExplicitNoSource(SimpleErr); + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_explicit_source() { + let err = TestErr::UnnamedExplicitSource(SimpleErr, 0); + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source_redundant() { + let err = TestErr::<SimpleErr, _>::UnnamedExplicitNoSourceRedundant(0, 0); + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_explicit_source_redundant() { + let err = TestErr::<_, i32>::UnnamedExplicitSourceRedundant(SimpleErr); + + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_ignore() { + let err = TestErr::NamedIgnore { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_ignore() { + let err = TestErr::<_, i32>::UnnamedIgnore(SimpleErr); + + assert!(err.source().is_none()); +} + +#[test] +fn named_ignore_redundant() { + let err = TestErr::<SimpleErr, _>::NamedIgnoreRedundant { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_ignore_redundant() { + let err = TestErr::<SimpleErr, _>::UnnamedIgnoreRedundant(0, 0); + + assert!(err.source().is_none()); +} + +#[test] +fn named_variant_ignore() { + let err = TestErr::NamedVariantIgnore { + source: SimpleErr, + field: 0, + }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_variant_ignore() { + let err = TestErr::<_, i32>::UnnamedVariantIgnore(SimpleErr); + + assert!(err.source().is_none()) +} + +#[test] +fn named_variant_ignore_redundant() { + let err = TestErr::<SimpleErr, _>::NamedVariantIgnoreRedundant { field: 0 }; + + assert!(err.source().is_none()); +} + +#[test] +fn unnamed_variant_ignore_redundant() { + let err = TestErr::<SimpleErr, _>::UnnamedVariantIgnoreRedundant(0, 0); + + assert!(err.source().is_none()) +} diff --git a/vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs b/vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs new file mode 100644 index 000000000..248e3c97f --- /dev/null +++ b/vendor/derive_more/tests/error/derives_for_generic_structs_with_source.rs @@ -0,0 +1,245 @@ +use super::*; + +#[test] +fn named_implicit_no_source() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T> { + field: T, + } + + assert!(TestErr::<i32>::default().source().is_none()); +} + +#[test] +fn named_implicit_source() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T> { + source: E, + field: T, + } + + let err = TestErr::<SimpleErr, i32>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T> { + #[error(not(source))] + source: E, + field: T, + } + + let err = TestErr::<SimpleErr, i32>::default(); + assert!(err.source().is_none()); +} + +#[test] +fn named_explicit_source() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T> { + #[error(source)] + explicit_source: E, + field: T, + } + + let err = TestErr::<SimpleErr, i32>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source_redundant() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T> { + #[error(not(source))] + field: T, + } + + assert!(TestErr::<i32>::default().source().is_none()); +} + +#[test] +fn named_explicit_source_redundant() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T> { + #[error(source)] + source: E, + field: T, + } + + let err = TestErr::<SimpleErr, i32>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_suppresses_implicit() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T> { + source: E, + #[error(source)] + field: T, + } + + let err = TestErr::<i32, SimpleErr>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_implicit_no_source() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T>(T, T); + + assert!(TestErr::<i32>::default().source().is_none()); +} + +#[test] +fn unnamed_implicit_source() { + derive_display!(TestErr, E); + #[derive(Default, Debug, Error)] + struct TestErr<E>(E); + + let err = TestErr::<SimpleErr>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source() { + derive_display!(TestErr, E); + #[derive(Default, Debug, Error)] + struct TestErr<E>(#[error(not(source))] E); + + assert!(TestErr::<SimpleErr>::default().source().is_none()); +} + +#[test] +fn unnamed_explicit_source() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T>(#[error(source)] E, T); + + let err = TestErr::<SimpleErr, i32>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source_redundant() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T>(#[error(not(source))] T, #[error(not(source))] T); + + assert!(TestErr::<i32>::default().source().is_none()); +} + +#[test] +fn unnamed_explicit_source_redundant() { + derive_display!(TestErr, E); + #[derive(Default, Debug, Error)] + struct TestErr<E>(#[error(source)] E); + + let err = TestErr::<SimpleErr>::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_ignore() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + struct TestErr<E, T> { + #[error(ignore)] + source: E, + field: T, + } + + assert!(TestErr::<SimpleErr, i32>::default().source().is_none()); +} + +#[test] +fn unnamed_ignore() { + derive_display!(TestErr, E); + #[derive(Default, Debug, Error)] + struct TestErr<E>(#[error(ignore)] E); + + assert!(TestErr::<SimpleErr>::default().source().is_none()); +} + +#[test] +fn named_ignore_redundant() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T> { + #[error(ignore)] + field: T, + } + + assert!(TestErr::<i32>::default().source().is_none()); +} + +#[test] +fn unnamed_ignore_redundant() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T>(#[error(ignore)] T, #[error(ignore)] T); + + assert!(TestErr::<i32>::default().source().is_none()); +} + +#[test] +fn named_struct_ignore() { + derive_display!(TestErr, E, T); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr<E, T> { + source: E, + field: T, + } + + assert!(TestErr::<SimpleErr, i32>::default().source().is_none()) +} + +#[test] +fn unnamed_struct_ignore() { + derive_display!(TestErr, E); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr<E>(E); + + assert!(TestErr::<SimpleErr>::default().source().is_none()) +} + +#[test] +fn named_struct_ignore_redundant() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr<T> { + field: T, + } + + assert!(TestErr::<i32>::default().source().is_none()) +} + +#[test] +fn unnamed_struct_ignore_redundant() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr<T>(T, T); + + assert!(TestErr::<i32>::default().source().is_none()) +} diff --git a/vendor/derive_more/tests/error/derives_for_structs_with_source.rs b/vendor/derive_more/tests/error/derives_for_structs_with_source.rs new file mode 100644 index 000000000..d46bd5ad5 --- /dev/null +++ b/vendor/derive_more/tests/error/derives_for_structs_with_source.rs @@ -0,0 +1,249 @@ +use super::*; + +#[test] +fn unit() { + assert!(SimpleErr.source().is_none()); +} + +#[test] +fn named_implicit_no_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + field: i32, + } + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn named_implicit_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + source: SimpleErr, + field: i32, + } + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + #[error(not(source))] + source: SimpleErr, + field: i32, + } + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn named_explicit_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + #[error(source)] + explicit_source: SimpleErr, + field: i32, + } + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_no_source_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + #[error(not(source))] + field: i32, + } + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn named_explicit_source_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + #[error(source)] + source: SimpleErr, + field: i32, + } + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_explicit_suppresses_implicit() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + source: i32, + #[error(source)] + field: SimpleErr, + } + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_implicit_no_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(i32, i32); + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn unnamed_implicit_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(SimpleErr); + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(#[error(not(source))] SimpleErr); + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn unnamed_explicit_source() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(#[error(source)] SimpleErr, i32); + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn unnamed_explicit_no_source_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(#[error(not(source))] i32, #[error(not(source))] i32); + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn unnamed_explicit_source_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(#[error(source)] SimpleErr); + + let err = TestErr::default(); + assert!(err.source().is_some()); + assert!(err.source().unwrap().is::<SimpleErr>()); +} + +#[test] +fn named_ignore() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + #[error(ignore)] + source: SimpleErr, + field: i32, + } + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn unnamed_ignore() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(#[error(ignore)] SimpleErr); + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn named_ignore_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + #[error(ignore)] + field: i32, + } + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn unnamed_ignore_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(#[error(ignore)] i32, #[error(ignore)] i32); + + assert!(TestErr::default().source().is_none()); +} + +#[test] +fn named_struct_ignore() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr { + source: SimpleErr, + field: i32, + } + + assert!(TestErr::default().source().is_none()) +} + +#[test] +fn unnamed_struct_ignore() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr(SimpleErr); + + assert!(TestErr::default().source().is_none()) +} + +#[test] +fn named_struct_ignore_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr { + field: i32, + } + + assert!(TestErr::default().source().is_none()) +} + +#[test] +fn unnamed_struct_ignore_redundant() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + #[error(ignore)] + struct TestErr(i32, i32); + + assert!(TestErr::default().source().is_none()) +} diff --git a/vendor/derive_more/tests/error/mod.rs b/vendor/derive_more/tests/error/mod.rs new file mode 100644 index 000000000..5d7190d8f --- /dev/null +++ b/vendor/derive_more/tests/error/mod.rs @@ -0,0 +1,56 @@ +use std::error::Error; + +/// Derives `std::fmt::Display` for structs/enums. +/// Derived implementation outputs empty string. +/// Useful, as a way to formally satisfy `Display` trait bound. +/// +/// ## Syntax: +/// +/// For regular structs/enums: +/// +/// ``` +/// enum MyEnum { +/// ... +/// } +/// +/// derive_display!(MyEnum); +/// ``` +/// +/// For generic structs/enums: +/// +/// ``` +/// struct MyGenericStruct<T, U> { +/// ... +/// } +/// +/// derive_display!(MyGenericStruct, T, U); +/// ``` +macro_rules! derive_display { + (@fmt) => { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + write!(f, "") + } + }; + ($type:ident) => { + impl ::std::fmt::Display for $type { + derive_display!(@fmt); + } + }; + ($type:ident, $($type_parameters:ident),*) => { + impl<$($type_parameters),*> ::std::fmt::Display for $type<$($type_parameters),*> { + derive_display!(@fmt); + } + }; +} + +mod derives_for_enums_with_source; +mod derives_for_generic_enums_with_source; +mod derives_for_generic_structs_with_source; +mod derives_for_structs_with_source; + +#[cfg(feature = "nightly")] +mod nightly; + +derive_display!(SimpleErr); +#[derive(Default, Debug, Error)] +struct SimpleErr; diff --git a/vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs new file mode 100644 index 000000000..c4ff4817d --- /dev/null +++ b/vendor/derive_more/tests/error/nightly/derives_for_enums_with_backtrace.rs @@ -0,0 +1,272 @@ +use super::*; + +derive_display!(TestErr); +#[derive(Debug, Error)] +enum TestErr { + Unit, + NamedImplicitNoBacktrace { + field: i32, + }, + NamedImplicitBacktraceByFieldName { + backtrace: MyBacktrace, + field: i32, + }, + NamedImplicitBacktraceByFieldType { + implicit_backtrace: Backtrace, + field: i32, + }, + NamedExplicitNoBacktraceByFieldName { + #[error(not(backtrace))] + backtrace: MyBacktrace, + field: i32, + }, + NamedExplicitNoBacktraceByFieldType { + #[error(not(backtrace))] + implicit_backtrace: Backtrace, + field: i32, + }, + NamedExplicitBacktrace { + #[error(backtrace)] + explicit_backtrace: MyBacktrace, + field: i32, + }, + NamedExplicitNoBacktraceRedundant { + #[error(not(backtrace))] + not_backtrace: MyBacktrace, + #[error(not(backtrace))] + field: i32, + }, + NamedExplicitBacktraceByFieldNameRedundant { + #[error(backtrace)] + backtrace: MyBacktrace, + field: i32, + }, + NamedExplicitBacktraceByFieldTypeRedundant { + #[error(backtrace)] + implicit_backtrace: Backtrace, + field: i32, + }, + NamedExplicitSupressesImplicit { + #[error(backtrace)] + not_backtrace: MyBacktrace, + backtrace: Backtrace, + field: i32, + }, + UnnamedImplicitNoBacktrace(i32, i32), + UnnamedImplicitBacktrace(Backtrace, i32, i32), + UnnamedExplicitNoBacktrace(#[error(not(backtrace))] Backtrace, i32), + UnnamedExplicitBacktrace(#[error(backtrace)] MyBacktrace, i32, i32), + UnnamedExplicitNoBacktraceRedundant( + #[error(not(backtrace))] MyBacktrace, + #[error(not(backtrace))] i32, + ), + UnnamedExplicitBacktraceRedundant(#[error(backtrace)] Backtrace, i32, i32), + UnnamedExplicitSupressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, i32), +} + +impl TestErr { + fn get_stored_backtrace(&self) -> &Backtrace { + match self { + Self::NamedImplicitBacktraceByFieldName { backtrace, .. } => backtrace, + Self::NamedImplicitBacktraceByFieldType { + implicit_backtrace, .. + } => implicit_backtrace, + Self::NamedExplicitBacktrace { + explicit_backtrace, .. + } => explicit_backtrace, + Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. } => { + backtrace + } + Self::NamedExplicitBacktraceByFieldTypeRedundant { + implicit_backtrace, + .. + } => implicit_backtrace, + Self::NamedExplicitSupressesImplicit { not_backtrace, .. } => not_backtrace, + Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace, + Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace, + Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace, + Self::UnnamedExplicitSupressesImplicit(backtrace, _, _) => backtrace, + _ => panic!("ERROR IN TEST IMPLEMENTATION"), + } + } + + fn get_unused_backtrace(&self) -> &Backtrace { + match self { + Self::NamedExplicitSupressesImplicit { backtrace, .. } => backtrace, + Self::UnnamedExplicitSupressesImplicit(_, backtrace, _) => backtrace, + _ => panic!("ERROR IN TEST IMPLEMENTATION"), + } + } +} + +type MyBacktrace = Backtrace; + +#[test] +fn unit() { + assert!(TestErr::Unit.backtrace().is_none()); +} + +#[test] +fn named_implicit_no_backtrace() { + let err = TestErr::NamedImplicitNoBacktrace { field: 0 }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_implicit_backtrace_by_field_name() { + let err = TestErr::NamedImplicitBacktraceByFieldName { + backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_implicit_backtrace_by_field_type() { + let err = TestErr::NamedImplicitBacktraceByFieldType { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_by_field_name() { + let err = TestErr::NamedExplicitNoBacktraceByFieldName { + backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_explicit_no_backtrace_by_field_type() { + let err = TestErr::NamedExplicitNoBacktraceByFieldType { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_explicit_backtrace() { + let err = TestErr::NamedExplicitBacktrace { + explicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_redundant() { + let err = TestErr::NamedExplicitNoBacktraceRedundant { + not_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_explicit_backtrace_by_field_name_redundant() { + let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant { + backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_backtrace_by_field_type_redundant() { + let err = TestErr::NamedExplicitBacktraceByFieldTypeRedundant { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_supresses_implicit() { + let err = TestErr::NamedExplicitSupressesImplicit { + not_backtrace: Backtrace::force_capture(), + backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); + assert_bt!(!=, err, .get_unused_backtrace); +} + +#[test] +fn unnamed_implicit_no_backtrace() { + let err = TestErr::UnnamedImplicitNoBacktrace(0, 0); + + assert!(err.backtrace().is_none()); +} + +#[test] +fn unnamed_implicit_backtrace() { + let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn unnamed_explicit_no_backtrace() { + let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0); + + assert!(err.backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace() { + let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn unnamed_explicit_no_backtrace_redundant() { + let err = + TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0); + + assert!(err.backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace_redundant() { + let err = + TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn unnamed_explicit_supresses_implicit() { + let err = TestErr::UnnamedExplicitSupressesImplicit( + Backtrace::force_capture(), + (|| Backtrace::force_capture())(), // ensure backtraces are different + 0, + ); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); + assert_bt!(!=, err, .get_unused_backtrace); +} diff --git a/vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs new file mode 100644 index 000000000..8574751d0 --- /dev/null +++ b/vendor/derive_more/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs @@ -0,0 +1,272 @@ +use super::*; + +derive_display!(TestErr, T); +#[derive(Debug, Error)] +enum TestErr<T> { + Unit, + NamedImplicitNoBacktrace { + field: T, + }, + NamedImplicitBacktraceByFieldName { + backtrace: MyBacktrace, + field: T, + }, + NamedImplicitBacktraceByFieldType { + implicit_backtrace: Backtrace, + field: T, + }, + NamedExplicitNoBacktraceByFieldName { + #[error(not(backtrace))] + backtrace: MyBacktrace, + field: T, + }, + NamedExplicitNoBacktraceByFieldType { + #[error(not(backtrace))] + implicit_backtrace: Backtrace, + field: T, + }, + NamedExplicitBacktrace { + #[error(backtrace)] + explicit_backtrace: MyBacktrace, + field: T, + }, + NamedExplicitNoBacktraceRedundant { + #[error(not(backtrace))] + not_backtrace: MyBacktrace, + #[error(not(backtrace))] + field: T, + }, + NamedExplicitBacktraceByFieldNameRedundant { + #[error(backtrace)] + backtrace: MyBacktrace, + field: T, + }, + NamedExplicitBacktraceByFieldTypeRedundant { + #[error(backtrace)] + implicit_backtrace: Backtrace, + field: T, + }, + NamedExplicitSupressesImplicit { + #[error(backtrace)] + not_backtrace: MyBacktrace, + backtrace: Backtrace, + field: T, + }, + UnnamedImplicitNoBacktrace(T, T), + UnnamedImplicitBacktrace(Backtrace, T, T), + UnnamedExplicitNoBacktrace(#[error(not(backtrace))] Backtrace, T), + UnnamedExplicitBacktrace(#[error(backtrace)] MyBacktrace, T, T), + UnnamedExplicitNoBacktraceRedundant( + #[error(not(backtrace))] MyBacktrace, + #[error(not(backtrace))] T, + ), + UnnamedExplicitBacktraceRedundant(#[error(backtrace)] Backtrace, T, T), + UnnamedExplicitSupressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, T), +} + +impl<T> TestErr<T> { + fn get_stored_backtrace(&self) -> &Backtrace { + match self { + Self::NamedImplicitBacktraceByFieldName { backtrace, .. } => backtrace, + Self::NamedImplicitBacktraceByFieldType { + implicit_backtrace, .. + } => implicit_backtrace, + Self::NamedExplicitBacktrace { + explicit_backtrace, .. + } => explicit_backtrace, + Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. } => { + backtrace + } + Self::NamedExplicitBacktraceByFieldTypeRedundant { + implicit_backtrace, + .. + } => implicit_backtrace, + Self::NamedExplicitSupressesImplicit { not_backtrace, .. } => not_backtrace, + Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace, + Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace, + Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace, + Self::UnnamedExplicitSupressesImplicit(backtrace, _, _) => backtrace, + _ => panic!("ERROR IN TEST IMPLEMENTATION"), + } + } + + fn get_unused_backtrace(&self) -> &Backtrace { + match self { + Self::NamedExplicitSupressesImplicit { backtrace, .. } => backtrace, + Self::UnnamedExplicitSupressesImplicit(_, backtrace, _) => backtrace, + _ => panic!("ERROR IN TEST IMPLEMENTATION"), + } + } +} + +type MyBacktrace = Backtrace; + +#[test] +fn unit() { + assert!(TestErr::<i32>::Unit.backtrace().is_none()); +} + +#[test] +fn named_implicit_no_backtrace() { + let err = TestErr::NamedImplicitNoBacktrace { field: 0 }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_implicit_backtrace_by_field_name() { + let err = TestErr::NamedImplicitBacktraceByFieldName { + backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_implicit_backtrace_by_field_type() { + let err = TestErr::NamedImplicitBacktraceByFieldType { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_by_field_name() { + let err = TestErr::NamedExplicitNoBacktraceByFieldName { + backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_explicit_no_backtrace_by_field_type() { + let err = TestErr::NamedExplicitNoBacktraceByFieldType { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_explicit_backtrace() { + let err = TestErr::NamedExplicitBacktrace { + explicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_redundant() { + let err = TestErr::NamedExplicitNoBacktraceRedundant { + not_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_none()); +} + +#[test] +fn named_explicit_backtrace_by_field_name_redundant() { + let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant { + backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_backtrace_by_field_type_redundant() { + let err = TestErr::NamedExplicitBacktraceByFieldTypeRedundant { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn named_explicit_supresses_implicit() { + let err = TestErr::NamedExplicitSupressesImplicit { + not_backtrace: Backtrace::force_capture(), + backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); + assert_bt!(!=, err, .get_unused_backtrace); +} + +#[test] +fn unnamed_implicit_no_backtrace() { + let err = TestErr::UnnamedImplicitNoBacktrace(0, 0); + + assert!(err.backtrace().is_none()); +} + +#[test] +fn unnamed_implicit_backtrace() { + let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn unnamed_explicit_no_backtrace() { + let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0); + + assert!(err.backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace() { + let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn unnamed_explicit_no_backtrace_redundant() { + let err = + TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0); + + assert!(err.backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace_redundant() { + let err = + TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); +} + +#[test] +fn unnamed_explicit_supresses_implicit() { + let err = TestErr::UnnamedExplicitSupressesImplicit( + Backtrace::force_capture(), + (|| Backtrace::force_capture())(), // ensure backtraces are different + 0, + ); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, .get_stored_backtrace); + assert_bt!(!=, err, .get_unused_backtrace); +} diff --git a/vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs new file mode 100644 index 000000000..91df87c82 --- /dev/null +++ b/vendor/derive_more/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs @@ -0,0 +1,275 @@ +use super::*; + +#[test] +fn named_implicit_no_backtrace() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T> { + field: T, + } + + assert!(TestErr::<i32>::default().backtrace().is_none()); +} + +#[test] +fn named_implicit_backtrace_by_field_name() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + backtrace: MyBacktrace, + field: T, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err); +} + +#[test] +fn named_implicit_backtrace_by_field_type() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + implicit_backtrace: Backtrace, + field: T, + } + + let err = TestErr { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err, implicit_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_by_field_name() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(not(backtrace))] + backtrace: MyBacktrace, + field: T, + } + + type MyBacktrace = Backtrace; + + assert!(TestErr { + backtrace: Backtrace::force_capture(), + field: 0 + } + .backtrace() + .is_none()); +} + +#[test] +fn named_explicit_no_backtrace_by_field_type() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(not(backtrace))] + implicit_backtrace: Backtrace, + field: T, + } + + assert!(TestErr { + implicit_backtrace: Backtrace::force_capture(), + field: 0 + } + .backtrace() + .is_none()); +} + +#[test] +fn named_explicit_backtrace() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(backtrace)] + explicit_backtrace: MyBacktrace, + field: T, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + explicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err, explicit_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_redundant() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(not(backtrace))] + not_backtrace: MyBacktrace, + #[error(not(backtrace))] + field: T, + } + + type MyBacktrace = Backtrace; + + assert!(TestErr { + not_backtrace: Backtrace::force_capture(), + field: 0 + } + .backtrace() + .is_none()); +} + +#[test] +fn named_explicit_backtrace_by_field_name_redundant() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(backtrace)] + backtrace: MyBacktrace, + field: T, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err); +} + +#[test] +fn named_explicit_backtrace_by_field_type_redundant() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(backtrace)] + implicit_backtrace: Backtrace, + field: T, + } + + let err = TestErr { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err, implicit_backtrace); +} + +#[test] +fn named_explicit_supresses_implicit() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T> { + #[error(backtrace)] + not_backtrace: MyBacktrace, + backtrace: Backtrace, + field: T, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + not_backtrace: Backtrace::force_capture(), + backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, not_backtrace); + assert_bt!(!=, err); +} + +#[test] +fn unnamed_implicit_no_backtrace() { + derive_display!(TestErr, T); + #[derive(Default, Debug, Error)] + struct TestErr<T>(T, T); + + assert!(TestErr::<i32>::default().backtrace().is_none()); +} + +#[test] +fn unnamed_implicit_backtrace() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T>(Backtrace, T, T); + + let err = TestErr(Backtrace::force_capture(), 0, 0); + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); +} + +#[test] +fn unnamed_explicit_no_backtrace() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T>(#[error(not(backtrace))] Backtrace, T); + + assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T>(#[error(backtrace)] MyBacktrace, T, T); + + type MyBacktrace = Backtrace; + + let err = TestErr(Backtrace::force_capture(), 0, 0); + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); +} + +#[test] +fn unnamed_explicit_no_backtrace_redundant() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T>( + #[error(not(backtrace))] MyBacktrace, + #[error(not(backtrace))] T, + ); + + type MyBacktrace = Backtrace; + + assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace_redundant() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T>(#[error(backtrace)] Backtrace, T, T); + + let err = TestErr(Backtrace::force_capture(), 0, 0); + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); +} + +#[test] +fn unnamed_explicit_supresses_implicit() { + derive_display!(TestErr, T); + #[derive(Debug, Error)] + struct TestErr<T>(#[error(backtrace)] MyBacktrace, Backtrace, T); + + type MyBacktrace = Backtrace; + + let err = TestErr( + Backtrace::force_capture(), + (|| Backtrace::force_capture())(), // ensure backtraces are different + 0, + ); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); + assert_bt!(!=, err, 1); +} diff --git a/vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs b/vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs new file mode 100644 index 000000000..18e268f84 --- /dev/null +++ b/vendor/derive_more/tests/error/nightly/derives_for_structs_with_backtrace.rs @@ -0,0 +1,280 @@ +use super::*; + +#[test] +fn unit() { + assert!(SimpleErr.backtrace().is_none()); +} + +#[test] +fn named_implicit_no_backtrace() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr { + field: i32, + } + + assert!(TestErr::default().backtrace().is_none()); +} + +#[test] +fn named_implicit_backtrace_by_field_name() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + backtrace: MyBacktrace, + field: i32, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err); +} + +#[test] +fn named_implicit_backtrace_by_field_type() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + implicit_backtrace: Backtrace, + field: i32, + } + + let err = TestErr { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err, implicit_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_by_field_name() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(not(backtrace))] + backtrace: MyBacktrace, + field: i32, + } + + type MyBacktrace = Backtrace; + + assert!(TestErr { + backtrace: Backtrace::force_capture(), + field: 0 + } + .backtrace() + .is_none()); +} + +#[test] +fn named_explicit_no_backtrace_by_field_type() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(not(backtrace))] + implicit_backtrace: Backtrace, + field: i32, + } + + assert!(TestErr { + implicit_backtrace: Backtrace::force_capture(), + field: 0 + } + .backtrace() + .is_none()); +} + +#[test] +fn named_explicit_backtrace() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(backtrace)] + explicit_backtrace: MyBacktrace, + field: i32, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + explicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err, explicit_backtrace); +} + +#[test] +fn named_explicit_no_backtrace_redundant() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(not(backtrace))] + not_backtrace: MyBacktrace, + #[error(not(backtrace))] + field: i32, + } + + type MyBacktrace = Backtrace; + + assert!(TestErr { + not_backtrace: Backtrace::force_capture(), + field: 0 + } + .backtrace() + .is_none()); +} + +#[test] +fn named_explicit_backtrace_by_field_name_redundant() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(backtrace)] + backtrace: MyBacktrace, + field: i32, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err); +} + +#[test] +fn named_explicit_backtrace_by_field_type_redundant() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(backtrace)] + implicit_backtrace: Backtrace, + field: i32, + } + + let err = TestErr { + implicit_backtrace: Backtrace::force_capture(), + field: 0, + }; + assert!(err.backtrace().is_some()); + assert_bt!(==, err, implicit_backtrace); +} + +#[test] +fn named_explicit_supresses_implicit() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr { + #[error(backtrace)] + not_backtrace: MyBacktrace, + backtrace: Backtrace, + field: i32, + } + + type MyBacktrace = Backtrace; + + let err = TestErr { + not_backtrace: Backtrace::force_capture(), + backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different + field: 0, + }; + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, not_backtrace); + assert_bt!(!=, err); +} + +#[test] +fn unnamed_implicit_no_backtrace() { + derive_display!(TestErr); + #[derive(Default, Debug, Error)] + struct TestErr(i32, i32); + + assert!(TestErr::default().backtrace().is_none()); +} + +#[test] +fn unnamed_implicit_backtrace() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr(Backtrace, i32, i32); + + let err = TestErr(Backtrace::force_capture(), 0, 0); + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); +} + +#[test] +fn unnamed_explicit_no_backtrace() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr(#[error(not(backtrace))] Backtrace, i32); + + assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr(#[error(backtrace)] MyBacktrace, i32, i32); + + type MyBacktrace = Backtrace; + + let err = TestErr(Backtrace::force_capture(), 0, 0); + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); +} + +#[test] +fn unnamed_explicit_no_backtrace_redundant() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr( + #[error(not(backtrace))] MyBacktrace, + #[error(not(backtrace))] i32, + ); + + type MyBacktrace = Backtrace; + + assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none()); +} + +#[test] +fn unnamed_explicit_backtrace_redundant() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr(#[error(backtrace)] Backtrace, i32, i32); + + let err = TestErr(Backtrace::force_capture(), 0, 0); + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); +} + +#[test] +fn unnamed_explicit_supresses_implicit() { + derive_display!(TestErr); + #[derive(Debug, Error)] + struct TestErr(#[error(backtrace)] MyBacktrace, Backtrace, i32); + + type MyBacktrace = Backtrace; + + let err = TestErr( + Backtrace::force_capture(), + (|| Backtrace::force_capture())(), // ensure backtraces are different + 0, + ); + + assert!(err.backtrace().is_some()); + assert_bt!(==, err, 0); + assert_bt!(!=, err, 1); +} diff --git a/vendor/derive_more/tests/error/nightly/mod.rs b/vendor/derive_more/tests/error/nightly/mod.rs new file mode 100644 index 000000000..57de7ba2a --- /dev/null +++ b/vendor/derive_more/tests/error/nightly/mod.rs @@ -0,0 +1,85 @@ +use std::backtrace::Backtrace; + +use super::*; + +/// Asserts that backtrace returned by `Error::backtrace` method equals/not-equals +/// backtrace stored in object itself. +/// +/// Comparison is done by converting backtraces to strings +/// and then comparing these strings. +/// +/// ## Syntax +/// +/// * Equals: `assert_bt!(==, ...)` +/// * Not-equals: `assert_bt!(!=, ...)` +/// +/// ### Backtrace Access +/// +/// Shortcut for named-structs with `backtrace` field. +/// Access backtrace as `error.backtrace`. +/// +/// ``` +/// assert_bt!(==, error); +/// ``` +/// +/// Full form for named- and tuple-structs. +/// Access backtrace as `error.some_other_field` and `error.1` respectively. +/// +/// ``` +/// assert_bt!(!=, error, some_other_field); +/// assert_bt!(==, error, 1); +/// ``` +/// +/// Access as a method call. +/// Useful for enums (i.e., you can define a method that will match on enum variants +/// and return backtrace for each variant). +/// Access backtrace as `error.get_stored_backtrace_method()`. +/// +/// ``` +/// assert_bt!(!=, error, .get_stored_backtrace_method); +/// ``` +macro_rules! assert_bt { + (@impl $macro:ident, $error:expr, $backtrace:expr) => { + $macro!($error.backtrace().unwrap().to_string(), $backtrace.to_string()); + }; + (@expand $macro:ident, $error:expr, .$backtrace:ident) => { + assert_bt!(@impl $macro, $error, $error.$backtrace()) + }; + (@expand $macro:ident, $error:expr, $backtrace:tt) => { + assert_bt!(@impl $macro, $error, $error.$backtrace) + }; + (@expand $macro:ident, $error:expr) => { + assert_bt!(@expand $macro, $error, backtrace) + }; + (==, $($args:tt)*) => { + assert_bt!(@expand assert_eq, $($args)*) + }; + (!=, $($args:tt)*) => { + assert_bt!(@expand assert_ne, $($args)*) + }; +} + +mod derives_for_enums_with_backtrace; +mod derives_for_generic_enums_with_backtrace; +mod derives_for_generic_structs_with_backtrace; +mod derives_for_structs_with_backtrace; + +derive_display!(BacktraceErr); +#[derive(Debug)] +struct BacktraceErr { + backtrace: Backtrace, +} + +impl Default for BacktraceErr { + fn default() -> Self { + Self { + backtrace: Backtrace::force_capture(), + } + } +} + +impl Error for BacktraceErr { + fn backtrace(&self) -> Option<&Backtrace> { + Some(&self.backtrace) + } +} diff --git a/vendor/derive_more/tests/error_tests.rs b/vendor/derive_more/tests/error_tests.rs new file mode 100644 index 000000000..c2798bd14 --- /dev/null +++ b/vendor/derive_more/tests/error_tests.rs @@ -0,0 +1,6 @@ +#![cfg_attr(feature = "nightly", feature(backtrace))] + +#[macro_use] +extern crate derive_more; + +mod error; diff --git a/vendor/derive_more/tests/from.rs b/vendor/derive_more/tests/from.rs new file mode 100644 index 000000000..63bb10201 --- /dev/null +++ b/vendor/derive_more/tests/from.rs @@ -0,0 +1,187 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +use std::borrow::Cow; + +#[derive(From)] +struct EmptyTuple(); + +#[derive(From)] +struct EmptyStruct {} + +#[derive(From)] +struct EmptyUnit; + +#[derive(From)] +struct MyInt(i32); + +#[derive(From)] +struct MyInts(i32, i32); + +#[derive(From)] +struct Point1D { + x: i32, +} + +#[derive(From)] +struct Point2D { + x: i32, + y: i32, +} + +#[derive(From)] +enum MixedInts { + SmallInt(i32), + NamedBigInt { + int: i64, + }, + TwoSmallInts(i32, i32), + NamedBigInts { + x: i64, + y: i64, + }, + #[from(ignore)] + Unsigned(u32), + NamedUnsigned { + x: u32, + }, +} + +#[derive(PartialEq, Eq, Debug)] +#[derive(From)] +#[from(forward)] +struct MyIntForward(u64); + +#[test] +fn forward_struct() { + assert_eq!(MyIntForward(42), 42u32.into()); + assert_eq!(MyIntForward(42), 42u16.into()); + assert_eq!(MyIntForward(42), 42u64.into()); +} + +#[derive(PartialEq, Eq, Debug)] +#[derive(From)] +enum MixedIntsForward { + #[from(forward)] + SmallInt(i32), + NamedBigInt { + int: i64, + }, +} + +#[test] +fn forward_enum() { + assert_eq!(MixedIntsForward::SmallInt(42), 42i32.into()); + assert_eq!(MixedIntsForward::SmallInt(42), 42i16.into()); +} + +#[derive(From, PartialEq)] +enum AutoIgnore { + SmallInt(i32), + Uninteresting, + Uninteresting2, +} + +#[test] +fn auto_ignore_variants() { + assert!(AutoIgnore::SmallInt(42) == 42i32.into()); +} + +#[derive(From, PartialEq)] +enum AutoIgnoreWithDefaultTrue { + #[from(ignore)] + SmallInt(i32), + Uninteresting, + Uninteresting2, +} + +#[derive(From, PartialEq)] +enum AutoIgnoreWithForwardFields2 { + #[from(forward)] + SmallInt(i32), + SmallIntIgnore(i32), +} + +#[test] +fn auto_ignore_with_forward_field2() { + assert!(AutoIgnoreWithForwardFields2::SmallInt(42) == 42i32.into()); + assert!(AutoIgnoreWithForwardFields2::SmallInt(42) == 42i16.into()); +} + +#[derive(Debug, Eq, PartialEq)] +#[derive(From)] +#[from(types(u8, u16, u32))] +struct MyIntExplicit(u64); + +#[test] +fn explicit_types_struct() { + assert_eq!(MyIntExplicit(42), 42u8.into()); + assert_eq!(MyIntExplicit(42), 42u16.into()); + assert_eq!(MyIntExplicit(42), 42u32.into()); + assert_eq!(MyIntExplicit(42), 42u64.into()); +} + +#[derive(Debug, Eq, PartialEq)] +#[derive(From)] +#[from(types(i8, i16))] +struct MyIntsExplicit(i32, i32); + +#[test] +fn explicit_types_struct_tupled() { + assert_eq!(MyIntsExplicit(42, 42), (42i32, 42i32).into()); + assert_eq!(MyIntsExplicit(42, 42), (42i8, 42i8).into()); + assert_eq!(MyIntsExplicit(42, 42), (42i16, 42i16).into()); +} + +#[derive(Debug, Eq, PartialEq)] +#[derive(From)] +enum MixedIntsExplicit { + #[from(types(i8))] + SmallInt(i32), + #[from(types(i16, i64))] + AnotherInt(i128), + NamedBigInt { + int: i64, + }, +} + +#[test] +fn explicit_types_enum() { + assert_eq!(MixedIntsExplicit::SmallInt(42), 42i32.into()); + assert_eq!(MixedIntsExplicit::SmallInt(42), 42i8.into()); + + assert_eq!(MixedIntsExplicit::AnotherInt(42), 42i128.into()); + assert_eq!(MixedIntsExplicit::AnotherInt(42), 42i64.into()); + assert_eq!(MixedIntsExplicit::AnotherInt(42), 42i16.into()); +} + +#[derive(Debug, Eq, PartialEq)] +#[derive(From)] +#[from(types(i8, i16))] +struct Point2DExplicit { + x: i32, + y: i32, +} + +#[test] +fn explicit_types_point_2d() { + let expected = Point2DExplicit { x: 42, y: 42 }; + assert_eq!(expected, (42i32, 42i32).into()); + assert_eq!(expected, (42i8, 42i8).into()); + assert_eq!(expected, (42i16, 42i16).into()); +} + +#[derive(Debug, Eq, PartialEq)] +#[derive(From)] +#[from(types("Cow<'_, str>", "&str"))] +struct Name(String); + +#[test] +fn explicit_complex_types_name() { + let name = "Eärendil"; + let expected = Name(name.to_owned()); + assert_eq!(expected, name.to_owned().into()); + assert_eq!(expected, name.into()); + assert_eq!(expected, Cow::Borrowed(name).into()); +} diff --git a/vendor/derive_more/tests/from_str.rs b/vendor/derive_more/tests/from_str.rs new file mode 100644 index 000000000..4bb0eca63 --- /dev/null +++ b/vendor/derive_more/tests/from_str.rs @@ -0,0 +1,11 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +#[derive(FromStr)] +struct MyInt(i32); + +#[derive(FromStr)] +struct Point1D { + x: i32, +} diff --git a/vendor/derive_more/tests/generics.rs b/vendor/derive_more/tests/generics.rs new file mode 100644 index 000000000..17af5f397 --- /dev/null +++ b/vendor/derive_more/tests/generics.rs @@ -0,0 +1,123 @@ +#![allow(dead_code, non_camel_case_types)] +#[macro_use] +extern crate derive_more; + +#[derive( + From, + FromStr, + Display, + Index, + Not, + Add, + Mul, + Sum, + IndexMut, + AddAssign, + MulAssign, + Deref, + DerefMut, + IntoIterator, + Constructor +)] +#[deref(forward)] +#[deref_mut(forward)] +#[into_iterator(owned, ref, ref_mut)] +struct Wrapped<T: Clone>(T); + +#[derive(Deref, DerefMut)] +struct Wrapped2<T: Clone>(T); + +#[derive(From, Not, Add, Mul, AddAssign, MulAssign, Constructor, Sum)] +struct WrappedDouble<T: Clone, U: Clone>(T, U); + +#[derive(From)] +#[from(forward)] +struct WrappedDouble2<T: Clone, U: Clone>(T, U); + +#[cfg(feature = "nightly")] +#[derive( + From, + FromStr, + Display, + Index, + Not, + Add, + Mul, + Sum, + IndexMut, + AddAssign, + MulAssign, + Deref, + DerefMut, + IntoIterator, + Constructor +)] +struct WrappedWithConst<T, const C: u32>(T); + +#[derive( + From, + FromStr, + Display, + Index, + Not, + Add, + Mul, + IndexMut, + AddAssign, + MulAssign, + Deref, + DerefMut, + IntoIterator, + Constructor, + Sum +)] +#[deref(forward)] +#[deref_mut(forward)] +#[into_iterator(owned, ref, ref_mut)] +struct Struct<T: Clone> { + t: T, +} + +#[derive(Deref, DerefMut)] +struct Struct2<T: Clone> { + t: T, +} + +#[derive(From, Not, Add, Mul, AddAssign, MulAssign, Constructor, Sum)] +struct DoubleStruct<T: Clone, U: Clone> { + t: T, + u: U, +} + +#[derive(From)] +#[from(forward)] +struct DoubleStruct2<T: Clone, U: Clone> { + t: T, + u: U, +} + +#[derive(From, Not, Add)] +enum TupleEnum<T: Clone, U: Clone> { + Tuple(T), + DoubleTuple(T, U), +} + +#[derive(From)] +#[from(forward)] +enum TupleEnum2<T: Clone, U: Clone, X: Clone> { + DoubleTuple(T, U), + TripleTuple(T, U, X), +} + +#[derive(From, Not, Add)] +enum StructEnum<T: Clone, U: Clone> { + Struct { t: T }, + DoubleStruct { t: T, u: U }, +} + +#[derive(From)] +#[from(forward)] +enum StructEnum2<T: Clone, U: Clone, X: Clone> { + DoubleStruct { t: T, u: U }, + TripleStruct { t: T, u: U, x: X }, +} diff --git a/vendor/derive_more/tests/index.rs b/vendor/derive_more/tests/index.rs new file mode 100644 index 000000000..952223c09 --- /dev/null +++ b/vendor/derive_more/tests/index.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, unused_imports)] +#[macro_use] +extern crate derive_more; + +#[derive(Index)] +struct MyVec(Vec<i32>); + +#[derive(Index)] +struct Numbers { + #[index] + numbers: Vec<i32>, + useless: bool, +} diff --git a/vendor/derive_more/tests/index_mut.rs b/vendor/derive_more/tests/index_mut.rs new file mode 100644 index 000000000..a053fd332 --- /dev/null +++ b/vendor/derive_more/tests/index_mut.rs @@ -0,0 +1,36 @@ +#![allow(dead_code, unused_imports)] +#[macro_use] +extern crate derive_more; + +#[derive(IndexMut)] +struct MyVec(Vec<i32>); +//Index implementation is required for IndexMut +impl<__IdxT> ::core::ops::Index<__IdxT> for MyVec +where + Vec<i32>: ::core::ops::Index<__IdxT>, +{ + type Output = <Vec<i32> as ::core::ops::Index<__IdxT>>::Output; + #[inline] + fn index(&self, idx: __IdxT) -> &Self::Output { + <Vec<i32> as ::core::ops::Index<__IdxT>>::index(&self.0, idx) + } +} + +#[derive(IndexMut)] +struct Numbers { + #[index_mut] + numbers: Vec<i32>, + useless: bool, +} + +//Index implementation is required for IndexMut +impl<__IdxT> ::core::ops::Index<__IdxT> for Numbers +where + Vec<i32>: ::core::ops::Index<__IdxT>, +{ + type Output = <Vec<i32> as ::core::ops::Index<__IdxT>>::Output; + #[inline] + fn index(&self, idx: __IdxT) -> &Self::Output { + <Vec<i32> as ::core::ops::Index<__IdxT>>::index(&self.numbers, idx) + } +} diff --git a/vendor/derive_more/tests/into.rs b/vendor/derive_more/tests/into.rs new file mode 100644 index 000000000..075abd1c9 --- /dev/null +++ b/vendor/derive_more/tests/into.rs @@ -0,0 +1,141 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +use std::borrow::Cow; + +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct EmptyTuple(); + +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct EmptyStruct {} + +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct EmptyUnit; + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[derive(Into)] +#[into(owned(types(i64, i128)), ref, ref_mut)] +struct MyInt(i32); + +#[test] +fn explicit_types_struct_owned_only() { + assert_eq!(i32::from(MyInt(42)), 42i32); + assert_eq!(<&i32>::from(&MyInt(42)), &42i32); + assert_eq!(<&mut i32>::from(&mut MyInt(42)), &mut 42i32); + assert_eq!(i64::from(MyInt(42)), 42i64); + assert_eq!(i128::from(MyInt(42)), 42i128); +} + +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct MyInts(i32, i32); + +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct Point1D { + x: i32, +} + +#[derive(Debug, Eq, PartialEq)] +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct Point2D { + x: i32, + y: i32, +} + +#[derive(Into)] +#[into(owned, ref, ref_mut)] +struct Point2DWithIgnored { + x: i32, + y: i32, + #[into(ignore)] + useless: bool, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[derive(Into)] +#[into(owned(types(i64, i128)), ref, ref_mut, types(i32))] +struct MyIntExplicit(MyInt); + +#[test] +fn explicit_types_struct_all() { + let mut input = MyIntExplicit(MyInt(42)); + assert_eq!(MyInt::from(input), MyInt(42)); + assert_eq!(<&MyInt>::from(&input), &MyInt(42)); + assert_eq!(<&mut MyInt>::from(&mut input), &mut MyInt(42)); + assert_eq!(i32::from(input), 42i32); + assert_eq!(<&i32>::from(&input), &42i32); + assert_eq!(<&mut i32>::from(&mut input), &mut 42i32); + assert_eq!(i64::from(input), 42i64); + assert_eq!(i128::from(input), 42i128); +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[derive(Into)] +#[into(owned(types(i32, i64, i128)), ref(types(i32)), ref_mut(types(i32)))] +struct MyIntsExplicit(i32, MyInt, MyIntExplicit); + +#[test] +fn explicit_types_struct_tupled() { + let mut input = MyIntsExplicit(42i32, MyInt(42), MyIntExplicit(MyInt(42))); + assert_eq!( + <(i32, MyInt, MyIntExplicit)>::from(input), + (42i32, MyInt(42), MyIntExplicit(MyInt(42))), + ); + assert_eq!( + <(&i32, &MyInt, &MyIntExplicit)>::from(&input), + (&42i32, &MyInt(42), &MyIntExplicit(MyInt(42))), + ); + assert_eq!( + <(&mut i32, &mut MyInt, &mut MyIntExplicit)>::from(&mut input), + (&mut 42i32, &mut MyInt(42), &mut MyIntExplicit(MyInt(42))), + ); + assert_eq!(<(i32, i32, i32)>::from(input), (42i32, 42i32, 42i32)); + assert_eq!(<(&i32, &i32, &i32)>::from(&input), (&42i32, &42i32, &42i32)); + assert_eq!( + <(&mut i32, &mut i32, &mut i32)>::from(&mut input), + (&mut 42i32, &mut 42i32, &mut 42i32), + ); + assert_eq!(<(i64, i64, i64)>::from(input), (42i64, 42i64, 42i64)); + assert_eq!(<(i128, i128, i128)>::from(input), (42i128, 42i128, 42i128)); +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[derive(Into)] +#[into(owned, ref, ref_mut, types(i32))] +struct Point2DExplicit { + x: MyInt, + y: MyInt, +} + +#[test] +fn explicit_types_point_2d() { + let mut input = Point2DExplicit { + x: MyInt(42), + y: MyInt(42), + }; + assert_eq!(<(i32, i32)>::from(input), (42i32, 42i32)); + assert_eq!(<(&i32, &i32)>::from(&input), (&42i32, &42i32)); + assert_eq!( + <(&mut i32, &mut i32)>::from(&mut input), + (&mut 42i32, &mut 42i32) + ); +} + +#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Into)] +#[into(owned(types("Cow<'_, str>")))] +struct Name(String); + +#[test] +fn explicit_complex_types_name() { + let name = "Ñolofinwë"; + let input = Name(name.to_owned()); + assert_eq!(String::from(input.clone()), name.to_owned()); + assert_eq!(Cow::from(input.clone()), Cow::Borrowed(name)); +} diff --git a/vendor/derive_more/tests/into_iterator.rs b/vendor/derive_more/tests/into_iterator.rs new file mode 100644 index 000000000..8c0e48f57 --- /dev/null +++ b/vendor/derive_more/tests/into_iterator.rs @@ -0,0 +1,39 @@ +#![allow(dead_code, unused_imports)] +#[macro_use] +extern crate derive_more; + +#[derive(IntoIterator)] +#[into_iterator(owned, ref, ref_mut)] +struct MyVec(Vec<i32>); + +#[derive(IntoIterator)] +#[into_iterator(owned, ref, ref_mut)] +struct Numbers { + numbers: Vec<i32>, +} + +#[derive(IntoIterator)] +struct Numbers2 { + #[into_iterator(owned, ref, ref_mut)] + numbers: Vec<i32>, + useless: bool, + useless2: bool, +} + +#[derive(IntoIterator)] +struct Numbers3 { + #[into_iterator(ref, ref_mut)] + numbers: Vec<i32>, + useless: bool, + useless2: bool, +} + +// Test that owned is not enabled when ref/ref_mut are enabled without owned +impl ::core::iter::IntoIterator for Numbers3 { + type Item = <Vec<i32> as ::core::iter::IntoIterator>::Item; + type IntoIter = <Vec<i32> as ::core::iter::IntoIterator>::IntoIter; + #[inline] + fn into_iter(self) -> Self::IntoIter { + <Vec<i32> as ::core::iter::IntoIterator>::into_iter(self.numbers) + } +} diff --git a/vendor/derive_more/tests/is_variant.rs b/vendor/derive_more/tests/is_variant.rs new file mode 100644 index 000000000..10876a40b --- /dev/null +++ b/vendor/derive_more/tests/is_variant.rs @@ -0,0 +1,57 @@ +#![allow(dead_code)] + +#[macro_use] +extern crate derive_more; + +#[derive(IsVariant)] +enum Either<TLeft, TRight> { + Left(TLeft), + Right(TRight), +} + +#[derive(IsVariant)] +enum Maybe<T> { + Nothing, + Just(T), +} + +#[derive(IsVariant)] +enum Color { + RGB(u8, u8, u8), + CMYK { c: u8, m: u8, y: u8, k: u8 }, +} + +#[derive(IsVariant)] +enum Nonsense<'a, T> { + Ref(&'a T), + NoRef, + #[is_variant(ignore)] + NoRefIgnored, +} + +#[derive(IsVariant)] +enum WithConstraints<T> +where + T: Copy, +{ + One(T), + Two, +} +#[derive(IsVariant)] +enum KitchenSink<'a, 'b, T1: Copy, T2: Clone> +where + T2: Into<T1> + 'b, +{ + Left(&'a T1), + Right(&'b T2), + OwnBoth { left: T1, right: T2 }, + Empty, + NeverMind(), + NothingToSeeHere {}, +} + +#[test] +pub fn test_is_variant() { + assert!(Maybe::<()>::Nothing.is_nothing()); + assert!(!Maybe::<()>::Nothing.is_just()); +} diff --git a/vendor/derive_more/tests/lib.rs b/vendor/derive_more/tests/lib.rs new file mode 100644 index 000000000..27fd53d33 --- /dev/null +++ b/vendor/derive_more/tests/lib.rs @@ -0,0 +1,275 @@ +#[macro_use] +extern crate derive_more; + +#[derive(From)] +#[derive(Into)] +#[derive(Constructor)] +#[derive(Eq, PartialEq, Debug, Clone)] +#[derive(Add)] +#[derive(Mul)] +#[derive(Neg)] +#[derive(AddAssign)] +#[derive(MulAssign)] +#[derive(FromStr)] +#[derive(Display)] +#[derive(Octal)] +#[derive(Binary)] +#[derive(Deref, DerefMut)] +#[into(owned, ref, ref_mut)] +struct MyInt(i32); + +#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Add)] +#[derive(Sum)] +#[derive(Mul)] +#[derive(MulAssign)] +#[derive(Product)] +#[mul(forward)] +#[mul_assign(forward)] +struct MyInt2(i32); + +#[derive(Eq, PartialEq, Debug)] +#[derive(Index, IndexMut)] +#[derive(Deref, DerefMut)] +#[derive(IntoIterator)] +#[deref(forward)] +#[deref_mut(forward)] +#[into_iterator(owned, ref, ref_mut)] +struct MyVec(Vec<i32>); + +#[derive(Eq, PartialEq, Debug)] +#[derive(Deref, DerefMut)] +#[deref(forward)] +#[deref_mut(forward)] +struct MyBoxedInt(Box<i32>); + +#[derive(Eq, PartialEq, Debug)] +#[derive(Not)] +#[derive(From)] +struct MyBool(bool); + +#[derive(From)] +#[derive(Into)] +#[derive(Constructor)] +#[derive(Add)] +#[derive(Eq, PartialEq, Debug)] +#[derive(Mul)] +#[derive(AddAssign)] +struct MyUInt(u64, u64); + +#[derive(From)] +#[derive(Into)] +#[derive(Constructor)] +#[derive(FromStr)] +#[derive(Eq, PartialEq, Debug)] +#[derive(Display)] +struct SimpleStruct { + int1: u64, +} + +#[derive(From)] +#[derive(Constructor)] +#[derive(Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shr, Shl)] +#[derive(Eq, PartialEq, Debug, Clone, Copy)] +#[derive(Into)] +#[derive(AddAssign)] +#[into(owned, ref, ref_mut)] +struct NormalStruct { + int1: u64, + int2: u64, +} + +#[derive(From)] +#[derive(Eq, PartialEq, Debug)] +struct NestedInt(MyInt); + +#[derive(Eq, PartialEq, Debug)] +#[derive(From)] +#[derive(Add, Sub)] +enum SimpleMyIntEnum { + Int(i32), + #[from(ignore)] + _UnsignedOne(u32), + _UnsignedTwo(u32), +} +#[derive(Eq, PartialEq, Debug)] +#[derive(From)] +#[derive(Neg)] +enum SimpleSignedIntEnum { + Int(i32), + Int2(i16), +} + +#[derive(Eq, PartialEq, Debug)] +#[derive(From)] +#[derive(Add, Sub)] +#[derive(Neg)] +enum SimpleEnum { + Int(i32), + #[from(ignore)] + _Ints(i32, i32), + LabeledInts { + a: i32, + b: i32, + }, + _SomeUnit, +} + +#[derive(Eq, PartialEq, Debug)] +#[derive(From)] +#[derive(Add, Sub)] +enum MyIntEnum { + SmallInt(i32), + BigInt(i64), + TwoInts(i32, i32), + Point2D { + x: i64, + y: i64, + }, + #[from(ignore)] + _UnsignedOne(u32), + _UnsignedTwo(u32), + #[from(ignore)] + _Uints1(u64, u64), + _Uints2 { + x: u64, + y: u64, + }, + Nothing, +} + +#[derive(Eq, PartialEq, Debug)] +#[derive(Add, Mul)] +struct DoubleUInt(u32, u32); + +#[derive(Eq, PartialEq, Debug)] +#[derive(Add, Mul)] +struct DoubleUIntStruct { + x: u32, + y: u32, +} + +#[derive(Eq, PartialEq, Debug)] +#[derive(From, Into, Constructor)] +struct Unit; + +// Tests that we can forward to a path +// containing `$crate` +macro_rules! use_dollar_crate { + () => { + struct Foo; + #[derive(From)] + enum Bar { + First(#[from(forward)] $crate::Foo), + } + }; +} + +use_dollar_crate!(); + +#[test] +fn main() { + let mut myint: MyInt = 5.into(); + let _: SimpleMyIntEnum = 5i32.into(); + let _: MyIntEnum = 5i32.into(); + let _: MyIntEnum = 6i64.into(); + let _: MyIntEnum = (5i32, 8i32).into(); + let _: MyIntEnum = (5i64, 8i64).into(); + let _: MyIntEnum = ().into(); + + let int_ref: &i32 = (&myint).into(); + assert_eq!(int_ref, &5); + + let int_ref_mut: &mut i32 = (&mut myint).into(); + assert_eq!(int_ref_mut, &mut 5); + + let mut myint: MyInt = 5.into(); + let _: Unit = ().into(); + assert_eq!((), Unit.into()); + assert_eq!(Unit, Unit::new()); + assert_eq!(MyInt(5), 5.into()); + assert_eq!(Ok(MyInt(5)), "5".parse()); + assert_eq!(5, MyInt(5).into()); + assert_eq!(MyInt(5), MyInt::new(5)); + assert_eq!(-MyInt(5), (-5).into()); + assert_eq!("30", format!("{}", MyInt(30))); + assert_eq!("36", format!("{:o}", MyInt(30))); + assert_eq!("100", format!("{:b}", MyInt(4))); + assert_eq!(!MyBool(true), false.into()); + assert_eq!(MyIntEnum::SmallInt(5), 5.into()); + + assert_eq!(SimpleStruct { int1: 5 }, 5.into()); + assert_eq!(5u64, SimpleStruct { int1: 5 }.into()); + assert_eq!(Ok(SimpleStruct { int1: 5 }), "5".parse()); + assert_eq!("5", format!("{}", SimpleStruct { int1: 5 })); + assert_eq!(NormalStruct { int1: 5, int2: 6 }, (5, 6).into()); + assert_eq!(SimpleStruct { int1: 5 }, SimpleStruct::new(5)); + assert_eq!(NormalStruct { int1: 5, int2: 6 }, NormalStruct::new(5, 6)); + assert_eq!((5, 6), NormalStruct::new(5, 6).into()); + let mut norm_struct = NormalStruct::new(5, 6); + let uints_ref: (&u64, &u64) = (&norm_struct).into(); + assert_eq!((&5, &6), uints_ref); + let uints_ref_mut: (&mut u64, &mut u64) = (&mut norm_struct).into(); + assert_eq!((&mut 5, &mut 6), uints_ref_mut); + + assert_eq!(MyInt(4) + MyInt(1), 5.into()); + myint += MyInt(3); + assert_eq!(myint, 8.into()); + myint *= 5; + assert_eq!(myint, 40.into()); + assert_eq!(MyInt(4) + MyInt(1), 5.into()); + assert_eq!(MyUInt(4, 5) + MyUInt(1, 2), MyUInt(5, 7)); + assert_eq!(MyUInt(4, 5), MyUInt::new(4, 5)); + assert_eq!((4, 5), MyUInt(4, 5).into()); + let mut s1 = NormalStruct { int1: 1, int2: 2 }; + let s2 = NormalStruct { int1: 2, int2: 3 }; + let s3 = NormalStruct { int1: 3, int2: 5 }; + assert_eq!(s1 + s2, s3); + assert_eq!(s3 - s2, s1); + s1 += s2; + assert_eq!(s1, s3); + + assert_eq!((SimpleMyIntEnum::Int(6) + 5.into()).unwrap(), 11.into()); + assert_eq!((SimpleMyIntEnum::Int(6) - 5.into()).unwrap(), 1.into()); + assert_eq!((SimpleMyIntEnum::Int(6) - 5.into()).unwrap(), 1.into()); + assert_eq!(-SimpleSignedIntEnum::Int(6), (-6i32).into()); + assert_eq!( + (SimpleEnum::LabeledInts { a: 6, b: 5 } + + SimpleEnum::LabeledInts { a: 1, b: 4 }) + .unwrap(), + SimpleEnum::LabeledInts { a: 7, b: 9 } + ); + + let _ = (MyIntEnum::SmallInt(5) + 6.into()).unwrap(); + assert_eq!((-SimpleEnum::Int(5)).unwrap(), (-5).into()); + + assert_eq!(MyInt(50), MyInt(5) * 10); + assert_eq!(DoubleUInt(5, 6) * 10, DoubleUInt(50, 60)); + // assert_eq!(DoubleUIntStruct{x:5, y:6} * 10, DoubleUIntStruct{x:50, y:60}); + + let mut myint = MyInt(5); + assert_eq!(5, *myint); + *myint = 7; + assert_eq!(MyInt(7), myint); + + let mut my_vec = MyVec(vec![5, 8]); + assert_eq!(5, my_vec[0]); + assert_eq!(8, my_vec[1]); + my_vec[0] = 20; + assert_eq!(20, my_vec[0]); + assert_eq!((&my_vec).into_iter().next(), Some(&20)); + assert_eq!((&mut my_vec).into_iter().next(), Some(&mut 20)); + assert_eq!(my_vec.into_iter().next(), Some(20)); + + let int_vec = vec![MyInt2(2), MyInt2(3)]; + assert_eq!(MyInt2(5), int_vec.clone().into_iter().sum()); + assert_eq!(MyInt2(6), int_vec.clone().into_iter().product()); + let mut myint2 = MyInt2(8); + myint2 *= MyInt2(4); + assert_eq!(MyInt2(32), myint2); + + let mut boxed = MyBoxedInt(Box::new(5)); + assert_eq!(5, *boxed); + *boxed = 7; + assert_eq!(MyBoxedInt(Box::new(7)), boxed) +} diff --git a/vendor/derive_more/tests/mul.rs b/vendor/derive_more/tests/mul.rs new file mode 100644 index 000000000..192806032 --- /dev/null +++ b/vendor/derive_more/tests/mul.rs @@ -0,0 +1,20 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +#[derive(Mul)] +struct MyInt(i32); + +#[derive(Mul)] +struct MyInts(i32, i32); + +#[derive(Mul)] +struct Point1D { + x: i32, +} + +#[derive(Mul)] +struct Point2D { + x: i32, + y: i32, +} diff --git a/vendor/derive_more/tests/mul_assign.rs b/vendor/derive_more/tests/mul_assign.rs new file mode 100644 index 000000000..f8aee3e18 --- /dev/null +++ b/vendor/derive_more/tests/mul_assign.rs @@ -0,0 +1,32 @@ +#![allow(dead_code)] +use std::marker::PhantomData; + +#[macro_use] +extern crate derive_more; + +#[derive(MulAssign)] +struct MyInt(i32); + +#[derive(MulAssign)] +struct MyInts(i32, i32); + +#[derive(MulAssign)] +#[mul_assign(forward)] +struct MyIntForward(i32); + +#[derive(MulAssign)] +struct Point1D { + x: i32, +} + +#[derive(MulAssign)] +struct Point2D { + x: i32, + y: i32, +} + +#[derive(MulAssign)] +struct MyInt2<T> { + x: i32, + ph: PhantomData<T>, +} diff --git a/vendor/derive_more/tests/no_std.rs b/vendor/derive_more/tests/no_std.rs new file mode 100644 index 000000000..a6680c38c --- /dev/null +++ b/vendor/derive_more/tests/no_std.rs @@ -0,0 +1,74 @@ +#![no_std] +#![allow(dead_code)] + +#[macro_use] +extern crate derive_more; + +#[derive( + AddAssign, + MulAssign, + Add, + Mul, + Not, + Index, + Display, + FromStr, + Into, + From, + IndexMut, + Sum, + Deref, + DerefMut, + Constructor +)] +#[into(owned, ref, ref_mut)] +struct MyInts(u64); + +#[derive(Deref, DerefMut)] +#[deref(forward)] +#[deref_mut(forward)] +struct MyBoxedInt<'a>(&'a mut u64); + +#[derive( + From, + FromStr, + Display, + Index, + Not, + Add, + Mul, + Sum, + IndexMut, + AddAssign, + Deref, + DerefMut, + IntoIterator, + Constructor +)] +#[deref(forward)] +#[deref_mut(forward)] +#[into_iterator(owned, ref, ref_mut)] +struct Wrapped<T: Clone>(T); + +#[derive(Deref, DerefMut)] +struct Wrapped2<T: Clone>(T); + +#[derive(From, Not, Add, Mul, AddAssign, Constructor, Sum)] +struct WrappedDouble<T: Clone, U: Clone>(T, U); + +#[derive(Add, Not, TryInto)] +#[try_into(owned, ref, ref_mut)] +enum MixedInts { + SmallInt(i32), + BigInt(i64), + TwoSmallInts(i32, i32), + NamedSmallInts { x: i32, y: i32 }, + UnsignedOne(u32), + UnsignedTwo(u32), +} + +#[derive(Not, Add)] +enum EnumWithUnit { + SmallInt(i32), + Unit, +} diff --git a/vendor/derive_more/tests/not.rs b/vendor/derive_more/tests/not.rs new file mode 100644 index 000000000..7e3ad8d01 --- /dev/null +++ b/vendor/derive_more/tests/not.rs @@ -0,0 +1,28 @@ +#![allow(dead_code)] +#[macro_use] +extern crate derive_more; + +#[derive(Not)] +struct MyInts(i32, i32); + +#[derive(Not)] +struct Point2D { + x: i32, + y: i32, +} + +#[derive(Not)] +enum MixedInts { + SmallInt(i32), + BigInt(i64), + TwoSmallInts(i32, i32), + NamedSmallInts { x: i32, y: i32 }, + UnsignedOne(u32), + UnsignedTwo(u32), +} + +#[derive(Not)] +enum EnumWithUnit { + SmallInt(i32), + Unit, +} diff --git a/vendor/derive_more/tests/sum.rs b/vendor/derive_more/tests/sum.rs new file mode 100644 index 000000000..a0b0967bd --- /dev/null +++ b/vendor/derive_more/tests/sum.rs @@ -0,0 +1,31 @@ +#[macro_use] +extern crate derive_more; + +#[derive(Sum)] +struct MyInts(i32, i64); + +// Add implementation is needed for Sum +impl ::core::ops::Add for MyInts { + type Output = MyInts; + #[inline] + fn add(self, rhs: MyInts) -> MyInts { + MyInts(self.0.add(rhs.0), self.1.add(rhs.1)) + } +} + +#[derive(Sum)] +struct Point2D { + x: i32, + y: i32, +} + +impl ::core::ops::Add for Point2D { + type Output = Point2D; + #[inline] + fn add(self, rhs: Point2D) -> Point2D { + Point2D { + x: self.x.add(rhs.x), + y: self.y.add(rhs.y), + } + } +} diff --git a/vendor/derive_more/tests/try_into.rs b/vendor/derive_more/tests/try_into.rs new file mode 100644 index 000000000..837c8e991 --- /dev/null +++ b/vendor/derive_more/tests/try_into.rs @@ -0,0 +1,199 @@ +#![allow(dead_code)] + +#[macro_use] +extern crate derive_more; + +use std::convert::{TryFrom, TryInto}; + +// Ensure that the TryFrom macro is hygenic and doesn't break when `Result` has +// been redefined. +type Result = (); + +#[derive(Clone, Copy, TryInto)] +#[try_into(owned, ref, ref_mut)] +enum MixedInts { + SmallInt(i32), + NamedBigInt { + int: i64, + }, + UnsignedWithIgnoredField(#[try_into(ignore)] bool, i64), + NamedUnsignedWithIgnnoredField { + #[try_into(ignore)] + useless: bool, + x: i64, + }, + TwoSmallInts(i32, i32), + NamedBigInts { + x: i64, + y: i64, + }, + Unsigned(u32), + NamedUnsigned { + x: u32, + }, + Unit, + #[try_into(ignore)] + Unit2, +} + +#[test] +fn test_try_into() { + let mut i = MixedInts::SmallInt(42); + assert_eq!(Ok(42i32), i.try_into()); + assert_eq!(Ok(&42i32), (&i).try_into()); + assert_eq!(Ok(&mut 42i32), (&mut i).try_into()); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!( + <(i32, i32)>::try_from(i), + Err("Only TwoSmallInts can be converted to (i32, i32)") + ); + assert_eq!( + <(i64, i64)>::try_from(i), + Err("Only NamedBigInts can be converted to (i64, i64)") + ); + assert_eq!( + u32::try_from(i), + Err("Only Unsigned, NamedUnsigned can be converted to u32") + ); + assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()")); + + let mut i = MixedInts::NamedBigInt { int: 42 }; + assert_eq!( + i32::try_from(i), + Err("Only SmallInt can be converted to i32") + ); + assert_eq!(Ok(42i64), i.try_into()); + assert_eq!(Ok(&42i64), (&i).try_into()); + assert_eq!(Ok(&mut 42i64), (&mut i).try_into()); + assert_eq!( + <(i32, i32)>::try_from(i), + Err("Only TwoSmallInts can be converted to (i32, i32)") + ); + assert_eq!( + <(i64, i64)>::try_from(i), + Err("Only NamedBigInts can be converted to (i64, i64)") + ); + assert_eq!( + u32::try_from(i), + Err("Only Unsigned, NamedUnsigned can be converted to u32") + ); + assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()")); + + let mut i = MixedInts::TwoSmallInts(42, 64); + assert_eq!( + i32::try_from(i), + Err("Only SmallInt can be converted to i32") + ); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!(Ok((42i32, 64i32)), i.try_into()); + assert_eq!(Ok((&42i32, &64i32)), (&i).try_into()); + assert_eq!(Ok((&mut 42i32, &mut 64i32)), (&mut i).try_into()); + assert_eq!( + <(i64, i64)>::try_from(i), + Err("Only NamedBigInts can be converted to (i64, i64)") + ); + assert_eq!( + u32::try_from(i), + Err("Only Unsigned, NamedUnsigned can be converted to u32") + ); + assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()")); + + let mut i = MixedInts::NamedBigInts { x: 42, y: 64 }; + assert_eq!( + i32::try_from(i), + Err("Only SmallInt can be converted to i32") + ); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!( + <(i32, i32)>::try_from(i), + Err("Only TwoSmallInts can be converted to (i32, i32)") + ); + assert_eq!(Ok((42i64, 64i64)), i.try_into()); + assert_eq!(Ok((&42i64, &64i64)), (&i).try_into()); + assert_eq!(Ok((&mut 42i64, &mut 64i64)), (&mut i).try_into()); + assert_eq!( + u32::try_from(i), + Err("Only Unsigned, NamedUnsigned can be converted to u32") + ); + assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()")); + + let mut i = MixedInts::Unsigned(42); + assert_eq!( + i32::try_from(i), + Err("Only SmallInt can be converted to i32") + ); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!( + <(i32, i32)>::try_from(i), + Err("Only TwoSmallInts can be converted to (i32, i32)") + ); + assert_eq!( + <(i64, i64)>::try_from(i), + Err("Only NamedBigInts can be converted to (i64, i64)") + ); + assert_eq!(Ok(42u32), i.try_into()); + assert_eq!(Ok(&42u32), (&i).try_into()); + assert_eq!(Ok(&mut 42u32), (&mut i).try_into()); + assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()")); + + let mut i = MixedInts::NamedUnsigned { x: 42 }; + assert_eq!( + i32::try_from(i), + Err("Only SmallInt can be converted to i32") + ); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!( + <(i32, i32)>::try_from(i), + Err("Only TwoSmallInts can be converted to (i32, i32)") + ); + assert_eq!( + <(i64, i64)>::try_from(i), + Err("Only NamedBigInts can be converted to (i64, i64)") + ); + assert_eq!(Ok(42u32), i.try_into()); + assert_eq!(Ok(&42u32), (&i).try_into()); + assert_eq!(Ok(&mut 42u32), (&mut i).try_into()); + assert_eq!(<()>::try_from(i), Err("Only Unit can be converted to ()")); + + let i = MixedInts::Unit; + assert_eq!( + i32::try_from(i), + Err("Only SmallInt can be converted to i32") + ); + assert_eq!( + i64::try_from(i), + Err("Only NamedBigInt, UnsignedWithIgnoredField, NamedUnsignedWithIgnnoredField can be converted to i64") + ); + assert_eq!( + <(i32, i32)>::try_from(i), + Err("Only TwoSmallInts can be converted to (i32, i32)") + ); + assert_eq!( + <(i64, i64)>::try_from(i), + Err("Only NamedBigInts can be converted to (i64, i64)") + ); + assert_eq!( + u32::try_from(i), + Err("Only Unsigned, NamedUnsigned can be converted to u32") + ); + assert_eq!(Ok(()), i.try_into()); +} diff --git a/vendor/derive_more/tests/unwrap.rs b/vendor/derive_more/tests/unwrap.rs new file mode 100644 index 000000000..ec84f7de9 --- /dev/null +++ b/vendor/derive_more/tests/unwrap.rs @@ -0,0 +1,62 @@ +#![allow(dead_code)] + +#[macro_use] +extern crate derive_more; + +#[derive(Unwrap)] +enum Either<TLeft, TRight> { + Left(TLeft), + Right(TRight), +} + +#[derive(Unwrap)] +enum Maybe<T> { + Nothing, + Just(T), +} + +#[derive(Unwrap)] +enum Color { + RGB(u8, u8, u8), + CMYK(u8, u8, u8, u8), +} + +#[derive(Unwrap)] +enum Nonsense<'a, T> { + Ref(&'a T), + NoRef, + #[unwrap(ignore)] + NoRefIgnored, +} + +#[derive(Unwrap)] +enum WithConstraints<T> +where + T: Copy, +{ + One(T), + Two, +} +#[derive(Unwrap)] +enum KitchenSink<'a, 'b, T1: Copy, T2: Clone> +where + T2: Into<T1> + 'b, +{ + Left(&'a T1), + Right(&'b T2), + OwnBoth(T1, T2), + Empty, + NeverMind(), + NothingToSeeHere(), +} + +#[test] +pub fn test_unwrap() { + assert_eq!(Maybe::<()>::Nothing.unwrap_nothing(), ()); +} + +#[test] +#[should_panic] +pub fn test_unwrap_panic() { + Maybe::<()>::Nothing.unwrap_just() +} |