1 // Copyright 2023 The ChromiumOS Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 use enum_utils::enum_as;
6 use enum_utils::passthru_to;
7
8 #[derive(Debug)]
9 #[enum_as(u8)]
10 pub enum TestU8 {
11 /// One Value
12 One = 1,
13 // Eight with other kind of comment
14 Eight = 0o10,
15 ThirtyTwo = 0x20, // inline comment afterwards
16 }
17
18 #[test]
test_u8_enum_conversion()19 fn test_u8_enum_conversion() {
20 assert_eq!(TestU8::from_u8(1), Some(TestU8::One));
21 assert_eq!(TestU8::from_u8(8), Some(TestU8::Eight));
22 assert_eq!(TestU8::from_u8(32), Some(TestU8::ThirtyTwo));
23 assert_eq!(TestU8::END, 33);
24
25 for i in 0..u8::MAX {
26 if matches!(i, 1 | 8 | 32) {
27 continue;
28 }
29 assert!(TestU8::from_u8(i).is_none());
30 }
31 }
32
33 #[test]
test_u8_enum_equals()34 fn test_u8_enum_equals() {
35 assert_eq!(TestU8::One, TestU8::One);
36 assert_eq!(TestU8::Eight, TestU8::Eight);
37 assert_eq!(TestU8::ThirtyTwo, TestU8::ThirtyTwo);
38
39 assert_ne!(TestU8::One, TestU8::Eight);
40 assert_ne!(TestU8::Eight, TestU8::ThirtyTwo);
41 assert_ne!(TestU8::ThirtyTwo, TestU8::One);
42 }
43
44 #[derive(Debug)]
45 #[enum_as(u16)]
46 pub enum TestU16 {
47 Zero,
48 One,
49 Ten = 10,
50 Max = 0xffff,
51 }
52
53 #[test]
test_u16_enum_conversion()54 fn test_u16_enum_conversion() {
55 assert_eq!(TestU16::from_u16(0), Some(TestU16::Zero));
56 assert_eq!(TestU16::from_u16(1), Some(TestU16::One));
57 assert_eq!(TestU16::from_u16(10), Some(TestU16::Ten));
58 assert_eq!(TestU16::from_u16(u16::MAX), Some(TestU16::Max));
59 assert_eq!(TestU16::END, (u16::MAX as usize) + 1);
60
61 for i in 0..u16::MAX {
62 if matches!(i, 0 | 1 | 10) {
63 continue;
64 }
65 assert!(TestU16::from_u16(i).is_none());
66 }
67 }
68
69 #[test]
test_u16_enum_equals()70 fn test_u16_enum_equals() {
71 assert_eq!(TestU16::Zero, TestU16::Zero);
72 assert_eq!(TestU16::One, TestU16::One);
73 assert_eq!(TestU16::Ten, TestU16::Ten);
74
75 assert_ne!(TestU16::Zero, TestU16::One);
76 assert_ne!(TestU16::One, TestU16::Ten);
77 assert_ne!(TestU16::Ten, TestU16::Zero);
78 }
79
80 #[derive(Debug)]
81 #[enum_as(usize)]
82 pub enum TestUsize {
83 Zero,
84 One,
85 Two,
86 }
87
88 #[test]
test_usize_enum_conversion()89 fn test_usize_enum_conversion() {
90 assert_eq!(TestUsize::from_usize(0), Some(TestUsize::Zero));
91 assert_eq!(TestUsize::from_usize(1), Some(TestUsize::One));
92 assert_eq!(TestUsize::from_usize(2), Some(TestUsize::Two));
93 assert_eq!(TestUsize::END, 3);
94
95 // Too expensive to test all cases
96 for i in 3..100 {
97 assert!(TestUsize::from_usize(i).is_none());
98 }
99 assert!(TestUsize::from_usize(usize::MAX).is_none());
100 }
101
102 #[test]
test_usize_enum_equals()103 fn test_usize_enum_equals() {
104 assert_eq!(TestUsize::Zero, TestUsize::Zero);
105 assert_eq!(TestUsize::One, TestUsize::One);
106 assert_eq!(TestUsize::Two, TestUsize::Two);
107
108 assert_ne!(TestUsize::Zero, TestUsize::One);
109 assert_ne!(TestUsize::One, TestUsize::Two);
110 assert_ne!(TestUsize::Two, TestUsize::Zero);
111 }
112
113 #[derive(Debug)]
114 #[enum_as(u64)]
115 pub enum TestU64 {
116 Zero,
117 MaxU32 = 0xFFFF_FFFF,
118 U64,
119 }
120
121 #[test]
test_u64_enum_conversion()122 fn test_u64_enum_conversion() {
123 assert_eq!(TestU64::from_u64(0), Some(TestU64::Zero));
124 assert_eq!(TestU64::from_u64(0xFFFF_FFFF), Some(TestU64::MaxU32));
125 assert_eq!(TestU64::from_u64(0x1_0000_0000), Some(TestU64::U64));
126 assert_eq!(TestU64::END, 0x1_0000_0001);
127
128 // Too expensive to test all cases
129 for i in 1..100 {
130 assert!(TestU64::from_u64(i).is_none());
131 }
132 assert!(TestU64::from_u64(u64::MAX).is_none());
133 }
134
135 #[test]
test_u64_enum_equals()136 fn test_u64_enum_equals() {
137 assert_eq!(TestU64::Zero, TestU64::Zero);
138 assert_eq!(TestU64::MaxU32, TestU64::MaxU32);
139 assert_eq!(TestU64::U64, TestU64::U64);
140
141 assert_ne!(TestU64::Zero, TestU64::MaxU32);
142 assert_ne!(TestU64::MaxU32, TestU64::U64);
143 assert_ne!(TestU64::U64, TestU64::Zero);
144 }
145
146 #[derive(Debug)]
147 #[enum_as(i32)]
148 pub enum TestI32 {
149 NegativeFour = -4,
150 NegativeOne = -1,
151 One = 1,
152 Two = 2,
153 }
154
155 #[test]
test_ui32_enum_conversion()156 fn test_ui32_enum_conversion() {
157 assert_eq!(TestI32::from_i32(-4), Some(TestI32::NegativeFour));
158 assert_eq!(TestI32::from_i32(-1), Some(TestI32::NegativeOne));
159 assert_eq!(TestI32::from_i32(1), Some(TestI32::One));
160 assert_eq!(TestI32::from_i32(2), Some(TestI32::Two));
161 assert_eq!(TestI32::END, 3);
162
163 // Too expensive to test all cases
164 for i in [-6, -5, -3, -2, 0, 3, 4] {
165 assert!(TestI32::from_i32(i).is_none());
166 }
167 }
168
169 #[test]
test_ui32_enum_equals()170 fn test_ui32_enum_equals() {
171 assert_eq!(TestI32::NegativeFour, TestI32::NegativeFour);
172 assert_eq!(TestI32::NegativeOne, TestI32::NegativeOne);
173 assert_eq!(TestI32::One, TestI32::One);
174 assert_eq!(TestI32::Two, TestI32::Two);
175
176 assert_ne!(TestI32::NegativeFour, TestI32::NegativeOne);
177 assert_ne!(TestI32::NegativeFour, TestI32::One);
178 assert_ne!(TestI32::NegativeFour, TestI32::Two);
179 assert_ne!(TestI32::One, TestI32::Two);
180 }
181
182 pub struct Inner(usize);
183
184 impl Inner {
increment(&mut self, by: usize) -> usize185 pub fn increment(&mut self, by: usize) -> usize {
186 self.0 += by;
187 self.0
188 }
read(&self) -> usize189 pub fn read(&self) -> usize {
190 self.0
191 }
192 }
193
194 pub struct Outer {
195 pub inner: Inner,
196 }
197
198 impl Outer {
199 #[passthru_to(inner)]
increment(&mut self, by: usize) -> usize200 pub fn increment(&mut self, by: usize) -> usize {}
201 #[passthru_to(inner)]
read(&self) -> usize202 pub fn read(&self) -> usize {}
203 }
204
205 #[test]
test_passthru()206 fn test_passthru() {
207 let mut outer = Outer { inner: Inner(1) };
208
209 assert_eq!(outer.increment(4), 5);
210 assert_eq!(outer.increment(5), 10);
211 assert_eq!(outer.read(), 10);
212 }
213