1 #![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref, dead_code)]
2
3 #[cfg(feature = "use_core")]
4 extern crate core;
5
6 use std::marker::PhantomData;
7
8 #[macro_use]
9 extern crate derivative;
10
11 #[derive(Derivative)]
12 #[derivative(PartialEq)]
13 struct Foo {
14 foo: u8,
15 }
16
17 /// Test for backward compatibility.
18 #[derive(Derivative)]
19 #[derivative(PartialEq = "feature_allow_slow_enum")]
20 #[allow(unused)]
21 enum AllowsFeature<T> {
22 Some(T),
23 None,
24 }
25
26 #[derive(Derivative)]
27 #[derivative(PartialEq)]
28 enum Option<T> {
29 Some(T),
30 None,
31 }
32
33 #[derive(Derivative)]
34 #[derivative(PartialEq)]
35 enum SimpleEnum {
36 Some,
37 None,
38 }
39
40 #[derive(Derivative)]
41 #[derivative(PartialEq)]
42 enum UnitEnum {
43 Single,
44 }
45
46 #[derive(Derivative)]
47 #[derivative(PartialEq)]
48 struct WithPtr<T: ?Sized> {
49 #[derivative(PartialEq(bound = ""))]
50 foo: *const T,
51 }
52
53 #[derive(Derivative)]
54 #[derivative(PartialEq)]
55 struct Empty;
56
57 #[derive(Derivative)]
58 #[derivative(PartialEq)]
59 struct AllIgnored {
60 #[derivative(PartialEq = "ignore")]
61 foo: u8,
62 }
63
64 #[derive(Derivative)]
65 #[derivative(PartialEq)]
66 struct OneIgnored {
67 #[derivative(PartialEq = "ignore")]
68 foo: u8,
69 bar: u8,
70 }
71
72 #[derive(Derivative)]
73 #[derivative(PartialEq)]
74 struct Parity(#[derivative(PartialEq(compare_with = "same_parity"))] u8);
75
same_parity(lhs: &u8, rhs: &u8) -> bool76 fn same_parity(lhs: &u8, rhs: &u8) -> bool {
77 lhs % 2 == rhs % 2
78 }
79
80 #[derive(Derivative)]
81 #[derivative(PartialEq)]
82 struct Generic<T>(#[derivative(PartialEq(compare_with = "dummy_cmp", bound = ""))] T);
83
dummy_cmp<T>(_: &T, _: &T) -> bool84 fn dummy_cmp<T>(_: &T, _: &T) -> bool {
85 true
86 }
87
88 struct NonPartialEq;
89
90 #[derive(Derivative)]
91 #[derivative(PartialEq, Eq)]
92 struct GenericIgnore<T> {
93 f: u32,
94 #[derivative(PartialEq = "ignore")]
95 t: PhantomData<T>,
96 }
97
98 trait SomeTrait {}
99 struct SomeType {
100 #[allow(dead_code)]
101 foo: u8,
102 }
103 impl SomeTrait for SomeType {}
104
105 #[test]
main()106 fn main() {
107 assert!(Foo { foo: 7 } == Foo { foo: 7 });
108 assert!(Foo { foo: 7 } != Foo { foo: 42 });
109
110 let ptr1: *const dyn SomeTrait = &SomeType { foo: 0 };
111 let ptr2: *const dyn SomeTrait = &SomeType { foo: 1 };
112 assert!(WithPtr { foo: ptr1 } == WithPtr { foo: ptr1 });
113 assert!(WithPtr { foo: ptr1 } != WithPtr { foo: ptr2 });
114
115 assert!(Empty == Empty);
116 assert!(AllIgnored { foo: 0 } == AllIgnored { foo: 42 });
117 assert!(OneIgnored { foo: 0, bar: 6 } == OneIgnored { foo: 42, bar: 6 });
118 assert!(OneIgnored { foo: 0, bar: 6 } != OneIgnored { foo: 42, bar: 7 });
119
120 assert!(Option::Some(42) == Option::Some(42));
121 assert!(Option::Some(0) != Option::Some(42));
122 assert!(Option::Some(42) != Option::None);
123 assert!(Option::None != Option::Some(42));
124 assert!(Option::None::<u8> == Option::None::<u8>);
125
126 assert!(SimpleEnum::Some == SimpleEnum::Some);
127 assert!(SimpleEnum::None == SimpleEnum::None);
128 assert!(SimpleEnum::Some != SimpleEnum::None);
129 assert!(SimpleEnum::None != SimpleEnum::Some);
130
131 assert!(UnitEnum::Single == UnitEnum::Single);
132
133 assert!(Parity(3) == Parity(7));
134 assert!(Parity(2) == Parity(42));
135 assert!(Parity(3) != Parity(42));
136 assert!(Parity(2) != Parity(7));
137
138 assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 }));
139 assert!(
140 GenericIgnore {
141 f: 123,
142 t: PhantomData::<NonPartialEq>::default()
143 } == GenericIgnore {
144 f: 123,
145 t: PhantomData::<NonPartialEq>::default()
146 }
147 );
148 }
149