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