diff options
Diffstat (limited to 'vendor/derivative/tests')
84 files changed, 5049 insertions, 0 deletions
diff --git a/vendor/derivative/tests/clippy-warning-clone-from.rs b/vendor/derivative/tests/clippy-warning-clone-from.rs new file mode 100644 index 000000000..6811e1a4b --- /dev/null +++ b/vendor/derivative/tests/clippy-warning-clone-from.rs @@ -0,0 +1,13 @@ +#![deny(clippy::all)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone(clone_from = "true"))] +pub struct Foo {} + +fn main() {} diff --git a/vendor/derivative/tests/compile-fail/derive-debug-unused.rs b/vendor/derivative/tests/compile-fail/derive-debug-unused.rs new file mode 100644 index 000000000..91cc077c7 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/derive-debug-unused.rs @@ -0,0 +1,19 @@ +#![deny(dead_code)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Foo { + foo: u8, + #[derivative(Debug="ignore")] + bar: u8, +} + +fn main() { + let _ = Foo { foo: 42, bar: 1 }; +}
\ No newline at end of file diff --git a/vendor/derivative/tests/compile-fail/derive-debug-unused.stderr b/vendor/derivative/tests/compile-fail/derive-debug-unused.stderr new file mode 100644 index 000000000..a56c9a2c6 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/derive-debug-unused.stderr @@ -0,0 +1,11 @@ +error: field is never used: `bar` + --> $DIR/derive-debug-unused.rs:14:5 + | +14 | bar: u8, + | ^^^^^^^ + | +note: lint level defined here + --> $DIR/derive-debug-unused.rs:1:9 + | +1 | #![deny(dead_code)] + | ^^^^^^^^^ diff --git a/vendor/derivative/tests/compile-fail/derive-debug.rs b/vendor/derivative/tests/compile-fail/derive-debug.rs new file mode 100644 index 000000000..82822a853 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/derive-debug.rs @@ -0,0 +1,15 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Foo<T, U> { + foo: T, + #[derivative(Debug(format_with="std::fmt::Debug::fmt"))] + bar: U, +} + +fn main() {}
\ No newline at end of file diff --git a/vendor/derivative/tests/compile-fail/derive-debug.stderr b/vendor/derivative/tests/compile-fail/derive-debug.stderr new file mode 100644 index 000000000..9bca7161e --- /dev/null +++ b/vendor/derivative/tests/compile-fail/derive-debug.stderr @@ -0,0 +1,9 @@ +error[E0277]: `U` doesn't implement `std::fmt::Debug` + --> $DIR/derive-debug.rs:11:36 + | +11 | #[derivative(Debug(format_with="std::fmt::Debug::fmt"))] + | ^^^^^^^^^^^^^^^^^^^^^^ `U` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug` + | + = help: the trait `std::fmt::Debug` is not implemented for `U` + = help: consider adding a `where U: std::fmt::Debug` bound + = note: required by `std::fmt::Debug::fmt` diff --git a/vendor/derivative/tests/compile-fail/derive-partial-ord.rs b/vendor/derivative/tests/compile-fail/derive-partial-ord.rs new file mode 100644 index 000000000..619788be7 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/derive-partial-ord.rs @@ -0,0 +1,11 @@ +#[macro_use] +extern crate derivative; + +#[derive(Derivative, PartialEq)] +#[derivative(PartialOrd)] +enum Option { + Some, + None, +} + +fn main() {} diff --git a/vendor/derivative/tests/compile-fail/derive-partial-ord.stderr b/vendor/derivative/tests/compile-fail/derive-partial-ord.stderr new file mode 100644 index 000000000..5786998cd --- /dev/null +++ b/vendor/derivative/tests/compile-fail/derive-partial-ord.stderr @@ -0,0 +1,5 @@ +error: can't use `#[derivative(PartialOrd)]` on an enumeration without `feature_allow_slow_enum`; see the documentation for more details + --> $DIR/derive-partial-ord.rs:5:1 + | +5 | #[derivative(PartialOrd)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/vendor/derivative/tests/compile-fail/invalid-attribute.rs b/vendor/derivative/tests/compile-fail/invalid-attribute.rs new file mode 100644 index 000000000..b03412356 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/invalid-attribute.rs @@ -0,0 +1,23 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone = not_a_string)] +struct Foo1; + +#[derive(Derivative)] +#[derivative(Clone = 1+2)] +struct Foo2; + +#[derive(Derivative)] +#[derivative(Default(new = "True"))] +struct Foo3; + +#[derive(Derivative)] +#[derivative(Debug(bound))] +struct Foo4; + +fn main() {}
\ No newline at end of file diff --git a/vendor/derivative/tests/compile-fail/invalid-attribute.stderr b/vendor/derivative/tests/compile-fail/invalid-attribute.stderr new file mode 100644 index 000000000..e3e0bb7b6 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/invalid-attribute.stderr @@ -0,0 +1,23 @@ +error: invalid attribute: expected literal + --> $DIR/invalid-attribute.rs:8:22 + | +8 | #[derivative(Clone = not_a_string)] + | ^^^^^^^^^^^^ + +error: invalid attribute: expected `,` + --> $DIR/invalid-attribute.rs:12:23 + | +12 | #[derivative(Clone = 1+2)] + | ^ + +error: expected `"true"` or `"false"` for `new`, got `True` + --> $DIR/invalid-attribute.rs:16:28 + | +16 | #[derivative(Default(new = "True"))] + | ^^^^^^ + +error: expected named value + --> $DIR/invalid-attribute.rs:20:20 + | +20 | #[derivative(Debug(bound))] + | ^^^^^ diff --git a/vendor/derivative/tests/compile-fail/unknown-attribute.rs b/vendor/derivative/tests/compile-fail/unknown-attribute.rs new file mode 100644 index 000000000..31cdaf431 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/unknown-attribute.rs @@ -0,0 +1,15 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone = "does_not_exist")] +struct Foo; + +#[derive(Derivative)] +#[derivative(Clone(does_not_exist = "true"))] +struct Bar; + +fn main() {}
\ No newline at end of file diff --git a/vendor/derivative/tests/compile-fail/unknown-attribute.stderr b/vendor/derivative/tests/compile-fail/unknown-attribute.stderr new file mode 100644 index 000000000..5383a2f4a --- /dev/null +++ b/vendor/derivative/tests/compile-fail/unknown-attribute.stderr @@ -0,0 +1,11 @@ +error: Unknown attribute `does_not_exist` for trait `Clone` + --> $DIR/unknown-attribute.rs:8:22 + | +8 | #[derivative(Clone = "does_not_exist")] + | ^^^^^^^^^^^^^^^^ + +error: Unknown attribute `does_not_exist` for trait `Clone` + --> $DIR/unknown-attribute.rs:12:20 + | +12 | #[derivative(Clone(does_not_exist = "true"))] + | ^^^^^^^^^^^^^^ diff --git a/vendor/derivative/tests/compile-fail/unknown-derive.rs b/vendor/derivative/tests/compile-fail/unknown-derive.rs new file mode 100644 index 000000000..0a9a689ae --- /dev/null +++ b/vendor/derivative/tests/compile-fail/unknown-derive.rs @@ -0,0 +1,22 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(DoesNotExist1)] +struct Foo; + +#[derive(Derivative)] +#[derivative(DoesNotExist2(with_some="argument"))] +struct Bar; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Baz { + #[derivative(DoesNotExist3)] + _baz: (), +} + +fn main() {}
\ No newline at end of file diff --git a/vendor/derivative/tests/compile-fail/unknown-derive.stderr b/vendor/derivative/tests/compile-fail/unknown-derive.stderr new file mode 100644 index 000000000..2d83f1834 --- /dev/null +++ b/vendor/derivative/tests/compile-fail/unknown-derive.stderr @@ -0,0 +1,17 @@ +error: deriving `DoesNotExist1` is not supported by derivative + --> $DIR/unknown-derive.rs:8:14 + | +8 | #[derivative(DoesNotExist1)] + | ^^^^^^^^^^^^^ + +error: deriving `DoesNotExist2` is not supported by derivative + --> $DIR/unknown-derive.rs:12:14 + | +12 | #[derivative(DoesNotExist2(with_some="argument"))] + | ^^^^^^^^^^^^^ + +error: deriving `DoesNotExist3` is not supported by derivative + --> $DIR/unknown-derive.rs:18:18 + | +18 | #[derivative(DoesNotExist3)] + | ^^^^^^^^^^^^^ diff --git a/vendor/derivative/tests/compile-test.rs b/vendor/derivative/tests/compile-test.rs new file mode 100644 index 000000000..361332a1c --- /dev/null +++ b/vendor/derivative/tests/compile-test.rs @@ -0,0 +1,9 @@ +extern crate trybuild; + +#[test] +#[ignore] +fn compile_test() { + let t = trybuild::TestCases::new(); + let pattern = std::env::var("DERIVATIVE_TEST_FILTER").unwrap_or_else(|_| String::from("*.rs")); + t.compile_fail(format!("tests/compile-fail/{}", pattern)); +} diff --git a/vendor/derivative/tests/derive-clone-generics.rs b/vendor/derivative/tests/derive-clone-generics.rs new file mode 100644 index 000000000..96919f9b3 --- /dev/null +++ b/vendor/derivative/tests/derive-clone-generics.rs @@ -0,0 +1,29 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::marker::PhantomData; + +struct NoClone; + +#[derive(Derivative)] +#[derivative(Clone, PartialEq)] +struct PhantomField<T> { + foo: PhantomData<T>, +} + +#[derive(Derivative)] +#[derivative(Clone, PartialEq)] +struct PhantomTuple<T> { + foo: PhantomData<(T,)>, +} + +#[test] +fn main() { + let phantom_field = PhantomField::<NoClone> { foo: Default::default() }; + let phantom_tuple = PhantomTuple::<NoClone> { foo: Default::default() }; + assert!(phantom_field == phantom_field.clone()); + assert!(phantom_tuple == phantom_tuple.clone()); +} diff --git a/vendor/derivative/tests/derive-clone.rs b/vendor/derivative/tests/derive-clone.rs new file mode 100755 index 000000000..9120d3ee3 --- /dev/null +++ b/vendor/derivative/tests/derive-clone.rs @@ -0,0 +1,66 @@ +#![allow(clippy::blacklisted_name, clippy::redundant_clone, clippy::trivially_copy_pass_by_ref)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Clone)] +struct Foo { + foo: u8, + #[derivative(Clone(clone_with="seventh"))] + bar: u8, +} + +fn seventh(a: &u8) -> u8 { + a/7 +} + +#[derive(Debug, PartialEq)] +struct EvilCloneFrom(u8); + +impl Clone for EvilCloneFrom { + fn clone(&self) -> Self { + EvilCloneFrom(self.0) + } + + fn clone_from(&mut self, _: &Self) { + self.0 = 42; + } +} + +#[derive(Derivative)] +#[derivative(Clone(clone_from="true"))] +struct StructWithCloneFrom(EvilCloneFrom); + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Clone(clone_from="true"))] +enum EnumWithCloneFrom { + Evil(EvilCloneFrom), + Good(u32), + None +} + +#[test] +fn main() { + let foo = Foo { foo: 31, bar: 42 }; + assert_eq!(Foo { foo: 31, bar: 6 }, foo.clone()); + + let mut foo = StructWithCloneFrom(EvilCloneFrom(27)); + foo.clone_from(&StructWithCloneFrom(EvilCloneFrom(0))); + assert_eq!((foo.0).0, 42); + + let mut foo = EnumWithCloneFrom::Evil(EvilCloneFrom(27)); + foo.clone_from(&EnumWithCloneFrom::Evil(EvilCloneFrom(0))); + assert_eq!(foo, EnumWithCloneFrom::Evil(EvilCloneFrom(42))); + + let mut foo = EnumWithCloneFrom::Evil(EvilCloneFrom(27)); + foo.clone_from(&EnumWithCloneFrom::None); + assert_eq!(foo, EnumWithCloneFrom::None); + + let mut foo = EnumWithCloneFrom::Good(27); + foo.clone_from(&EnumWithCloneFrom::None); + assert_eq!(foo, EnumWithCloneFrom::None); +} diff --git a/vendor/derivative/tests/derive-debug-bounds.rs b/vendor/derivative/tests/derive-debug-bounds.rs new file mode 100644 index 000000000..c572a508f --- /dev/null +++ b/vendor/derivative/tests/derive-debug-bounds.rs @@ -0,0 +1,83 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::fmt::{Formatter, Result as FmtResult}; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Foo<T, U> { + foo: T, + #[derivative(Debug(format_with="MyDebug::my_fmt", bound="U: MyDebug"))] + bar: U, +} + +#[derive(Derivative)] +#[derivative(Debug(bound="T: std::fmt::Debug, U: MyDebug"))] +struct Foo2<T, U> { + foo: T, + #[derivative(Debug(format_with="MyDebug::my_fmt"))] + bar: U, +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct Bar<T, U> ( + T, + #[derivative(Debug(format_with="MyDebug::my_fmt", bound="U: MyDebug"))] + U, +); + +#[derive(Derivative)] +#[derivative(Debug(bound="T: std::fmt::Debug, U: MyDebug"))] +struct Bar2<T, U> ( + T, + #[derivative(Debug(format_with="MyDebug::my_fmt"))] + U, +); + +struct NoDebug; + +struct GenericNeedsNoDebug<T>(T); +impl<T> std::fmt::Debug for GenericNeedsNoDebug<T> { + fn fmt(&self, f: &mut std::fmt::Formatter) -> FmtResult { + f.write_str("GenericNeedsNoDebug") + } +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct TestUnneededBound<T>( // Test that we don't add T: Debug + #[derivative(Debug(bound=""))] GenericNeedsNoDebug<T>, +); + +trait MyDebug { + fn my_fmt(&self, f: &mut Formatter) -> FmtResult { + f.write_str("MyDebug") + } +} + +impl MyDebug for i32 { } +impl<'a, T> MyDebug for &'a T { } + + +trait ToDebug { + fn to_show(&self) -> String; +} + +impl<T: std::fmt::Debug> ToDebug for T { + fn to_show(&self) -> String { + format!("{:?}", self) + } +} + +#[test] +fn main() { + assert_eq!(Foo { foo: 42, bar: 0 }.to_show(), "Foo { foo: 42, bar: MyDebug }".to_string()); + assert_eq!(Foo2 { foo: 42, bar: 0 }.to_show(), "Foo2 { foo: 42, bar: MyDebug }".to_string()); + assert_eq!(Bar(42, 0).to_show(), "Bar(42, MyDebug)".to_string()); + assert_eq!(Bar2(42, 0).to_show(), "Bar2(42, MyDebug)".to_string()); + assert_eq!(TestUnneededBound(GenericNeedsNoDebug(NoDebug)).to_show(), "TestUnneededBound(GenericNeedsNoDebug)".to_string()); +} diff --git a/vendor/derivative/tests/derive-debug-generics.rs b/vendor/derivative/tests/derive-debug-generics.rs new file mode 100644 index 000000000..97104c1d2 --- /dev/null +++ b/vendor/derivative/tests/derive-debug-generics.rs @@ -0,0 +1,93 @@ +#![allow(dead_code)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::marker::PhantomData; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Foo<T, U> { + foo: T, + #[derivative(Debug="ignore")] + bar: U, +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct Bar<T, U> ( + T, + #[derivative(Debug="ignore")] + U, +); + +#[derive(Derivative)] +#[derivative(Debug)] +enum C<T, U> { + V1(T), + V2(#[derivative(Debug="ignore")] U), + V3(String), +} + +#[derive(Derivative)] +#[derivative(Debug)] +enum D<U> { + V1 { + #[derivative(Debug="ignore")] + a: U + } +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct F<U>(#[derivative(Debug="ignore")] U); + +#[derive(Derivative)] +#[derivative(Debug)] +struct G<U>(isize, #[derivative(Debug="ignore")] U); + +#[derive(Derivative)] +#[derivative(Debug)] +struct J<U>(#[derivative(Debug="ignore")] U); + +struct NoDebug; + +trait ToDebug { + fn to_show(&self) -> String; +} + +impl<T: std::fmt::Debug> ToDebug for T { + fn to_show(&self) -> String { + format!("{:?}", self) + } +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct PhantomField<T> { + foo: PhantomData<T>, +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct PhantomTuple<T> { + foo: PhantomData<(T,)>, +} + +#[test] +fn main() { + assert_eq!(Foo { foo: 42, bar: NoDebug }.to_show(), "Foo { foo: 42 }".to_string()); + assert_eq!(Bar(42, NoDebug).to_show(), "Bar(42)".to_string()); + assert_eq!(C::V1::<i32, NoDebug>(12).to_show(), "V1(12)".to_string()); + assert_eq!(C::V2::<i32, NoDebug>(NoDebug).to_show(), "V2".to_string()); + assert_eq!(C::V3::<i32, NoDebug>("foo".to_string()).to_show(), "V3(\"foo\")".to_string()); + assert_eq!(D::V1 { a: NoDebug }.to_show(), "V1".to_string()); + assert_eq!(F(NoDebug).to_show(), "F".to_string()); + assert_eq!(G(42, NoDebug).to_show(), "G(42)".to_string()); + assert_eq!(J(NoDebug).to_show(), "J".to_string()); + assert_eq!(&format!("{:?}", PhantomField::<NoDebug> { foo: Default::default() }), "PhantomField { foo: PhantomData }"); + assert_eq!(&format!("{:?}", PhantomTuple::<NoDebug> { foo: Default::default() }), "PhantomTuple { foo: PhantomData }"); +} diff --git a/vendor/derivative/tests/derive-debug-packed.rs b/vendor/derivative/tests/derive-debug-packed.rs new file mode 100644 index 000000000..08ece8fea --- /dev/null +++ b/vendor/derivative/tests/derive-debug-packed.rs @@ -0,0 +1,74 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct Foo { + foo: u8, + #[derivative(Debug="ignore")] + bar: u8, +} + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct Bar ( + u8, + #[derivative(Debug="ignore")] + u8, +); + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct F(#[derivative(Debug="ignore")] isize); + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct G(isize, #[derivative(Debug="ignore")] isize); + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct J(#[derivative(Debug="ignore")] NoDebug); + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct K(isize, #[derivative(Debug="ignore")] NoDebug); + +#[derive(Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct L { + #[derivative(Debug="ignore")] + foo: NoDebug +} + +struct NoDebug; + +trait ToDebug { + fn to_show(&self) -> String; +} + +impl<T: std::fmt::Debug> ToDebug for T { + fn to_show(&self) -> String { + format!("{:?}", self) + } +} + +#[test] +fn main() { + assert_eq!(Foo { foo: 42, bar: 1 }.to_show(), "Foo { foo: 42 }".to_string()); + assert_eq!(Bar(42, 1).to_show(), "Bar(42)".to_string()); + assert_eq!(F(42).to_show(), "F".to_string()); + assert_eq!(G(42, 0).to_show(), "G(42)".to_string()); + assert_eq!(J(NoDebug).to_show(), "J".to_string()); + assert_eq!(K(42, NoDebug).to_show(), "K(42)".to_string()); + assert_eq!(L{ foo: NoDebug }.to_show(), "L".to_string()); +} diff --git a/vendor/derivative/tests/derive-debug-transparent.rs b/vendor/derivative/tests/derive-debug-transparent.rs new file mode 100644 index 000000000..fcbc587f8 --- /dev/null +++ b/vendor/derivative/tests/derive-debug-transparent.rs @@ -0,0 +1,39 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug="transparent")] +struct A(isize); + +#[derive(Derivative)] +#[derivative(Debug="transparent")] +struct B([isize; 1]); + +#[derive(Derivative)] +#[derivative(Debug)] +enum C { + Foo(u8), + #[derivative(Debug="transparent")] + Bar(u8), +} + +trait ToDebug { + fn to_show(&self) -> String; +} + +impl<T: std::fmt::Debug> ToDebug for T { + fn to_show(&self) -> String { + format!("{:?}", self) + } +} + +#[test] +fn main() { + assert_eq!(A(42).to_show(), "42".to_string()); + assert_eq!(B([42]).to_show(), "[42]".to_string()); + assert_eq!(C::Foo(42).to_show(), "Foo(42)".to_string()); + assert_eq!(C::Bar(42).to_show(), "42".to_string()); +} diff --git a/vendor/derivative/tests/derive-debug.rs b/vendor/derivative/tests/derive-debug.rs new file mode 100644 index 000000000..1c218bbeb --- /dev/null +++ b/vendor/derivative/tests/derive-debug.rs @@ -0,0 +1,77 @@ +#![allow(dead_code)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Foo { + foo: u8, + #[derivative(Debug="ignore")] + bar: u8, +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct Bar ( + u8, + #[derivative(Debug="ignore")] + u8, +); + +#[derive(Derivative)] +#[derivative(Debug)] +enum C { + V1(isize), + V2(#[derivative(Debug="ignore")] i32), + V3(String), +} + +#[derive(Derivative)] +#[derivative(Debug)] +enum D { + V1 { + #[derivative(Debug="ignore")] + a: isize + } +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct F(#[derivative(Debug="ignore")] isize); + +#[derive(Derivative)] +#[derivative(Debug)] +struct G(isize, #[derivative(Debug="ignore")] isize); + +#[derive(Derivative)] +#[derivative(Debug)] +struct J(#[derivative(Debug="ignore")] NoDebug); + +struct NoDebug; + +trait ToDebug { + fn to_show(&self) -> String; +} + +impl<T: std::fmt::Debug> ToDebug for T { + fn to_show(&self) -> String { + format!("{:?}", self) + } +} + +#[test] +fn main() { + assert_eq!(Foo { foo: 42, bar: 1 }.to_show(), "Foo { foo: 42 }".to_string()); + assert_eq!(Bar(42, 1).to_show(), "Bar(42)".to_string()); + assert_eq!(C::V1(12).to_show(), "V1(12)".to_string()); + assert_eq!(C::V2(12).to_show(), "V2".to_string()); + assert_eq!(C::V3("foo".to_string()).to_show(), "V3(\"foo\")".to_string()); + assert_eq!(D::V1 { a: 42 }.to_show(), "V1".to_string()); + assert_eq!(F(42).to_show(), "F".to_string()); + assert_eq!(G(42, 0).to_show(), "G(42)".to_string()); + assert_eq!(J(NoDebug).to_show(), "J".to_string()); +} diff --git a/vendor/derivative/tests/derive-default-bounds.rs b/vendor/derivative/tests/derive-default-bounds.rs new file mode 100755 index 000000000..fda2efc98 --- /dev/null +++ b/vendor/derivative/tests/derive-default-bounds.rs @@ -0,0 +1,42 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default="new")] +struct Foo<T, U> { + foo: T, + #[derivative(Default(value="min()", bound="U: std::ops::Not<Output=U>, U: Default"))] + bar: U, +} + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default(bound="T: Default, U: std::ops::Not<Output=U>, U: Default", new="true"))] +struct Bar<T, U> { + foo: T, + #[derivative(Default(value="min()"))] + bar: U, +} + +fn min<T: Default + std::ops::Not<Output=T>>() -> T { + !T::default() +} + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default(bound=""))] +struct WithOption<T> { + foo: Option<T>, +} + +struct NonDefault; + +#[test] +fn main() { + assert_eq!(Foo::default(), Foo { foo: 0u8, bar: 0xffu8 }); + assert_eq!(Bar::default(), Bar { foo: 0u8, bar: 0xffu8 }); + assert_eq!(Foo::new(), Foo { foo: 0u8, bar: 0xffu8 }); + assert_eq!(Bar::new(), Bar { foo: 0u8, bar: 0xffu8 }); + WithOption::<NonDefault>::default(); +} diff --git a/vendor/derivative/tests/derive-default.rs b/vendor/derivative/tests/derive-default.rs new file mode 100644 index 000000000..34e0806b8 --- /dev/null +++ b/vendor/derivative/tests/derive-default.rs @@ -0,0 +1,78 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default="new")] +struct Foo { + foo: u8, + #[derivative(Default(value="42"))] + bar: u8, +} + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default(new="true"))] +struct Bar ( + u8, + #[derivative(Default(value="42"))] + u8, +); + +#[derive(Debug, PartialEq)] +struct B1(u8, u8); +#[derive(Debug, PartialEq)] +struct B2{a:u8, b:u8} + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default(new="true"))] +struct Baz ( + #[derivative(Default(value="[1,2]"))] + [u8;2], + #[derivative(Default(value="[3;2]"))] + [u8;2], + #[derivative(Default(value="(4,5)"))] + (u8, u8), + #[derivative(Default(value="B1(6,7)"))] + B1, + #[derivative(Default(value="B2{a:8,b:9}"))] + B2, +); + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default)] +enum Enum1 { + #[allow(dead_code)] + A, + #[derivative(Default)] + B, +} + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default)] +enum Enum2 { + #[derivative(Default)] + A, + #[allow(dead_code)] + B, +} + +#[derive(Debug, Derivative, PartialEq)] +#[derivative(Default)] +struct A(#[derivative(Default(value="NoDefault"))] NoDefault); + +#[derive(Debug, PartialEq)] +struct NoDefault; + +#[test] +fn main() { + assert_eq!(Foo::default(), Foo { foo: 0, bar: 42 }); + assert_eq!(Foo::new(), Foo { foo: 0, bar: 42 }); + assert_eq!(Bar::default(), Bar(0, 42)); + assert_eq!(Bar::new(), Bar(0, 42)); + assert_eq!(Baz::new(), Baz([1,2], [3,3], (4,5), B1(6,7), B2{a:8,b:9})); + assert_eq!(A::default(), A(NoDefault)); + assert_eq!(Enum1::default(), Enum1::B); + assert_eq!(Enum2::default(), Enum2::A); +} diff --git a/vendor/derivative/tests/derive-eq-packed.rs b/vendor/derivative/tests/derive-eq-packed.rs new file mode 100644 index 000000000..6e495c274 --- /dev/null +++ b/vendor/derivative/tests/derive-eq-packed.rs @@ -0,0 +1,61 @@ +#![allow(clippy::eq_op)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative, PartialEq)] +#[derivative(Eq)] +#[repr(C, packed)] +struct Foo { + foo: u8 +} + +#[derive(Derivative)] +#[derivative(Eq)] +#[repr(C, packed)] +struct WithPtr<T: ?Sized> { + #[derivative(Eq(bound=""))] + foo: *const T +} + +impl<T: ?Sized> PartialEq for WithPtr<T> { + fn eq(&self, other: &Self) -> bool { + self.foo == other.foo + } +} + +#[derive(Derivative)] +#[derivative(PartialEq, Eq)] +#[repr(C, packed)] +struct Generic<T>(T); + +trait SomeTrait {} +#[derive(Clone, Copy, PartialEq, Eq)] +struct SomeType { + #[allow(dead_code)] + foo: u8 +} +impl SomeTrait for SomeType {} + +fn assert_eq<T: Eq>(_: T) {} + +#[test] +fn main() { + assert!(Foo { foo: 7 } == Foo { foo: 7 }); + assert!(Foo { foo: 7 } != Foo { foo: 42 }); + + assert_eq(Foo { foo: 7 }); + + let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 }; + let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 }; + assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 }); + assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 }); + + assert_eq(WithPtr { foo: ptr1 }); + + assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 })); + assert_eq(Generic(SomeType { foo: 0 })); +} diff --git a/vendor/derivative/tests/derive-eq.rs b/vendor/derivative/tests/derive-eq.rs new file mode 100644 index 000000000..c52a5d3b3 --- /dev/null +++ b/vendor/derivative/tests/derive-eq.rs @@ -0,0 +1,50 @@ +#![allow(clippy::eq_op)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative, PartialEq)] +#[derivative(Eq)] +struct Foo { + foo: u8 +} + +#[derive(Derivative)] +#[derivative(Eq)] +struct WithPtr<T: ?Sized> { + #[derivative(Eq(bound=""))] + foo: *const T +} + +impl<T: ?Sized> PartialEq for WithPtr<T> { + fn eq(&self, other: &Self) -> bool { + self.foo == other.foo + } +} + +trait SomeTrait {} +struct SomeType { + #[allow(dead_code)] + foo: u8 +} +impl SomeTrait for SomeType {} + +fn assert_eq<T: Eq>(_: T) {} + +#[test] +fn main() { + assert!(Foo { foo: 7 } == Foo { foo: 7 }); + assert!(Foo { foo: 7 } != Foo { foo: 42 }); + + assert_eq(Foo { foo: 7 }); + + let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 }; + let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 }; + assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 }); + assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 }); + + assert_eq(WithPtr { foo: ptr1 }); +} diff --git a/vendor/derivative/tests/derive-hash.rs b/vendor/derivative/tests/derive-hash.rs new file mode 100755 index 000000000..e7d057aed --- /dev/null +++ b/vendor/derivative/tests/derive-hash.rs @@ -0,0 +1,134 @@ +//! This tests that we compute the same hash as `derive(Hash)`. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +macro_rules! define { + ($kw:tt $($rest:tt)*) => { + #[derive(Derivative)] + #[derivative(Hash)] + $kw Ours $($rest)* + + #[derive(Hash)] + $kw Theirs $($rest)* + } +} + +struct FakeHasher<'a>(&'a mut Vec<u8>); +impl<'a> ::std::hash::Hasher for FakeHasher<'a> { + fn finish(&self) -> u64 { + unimplemented!() + } + + fn write(&mut self, bytes: &[u8]) { + self.0.extend(bytes); + } +} + +fn fake_hash<E: ::std::hash::Hash>(e: E) -> Vec<u8> { + let mut v = Vec::new(); + e.hash(&mut FakeHasher(&mut v)); + v +} + +#[test] +fn main() { + { + define! { + struct; + } + + assert_eq!(fake_hash(Ours), fake_hash(Theirs)); + } + + { + define! { + struct { + foo: u8 + } + } + + assert_eq!(fake_hash(Ours { foo: 0 }), fake_hash(Theirs { foo: 0 })); + assert_eq!(fake_hash(Ours { foo: 42 }), fake_hash(Theirs { foo: 42 })); + } + + { + define! { + struct<'a> { + foo: u8, + bar: &'a str, + } + } + + assert_eq!(fake_hash(Ours { foo: 0, bar: "bar" }), fake_hash(Theirs { foo: 0, bar: "bar" })); + assert_eq!(fake_hash(Ours { foo: 42, bar: "bar" }), fake_hash(Theirs { foo: 42, bar: "bar" })); + } + + { + define! { + struct<'a> (u8, &'a str); + } + + assert_eq!(fake_hash(Ours ( 0, "bar" )), fake_hash(Theirs ( 0, "bar" ))); + assert_eq!(fake_hash(Ours ( 42, "bar" )), fake_hash(Theirs ( 42, "bar" ))); + } + + { + define! { + enum { + A, B, C + } + } + + assert_eq!(fake_hash(Ours::A), fake_hash(Theirs::A)); + assert_eq!(fake_hash(Ours::B), fake_hash(Theirs::B)); + assert_eq!(fake_hash(Ours::C), fake_hash(Theirs::C)); + } + + { + define! { + enum { + A, B = 42, C + } + } + + assert_eq!(fake_hash(Ours::A), fake_hash(Theirs::A)); + assert_eq!(fake_hash(Ours::B), fake_hash(Theirs::B)); + assert_eq!(fake_hash(Ours::C), fake_hash(Theirs::C)); + } + + { + define! { + enum { + A, B = 42, C=1 + } + } + + assert_eq!(fake_hash(Ours::A), fake_hash(Theirs::A)); + assert_eq!(fake_hash(Ours::B), fake_hash(Theirs::B)); + assert_eq!(fake_hash(Ours::C), fake_hash(Theirs::C)); + } + + { + #[derive(Derivative)] + #[derivative(Hash)] + struct Ours<'a> { + foo: u8, + #[derivative(Hash="ignore")] + bar: &'a str, + baz: i64, + } + + #[derive(Hash)] + struct Theirs { + foo: u8, + baz: i64, + } + + assert_eq!(fake_hash(Ours { foo: 0, bar: "bar", baz: 312 }), fake_hash(Theirs { foo: 0, baz: 312 })); + assert_eq!(fake_hash(Ours { foo: 42, bar: "bar", baz: 312 }), fake_hash(Theirs { foo: 42, baz: 312 })); + } +} diff --git a/vendor/derivative/tests/derive-ord-packed.rs b/vendor/derivative/tests/derive-ord-packed.rs new file mode 100644 index 000000000..7b4cad711 --- /dev/null +++ b/vendor/derivative/tests/derive-ord-packed.rs @@ -0,0 +1,264 @@ +#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity +#![allow(clippy::cyclomatic_complexity)] +#![allow(clippy::cognitive_complexity)] +#![allow(clippy::trivially_copy_pass_by_ref)] +#![allow(clippy::unknown_clippy_lints)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +#[repr(C, packed)] +struct Foo { + foo: u8, +} + +#[derive(Derivative)] +#[derivative(PartialEq, PartialOrd, Ord, Eq)] +#[repr(C, packed)] +struct WithPtr<T: ?Sized> { + #[derivative(PartialEq(bound = ""))] + #[derivative(PartialOrd(bound = ""))] + #[derivative(Ord(bound = ""))] + #[derivative(Eq(bound = ""))] + foo: *const T, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +#[repr(C, packed)] +struct Empty; + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +#[repr(C, packed)] +struct AllIgnored { + #[derivative(PartialOrd = "ignore")] + #[derivative(Ord = "ignore")] + foo: u8, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +#[repr(C, packed)] +struct OneIgnored { + #[derivative(PartialOrd = "ignore")] + #[derivative(Ord = "ignore")] + foo: u8, + bar: u8, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +#[repr(C, packed)] +struct Tenth( + #[derivative( + PartialOrd(compare_with = "partial_cmp_tenth"), + Ord(compare_with = "cmp_tenth") + )] + u8, +); + +fn partial_cmp_tenth(lhs: &u8, rhs: &u8) -> std::option::Option<std::cmp::Ordering> { + if *lhs == 0 { + None + } else { + Some((lhs / 10).cmp(&(rhs / 10))) + } +} +fn cmp_tenth(lhs: &u8, rhs: &u8) -> std::cmp::Ordering { + (lhs / 10).cmp(&(rhs / 10)) +} + +#[derive(Derivative)] +#[derivative(PartialOrd, Ord, PartialEq, Eq)] +#[repr(C, packed)] +struct Generic<T>( + #[derivative( + PartialEq = "ignore", + PartialOrd(compare_with = "dummy_partial_cmp", bound = ""), + Ord(compare_with = "dummy_cmp", bound = "") + )] + T, +); + +fn dummy_partial_cmp<T>(_: &T, _: &T) -> std::option::Option<std::cmp::Ordering> { + Some(std::cmp::Ordering::Less) +} +fn dummy_cmp<T>(_: &T, _: &T) -> std::cmp::Ordering { + std::cmp::Ordering::Less +} + +struct NonPartialOrd; + +#[derive(Derivative)] +#[derivative(PartialEq, PartialOrd, Ord, Eq)] +#[repr(C, packed)] +struct GenericIgnore<T> { + f: u32, + #[derivative(PartialEq = "ignore")] + #[derivative(PartialOrd = "ignore")] + #[derivative(Ord = "ignore")] + t: T, +} + +trait SomeTrait {} + +#[derive(Clone, Copy)] +struct SomeType { + #[allow(dead_code)] + foo: u8, +} +impl SomeTrait for SomeType {} + +#[test] +fn main() { + use std::cmp::Ordering; + + assert_eq!( + Foo { foo: 7 }.partial_cmp(&Foo { foo: 42 }), + Some(Ordering::Less) + ); + assert_eq!( + Foo { foo: 42 }.partial_cmp(&Foo { foo: 42 }), + Some(Ordering::Equal) + ); + assert_eq!( + Foo { foo: 42 }.partial_cmp(&Foo { foo: 7 }), + Some(Ordering::Greater) + ); + assert_eq!(Foo { foo: 7 }.cmp(&Foo { foo: 42 }), Ordering::Less); + assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 42 }), Ordering::Equal); + assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 7 }), Ordering::Greater); + + let pointers: [*const dyn SomeTrait; 2] = [&SomeType { foo: 1 }, &SomeType { foo: 0 }]; + let ptr1: *const dyn SomeTrait = pointers[0]; + let ptr2: *const dyn SomeTrait = pointers[1]; + let (ptr1, ptr2) = (std::cmp::min(ptr1, ptr2), std::cmp::max(ptr1, ptr2)); + assert_eq!( + WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr1 }), + Some(Ordering::Equal) + ); + assert_eq!( + WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr1 }), + Ordering::Equal + ); + assert_eq!( + WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr2 }), + Some(Ordering::Less) + ); + assert_eq!( + WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr2 }), + Ordering::Less + ); + + assert_eq!(Empty.partial_cmp(&Empty), Some(Ordering::Equal)); + assert_eq!( + AllIgnored { foo: 0 }.partial_cmp(&AllIgnored { foo: 42 }), + Some(Ordering::Equal) + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 7 }), + Some(Ordering::Less) + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }), + Some(Ordering::Equal) + ); + assert_eq!( + OneIgnored { foo: 0, bar: 7 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }), + Some(Ordering::Greater) + ); + assert_eq!(Empty.cmp(&Empty), Ordering::Equal); + assert_eq!( + AllIgnored { foo: 0 }.cmp(&AllIgnored { foo: 42 }), + Ordering::Equal + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 7 }), + Ordering::Less + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 6 }), + Ordering::Equal + ); + assert_eq!( + OneIgnored { foo: 0, bar: 7 }.cmp(&OneIgnored { foo: 42, bar: 6 }), + Ordering::Greater + ); + + assert_eq!( + Option::None::<u8>.partial_cmp(&Option::Some(7)), + Some(Ordering::Less) + ); + assert_eq!( + Option::Some(6).partial_cmp(&Option::Some(7)), + Some(Ordering::Less) + ); + assert_eq!( + Option::Some(42).partial_cmp(&Option::Some(42)), + Some(Ordering::Equal) + ); + assert_eq!( + Option::None::<u8>.partial_cmp(&Option::None::<u8>), + Some(Ordering::Equal) + ); + assert_eq!( + Option::Some(7).partial_cmp(&Option::Some(6)), + Some(Ordering::Greater) + ); + assert_eq!( + Option::Some(7).partial_cmp(&Option::None::<u8>), + Some(Ordering::Greater) + ); + assert_eq!(Option::None::<u8>.cmp(&Option::Some(7)), Ordering::Less); + assert_eq!(Option::Some(6).cmp(&Option::Some(7)), Ordering::Less); + assert_eq!(Option::Some(42).cmp(&Option::Some(42)), Ordering::Equal); + assert_eq!(Option::None::<u8>.cmp(&Option::None::<u8>), Ordering::Equal); + assert_eq!(Option::Some(7).cmp(&Option::Some(6)), Ordering::Greater); + assert_eq!(Option::Some(7).cmp(&Option::None::<u8>), Ordering::Greater); + + assert_eq!(Tenth(0).partial_cmp(&Tenth(67)), None); + assert_eq!(Tenth(42).partial_cmp(&Tenth(67)), Some(Ordering::Less)); + assert_eq!(Tenth(60).partial_cmp(&Tenth(67)), Some(Ordering::Equal)); + assert_eq!(Tenth(100).partial_cmp(&Tenth(67)), Some(Ordering::Greater)); + assert_eq!(Tenth(42).cmp(&Tenth(67)), Ordering::Less); + assert_eq!(Tenth(60).cmp(&Tenth(67)), Ordering::Equal); + assert_eq!(Tenth(100).cmp(&Tenth(67)), Ordering::Greater); + + assert_eq!( + Generic(SomeType { foo: 0 }).partial_cmp(&Generic(SomeType { foo: 0 })), + Some(Ordering::Less) + ); + assert_eq!( + Generic(SomeType { foo: 0 }).cmp(&Generic(SomeType { foo: 0 })), + Ordering::Less + ); + + assert_eq!( + GenericIgnore { + f: 123, + t: NonPartialOrd + } + .cmp(&GenericIgnore { + f: 123, + t: NonPartialOrd + }), + Ordering::Equal + ); + assert_eq!( + GenericIgnore { + f: 123, + t: NonPartialOrd + } + .partial_cmp(&GenericIgnore { + f: 123, + t: NonPartialOrd + }), + Some(Ordering::Equal) + ); +} diff --git a/vendor/derivative/tests/derive-ord.rs b/vendor/derivative/tests/derive-ord.rs new file mode 100644 index 000000000..cb55a19e8 --- /dev/null +++ b/vendor/derivative/tests/derive-ord.rs @@ -0,0 +1,266 @@ +#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity +#![allow(clippy::cyclomatic_complexity)] +#![allow(clippy::cognitive_complexity)] +#![allow(clippy::trivially_copy_pass_by_ref)] +#![allow(clippy::unknown_clippy_lints)] + +#[cfg(feature = "use_core")] +extern crate core; + +use std::marker::PhantomData; + +#[macro_use] +extern crate derivative; + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +struct Foo { + foo: u8, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative( + PartialOrd = "feature_allow_slow_enum", + Ord = "feature_allow_slow_enum" +)] +enum Option<T> { + None, + Some(T), +} + +#[derive(Derivative)] +#[derivative(PartialEq, PartialOrd, Ord, Eq)] +struct WithPtr<T: ?Sized> { + #[derivative(PartialEq(bound = ""))] + #[derivative(PartialOrd(bound = ""))] + #[derivative(Ord(bound = ""))] + #[derivative(Eq(bound = ""))] + foo: *const T, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +struct Empty; + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +struct AllIgnored { + #[derivative(PartialOrd = "ignore")] + #[derivative(Ord = "ignore")] + foo: u8, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +struct OneIgnored { + #[derivative(PartialOrd = "ignore")] + #[derivative(Ord = "ignore")] + foo: u8, + bar: u8, +} + +#[derive(PartialEq, Eq, Derivative)] +#[derivative(PartialOrd, Ord)] +struct Tenth( + #[derivative( + PartialOrd(compare_with = "partial_cmp_tenth"), + Ord(compare_with = "cmp_tenth") + )] + u8, +); + +fn partial_cmp_tenth(lhs: &u8, rhs: &u8) -> std::option::Option<std::cmp::Ordering> { + if *lhs == 0 { + None + } else { + Some((lhs / 10).cmp(&(rhs / 10))) + } +} +fn cmp_tenth(lhs: &u8, rhs: &u8) -> std::cmp::Ordering { + (lhs / 10).cmp(&(rhs / 10)) +} + +#[derive(Derivative)] +#[derivative(PartialOrd, Ord, PartialEq, Eq)] +struct Generic<T>( + #[derivative( + PartialEq = "ignore", + PartialOrd(compare_with = "dummy_partial_cmp", bound = ""), + Ord(compare_with = "dummy_cmp", bound = "") + )] + T, +); + +fn dummy_partial_cmp<T>(_: &T, _: &T) -> std::option::Option<std::cmp::Ordering> { + Some(std::cmp::Ordering::Less) +} +fn dummy_cmp<T>(_: &T, _: &T) -> std::cmp::Ordering { + std::cmp::Ordering::Less +} + +struct NonPartialOrd; + +#[derive(Derivative)] +#[derivative(PartialEq, PartialOrd, Ord, Eq)] +struct GenericIgnore<T> { + f: u32, + #[derivative(PartialEq = "ignore")] + #[derivative(PartialOrd = "ignore")] + #[derivative(Ord = "ignore")] + t: PhantomData<T>, +} + +trait SomeTrait {} +struct SomeType { + #[allow(dead_code)] + foo: u8, +} +impl SomeTrait for SomeType {} + +#[test] +fn main() { + use std::cmp::Ordering; + + assert_eq!( + Foo { foo: 7 }.partial_cmp(&Foo { foo: 42 }), + Some(Ordering::Less) + ); + assert_eq!( + Foo { foo: 42 }.partial_cmp(&Foo { foo: 42 }), + Some(Ordering::Equal) + ); + assert_eq!( + Foo { foo: 42 }.partial_cmp(&Foo { foo: 7 }), + Some(Ordering::Greater) + ); + assert_eq!(Foo { foo: 7 }.cmp(&Foo { foo: 42 }), Ordering::Less); + assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 42 }), Ordering::Equal); + assert_eq!(Foo { foo: 42 }.cmp(&Foo { foo: 7 }), Ordering::Greater); + + let pointers: [*const dyn SomeTrait; 2] = [&SomeType { foo: 1 }, &SomeType { foo: 0 }]; + let ptr1: *const dyn SomeTrait = pointers[0]; + let ptr2: *const dyn SomeTrait = pointers[1]; + let (ptr1, ptr2) = (std::cmp::min(ptr1, ptr2), std::cmp::max(ptr1, ptr2)); + assert_eq!( + WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr1 }), + Some(Ordering::Equal) + ); + assert_eq!( + WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr1 }), + Ordering::Equal + ); + assert_eq!( + WithPtr { foo: ptr1 }.partial_cmp(&WithPtr { foo: ptr2 }), + Some(Ordering::Less) + ); + assert_eq!( + WithPtr { foo: ptr1 }.cmp(&WithPtr { foo: ptr2 }), + Ordering::Less + ); + + assert_eq!(Empty.partial_cmp(&Empty), Some(Ordering::Equal)); + assert_eq!( + AllIgnored { foo: 0 }.partial_cmp(&AllIgnored { foo: 42 }), + Some(Ordering::Equal) + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 7 }), + Some(Ordering::Less) + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }), + Some(Ordering::Equal) + ); + assert_eq!( + OneIgnored { foo: 0, bar: 7 }.partial_cmp(&OneIgnored { foo: 42, bar: 6 }), + Some(Ordering::Greater) + ); + assert_eq!(Empty.cmp(&Empty), Ordering::Equal); + assert_eq!( + AllIgnored { foo: 0 }.cmp(&AllIgnored { foo: 42 }), + Ordering::Equal + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 7 }), + Ordering::Less + ); + assert_eq!( + OneIgnored { foo: 0, bar: 6 }.cmp(&OneIgnored { foo: 42, bar: 6 }), + Ordering::Equal + ); + assert_eq!( + OneIgnored { foo: 0, bar: 7 }.cmp(&OneIgnored { foo: 42, bar: 6 }), + Ordering::Greater + ); + + assert_eq!( + Option::None::<u8>.partial_cmp(&Option::Some(7)), + Some(Ordering::Less) + ); + assert_eq!( + Option::Some(6).partial_cmp(&Option::Some(7)), + Some(Ordering::Less) + ); + assert_eq!( + Option::Some(42).partial_cmp(&Option::Some(42)), + Some(Ordering::Equal) + ); + assert_eq!( + Option::None::<u8>.partial_cmp(&Option::None::<u8>), + Some(Ordering::Equal) + ); + assert_eq!( + Option::Some(7).partial_cmp(&Option::Some(6)), + Some(Ordering::Greater) + ); + assert_eq!( + Option::Some(7).partial_cmp(&Option::None::<u8>), + Some(Ordering::Greater) + ); + assert_eq!(Option::None::<u8>.cmp(&Option::Some(7)), Ordering::Less); + assert_eq!(Option::Some(6).cmp(&Option::Some(7)), Ordering::Less); + assert_eq!(Option::Some(42).cmp(&Option::Some(42)), Ordering::Equal); + assert_eq!(Option::None::<u8>.cmp(&Option::None::<u8>), Ordering::Equal); + assert_eq!(Option::Some(7).cmp(&Option::Some(6)), Ordering::Greater); + assert_eq!(Option::Some(7).cmp(&Option::None::<u8>), Ordering::Greater); + + assert_eq!(Tenth(0).partial_cmp(&Tenth(67)), None); + assert_eq!(Tenth(42).partial_cmp(&Tenth(67)), Some(Ordering::Less)); + assert_eq!(Tenth(60).partial_cmp(&Tenth(67)), Some(Ordering::Equal)); + assert_eq!(Tenth(100).partial_cmp(&Tenth(67)), Some(Ordering::Greater)); + assert_eq!(Tenth(42).cmp(&Tenth(67)), Ordering::Less); + assert_eq!(Tenth(60).cmp(&Tenth(67)), Ordering::Equal); + assert_eq!(Tenth(100).cmp(&Tenth(67)), Ordering::Greater); + + assert_eq!( + Generic(SomeType { foo: 0 }).partial_cmp(&Generic(SomeType { foo: 0 })), + Some(Ordering::Less) + ); + assert_eq!( + Generic(SomeType { foo: 0 }).cmp(&Generic(SomeType { foo: 0 })), + Ordering::Less + ); + + assert_eq!( + GenericIgnore { + f: 123, + t: PhantomData::<NonPartialOrd>::default() + } + .cmp(&GenericIgnore { + f: 123, + t: PhantomData::<NonPartialOrd>::default() + }), + Ordering::Equal + ); + assert_eq!( + GenericIgnore { + f: 123, + t: PhantomData::<NonPartialOrd>::default() + } + .partial_cmp(&GenericIgnore { + f: 123, + t: PhantomData::<NonPartialOrd>::default() + }), + Some(Ordering::Equal) + ); +} diff --git a/vendor/derivative/tests/derive-partial-eq-packed.rs b/vendor/derivative/tests/derive-partial-eq-packed.rs new file mode 100644 index 000000000..e3bce6c78 --- /dev/null +++ b/vendor/derivative/tests/derive-partial-eq-packed.rs @@ -0,0 +1,120 @@ +#![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct Foo { + foo: u8, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct WithPtr<T: ?Sized> { + #[derivative(PartialEq(bound = ""))] + foo: *const T, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct Empty; + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct AllIgnored { + #[derivative(PartialEq = "ignore")] + foo: u8, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct OneIgnored { + #[derivative(PartialEq = "ignore")] + foo: u8, + bar: u8, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct Parity(#[derivative(PartialEq(compare_with = "same_parity"))] u8); + +fn same_parity(lhs: &u8, rhs: &u8) -> bool { + lhs % 2 == rhs % 2 +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +#[repr(C, packed)] +struct Generic<T>(#[derivative(PartialEq(compare_with = "dummy_cmp", bound = ""))] T); + +fn dummy_cmp<T>(_: &T, _: &T) -> bool { + true +} + +struct NonPartialEq; + +#[derive(Derivative)] +#[derivative(PartialEq, Eq)] +#[repr(C, packed)] +struct GenericIgnore<T> { + f: u32, + #[derivative(PartialEq = "ignore")] + t: T, +} + +trait SomeTrait {} + +#[derive(Copy, Clone)] +struct SomeType { + #[allow(dead_code)] + foo: u8, +} +impl SomeTrait for SomeType {} + +#[test] +fn main() { + assert!(Foo { foo: 7 } == Foo { foo: 7 }); + assert!(Foo { foo: 7 } != Foo { foo: 42 }); + + let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 }; + let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 }; + assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 }); + assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 }); + + assert!(Empty == Empty); + assert!(AllIgnored { foo: 0 } == AllIgnored { foo: 42 }); + assert!(OneIgnored { foo: 0, bar: 6 } == OneIgnored { foo: 42, bar: 6 }); + assert!(OneIgnored { foo: 0, bar: 6 } != OneIgnored { foo: 42, bar: 7 }); + + assert!(Option::Some(42) == Option::Some(42)); + assert!(Option::Some(0) != Option::Some(42)); + assert!(Option::Some(42) != Option::None); + assert!(Option::None != Option::Some(42)); + assert!(Option::None::<u8> == Option::None::<u8>); + + assert!(Parity(3) == Parity(7)); + assert!(Parity(2) == Parity(42)); + assert!(Parity(3) != Parity(42)); + assert!(Parity(2) != Parity(7)); + + assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 })); + assert!( + GenericIgnore { + f: 123, + t: NonPartialEq + } == GenericIgnore { + f: 123, + t: NonPartialEq + } + ); +} diff --git a/vendor/derivative/tests/derive-partial-eq.rs b/vendor/derivative/tests/derive-partial-eq.rs new file mode 100644 index 000000000..d9e67f38d --- /dev/null +++ b/vendor/derivative/tests/derive-partial-eq.rs @@ -0,0 +1,148 @@ +#![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref, dead_code)] + +#[cfg(feature = "use_core")] +extern crate core; + +use std::marker::PhantomData; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct Foo { + foo: u8, +} + +/// Test for backward compatibility. +#[derive(Derivative)] +#[derivative(PartialEq = "feature_allow_slow_enum")] +#[allow(unused)] +enum AllowsFeature<T> { + Some(T), + None, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +enum Option<T> { + Some(T), + None, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +enum SimpleEnum { + Some, + None, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +enum UnitEnum { + Single, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct WithPtr<T: ?Sized> { + #[derivative(PartialEq(bound = ""))] + foo: *const T, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct Empty; + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct AllIgnored { + #[derivative(PartialEq = "ignore")] + foo: u8, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct OneIgnored { + #[derivative(PartialEq = "ignore")] + foo: u8, + bar: u8, +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct Parity(#[derivative(PartialEq(compare_with = "same_parity"))] u8); + +fn same_parity(lhs: &u8, rhs: &u8) -> bool { + lhs % 2 == rhs % 2 +} + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct Generic<T>(#[derivative(PartialEq(compare_with = "dummy_cmp", bound = ""))] T); + +fn dummy_cmp<T>(_: &T, _: &T) -> bool { + true +} + +struct NonPartialEq; + +#[derive(Derivative)] +#[derivative(PartialEq, Eq)] +struct GenericIgnore<T> { + f: u32, + #[derivative(PartialEq = "ignore")] + t: PhantomData<T>, +} + +trait SomeTrait {} +struct SomeType { + #[allow(dead_code)] + foo: u8, +} +impl SomeTrait for SomeType {} + +#[test] +fn main() { + assert!(Foo { foo: 7 } == Foo { foo: 7 }); + assert!(Foo { foo: 7 } != Foo { foo: 42 }); + + let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 }; + let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 }; + assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 }); + assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 }); + + assert!(Empty == Empty); + assert!(AllIgnored { foo: 0 } == AllIgnored { foo: 42 }); + assert!(OneIgnored { foo: 0, bar: 6 } == OneIgnored { foo: 42, bar: 6 }); + assert!(OneIgnored { foo: 0, bar: 6 } != OneIgnored { foo: 42, bar: 7 }); + + assert!(Option::Some(42) == Option::Some(42)); + assert!(Option::Some(0) != Option::Some(42)); + assert!(Option::Some(42) != Option::None); + assert!(Option::None != Option::Some(42)); + assert!(Option::None::<u8> == Option::None::<u8>); + + assert!(SimpleEnum::Some == SimpleEnum::Some); + assert!(SimpleEnum::None == SimpleEnum::None); + assert!(SimpleEnum::Some != SimpleEnum::None); + assert!(SimpleEnum::None != SimpleEnum::Some); + + assert!(UnitEnum::Single == UnitEnum::Single); + + assert!(Parity(3) == Parity(7)); + assert!(Parity(2) == Parity(42)); + assert!(Parity(3) != Parity(42)); + assert!(Parity(2) != Parity(7)); + + assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 })); + assert!( + GenericIgnore { + f: 123, + t: PhantomData::<NonPartialEq>::default() + } == GenericIgnore { + f: 123, + t: PhantomData::<NonPartialEq>::default() + } + ); +} diff --git a/vendor/derivative/tests/issue-37-turbofish.rs b/vendor/derivative/tests/issue-37-turbofish.rs new file mode 100644 index 000000000..4e634b8c1 --- /dev/null +++ b/vendor/derivative/tests/issue-37-turbofish.rs @@ -0,0 +1,12 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +pub struct A { + #[derivative(Debug(format_with = "std::fmt::Debug::fmt"))] + v: u64, +} diff --git a/vendor/derivative/tests/issue-55.rs b/vendor/derivative/tests/issue-55.rs new file mode 100644 index 000000000..7b98142f5 --- /dev/null +++ b/vendor/derivative/tests/issue-55.rs @@ -0,0 +1,21 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +trait Foo {} + +fn fmt<T>(_: &T, _: &mut std::fmt::Formatter) -> std::fmt::Result { + unimplemented!() +} + +#[derive(Debug)] +struct Qux<'a, T: Foo>(&'a T); + +#[derive(Derivative)] +#[derivative(Debug)] +struct _Bar<'a, T: Foo>(#[derivative(Debug(format_with="fmt"))] Qux<'a, T>); + +fn main() { +}
\ No newline at end of file diff --git a/vendor/derivative/tests/issue-57.rs b/vendor/derivative/tests/issue-57.rs new file mode 100644 index 000000000..e3dc6502c --- /dev/null +++ b/vendor/derivative/tests/issue-57.rs @@ -0,0 +1,19 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +macro_rules! gen { + ($name:ident) => { + #[derive(Derivative)] + #[derivative(Debug)] + pub struct $name { + a: i32 + } + }; +} + +gen!(Test); + +fn main() {}
\ No newline at end of file diff --git a/vendor/derivative/tests/issue-58.rs b/vendor/derivative/tests/issue-58.rs new file mode 100644 index 000000000..313ffd5c2 --- /dev/null +++ b/vendor/derivative/tests/issue-58.rs @@ -0,0 +1,18 @@ +#![deny(clippy::all)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Default, Derivative)] +#[derivative(Debug)] +pub struct Foo { + foo: u8, +} + +fn main() { + let foo1 = Foo::default(); + println!("foo = {:?}", foo1); +} diff --git a/vendor/derivative/tests/issue-67.rs b/vendor/derivative/tests/issue-67.rs new file mode 100644 index 000000000..27af67fb5 --- /dev/null +++ b/vendor/derivative/tests/issue-67.rs @@ -0,0 +1,11 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Hash)] +enum _Enumeration<T> { + _Variant(T), +}
\ No newline at end of file diff --git a/vendor/derivative/tests/issue-82.rs b/vendor/derivative/tests/issue-82.rs new file mode 100644 index 000000000..69913d494 --- /dev/null +++ b/vendor/derivative/tests/issue-82.rs @@ -0,0 +1,13 @@ +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Copy, Clone, Derivative)] +#[derivative(Debug)] +#[repr(C, packed)] +struct Test { + a: u8, + b: u32, +}
\ No newline at end of file diff --git a/vendor/derivative/tests/rustc-class-implement-traits.rs b/vendor/derivative/tests/rustc-class-implement-traits.rs new file mode 100644 index 000000000..3e4574dfc --- /dev/null +++ b/vendor/derivative/tests/rustc-class-implement-traits.rs @@ -0,0 +1,80 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(non_camel_case_types)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +trait noisy { + fn speak(&mut self); +} + +#[derive(Derivative)] +#[derivative(Clone)] +struct cat { + meows : usize, + + how_hungry : isize, + name : String, +} + +impl cat { + fn meow(&mut self) { + println!("Meow"); + self.meows += 1_usize; + if self.meows % 5_usize == 0_usize { + self.how_hungry += 1; + } + } +} + +impl cat { + pub fn eat(&mut self) -> bool { + if self.how_hungry > 0 { + println!("OM NOM NOM"); + self.how_hungry -= 2; + true + } else { + println!("Not hungry!"); + false + } + } +} + +impl noisy for cat { + fn speak(&mut self) { self.meow(); } +} + +fn cat(in_x : usize, in_y : isize, in_name: String) -> cat { + cat { + meows: in_x, + how_hungry: in_y, + name: in_name, + } +} + + +fn make_speak<C:noisy>(mut c: C) { + c.speak(); +} + +#[test] +fn main() { + let mut nyan = cat(0_usize, 2, "nyan".to_string()); + nyan.eat(); + assert!((!nyan.eat())); + for _ in 1_usize..10_usize { + make_speak(nyan.clone()); + } +} diff --git a/vendor/derivative/tests/rustc-deriving-bounds.rs b/vendor/derivative/tests/rustc-deriving-bounds.rs new file mode 100644 index 000000000..7be0c57e7 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-bounds.rs @@ -0,0 +1,24 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Copy, Clone)] +struct Test; + +#[test] +fn main() { + let _ = Test; +} diff --git a/vendor/derivative/tests/rustc-deriving-clone-array.rs b/vendor/derivative/tests/rustc-deriving-clone-array.rs new file mode 100644 index 000000000..446eb49cf --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-clone-array.rs @@ -0,0 +1,27 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// test for issue #30244 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Copy, Clone)] +#[allow(dead_code)] +struct Array { + arr: [[u8; 256]; 4] +} + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-deriving-clone-enum.rs b/vendor/derivative/tests/rustc-deriving-clone-enum.rs new file mode 100644 index 000000000..0464d970f --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-clone-enum.rs @@ -0,0 +1,32 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone)] +enum E { + A, + B(()), + C, +} + +#[test] +fn main() { + let _ = E::A.clone(); + let _ = E::B(()).clone(); + let _ = E::C.clone(); +} diff --git a/vendor/derivative/tests/rustc-deriving-clone-generic-enum.rs b/vendor/derivative/tests/rustc-deriving-clone-generic-enum.rs new file mode 100644 index 000000000..58b9b1e28 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-clone-generic-enum.rs @@ -0,0 +1,31 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone)] +#[allow(dead_code)] +enum E<T,U> { + A(T), + B(T,U), + C +} + +#[test] +fn main() { + let _ = E::A::<isize, isize>(1).clone(); +} diff --git a/vendor/derivative/tests/rustc-deriving-clone-generic-tuple-struct.rs b/vendor/derivative/tests/rustc-deriving-clone-generic-tuple-struct.rs new file mode 100644 index 000000000..e1cc22454 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-clone-generic-tuple-struct.rs @@ -0,0 +1,26 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone)] +struct S<T>(T, ()); + +#[test] +fn main() { + let _ = S(1, ()).clone(); +} diff --git a/vendor/derivative/tests/rustc-deriving-clone-struct.rs b/vendor/derivative/tests/rustc-deriving-clone-struct.rs new file mode 100644 index 000000000..2e0440518 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-clone-struct.rs @@ -0,0 +1,47 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#![allow(clippy::redundant_clone)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Default, Derivative)] +#[derivative(Clone)] +struct S { + _int: isize, + _i8: i8, + _i16: i16, + _i32: i32, + _i64: i64, + + _uint: usize, + _u8: u8, + _u16: u16, + _u32: u32, + _u64: u64, + + _f32: f32, + _f64: f64, + + _bool: bool, + _char: char, + _nil: () +} + +#[test] +fn main() { + let _ = S::default().clone(); +} diff --git a/vendor/derivative/tests/rustc-deriving-clone-tuple-struct.rs b/vendor/derivative/tests/rustc-deriving-clone-tuple-struct.rs new file mode 100644 index 000000000..f5815d633 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-clone-tuple-struct.rs @@ -0,0 +1,24 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Clone)] +struct S((), ()); + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-enum.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-enum.rs new file mode 100644 index 000000000..d7bbe3998 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-enum.rs @@ -0,0 +1,68 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// no-pretty-expanded FIXME #15189 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative( + PartialEq = "feature_allow_slow_enum", + Eq, + PartialOrd = "feature_allow_slow_enum", + Ord = "feature_allow_slow_enum" +)] +enum E<T> { + V0, + V1(T), + V2(T, T), +} + +#[test] +fn main() { + let e0 = E::V0; + let e11 = E::V1(1); + let e12 = E::V1(2); + let e21 = E::V2(1, 1); + let e22 = E::V2(1, 2); + + // in order for both PartialOrd and Ord + let es = [e0, e11, e12, e21, e22]; + + for (i, e1) in es.iter().enumerate() { + for (j, e2) in es.iter().enumerate() { + let ord = i.cmp(&j); + + let eq = i == j; + let lt = i < j; + let le = i <= j; + let gt = i > j; + let ge = i >= j; + + // PartialEq + assert_eq!(*e1 == *e2, eq); + assert_eq!(*e1 != *e2, !eq); + + // PartialOrd + assert_eq!(*e1 < *e2, lt); + assert_eq!(*e1 > *e2, gt); + + assert_eq!(*e1 <= *e2, le); + assert_eq!(*e1 >= *e2, ge); + + // Ord + assert_eq!(e1.cmp(e2), ord); + } + } +} diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-struct-enum.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct-enum.rs new file mode 100644 index 000000000..780ef3a79 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct-enum.rs @@ -0,0 +1,66 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// no-pretty-expanded FIXME #15189 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative( + PartialEq = "feature_allow_slow_enum", + Eq, + PartialOrd = "feature_allow_slow_enum", + Ord = "feature_allow_slow_enum" +)] +enum ES<T> { + ES1 { x: T }, + ES2 { x: T, y: T }, +} + + +pub fn main() { + let (es11, es12, es21, es22) = ( + ES::ES1 { x: 1 }, + ES::ES1 { x: 2 }, + ES::ES2 { x: 1, y: 1 }, + ES::ES2 { x: 1, y: 2 }, + ); + + // in order for both PartialOrd and Ord + let ess = [es11, es12, es21, es22]; + + for (i, es1) in ess.iter().enumerate() { + for (j, es2) in ess.iter().enumerate() { + let ord = i.cmp(&j); + + let eq = i == j; + let (lt, le) = (i < j, i <= j); + let (gt, ge) = (i > j, i >= j); + + // PartialEq + assert_eq!(*es1 == *es2, eq); + assert_eq!(*es1 != *es2, !eq); + + // PartialOrd + assert_eq!(*es1 < *es2, lt); + assert_eq!(*es1 > *es2, gt); + + assert_eq!(*es1 <= *es2, le); + assert_eq!(*es1 >= *es2, ge); + + // Ord + assert_eq!(es1.cmp(es2), ord); + } + } +} diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-struct.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct.rs new file mode 100644 index 000000000..2c387282e --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-struct.rs @@ -0,0 +1,58 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// no-pretty-expanded FIXME #15189 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq, Eq, PartialOrd, Ord)] +struct S<T> { + x: T, + y: T, +} + +pub fn main() { + let s1 = S { x: 1, y: 1 }; + let s2 = S { x: 1, y: 2 }; + + // in order for both PartialOrd and Ord + let ss = [s1, s2]; + + for (i, s1) in ss.iter().enumerate() { + for (j, s2) in ss.iter().enumerate() { + let ord = i.cmp(&j); + + let eq = i == j; + let lt = i < j; + let le = i <= j; + let gt = i > j; + let ge = i >= j; + + // PartialEq + assert_eq!(*s1 == *s2, eq); + assert_eq!(*s1 != *s2, !eq); + + // PartialOrd + assert_eq!(*s1 < *s2, lt); + assert_eq!(*s1 > *s2, gt); + + assert_eq!(*s1 <= *s2, le); + assert_eq!(*s1 >= *s2, ge); + + // Ord + assert_eq!(s1.cmp(s2), ord); + } + } +} diff --git a/vendor/derivative/tests/rustc-deriving-cmp-generic-tuple-struct.rs b/vendor/derivative/tests/rustc-deriving-cmp-generic-tuple-struct.rs new file mode 100644 index 000000000..ffcb177ef --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-cmp-generic-tuple-struct.rs @@ -0,0 +1,55 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// no-pretty-expanded FIXME #15189 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq, Eq, PartialOrd, Ord)] +struct TS<T>(T, T); + +pub fn main() { + let ts1 = TS(1, 1); + let ts2 = TS(1, 2); + + // in order for both PartialOrd and Ord + let tss = [ts1, ts2]; + + for (i, ts1) in tss.iter().enumerate() { + for (j, ts2) in tss.iter().enumerate() { + let ord = i.cmp(&j); + + let eq = i == j; + let lt = i < j; + let le = i <= j; + let gt = i > j; + let ge = i >= j; + + // PartialEq + assert_eq!(*ts1 == *ts2, eq); + assert_eq!(*ts1 != *ts2, !eq); + + // PartialOrd + assert_eq!(*ts1 < *ts2, lt); + assert_eq!(*ts1 > *ts2, gt); + + assert_eq!(*ts1 <= *ts2, le); + assert_eq!(*ts1 >= *ts2, ge); + + // Ord + assert_eq!(ts1.cmp(ts2), ord); + } + } +} diff --git a/vendor/derivative/tests/rustc-deriving-copyclone.rs b/vendor/derivative/tests/rustc-deriving-copyclone.rs new file mode 100644 index 000000000..873263386 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-copyclone.rs @@ -0,0 +1,61 @@ +// Copyright 2016 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Test that #[derive(Copy, Clone)] produces a shallow copy +//! even when a member violates RFC 1521 + +#![allow(clippy::clone_on_copy)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::sync::atomic::{AtomicBool, Ordering}; + +/// A struct that pretends to be Copy, but actually does something +/// in its Clone impl +#[derive(Copy)] +struct Liar; + +/// Static cooperating with the rogue Clone impl +static CLONED: AtomicBool = AtomicBool::new(false); + +impl Clone for Liar { + fn clone(&self) -> Self { + // this makes Clone vs Copy observable + CLONED.store(true, Ordering::SeqCst); + + *self + } +} + +/// This struct is actually Copy... at least, it thinks it is! +#[derive(Copy, Clone)] +struct TheirTheir(Liar); + +#[derive(Derivative)] +#[derivative(Copy, Clone)] +struct OurOur1(Liar); +#[derive(Derivative)] +#[derivative(Clone, Copy)] +struct OurOur2(Liar); + +#[test] +fn main() { + let _ = TheirTheir(Liar).clone(); + assert!(!CLONED.load(Ordering::SeqCst), "TheirTheir"); + + let _ = OurOur1(Liar).clone(); + assert!(!CLONED.load(Ordering::SeqCst), "OurOur1"); + let _ = OurOur2(Liar).clone(); + assert!(!CLONED.load(Ordering::SeqCst), "OurOur2"); +} diff --git a/vendor/derivative/tests/rustc-deriving-default-box.rs b/vendor/derivative/tests/rustc-deriving-default-box.rs new file mode 100644 index 000000000..adcdd9261 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-default-box.rs @@ -0,0 +1,30 @@ +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::default::Default; + +#[derive(Derivative)] +#[derivative(Default)] +struct A { + foo: Box<[bool]>, +} + +#[test] +fn main() { + let a: A = Default::default(); + let b: Box<[_]> = Box::<[bool; 0]>::new([]); + assert_eq!(a.foo, b); +} diff --git a/vendor/derivative/tests/rustc-deriving-enum-single-variant.rs b/vendor/derivative/tests/rustc-deriving-enum-single-variant.rs new file mode 100644 index 000000000..70b647c88 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-enum-single-variant.rs @@ -0,0 +1,30 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +pub type TaskId = isize; + +#[derive(Derivative)] +#[derivative(PartialEq="feature_allow_slow_enum")] +pub enum Task { + TaskHandle(TaskId) +} + +#[test] +fn main() { + let _ = Task::TaskHandle(42); +} diff --git a/vendor/derivative/tests/rustc-deriving-hash.rs b/vendor/derivative/tests/rustc-deriving-hash.rs new file mode 100644 index 000000000..bae6e8c8e --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-hash.rs @@ -0,0 +1,83 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(non_camel_case_types)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +#[derive(Derivative)] +#[derivative(Hash)] +struct Person { + id: u16, + name: String, + phone: u64, +} + +// test for hygiene name collisions +#[derive(Derivative)] +#[derivative(Hash)] struct __H__H; +#[derive(Derivative)] +#[allow(dead_code)] #[derivative(Hash)] struct Collision<__H> ( __H ); +// TODO(rustc) #[derivative(Hash)] enum Collision<__H> { __H { __H__H: __H } } + +#[derive(Derivative)] +#[derivative(Hash)] +enum E { A=1, B } + +fn hash<T: Hash>(t: &T) -> u64 { + let mut s = DefaultHasher::new(); + t.hash(&mut s); + s.finish() +} + +struct FakeHasher<'a>(&'a mut Vec<u8>); +impl<'a> Hasher for FakeHasher<'a> { + fn finish(&self) -> u64 { + unimplemented!() + } + + fn write(&mut self, bytes: &[u8]) { + self.0.extend(bytes); + } +} + +fn fake_hash(v: &mut Vec<u8>, e: E) { + e.hash(&mut FakeHasher(v)); +} + +#[test] +fn main() { + let person1 = Person { + id: 5, + name: "Janet".to_string(), + phone: 555_666_777, + }; + let person2 = Person { + id: 5, + name: "Bob".to_string(), + phone: 555_666_777, + }; + assert_eq!(hash(&person1), hash(&person1)); + assert!(hash(&person1) != hash(&person2)); + + // test #21714 + let mut va = vec![]; + let mut vb = vec![]; + fake_hash(&mut va, E::A); + fake_hash(&mut vb, E::B); + assert!(va != vb); +} diff --git a/vendor/derivative/tests/rustc-deriving-in-fn.rs b/vendor/derivative/tests/rustc-deriving-in-fn.rs new file mode 100644 index 000000000..7d38e749d --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-in-fn.rs @@ -0,0 +1,27 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[test] +fn main() { + #[derive(Derivative)] + #[derivative(Debug)] + struct Foo { + foo: isize, + } + + let f = Foo { foo: 10 }; + format!("{:?}", f); +} diff --git a/vendor/derivative/tests/rustc-deriving-meta-multiple.rs b/vendor/derivative/tests/rustc-deriving-meta-multiple.rs new file mode 100644 index 000000000..beb41d696 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-meta-multiple.rs @@ -0,0 +1,42 @@ +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#![allow(clippy::eq_op, clippy::redundant_clone)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::hash::Hash; + +// testing multiple separate deriving attributes +#[derive(Derivative)] +#[derivative(PartialEq)] +#[derivative(Clone)] +#[derivative(Hash)] +struct Foo { + bar: usize, + baz: isize +} + +fn hash<T: Hash>(_t: &T) {} + +#[test] +fn main() { + let a = Foo {bar: 4, baz: -3}; + + let _ = a == a; // check for PartialEq impl w/o testing its correctness + let _ = a.clone(); // check for Clone impl w/o testing its correctness + hash(&a); // check for Hash impl w/o testing its correctness +} diff --git a/vendor/derivative/tests/rustc-deriving-meta.rs b/vendor/derivative/tests/rustc-deriving-meta.rs new file mode 100644 index 000000000..9281e3e05 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-meta.rs @@ -0,0 +1,39 @@ +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#![allow(clippy::eq_op, clippy::redundant_clone)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::hash::Hash; + +#[derive(Derivative)] +#[derivative(PartialEq, Clone, Hash)] +struct Foo { + bar: usize, + baz: isize +} + +fn hash<T: Hash>(_t: &T) {} + +#[test] +fn main() { + let a = Foo {bar: 4, baz: -3}; + + let _ = a == a; // check for PartialEq impl w/o testing its correctness + let _ = a.clone(); // check for Clone impl w/o testing its correctness + hash(&a); // check for Hash impl w/o testing its correctness +} diff --git a/vendor/derivative/tests/rustc-deriving-show-2.rs b/vendor/derivative/tests/rustc-deriving-show-2.rs new file mode 100644 index 000000000..f4c173cb4 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-show-2.rs @@ -0,0 +1,75 @@ +#![allow(dead_code)] +#![deny(unused_variables)] // We used to generate warning: unused variable: `f` + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::fmt; + +#[derive(Derivative)] +#[derivative(Debug)] +enum A {} +#[derive(Derivative)] +#[derivative(Debug)] +enum B { V1, V2, V3 } + +#[derive(Derivative)] +#[derivative(Debug)] +enum C { V1(isize), V2(B), V3(String) } + +#[derive(Derivative)] +#[derivative(Debug)] +enum D { V1{ a: isize } } + +#[derive(Derivative)] +#[derivative(Debug)] +struct E; +#[derive(Derivative)] +#[derivative(Debug)] +struct F(isize); +#[derive(Derivative)] +#[derivative(Debug)] +struct G(isize, isize); +#[derive(Derivative)] +#[derivative(Debug)] +struct H { a: isize } +#[derive(Derivative)] +#[derivative(Debug)] +struct I { a: isize, b: isize } +#[derive(Derivative)] +#[derivative(Debug)] +struct J(Custom); + +struct Custom; +impl fmt::Debug for Custom { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "yay") + } +} + +trait ToDebug { + fn to_show(&self) -> String; +} + +impl<T: fmt::Debug> ToDebug for T { + fn to_show(&self) -> String { + format!("{:?}", self) + } +} + +#[test] +fn main() { + assert_eq!(B::V1.to_show(), "V1".to_string()); + assert_eq!(B::V2.to_show(), "V2".to_string()); + assert_eq!(C::V1(3).to_show(), "V1(3)".to_string()); + assert_eq!(C::V2(B::V2).to_show(), "V2(V2)".to_string()); + assert_eq!(D::V1{ a: 2 }.to_show(), "V1 { a: 2 }".to_string()); + assert_eq!(E.to_show(), "E".to_string()); + assert_eq!(F(3).to_show(), "F(3)".to_string()); + assert_eq!(G(3, 4).to_show(), "G(3, 4)".to_string()); + assert_eq!(I{ a: 2, b: 4 }.to_show(), "I { a: 2, b: 4 }".to_string()); + assert_eq!(J(Custom).to_show(), "J(yay)".to_string()); +} diff --git a/vendor/derivative/tests/rustc-deriving-show.rs b/vendor/derivative/tests/rustc-deriving-show.rs new file mode 100644 index 000000000..525d6020e --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-show.rs @@ -0,0 +1,51 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Unit; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Tuple(isize, usize); + +#[derive(Derivative)] +#[derivative(Debug)] +struct Struct { x: isize, y: usize } + +#[derive(Derivative)] +#[derivative(Debug)] +enum Enum { + Nullary, + Variant(isize, usize), + StructVariant { x: isize, y : usize } +} + +macro_rules! t { + ($x:expr, $expected:expr) => { + assert_eq!(format!("{:?}", $x), $expected.to_string()) + } +} + +#[test] +fn main() { + t!(Unit, "Unit"); + t!(Tuple(1, 2), "Tuple(1, 2)"); + t!(Struct { x: 1, y: 2 }, "Struct { x: 1, y: 2 }"); + t!(Enum::Nullary, "Nullary"); + t!(Enum::Variant(1, 2), "Variant(1, 2)"); + t!(Enum::StructVariant { x: 1, y: 2 }, "StructVariant { x: 1, y: 2 }"); +} diff --git a/vendor/derivative/tests/rustc-deriving-via-extension-hash-enum.rs b/vendor/derivative/tests/rustc-deriving-via-extension-hash-enum.rs new file mode 100644 index 000000000..c5348587d --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-via-extension-hash-enum.rs @@ -0,0 +1,36 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Hash)] +#[allow(dead_code)] +enum Foo { + Bar(isize, char), + Baz(char, isize) +} + +#[derive(Derivative)] +#[derivative(Hash)] +#[allow(dead_code)] +enum A { + B, + C, + D, + E +} + +#[test] +fn main(){} diff --git a/vendor/derivative/tests/rustc-deriving-via-extension-hash-struct.rs b/vendor/derivative/tests/rustc-deriving-via-extension-hash-struct.rs new file mode 100644 index 000000000..c653154c5 --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-via-extension-hash-struct.rs @@ -0,0 +1,34 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::collections::hash_map::DefaultHasher; + +#[derive(Derivative)] +#[derivative(Hash)] +struct Foo { + x: isize, + y: isize, + z: isize +} + +#[test] +fn main() { + use std::hash::Hash; + let mut hasher = DefaultHasher::new(); + Foo { x: 0, y: 0, z: 0 }.hash(&mut hasher); +} diff --git a/vendor/derivative/tests/rustc-deriving-via-extension-type-params.rs b/vendor/derivative/tests/rustc-deriving-via-extension-type-params.rs new file mode 100644 index 000000000..9fb62ce1c --- /dev/null +++ b/vendor/derivative/tests/rustc-deriving-via-extension-type-params.rs @@ -0,0 +1,33 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq, Hash, Debug)] +struct Foo<T> { + x: isize, + y: T, + z: isize +} + +#[test] +fn main() { + let a = Foo { x: 1, y: 2.0f64, z: 3 }; + let b = Foo { x: 1, y: 2.0f64, z: 3 }; + assert_eq!(a, b); + assert!(!(a != b)); + assert!(a.eq(&b)); + assert!(!a.ne(&b)); +} diff --git a/vendor/derivative/tests/rustc-expr-copy.rs b/vendor/derivative/tests/rustc-expr-copy.rs new file mode 100644 index 000000000..ab3ae912e --- /dev/null +++ b/vendor/derivative/tests/rustc-expr-copy.rs @@ -0,0 +1,35 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + + +fn f(arg: &mut A) { + arg.a = 100; +} + +#[derive(Derivative)] +#[derivative(Copy, Clone)] +struct A { a: isize } + +#[test] +fn main() { + let mut x = A {a: 10}; + f(&mut x); + assert_eq!(x.a, 100); + x.a = 20; + let mut y = x; + f(&mut y); + assert_eq!(x.a, 20); +} diff --git a/vendor/derivative/tests/rustc-exterior.rs b/vendor/derivative/tests/rustc-exterior.rs new file mode 100644 index 000000000..ec59daa0e --- /dev/null +++ b/vendor/derivative/tests/rustc-exterior.rs @@ -0,0 +1,41 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +use std::cell::Cell; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Copy, Clone)] +struct Point {x: isize, y: isize, z: isize} + +fn f(p: &Cell<Point>) { + assert_eq!(p.get().z, 12); + p.set(Point {x: 10, y: 11, z: 13}); + assert_eq!(p.get().z, 13); +} + +#[test] +fn main() { + let a: Point = Point {x: 10, y: 11, z: 12}; + let b: &Cell<Point> = &Cell::new(a); + assert_eq!(b.get().z, 12); + f(b); + assert_eq!(a.x, 10); + assert_eq!(a.y, 11); + assert_eq!(a.z, 12); + assert_eq!(b.get().x, 10); + assert_eq!(b.get().y, 11); + assert_eq!(b.get().z, 13); +} diff --git a/vendor/derivative/tests/rustc-issue-12860.rs b/vendor/derivative/tests/rustc-issue-12860.rs new file mode 100644 index 000000000..b4d878ce2 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-12860.rs @@ -0,0 +1,69 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(clippy::derive_hash_xor_eq)] + +#[cfg(feature = "use_core")] +extern crate core; + +use std::collections::HashSet; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Hash)] +#[derive(Copy, Clone, PartialEq, Eq)] +struct XYZ { + x: isize, + y: isize, + z: isize +} + +#[test] +fn main() { + let mut connected = HashSet::new(); + let mut border = HashSet::new(); + + let middle = XYZ{x: 0, y: 0, z: 0}; + border.insert(middle); + + while !border.is_empty() && connected.len() < 10000 { + let choice = *(border.iter().next().unwrap()); + border.remove(&choice); + connected.insert(choice); + + let cxp = XYZ{x: choice.x + 1, y: choice.y, z: choice.z}; + let cxm = XYZ{x: choice.x - 1, y: choice.y, z: choice.z}; + let cyp = XYZ{x: choice.x, y: choice.y + 1, z: choice.z}; + let cym = XYZ{x: choice.x, y: choice.y - 1, z: choice.z}; + let czp = XYZ{x: choice.x, y: choice.y, z: choice.z + 1}; + let czm = XYZ{x: choice.x, y: choice.y, z: choice.z - 1}; + + if !connected.contains(&cxp) { + border.insert(cxp); + } + if !connected.contains(&cxm){ + border.insert(cxm); + } + if !connected.contains(&cyp){ + border.insert(cyp); + } + if !connected.contains(&cym) { + border.insert(cym); + } + if !connected.contains(&czp){ + border.insert(czp); + } + if !connected.contains(&czm) { + border.insert(czm); + } + } +} diff --git a/vendor/derivative/tests/rustc-issue-13434.rs b/vendor/derivative/tests/rustc-issue-13434.rs new file mode 100644 index 000000000..f2ccab5e8 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-13434.rs @@ -0,0 +1,38 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct MyStruct; + +trait Repro { + fn repro(self, s: MyStruct) -> String; +} + +impl<F> Repro for F where F: FnOnce(MyStruct) -> String { + fn repro(self, s: MyStruct) -> String { + self(s) + } +} + +fn do_stuff<R: Repro>(r: R) -> String { + r.repro(MyStruct) +} + +#[test] +fn main() { + assert_eq!("MyStruct".to_string(), do_stuff(|s: MyStruct| format!("{:?}", s))); +} diff --git a/vendor/derivative/tests/rustc-issue-16530.rs b/vendor/derivative/tests/rustc-issue-16530.rs new file mode 100644 index 000000000..3cf55c671 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-16530.rs @@ -0,0 +1,32 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(deprecated)] + +#[cfg(feature = "use_core")] +extern crate core; + +use std::hash::{SipHasher, Hasher, Hash}; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Hash)] +struct Empty; + +#[test] +fn main() { + let mut s1 = SipHasher::new_with_keys(0, 0); + Empty.hash(&mut s1); + let mut s2 = SipHasher::new_with_keys(0, 0); + Empty.hash(&mut s2); + assert_eq!(s1.finish(), s2.finish()); +} diff --git a/vendor/derivative/tests/rustc-issue-19037.rs b/vendor/derivative/tests/rustc-issue-19037.rs new file mode 100644 index 000000000..06f461ab1 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-19037.rs @@ -0,0 +1,38 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#![allow(dead_code)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +struct Str([u8]); + +#[derive(Derivative)] +#[derivative(Clone)] +struct CharSplits<'a, Sep> { + string: &'a Str, + sep: Sep, + allow_trailing_empty: bool, + only_ascii: bool, + finished: bool, +} + +fn clone(s: &Str) -> &Str { + Clone::clone(&s) +} + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-19102.rs b/vendor/derivative/tests/rustc-issue-19102.rs new file mode 100644 index 000000000..8530b843a --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-19102.rs @@ -0,0 +1,26 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(unused_qualifications)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq="feature_allow_slow_enum")] +pub enum A { + B, +} + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-19135.rs b/vendor/derivative/tests/rustc-issue-19135.rs new file mode 100644 index 000000000..a73625c97 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-19135.rs @@ -0,0 +1,30 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +use std::marker::PhantomData; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct LifetimeStruct<'a>(PhantomData<&'a ()>); + +#[test] +fn main() { + takes_hrtb_closure(|lts| println!("{:?}", lts)); +} + +fn takes_hrtb_closure<F: for<'a>FnMut(LifetimeStruct<'a>)>(mut f: F) { + f(LifetimeStruct(PhantomData)); +} diff --git a/vendor/derivative/tests/rustc-issue-19358.rs b/vendor/derivative/tests/rustc-issue-19358.rs new file mode 100644 index 000000000..6f528adfe --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-19358.rs @@ -0,0 +1,38 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +trait Trait { fn dummy(&self) { } } + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Foo<T: Trait> { + foo: T, +} + +#[derive(Derivative)] +#[derivative(Debug)] +struct Bar<T> where T: Trait { + bar: T, +} + +impl Trait for isize {} + +#[test] +fn main() { + let a = Foo { foo: 12 }; + let b = Bar { bar: 12 }; + println!("{:?} {:?}", a, b); +} diff --git a/vendor/derivative/tests/rustc-issue-21402.rs b/vendor/derivative/tests/rustc-issue-21402.rs new file mode 100644 index 000000000..6e951178d --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-21402.rs @@ -0,0 +1,29 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Hash)] +#[allow(dead_code)] +struct Foo { + a: Vec<bool>, + b: (bool, bool), + c: [bool; 2], +} + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-23649-3.rs b/vendor/derivative/tests/rustc-issue-23649-3.rs new file mode 100644 index 000000000..1437fe1e1 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-23649-3.rs @@ -0,0 +1,23 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[allow(dead_code)] +#[derive(Derivative)] +#[derivative(PartialEq)] +struct Slice { slice: [u8] } + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-24085.rs b/vendor/derivative/tests/rustc-issue-24085.rs new file mode 100644 index 000000000..d3db02615 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-24085.rs @@ -0,0 +1,38 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Regression test for #24085. Errors were occurring in region +// inference due to the requirement that `'a:b'`, which was getting +// incorrectly translated in connection with the closure below. + +#![allow(clippy::redundant_closure)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Copy,Clone)] +#[allow(dead_code)] +struct Path<'a:'b, 'b> { + x: &'a i32, + tail: Option<&'b Path<'a, 'b>> +} + +#[allow(dead_code, unconditional_recursion)] +fn foo<'a,'b,F>(p: Path<'a, 'b>, mut f: F) + where F: for<'c> FnMut(Path<'a, 'c>) { + foo(p, |x| f(x)) +} + +#[test] +fn main() { } diff --git a/vendor/derivative/tests/rustc-issue-25394.rs b/vendor/derivative/tests/rustc-issue-25394.rs new file mode 100644 index 000000000..7f75ef993 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-25394.rs @@ -0,0 +1,26 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Row<T>([T]); + +fn use_row(_: &Row<u8>) {} + +#[test] +fn main() { + let _ = use_row; +} diff --git a/vendor/derivative/tests/rustc-issue-28561.rs b/vendor/derivative/tests/rustc-issue-28561.rs new file mode 100644 index 000000000..4476646fa --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-28561.rs @@ -0,0 +1,136 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(clippy::zero_prefixed_literal, clippy::type_complexity)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug, Default, Eq, Hash, PartialEq)] +// TODO: Ord, PartialOrd +struct Array<T> { + f00: [T; 00], + f01: [T; 01], + f02: [T; 02], + f03: [T; 03], + f04: [T; 04], + f05: [T; 05], + f06: [T; 06], + f07: [T; 07], + f08: [T; 08], + f09: [T; 09], + f10: [T; 10], + f11: [T; 11], + f12: [T; 12], + f13: [T; 13], + f14: [T; 14], + f15: [T; 15], + f16: [T; 16], + f17: [T; 17], + f18: [T; 18], + f19: [T; 19], + f20: [T; 20], + f21: [T; 21], + f22: [T; 22], + f23: [T; 23], + f24: [T; 24], + f25: [T; 25], + f26: [T; 26], + f27: [T; 27], + f28: [T; 28], + f29: [T; 29], + f30: [T; 30], + f31: [T; 31], + f32: [T; 32], +} + +// FIXME(#7622): merge with `Array` once `[T; N]: Clone` where `T: Clone` +#[derive(Derivative)] +#[derivative(Clone, Copy)] +struct CopyArray<T: Copy> { + f00: [T; 00], + f01: [T; 01], + f02: [T; 02], + f03: [T; 03], + f04: [T; 04], + f05: [T; 05], + f06: [T; 06], + f07: [T; 07], + f08: [T; 08], + f09: [T; 09], + f10: [T; 10], + f11: [T; 11], + f12: [T; 12], + f13: [T; 13], + f14: [T; 14], + f15: [T; 15], + f16: [T; 16], + f17: [T; 17], + f18: [T; 18], + f19: [T; 19], + f20: [T; 20], + f21: [T; 21], + f22: [T; 22], + f23: [T; 23], + f24: [T; 24], + f25: [T; 25], + f26: [T; 26], + f27: [T; 27], + f28: [T; 28], + f29: [T; 29], + f30: [T; 30], + f31: [T; 31], + f32: [T; 32], +} + +#[derive(Derivative)] +#[derivative(Clone, Copy, Debug, Eq, Hash, PartialEq)] +// TODO: Ord, PartialOrd +struct Fn<A, B, C, D, E, F, G, H, I, J, K, L> { + f00: fn(), + f01: fn(A), + f02: fn(A, B), + f03: fn(A, B, C), + f04: fn(A, B, C, D), + f05: fn(A, B, C, D, E), + f06: fn(A, B, C, D, E, F), + f07: fn(A, B, C, D, E, F, G), + f08: fn(A, B, C, D, E, F, G, H), + f09: fn(A, B, C, D, E, F, G, H, I), + f10: fn(A, B, C, D, E, F, G, H, I, J), + f11: fn(A, B, C, D, E, F, G, H, I, J, K), + f12: fn(A, B, C, D, E, F, G, H, I, J, K, L), +} + +#[derive(Derivative)] +#[derivative(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)] +// TODO: Ord, PartialOrd +struct Tuple<A, B, C, D, E, F, G, H, I, J, K, L> { + f00: (), + f01: (A,), + f02: (A, B), + f03: (A, B, C), + f04: (A, B, C, D), + f05: (A, B, C, D, E), + f06: (A, B, C, D, E, F), + f07: (A, B, C, D, E, F, G), + f08: (A, B, C, D, E, F, G, H), + f09: (A, B, C, D, E, F, G, H, I), + f10: (A, B, C, D, E, F, G, H, I, J), + f11: (A, B, C, D, E, F, G, H, I, J, K), + f12: (A, B, C, D, E, F, G, H, I, J, K, L), +} + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-29030.rs b/vendor/derivative/tests/rustc-issue-29030.rs new file mode 100644 index 000000000..c893ece7d --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-29030.rs @@ -0,0 +1,30 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct Message<'a, P: 'a = &'a [u8]> { + header: &'a [u8], + payload: P, +} + +#[test] +fn main() { + let _ = Message { + header: &[1], + payload: &[1], + }; +} diff --git a/vendor/derivative/tests/rustc-issue-29540.rs b/vendor/derivative/tests/rustc-issue-29540.rs new file mode 100644 index 000000000..3b1fcf74d --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-29540.rs @@ -0,0 +1,509 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +pub struct Config { + pub name: String, + pub cluster: String, + pub debug_none: String, + pub debug_lockdep: String, + pub debug_context: String, + pub debug_crush: String, + pub debug_mds: String, + pub debug_mds_balancer: String, + pub debug_mds_locker: String, + pub debug_mds_log: String, + pub debug_mds_log_expire: String, + pub debug_mds_migrator: String, + pub debug_buffer: String, + pub debug_timer: String, + pub debug_filer: String, + pub debug_striper: String, + pub debug_objecter: String, + pub debug_rados: String, + pub debug_rbd: String, + pub debug_journaler: String, + pub debug_objectcacher: String, + pub debug_client: String, + pub debug_osd: String, + pub debug_optracker: String, + pub debug_objclass: String, + pub debug_filestore: String, + pub debug_keyvaluestore: String, + pub debug_journal: String, + pub debug_ms: String, + pub debug_mon: String, + pub debug_monc: String, + pub debug_paxos: String, + pub debug_tp: String, + pub debug_auth: String, + pub debug_crypto: String, + pub debug_finisher: String, + pub debug_heartbeatmap: String, + pub debug_perfcounter: String, + pub debug_rgw: String, + pub debug_civetweb: String, + pub debug_javaclient: String, + pub debug_asok: String, + pub debug_throttle: String, + pub host: String, + pub fsid: String, + pub public_addr: String, + pub cluster_addr: String, + pub public_network: String, + pub cluster_network: String, + pub num_client: String, + pub monmap: String, + pub mon_host: String, + pub lockdep: String, + pub run_dir: String, + pub admin_socket: String, + pub daemonize: String, + pub pid_file: String, + pub chdir: String, + pub max_open_files: String, + pub restapi_log_level: String, + pub restapi_base_url: String, + pub fatal_signal_handlers: String, + pub log_file: String, + pub log_max_new: String, + pub log_max_recent: String, + pub log_to_stderr: String, + pub err_to_stderr: String, + pub log_to_syslog: String, + pub err_to_syslog: String, + pub log_flush_on_exit: String, + pub log_stop_at_utilization: String, + pub clog_to_monitors: String, + pub clog_to_syslog: String, + pub clog_to_syslog_level: String, + pub clog_to_syslog_facility: String, + pub mon_cluster_log_to_syslog: String, + pub mon_cluster_log_to_syslog_level: String, + pub mon_cluster_log_to_syslog_facility: String, + pub mon_cluster_log_file: String, + pub mon_cluster_log_file_level: String, + pub key: String, + pub keyfile: String, + pub keyring: String, + pub heartbeat_interval: String, + pub heartbeat_file: String, + pub heartbeat_inject_failure: String, + pub perf: String, + pub ms_tcp_nodelay: String, + pub ms_tcp_rcvbuf: String, + pub ms_initial_backoff: String, + pub ms_max_backoff: String, + pub ms_nocrc: String, + pub ms_die_on_bad_msg: String, + pub ms_die_on_unhandled_msg: String, + pub ms_die_on_old_message: String, + pub ms_dispatch_throttle_bytes: String, + pub ms_bind_ipv6: String, + pub ms_bind_port_min: String, + pub ms_bind_port_max: String, + pub ms_rwthread_stack_bytes: String, + pub ms_tcp_read_timeout: String, + pub ms_pq_max_tokens_per_priority: String, + pub ms_pq_min_cost: String, + pub ms_inject_socket_failures: String, + pub ms_inject_delay_type: String, + pub ms_inject_delay_msg_type: String, + pub ms_inject_delay_max: String, + pub ms_inject_delay_probability: String, + pub ms_inject_internal_delays: String, + pub ms_dump_on_send: String, + pub inject_early_sigterm: String, + pub mon_data: String, + pub mon_initial_members: String, + pub mon_sync_fs_threshold: String, + pub mon_compact_on_start: String, + pub mon_compact_on_bootstrap: String, + pub mon_compact_on_trim: String, + pub mon_tick_interval: String, + pub mon_subscribe_interval: String, + pub mon_delta_reset_interval: String, + pub mon_osd_laggy_halflife: String, + pub mon_osd_laggy_weight: String, + pub mon_osd_adjust_heartbeat_grace: String, + pub mon_osd_adjust_down_out_interval: String, + pub mon_osd_auto_mark_in: String, + pub mon_osd_auto_mark_auto_out_in: String, + pub mon_osd_auto_mark_new_in: String, + pub mon_osd_down_out_interval: String, + pub mon_osd_down_out_subtree_limit: String, + pub mon_osd_min_up_ratio: String, + pub mon_osd_min_in_ratio: String, + pub mon_osd_max_op_age: String, + pub mon_osd_max_split_count: String, + pub mon_osd_allow_primary_temp: String, + pub mon_osd_allow_primary_affinity: String, + pub mon_stat_smooth_intervals: String, + pub mon_lease: String, + pub mon_lease_renew_interval: String, + pub mon_lease_ack_timeout: String, + pub mon_clock_drift_allowed: String, + pub mon_clock_drift_warn_backoff: String, + pub mon_timecheck_interval: String, + pub mon_accept_timeout: String, + pub mon_pg_create_interval: String, + pub mon_pg_stuck_threshold: String, + pub mon_pg_warn_min_per_osd: String, + pub mon_pg_warn_max_object_skew: String, + pub mon_pg_warn_min_objects: String, + pub mon_pg_warn_min_pool_objects: String, + pub mon_cache_target_full_warn_ratio: String, + pub mon_osd_full_ratio: String, + pub mon_osd_nearfull_ratio: String, + pub mon_globalid_prealloc: String, + pub mon_osd_report_timeout: String, + pub mon_force_standby_active: String, + pub mon_warn_on_old_mons: String, + pub mon_warn_on_legacy_crush_tunables: String, + pub mon_warn_on_osd_down_out_interval_zero: String, + pub mon_warn_on_cache_pools_without_hit_sets: String, + pub mon_min_osdmap_epochs: String, + pub mon_max_pgmap_epochs: String, + pub mon_max_log_epochs: String, + pub mon_max_mdsmap_epochs: String, + pub mon_max_osd: String, + pub mon_probe_timeout: String, + pub mon_slurp_timeout: String, + pub mon_slurp_bytes: String, + pub mon_client_bytes: String, + pub mon_daemon_bytes: String, + pub mon_max_log_entries_per_event: String, + pub mon_health_data_update_interval: String, + pub mon_data_avail_crit: String, + pub mon_data_avail_warn: String, + pub mon_config_key_max_entry_size: String, + pub mon_sync_timeout: String, + pub mon_sync_max_payload_size: String, + pub mon_sync_debug: String, + pub mon_sync_debug_leader: String, + pub mon_sync_debug_provider: String, + pub mon_sync_debug_provider_fallback: String, + pub mon_inject_sync_get_chunk_delay: String, + pub mon_osd_min_down_reporters: String, + pub mon_osd_min_down_reports: String, + pub mon_osd_force_trim_to: String, + pub mon_mds_force_trim_to: String, + pub mon_advanced_debug_mode: String, + pub mon_debug_dump_transactions: String, + pub mon_debug_dump_location: String, + pub mon_sync_provider_kill_at: String, + pub mon_sync_requester_kill_at: String, + pub mon_leveldb_write_buffer_size: String, + pub mon_leveldb_cache_size: String, + pub mon_leveldb_block_size: String, + pub mon_leveldb_bloom_size: String, + pub mon_leveldb_max_open_files: String, + pub mon_leveldb_compression: String, + pub mon_leveldb_paranoid: String, + pub mon_leveldb_log: String, + pub mon_leveldb_size_warn: String, + pub mon_force_quorum_join: String, + pub paxos_stash_full_interval: String, + pub paxos_max_join_drift: String, + pub paxos_propose_interval: String, + pub paxos_min_wait: String, + pub paxos_min: String, + pub paxos_trim_min: String, + pub paxos_trim_max: String, + pub paxos_service_trim_min: String, + pub paxos_service_trim_max: String, + pub paxos_kill_at: String, + pub clock_offset: String, + pub auth_cluster_required: String, + pub auth_service_required: String, + pub auth_client_required: String, + pub auth_supported: String, + pub cephx_require_signatures: String, + pub cephx_cluster_require_signatures: String, + pub cephx_service_require_signatures: String, + pub cephx_sign_messages: String, + pub auth_mon_ticket_ttl: String, + pub auth_service_ticket_ttl: String, + pub auth_debug: String, + pub mon_client_hunt_interval: String, + pub mon_client_ping_interval: String, + pub mon_client_ping_timeout: String, + pub mon_client_hunt_interval_backoff: String, + pub mon_client_hunt_interval_max_multiple: String, + pub mon_client_max_log_entries_per_message: String, + pub mon_max_pool_pg_num: String, + pub mon_pool_quota_warn_threshold: String, + pub mon_pool_quota_crit_threshold: String, + pub client_cache_size: String, + pub client_cache_mid: String, + pub client_use_random_mds: String, + pub client_mount_timeout: String, + pub client_tick_interval: String, + pub client_trace: String, + pub client_readahead_min: String, + pub client_readahead_max_bytes: String, + pub client_readahead_max_periods: String, + pub client_snapdir: String, + pub client_mountpoint: String, + pub client_notify_timeout: String, + pub osd_client_watch_timeout: String, + pub client_caps_release_delay: String, + pub client_oc: String, + pub client_oc_size: String, + pub client_oc_max_dirty: String, + pub client_oc_target_dirty: String, + pub client_oc_max_dirty_age: String, + pub client_oc_max_objects: String, + pub client_debug_force_sync_read: String, + pub client_debug_inject_tick_delay: String, + pub client_max_inline_size: String, + pub fuse_use_invalidate_cb: String, + pub fuse_allow_other: String, + pub fuse_default_permissions: String, + pub fuse_big_writes: String, + pub fuse_atomic_o_trunc: String, + pub fuse_debug: String, + pub fuse_multithreaded: String, + pub crush_location: String, + pub objecter_tick_interval: String, + pub objecter_timeout: String, + pub objecter_inflight_op_bytes: String, + pub objecter_inflight_ops: String, + pub journaler_allow_split_entries: String, + pub journaler_write_head_interval: String, + pub journaler_prefetch_periods: String, + pub journaler_prezero_periods: String, + pub journaler_batch_interval: String, + pub journaler_batch_max: String, + pub mds_data: String, + pub mds_max_file_size: String, + pub mds_cache_size: String, + pub mds_cache_mid: String, + pub mds_mem_max: String, + pub mds_dir_max_commit_size: String, + pub mds_decay_halflife: String, + pub mds_beacon_interval: String, + pub mds_beacon_grace: String, + pub mds_enforce_unique_name: String, + pub mds_blacklist_interval: String, + pub mds_session_timeout: String, + pub mds_freeze_tree_timeout: String, + pub mds_session_autoclose: String, + pub mds_reconnect_timeout: String, + pub mds_tick_interval: String, + pub mds_dirstat_min_interval: String, + pub mds_scatter_nudge_interval: String, + pub mds_client_prealloc_inos: String, + pub mds_early_reply: String, + pub mds_default_dir_hash: String, + pub mds_log: String, + pub mds_log_skip_corrupt_events: String, + pub mds_log_max_events: String, + pub mds_log_segment_size: String, + pub mds_log_max_segments: String, + pub mds_log_max_expiring: String, + pub mds_bal_sample_interval: String, + pub mds_bal_replicate_threshold: String, + pub mds_bal_unreplicate_threshold: String, + pub mds_bal_frag: String, + pub mds_bal_split_size: String, + pub mds_bal_split_rd: String, + pub mds_bal_split_wr: String, + pub mds_bal_split_bits: String, + pub mds_bal_merge_size: String, + pub mds_bal_merge_rd: String, + pub mds_bal_merge_wr: String, + pub mds_bal_interval: String, + pub mds_bal_fragment_interval: String, + pub mds_bal_idle_threshold: String, + pub mds_bal_max: String, + pub mds_bal_max_until: String, + pub mds_bal_mode: String, + pub mds_bal_min_rebalance: String, + pub mds_bal_min_start: String, + pub mds_bal_need_min: String, + pub mds_bal_need_max: String, + pub mds_bal_midchunk: String, + pub mds_bal_minchunk: String, + pub mds_bal_target_removal_min: String, + pub mds_bal_target_removal_max: String, + pub mds_replay_interval: String, + pub mds_shutdown_check: String, + pub mds_thrash_exports: String, + pub mds_thrash_fragments: String, + pub mds_dump_cache_on_map: String, + pub mds_dump_cache_after_rejoin: String, + pub mds_verify_scatter: String, + pub mds_debug_scatterstat: String, + pub mds_debug_frag: String, + pub mds_debug_auth_pins: String, + pub mds_debug_subtrees: String, + pub mds_kill_mdstable_at: String, + pub mds_kill_export_at: String, + pub mds_kill_import_at: String, + pub mds_kill_link_at: String, + pub mds_kill_rename_at: String, + pub mds_kill_openc_at: String, + pub mds_kill_journal_at: String, + pub mds_kill_journal_expire_at: String, + pub mds_kill_journal_replay_at: String, + pub mds_kill_create_at: String, + pub mds_open_remote_link_mode: String, + pub mds_inject_traceless_reply_probability: String, + pub mds_wipe_sessions: String, + pub mds_wipe_ino_prealloc: String, + pub mds_skip_ino: String, + pub max_mds: String, + pub mds_standby_for_name: String, + pub mds_standby_for_rank: String, + pub mds_standby_replay: String, + pub osd_compact_leveldb_on_mount: String, + pub osd_max_backfills: String, + pub osd_backfill_full_ratio: String, + pub osd_backfill_retry_interval: String, + pub osd_agent_max_ops: String, + pub osd_agent_min_evict_effort: String, + pub osd_agent_quantize_effort: String, + pub osd_agent_delay_time: String, + pub osd_agent_hist_halflife: String, + pub osd_agent_slop: String, + pub osd_uuid: String, + pub osd_data: String, + pub osd_journal: String, + pub osd_journal_size: String, + pub osd_max_write_size: String, + pub osd_max_pgls: String, + pub osd_client_message_size_cap: String, + pub osd_client_message_cap: String, + pub osd_pg_bits: String, + pub osd_pgp_bits: String, + pub osd_crush_chooseleaf_type: String, + pub osd_pool_default_crush_rule: String, + pub osd_pool_default_crush_replicated_ruleset: String, + pub osd_pool_erasure_code_stripe_width: String, + pub osd_pool_default_size: String, + pub osd_pool_default_min_size: String, + pub osd_pool_default_pg_num: String, + pub osd_pool_default_pgp_num: String, + pub osd_pool_default_erasure_code_directory: String, + pub osd_pool_default_erasure_code_profile: String, + pub osd_erasure_code_plugins: String, + pub osd_pool_default_flags: String, + pub osd_pool_default_flag_hashpspool: String, + pub osd_pool_default_hit_set_bloom_fpp: String, + pub osd_pool_default_cache_target_dirty_ratio: String, + pub osd_pool_default_cache_target_full_ratio: String, + pub osd_pool_default_cache_min_flush_age: String, + pub osd_pool_default_cache_min_evict_age: String, + pub osd_hit_set_min_size: String, + pub osd_hit_set_max_size: String, + pub osd_hit_set_namespace: String, + pub osd_tier_default_cache_mode: String, + pub osd_tier_default_cache_hit_set_count: String, + pub osd_tier_default_cache_hit_set_period: String, + pub osd_tier_default_cache_hit_set_type: String, + pub osd_map_dedup: String, + pub osd_map_max_advance: String, + pub osd_map_cache_size: String, + pub osd_map_message_max: String, + pub osd_map_share_max_epochs: String, + pub osd_op_threads: String, + pub osd_peering_wq_batch_size: String, + pub osd_op_pq_max_tokens_per_priority: String, + pub osd_op_pq_min_cost: String, + pub osd_disk_threads: String, + pub osd_disk_thread_ioprio_class: String, + pub osd_disk_thread_ioprio_priority: String, + pub osd_recovery_threads: String, + pub osd_recover_clone_overlap: String, + pub osd_recover_clone_overlap_limit: String, + pub osd_backfill_scan_min: String, + pub osd_backfill_scan_max: String, + pub osd_op_thread_timeout: String, + pub osd_recovery_thread_timeout: String, + pub osd_snap_trim_thread_timeout: String, + pub osd_snap_trim_sleep: String, + pub osd_scrub_thread_timeout: String, + pub osd_scrub_finalize_thread_timeout: String, + pub osd_scrub_invalid_stats: String, + pub osd_remove_thread_timeout: String, + pub osd_command_thread_timeout: String, + pub osd_age: String, + pub osd_age_time: String, + pub osd_heartbeat_addr: String, + pub osd_heartbeat_interval: String, + pub osd_heartbeat_grace: String, + pub osd_heartbeat_min_peers: String, + pub osd_pg_max_concurrent_snap_trims: String, + pub osd_heartbeat_min_healthy_ratio: String, + pub osd_mon_heartbeat_interval: String, + pub osd_mon_report_interval_max: String, + pub osd_mon_report_interval_min: String, + pub osd_pg_stat_report_interval_max: String, + pub osd_mon_ack_timeout: String, + pub osd_default_data_pool_replay_window: String, + pub osd_preserve_trimmed_log: String, + pub osd_auto_mark_unfound_lost: String, + pub osd_recovery_delay_start: String, + pub osd_recovery_max_active: String, + pub osd_recovery_max_single_start: String, + pub osd_recovery_max_chunk: String, + pub osd_copyfrom_max_chunk: String, + pub osd_push_per_object_cost: String, + pub osd_max_push_cost: String, + pub osd_max_push_objects: String, + pub osd_recovery_forget_lost_objects: String, + pub osd_max_scrubs: String, + pub osd_scrub_load_threshold: String, + pub osd_scrub_min_interval: String, + pub osd_scrub_max_interval: String, + pub osd_scrub_chunk_min: String, + pub osd_scrub_chunk_max: String, + pub osd_scrub_sleep: String, + pub osd_deep_scrub_interval: String, + pub osd_deep_scrub_stride: String, + pub osd_scan_list_ping_tp_interval: String, + pub osd_auto_weight: String, + pub osd_class_dir: String, + pub osd_open_classes_on_start: String, + pub osd_check_for_log_corruption: String, + pub osd_use_stale_snap: String, + pub osd_rollback_to_cluster_snap: String, + pub osd_default_notify_timeout: String, + pub osd_kill_backfill_at: String, + pub osd_pg_epoch_persisted_max_stale: String, + pub osd_min_pg_log_entries: String, + pub osd_max_pg_log_entries: String, + pub osd_op_complaint_time: String, + pub osd_command_max_records: String, + pub osd_op_log_threshold: String, + pub osd_verify_sparse_read_holes: String, + pub osd_debug_drop_ping_probability: String, + pub osd_debug_drop_ping_duration: String, + pub osd_debug_drop_pg_create_probability: String, + pub osd_debug_drop_pg_create_duration: String, + pub osd_debug_drop_op_probability: String, + pub osd_debug_op_order: String, + pub osd_debug_verify_snaps_on_info: String, + pub osd_debug_verify_stray_on_activate: String, + pub osd_debug_skip_full_check_in_backfill_reservation: String, + pub osd_debug_reject_backfill_probability: String, + pub osd_enable_op_tracker: String, +} + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-29710.rs b/vendor/derivative/tests/rustc-issue-29710.rs new file mode 100644 index 000000000..d2198ed7a --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-29710.rs @@ -0,0 +1,29 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(unused_results)] +#![allow(dead_code)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct A(usize); + +#[derive(Derivative)] +#[derivative(Debug)] +struct B { a: usize } + +#[test] +fn main() {} diff --git a/vendor/derivative/tests/rustc-issue-32292.rs b/vendor/derivative/tests/rustc-issue-32292.rs new file mode 100644 index 000000000..6d4be3838 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-32292.rs @@ -0,0 +1,27 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(warnings)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Hash, Eq, PartialEq, Debug, Clone, Copy)] +// TODO: Ord, PartialOrd +struct Foo; + +#[test] +fn main() { + let _ = Foo; +} diff --git a/vendor/derivative/tests/rustc-issue-3935.rs b/vendor/derivative/tests/rustc-issue-3935.rs new file mode 100644 index 000000000..a63e6a771 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-3935.rs @@ -0,0 +1,29 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct Bike { + name: String, +} + +#[test] +fn main() { + let town_bike = Bike { name: "schwinn".to_string() }; + let my_bike = Bike { name: "surly".to_string() }; + + assert!(town_bike != my_bike); +} diff --git a/vendor/derivative/tests/rustc-issue-42453.rs b/vendor/derivative/tests/rustc-issue-42453.rs new file mode 100644 index 000000000..bd349de77 --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-42453.rs @@ -0,0 +1,28 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(warnings)] + +#![allow(dead_code)] +#![allow(non_camel_case_types)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(Debug)] +struct builder; + +fn main() { + +} diff --git a/vendor/derivative/tests/rustc-issue-58319.rs b/vendor/derivative/tests/rustc-issue-58319.rs new file mode 100644 index 000000000..4bb0077da --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-58319.rs @@ -0,0 +1,644 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![deny(warnings)] + +#![allow(dead_code)] +#![allow(non_camel_case_types)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +fn main() {} + +#[derive(Derivative)] +#[derivative(Clone)] +pub struct Little; + +#[derive(Clone)] +pub struct Big( + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, + Little, +); diff --git a/vendor/derivative/tests/rustc-issue-6341.rs b/vendor/derivative/tests/rustc-issue-6341.rs new file mode 100644 index 000000000..674f1918c --- /dev/null +++ b/vendor/derivative/tests/rustc-issue-6341.rs @@ -0,0 +1,30 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// pretty-expanded FIXME #23616 + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +#[derive(Derivative)] +#[derivative(PartialEq)] +struct A { x: usize } + +impl Drop for A { + fn drop(&mut self) {} +} + +#[test] +fn main() { + A { x: 42 }; +} diff --git a/vendor/derivative/tests/rustc-typeclasses-eq-example.rs b/vendor/derivative/tests/rustc-typeclasses-eq-example.rs new file mode 100644 index 000000000..4755df5b9 --- /dev/null +++ b/vendor/derivative/tests/rustc-typeclasses-eq-example.rs @@ -0,0 +1,83 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(non_snake_case)] +#![allow(non_camel_case_types)] + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +// Example from lkuper's intern talk, August 2012. +use Color::{cyan, magenta, yellow, black}; +use ColorTree::{leaf, branch}; + +trait Equal { + fn isEq(&self, a: &Self) -> bool; +} + +#[derive(Derivative)] +#[derivative(Clone, Copy)] +enum Color { cyan, magenta, yellow, black } + +impl Equal for Color { + fn isEq(&self, a: &Color) -> bool { + match (*self, *a) { + (cyan, cyan) => { true } + (magenta, magenta) => { true } + (yellow, yellow) => { true } + (black, black) => { true } + _ => { false } + } + } +} + +#[derive(Derivative)] +#[derivative(Clone)] +enum ColorTree { + leaf(Color), + branch(Box<ColorTree>, Box<ColorTree>) +} + +impl Equal for ColorTree { + fn isEq(&self, a: &ColorTree) -> bool { + match (self, a) { + (&leaf(ref x), &leaf(ref y)) => { x.isEq(&(*y)) } + (&branch(ref l1, ref r1), &branch(ref l2, ref r2)) => { + (*l1).isEq(&(**l2).clone()) && (*r1).isEq(&(**r2).clone()) + } + _ => { false } + } + } +} + +#[test] +fn main() { + assert!(cyan.isEq(&cyan)); + assert!(magenta.isEq(&magenta)); + assert!(!cyan.isEq(&yellow)); + assert!(!magenta.isEq(&cyan)); + + assert!(leaf(cyan).isEq(&leaf(cyan))); + assert!(!leaf(cyan).isEq(&leaf(yellow))); + + assert!(branch(Box::new(leaf(magenta)), Box::new(leaf(cyan))) + .isEq(&branch(Box::new(leaf(magenta)), Box::new(leaf(cyan))))); + + assert!(branch(Box::new(leaf(black)), Box::new(leaf(cyan))) + .isEq(&branch(Box::new(leaf(black)), Box::new(leaf(cyan))))); + + assert!(!branch(Box::new(leaf(magenta)), Box::new(leaf(cyan))) + .isEq(&branch(Box::new(leaf(magenta)), Box::new(leaf(magenta))))); + + println!("Assertions all succeeded!"); +} diff --git a/vendor/derivative/tests/rustc-zero-sized-btreemap-insert.rs b/vendor/derivative/tests/rustc-zero-sized-btreemap-insert.rs new file mode 100644 index 000000000..b6329f5d4 --- /dev/null +++ b/vendor/derivative/tests/rustc-zero-sized-btreemap-insert.rs @@ -0,0 +1,41 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(feature = "use_core")] +extern crate core; + +#[macro_use] +extern crate derivative; + +use std::collections::BTreeMap; +use std::iter::Iterator; + +#[derive(Derivative)] +#[derive(Ord, PartialOrd)] +#[derivative(Eq, Hash, Debug, PartialEq)] +// TODO: Ord, PartialOrd +struct Zst; + +#[test] +fn main() { + const N: usize = 8; + + for len in 0..N { + let mut tester = BTreeMap::new(); + assert_eq!(tester.len(), 0); + for _ in 0..len { + tester.insert(Zst, ()); + } + assert_eq!(tester.len(), if len == 0 { 0 } else { 1 }); + assert_eq!(tester.iter().count(), if len == 0 { 0 } else { 1 }); + assert_eq!(tester.get(&Zst).is_some(), len > 0); + tester.clear(); + } +} |