1 // run-pass
2 #![allow(unused_macros)]
3
4 // compile-flags: -C debug-assertions
5 //
6 // Test std::num::Wrapping<T> for {uN, iN, usize, isize}
7
8 #![feature(test)]
9
10 extern crate test;
11
12 use std::num::Wrapping;
13 use std::ops::{
14 Add, Sub, Mul, Div, Rem, BitXor, BitOr, BitAnd,
15 AddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitXorAssign, BitOrAssign, BitAndAssign,
16 Shl, Shr, ShlAssign, ShrAssign
17 };
18 use test::black_box;
19
20 macro_rules! int_modules {
21 ($(($name:ident, $size:expr),)*) => ($(
22 mod $name {
23 pub const BITS: usize = $size;
24 pub const MAX: $name = $name::MAX;
25 pub const MIN: $name = $name::MIN;
26 }
27 )*)
28 }
29
30 int_modules! {
31 (i8, 8),
32 (i16, 16),
33 (i32, 32),
34 (i64, 64),
35 (u8, 8),
36 (u16, 16),
37 (u32, 32),
38 (u64, 64),
39 }
40
41 #[cfg(target_pointer_width = "32")]
42 int_modules! {
43 (isize, 32),
44 (usize, 32),
45 }
46
47 #[cfg(target_pointer_width = "64")]
48 int_modules! {
49 (isize, 64),
50 (usize, 64),
51 }
52
main()53 fn main() {
54 test_ops();
55 test_op_assigns();
56 test_sh_ops();
57 test_sh_op_assigns();
58 }
59
test_ops()60 fn test_ops() {
61 macro_rules! op_test {
62 ($op:ident ($lhs:expr, $rhs:expr) == $ans:expr) => {
63 assert_eq!(black_box(Wrapping($lhs).$op(Wrapping($rhs))), Wrapping($ans));
64 // FIXME(30524): uncomment this test when it's implemented
65 // assert_eq!(black_box(Wrapping($lhs).$op($rhs)), Wrapping($ans));
66 }
67 }
68
69 op_test!(add(i8::MAX, 1) == i8::MIN);
70 op_test!(add(i16::MAX, 1) == i16::MIN);
71 op_test!(add(i32::MAX, 1) == i32::MIN);
72 op_test!(add(i64::MAX, 1) == i64::MIN);
73 op_test!(add(isize::MAX, 1) == isize::MIN);
74
75 op_test!(add(u8::MAX, 1) == 0);
76 op_test!(add(u16::MAX, 1) == 0);
77 op_test!(add(u32::MAX, 1) == 0);
78 op_test!(add(u64::MAX, 1) == 0);
79 op_test!(add(usize::MAX, 1) == 0);
80
81
82 op_test!(sub(i8::MIN, 1) == i8::MAX);
83 op_test!(sub(i16::MIN, 1) == i16::MAX);
84 op_test!(sub(i32::MIN, 1) == i32::MAX);
85 op_test!(sub(i64::MIN, 1) == i64::MAX);
86 op_test!(sub(isize::MIN, 1) == isize::MAX);
87
88 op_test!(sub(0u8, 1) == u8::MAX);
89 op_test!(sub(0u16, 1) == u16::MAX);
90 op_test!(sub(0u32, 1) == u32::MAX);
91 op_test!(sub(0u64, 1) == u64::MAX);
92 op_test!(sub(0usize, 1) == usize::MAX);
93
94
95 op_test!(mul(i8::MAX, 2) == -2);
96 op_test!(mul(i16::MAX, 2) == -2);
97 op_test!(mul(i32::MAX, 2) == -2);
98 op_test!(mul(i64::MAX, 2) == -2);
99 op_test!(mul(isize::MAX, 2) == -2);
100
101 op_test!(mul(u8::MAX, 2) == u8::MAX - 1);
102 op_test!(mul(u16::MAX, 2) == u16::MAX - 1);
103 op_test!(mul(u32::MAX, 2) == u32::MAX - 1);
104 op_test!(mul(u64::MAX, 2) == u64::MAX - 1);
105 op_test!(mul(usize::MAX, 2) == usize::MAX - 1);
106
107
108 op_test!(div(i8::MIN, -1) == i8::MIN);
109 op_test!(div(i16::MIN, -1) == i16::MIN);
110 op_test!(div(i32::MIN, -1) == i32::MIN);
111 op_test!(div(i64::MIN, -1) == i64::MIN);
112 op_test!(div(isize::MIN, -1) == isize::MIN);
113
114
115 op_test!(rem(i8::MIN, -1) == 0);
116 op_test!(rem(i16::MIN, -1) == 0);
117 op_test!(rem(i32::MIN, -1) == 0);
118 op_test!(rem(i64::MIN, -1) == 0);
119 op_test!(rem(isize::MIN, -1) == 0);
120
121 // these are not that interesting, just testing to make sure they are implemented correctly
122 op_test!(bitxor(0b101010i8, 0b100110) == 0b001100);
123 op_test!(bitxor(0b101010i16, 0b100110) == 0b001100);
124 op_test!(bitxor(0b101010i32, 0b100110) == 0b001100);
125 op_test!(bitxor(0b101010i64, 0b100110) == 0b001100);
126 op_test!(bitxor(0b101010isize, 0b100110) == 0b001100);
127
128 op_test!(bitxor(0b101010u8, 0b100110) == 0b001100);
129 op_test!(bitxor(0b101010u16, 0b100110) == 0b001100);
130 op_test!(bitxor(0b101010u32, 0b100110) == 0b001100);
131 op_test!(bitxor(0b101010u64, 0b100110) == 0b001100);
132 op_test!(bitxor(0b101010usize, 0b100110) == 0b001100);
133
134
135 op_test!(bitor(0b101010i8, 0b100110) == 0b101110);
136 op_test!(bitor(0b101010i16, 0b100110) == 0b101110);
137 op_test!(bitor(0b101010i32, 0b100110) == 0b101110);
138 op_test!(bitor(0b101010i64, 0b100110) == 0b101110);
139 op_test!(bitor(0b101010isize, 0b100110) == 0b101110);
140
141 op_test!(bitor(0b101010u8, 0b100110) == 0b101110);
142 op_test!(bitor(0b101010u16, 0b100110) == 0b101110);
143 op_test!(bitor(0b101010u32, 0b100110) == 0b101110);
144 op_test!(bitor(0b101010u64, 0b100110) == 0b101110);
145 op_test!(bitor(0b101010usize, 0b100110) == 0b101110);
146
147
148 op_test!(bitand(0b101010i8, 0b100110) == 0b100010);
149 op_test!(bitand(0b101010i16, 0b100110) == 0b100010);
150 op_test!(bitand(0b101010i32, 0b100110) == 0b100010);
151 op_test!(bitand(0b101010i64, 0b100110) == 0b100010);
152 op_test!(bitand(0b101010isize, 0b100110) == 0b100010);
153
154 op_test!(bitand(0b101010u8, 0b100110) == 0b100010);
155 op_test!(bitand(0b101010u16, 0b100110) == 0b100010);
156 op_test!(bitand(0b101010u32, 0b100110) == 0b100010);
157 op_test!(bitand(0b101010u64, 0b100110) == 0b100010);
158 op_test!(bitand(0b101010usize, 0b100110) == 0b100010);
159 }
160
test_op_assigns()161 fn test_op_assigns() {
162 macro_rules! op_assign_test {
163 ($op:ident ($initial:expr, $rhs:expr) == $ans:expr) => {
164 {
165 let mut tmp = Wrapping($initial);
166 tmp = black_box(tmp);
167 tmp.$op(Wrapping($rhs));
168 assert_eq!(black_box(tmp), Wrapping($ans));
169 }
170
171 // also test that a &Wrapping<T> right-hand side is possible
172 {
173 let mut tmp = Wrapping($initial);
174 tmp = black_box(tmp);
175 tmp.$op(&Wrapping($rhs));
176 assert_eq!(black_box(tmp), Wrapping($ans));
177 }
178
179 // FIXME(30524): uncomment this test
180 /*
181 {
182 let mut tmp = Wrapping($initial);
183 tmp = black_box(tmp);
184 tmp.$op($rhs);
185 assert_eq!(black_box(tmp), Wrapping($ans));
186 }
187 */
188 }
189 }
190 op_assign_test!(add_assign(i8::MAX, 1) == i8::MIN);
191 op_assign_test!(add_assign(i16::MAX, 1) == i16::MIN);
192 op_assign_test!(add_assign(i32::MAX, 1) == i32::MIN);
193 op_assign_test!(add_assign(i64::MAX, 1) == i64::MIN);
194 op_assign_test!(add_assign(isize::MAX, 1) == isize::MIN);
195
196 op_assign_test!(add_assign(u8::MAX, 1) == u8::MIN);
197 op_assign_test!(add_assign(u16::MAX, 1) == u16::MIN);
198 op_assign_test!(add_assign(u32::MAX, 1) == u32::MIN);
199 op_assign_test!(add_assign(u64::MAX, 1) == u64::MIN);
200 op_assign_test!(add_assign(usize::MAX, 1) == usize::MIN);
201
202
203 op_assign_test!(sub_assign(i8::MIN, 1) == i8::MAX);
204 op_assign_test!(sub_assign(i16::MIN, 1) == i16::MAX);
205 op_assign_test!(sub_assign(i32::MIN, 1) == i32::MAX);
206 op_assign_test!(sub_assign(i64::MIN, 1) == i64::MAX);
207 op_assign_test!(sub_assign(isize::MIN, 1) == isize::MAX);
208
209 op_assign_test!(sub_assign(u8::MIN, 1) == u8::MAX);
210 op_assign_test!(sub_assign(u16::MIN, 1) == u16::MAX);
211 op_assign_test!(sub_assign(u32::MIN, 1) == u32::MAX);
212 op_assign_test!(sub_assign(u64::MIN, 1) == u64::MAX);
213 op_assign_test!(sub_assign(usize::MIN, 1) == usize::MAX);
214
215
216 op_assign_test!(mul_assign(i8::MAX, 2) == -2);
217 op_assign_test!(mul_assign(i16::MAX, 2) == -2);
218 op_assign_test!(mul_assign(i32::MAX, 2) == -2);
219 op_assign_test!(mul_assign(i64::MAX, 2) == -2);
220 op_assign_test!(mul_assign(isize::MAX, 2) == -2);
221
222 op_assign_test!(mul_assign(u8::MAX, 2) == u8::MAX - 1);
223 op_assign_test!(mul_assign(u16::MAX, 2) == u16::MAX - 1);
224 op_assign_test!(mul_assign(u32::MAX, 2) == u32::MAX - 1);
225 op_assign_test!(mul_assign(u64::MAX, 2) == u64::MAX - 1);
226 op_assign_test!(mul_assign(usize::MAX, 2) == usize::MAX - 1);
227
228
229 op_assign_test!(div_assign(i8::MIN, -1) == i8::MIN);
230 op_assign_test!(div_assign(i16::MIN, -1) == i16::MIN);
231 op_assign_test!(div_assign(i32::MIN, -1) == i32::MIN);
232 op_assign_test!(div_assign(i64::MIN, -1) == i64::MIN);
233 op_assign_test!(div_assign(isize::MIN, -1) == isize::MIN);
234
235
236 op_assign_test!(rem_assign(i8::MIN, -1) == 0);
237 op_assign_test!(rem_assign(i16::MIN, -1) == 0);
238 op_assign_test!(rem_assign(i32::MIN, -1) == 0);
239 op_assign_test!(rem_assign(i64::MIN, -1) == 0);
240 op_assign_test!(rem_assign(isize::MIN, -1) == 0);
241
242
243 // these are not that interesting, just testing to make sure they are implemented correctly
244 op_assign_test!(bitxor_assign(0b101010i8, 0b100110) == 0b001100);
245 op_assign_test!(bitxor_assign(0b101010i16, 0b100110) == 0b001100);
246 op_assign_test!(bitxor_assign(0b101010i32, 0b100110) == 0b001100);
247 op_assign_test!(bitxor_assign(0b101010i64, 0b100110) == 0b001100);
248 op_assign_test!(bitxor_assign(0b101010isize, 0b100110) == 0b001100);
249
250 op_assign_test!(bitxor_assign(0b101010u8, 0b100110) == 0b001100);
251 op_assign_test!(bitxor_assign(0b101010u16, 0b100110) == 0b001100);
252 op_assign_test!(bitxor_assign(0b101010u32, 0b100110) == 0b001100);
253 op_assign_test!(bitxor_assign(0b101010u64, 0b100110) == 0b001100);
254 op_assign_test!(bitxor_assign(0b101010usize, 0b100110) == 0b001100);
255
256
257 op_assign_test!(bitor_assign(0b101010i8, 0b100110) == 0b101110);
258 op_assign_test!(bitor_assign(0b101010i16, 0b100110) == 0b101110);
259 op_assign_test!(bitor_assign(0b101010i32, 0b100110) == 0b101110);
260 op_assign_test!(bitor_assign(0b101010i64, 0b100110) == 0b101110);
261 op_assign_test!(bitor_assign(0b101010isize, 0b100110) == 0b101110);
262
263 op_assign_test!(bitor_assign(0b101010u8, 0b100110) == 0b101110);
264 op_assign_test!(bitor_assign(0b101010u16, 0b100110) == 0b101110);
265 op_assign_test!(bitor_assign(0b101010u32, 0b100110) == 0b101110);
266 op_assign_test!(bitor_assign(0b101010u64, 0b100110) == 0b101110);
267 op_assign_test!(bitor_assign(0b101010usize, 0b100110) == 0b101110);
268
269
270 op_assign_test!(bitand_assign(0b101010i8, 0b100110) == 0b100010);
271 op_assign_test!(bitand_assign(0b101010i16, 0b100110) == 0b100010);
272 op_assign_test!(bitand_assign(0b101010i32, 0b100110) == 0b100010);
273 op_assign_test!(bitand_assign(0b101010i64, 0b100110) == 0b100010);
274 op_assign_test!(bitand_assign(0b101010isize, 0b100110) == 0b100010);
275
276 op_assign_test!(bitand_assign(0b101010u8, 0b100110) == 0b100010);
277 op_assign_test!(bitand_assign(0b101010u16, 0b100110) == 0b100010);
278 op_assign_test!(bitand_assign(0b101010u32, 0b100110) == 0b100010);
279 op_assign_test!(bitand_assign(0b101010u64, 0b100110) == 0b100010);
280 op_assign_test!(bitand_assign(0b101010usize, 0b100110) == 0b100010);
281 }
282
test_sh_ops()283 fn test_sh_ops() {
284 macro_rules! sh_test {
285 ($op:ident ($lhs:expr, $rhs:expr) == $ans:expr) => {
286 assert_eq!(black_box(Wrapping($lhs).$op($rhs)), Wrapping($ans));
287 }
288 }
289 // NOTE: This will break for i8 if we ever get i/u128
290 macro_rules! sh_test_all {
291 ($t:ty) => {
292 sh_test!(shl(i8::MAX, (i8::BITS + 1) as $t) == -2);
293 sh_test!(shl(i16::MAX, (i16::BITS + 1) as $t) == -2);
294 sh_test!(shl(i32::MAX, (i32::BITS + 1) as $t) == -2);
295 sh_test!(shl(i64::MAX, (i64::BITS + 1) as $t) == -2);
296 sh_test!(shl(isize::MAX, (isize::BITS + 1) as $t) == -2);
297
298 sh_test!(shl(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX - 1);
299 sh_test!(shl(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX - 1);
300 sh_test!(shl(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX - 1);
301 sh_test!(shl(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX - 1);
302 sh_test!(shl(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX - 1);
303
304
305 sh_test!(shr(i8::MAX, (i8::BITS + 1) as $t) == i8::MAX / 2);
306 sh_test!(shr(i16::MAX, (i16::BITS + 1) as $t) == i16::MAX / 2);
307 sh_test!(shr(i32::MAX, (i32::BITS + 1) as $t) == i32::MAX / 2);
308 sh_test!(shr(i64::MAX, (i64::BITS + 1) as $t) == i64::MAX / 2);
309 sh_test!(shr(isize::MAX, (isize::BITS + 1) as $t) == isize::MAX / 2);
310
311 sh_test!(shr(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX / 2);
312 sh_test!(shr(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX / 2);
313 sh_test!(shr(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX / 2);
314 sh_test!(shr(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX / 2);
315 sh_test!(shr(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX / 2);
316 }
317 }
318 macro_rules! sh_test_negative_all {
319 ($t:ty) => {
320 sh_test!(shr(i8::MAX, -((i8::BITS + 1) as $t)) == -2);
321 sh_test!(shr(i16::MAX, -((i16::BITS + 1) as $t)) == -2);
322 sh_test!(shr(i32::MAX, -((i32::BITS + 1) as $t)) == -2);
323 sh_test!(shr(i64::MAX, -((i64::BITS + 1) as $t)) == -2);
324 sh_test!(shr(isize::MAX, -((isize::BITS + 1) as $t)) == -2);
325
326 sh_test!(shr(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX - 1);
327 sh_test!(shr(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX - 1);
328 sh_test!(shr(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX - 1);
329 sh_test!(shr(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX - 1);
330 sh_test!(shr(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX - 1);
331
332
333 sh_test!(shl(i8::MAX, -((i8::BITS + 1) as $t)) == i8::MAX / 2);
334 sh_test!(shl(i16::MAX, -((i16::BITS + 1) as $t)) == i16::MAX / 2);
335 sh_test!(shl(i32::MAX, -((i32::BITS + 1) as $t)) == i32::MAX / 2);
336 sh_test!(shl(i64::MAX, -((i64::BITS + 1) as $t)) == i64::MAX / 2);
337 sh_test!(shl(isize::MAX, -((isize::BITS + 1) as $t)) == isize::MAX / 2);
338
339 sh_test!(shl(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX / 2);
340 sh_test!(shl(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX / 2);
341 sh_test!(shl(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX / 2);
342 sh_test!(shl(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX / 2);
343 sh_test!(shl(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX / 2);
344 }
345 }
346 // FIXME(#23545): Uncomment the remaining tests
347 //sh_test_all!(i8);
348 //sh_test_all!(u8);
349 //sh_test_all!(i16);
350 //sh_test_all!(u16);
351 //sh_test_all!(i32);
352 //sh_test_all!(u32);
353 //sh_test_all!(i64);
354 //sh_test_all!(u64);
355 //sh_test_all!(isize);
356 sh_test_all!(usize);
357
358 //sh_test_negative_all!(i8);
359 //sh_test_negative_all!(i16);
360 //sh_test_negative_all!(i32);
361 //sh_test_negative_all!(i64);
362 //sh_test_negative_all!(isize);
363 }
364
test_sh_op_assigns()365 fn test_sh_op_assigns() {
366 macro_rules! sh_assign_test {
367 ($op:ident ($initial:expr, $rhs:expr) == $ans:expr) => {{
368 let mut tmp = Wrapping($initial);
369 tmp = black_box(tmp);
370 tmp.$op($rhs);
371 assert_eq!(black_box(tmp), Wrapping($ans));
372 }}
373 }
374 macro_rules! sh_assign_test_all {
375 ($t:ty) => {
376 sh_assign_test!(shl_assign(i8::MAX, (i8::BITS + 1) as $t) == -2);
377 sh_assign_test!(shl_assign(i16::MAX, (i16::BITS + 1) as $t) == -2);
378 sh_assign_test!(shl_assign(i32::MAX, (i32::BITS + 1) as $t) == -2);
379 sh_assign_test!(shl_assign(i64::MAX, (i64::BITS + 1) as $t) == -2);
380 sh_assign_test!(shl_assign(isize::MAX, (isize::BITS + 1) as $t) == -2);
381
382 sh_assign_test!(shl_assign(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX - 1);
383 sh_assign_test!(shl_assign(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX - 1);
384 sh_assign_test!(shl_assign(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX - 1);
385 sh_assign_test!(shl_assign(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX - 1);
386 sh_assign_test!(shl_assign(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX - 1);
387
388
389 sh_assign_test!(shr_assign(i8::MAX, (i8::BITS + 1) as $t) == i8::MAX / 2);
390 sh_assign_test!(shr_assign(i16::MAX, (i16::BITS + 1) as $t) == i16::MAX / 2);
391 sh_assign_test!(shr_assign(i32::MAX, (i32::BITS + 1) as $t) == i32::MAX / 2);
392 sh_assign_test!(shr_assign(i64::MAX, (i64::BITS + 1) as $t) == i64::MAX / 2);
393 sh_assign_test!(shr_assign(isize::MAX, (isize::BITS + 1) as $t) == isize::MAX / 2);
394
395 sh_assign_test!(shr_assign(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX / 2);
396 sh_assign_test!(shr_assign(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX / 2);
397 sh_assign_test!(shr_assign(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX / 2);
398 sh_assign_test!(shr_assign(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX / 2);
399 sh_assign_test!(shr_assign(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX / 2);
400 }
401 }
402 macro_rules! sh_assign_test_negative_all {
403 ($t:ty) => {
404 sh_assign_test!(shr_assign(i8::MAX, -((i8::BITS + 1) as $t)) == -2);
405 sh_assign_test!(shr_assign(i16::MAX, -((i16::BITS + 1) as $t)) == -2);
406 sh_assign_test!(shr_assign(i32::MAX, -((i32::BITS + 1) as $t)) == -2);
407 sh_assign_test!(shr_assign(i64::MAX, -((i64::BITS + 1) as $t)) == -2);
408 sh_assign_test!(shr_assign(isize::MAX, -((isize::BITS + 1) as $t)) == -2);
409
410 sh_assign_test!(shr_assign(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX - 1);
411 sh_assign_test!(shr_assign(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX - 1);
412 sh_assign_test!(shr_assign(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX - 1);
413 sh_assign_test!(shr_assign(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX - 1);
414 sh_assign_test!(shr_assign(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX - 1);
415
416
417 sh_assign_test!(shl_assign(i8::MAX, -((i8::BITS + 1) as $t)) == i8::MAX / 2);
418 sh_assign_test!(shl_assign(i16::MAX, -((i16::BITS + 1) as $t)) == i16::MAX / 2);
419 sh_assign_test!(shl_assign(i32::MAX, -((i32::BITS + 1) as $t)) == i32::MAX / 2);
420 sh_assign_test!(shl_assign(i64::MAX, -((i64::BITS + 1) as $t)) == i64::MAX / 2);
421 sh_assign_test!(shl_assign(isize::MAX, -((isize::BITS + 1) as $t)) == isize::MAX / 2);
422
423 sh_assign_test!(shl_assign(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX / 2);
424 sh_assign_test!(shl_assign(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX / 2);
425 sh_assign_test!(shl_assign(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX / 2);
426 sh_assign_test!(shl_assign(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX / 2);
427 sh_assign_test!(shl_assign(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX / 2);
428 }
429 }
430
431 // FIXME(#23545): Uncomment the remaining tests
432 //sh_assign_test_all!(i8);
433 //sh_assign_test_all!(u8);
434 //sh_assign_test_all!(i16);
435 //sh_assign_test_all!(u16);
436 //sh_assign_test_all!(i32);
437 //sh_assign_test_all!(u32);
438 //sh_assign_test_all!(i64);
439 //sh_assign_test_all!(u64);
440 //sh_assign_test_all!(isize);
441 sh_assign_test_all!(usize);
442
443 //sh_assign_test_negative_all!(i8);
444 //sh_assign_test_negative_all!(i16);
445 //sh_assign_test_negative_all!(i32);
446 //sh_assign_test_negative_all!(i64);
447 //sh_assign_test_negative_all!(isize);
448 }
449