1 //@compile-flags: -Coverflow-checks=off
2 #![allow(arithmetic_overflow)]
5 // This tests that we do (not) do sign extension properly when loading integers
6 assert_eq!(u32::MAX as i64, 4294967295);
7 assert_eq!(i32::MIN as i64, -2147483648);
9 assert_eq!(i8::MAX, 127);
10 assert_eq!(i8::MIN, -128);
12 // Shifts with negative offsets are subtle.
13 assert_eq!(13 << -2i8, 13 << 254);
14 assert_eq!(13 << i8::MIN, 13);
15 assert_eq!(13 << -1i16, 13 << u16::MAX);
16 assert_eq!(13 << i16::MIN, 13);
17 assert_eq!(13i128 << -2i8, 13i128 << 254);
18 assert_eq!(13i128 << i8::MIN, 13);
19 assert_eq!(13i128 << -1i16, 13i128 << u16::MAX);
20 assert_eq!(13i128 << i16::MIN, 13);
22 assert_eq!(i32::from_str_radix("A", 16), Ok(10));
24 let n = -0b1000_0000i8;
25 assert_eq!(n.count_ones(), 1);
27 let n = -0b1000_0000i8;
28 assert_eq!(n.count_zeros(), 7);
31 assert_eq!(n.leading_zeros(), 0);
34 assert_eq!(n.trailing_zeros(), 2);
36 let n = 0x0123456789ABCDEFi64;
37 let m = -0x76543210FEDCBA99i64;
38 assert_eq!(n.rotate_left(32), m);
40 let n = 0x0123456789ABCDEFi64;
41 let m = -0xFEDCBA987654322i64;
42 assert_eq!(n.rotate_right(4), m);
44 let n = 0x0123456789ABCDEFi64;
45 let m = -0x1032547698BADCFFi64;
46 assert_eq!(n.swap_bytes(), m);
48 let n = 0x0123456789ABCDEFi64;
49 if cfg!(target_endian = "big") {
50 assert_eq!(i64::from_be(n), n)
52 assert_eq!(i64::from_be(n), n.swap_bytes())
55 let n = 0x0123456789ABCDEFi64;
56 if cfg!(target_endian = "little") {
57 assert_eq!(i64::from_le(n), n)
59 assert_eq!(i64::from_le(n), n.swap_bytes())
62 let n = 0x0123456789ABCDEFi64;
63 if cfg!(target_endian = "big") {
64 assert_eq!(n.to_be(), n)
66 assert_eq!(n.to_be(), n.swap_bytes())
69 let n = 0x0123456789ABCDEFi64;
70 if cfg!(target_endian = "little") {
71 assert_eq!(n.to_le(), n)
73 assert_eq!(n.to_le(), n.swap_bytes())
76 assert_eq!(7i16.checked_add(32760), Some(32767));
77 assert_eq!(8i16.checked_add(32760), None);
79 assert_eq!((-127i8).checked_sub(1), Some(-128));
80 assert_eq!((-128i8).checked_sub(1), None);
82 assert_eq!(6i8.checked_mul(21), Some(126));
83 assert_eq!(6i8.checked_mul(22), None);
85 assert_eq!((-127i8).checked_div(-1), Some(127));
86 assert_eq!((-128i8).checked_div(-1), None);
87 assert_eq!((1i8).checked_div(0), None);
89 assert_eq!(5i32.checked_rem(2), Some(1));
90 assert_eq!(5i32.checked_rem(0), None);
91 assert_eq!(i32::MIN.checked_rem(-1), None);
93 assert_eq!(5i32.checked_neg(), Some(-5));
94 assert_eq!(i32::MIN.checked_neg(), None);
96 assert_eq!(0x10i32.checked_shl(4), Some(0x100));
97 assert_eq!(0x10i32.checked_shl(33), None);
99 assert_eq!(0x10i32.checked_shr(4), Some(0x1));
100 assert_eq!(0x10i32.checked_shr(33), None);
102 assert_eq!((-5i32).checked_abs(), Some(5));
103 assert_eq!(i32::MIN.checked_abs(), None);
105 assert_eq!(100i8.saturating_add(1), 101);
106 assert_eq!(100i8.saturating_add(127), 127);
108 assert_eq!(100i8.saturating_sub(127), -27);
109 assert_eq!((-100i8).saturating_sub(127), -128);
111 assert_eq!(100i32.saturating_mul(127), 12700);
112 assert_eq!((1i32 << 23).saturating_mul(1 << 23), i32::MAX);
113 assert_eq!((-1i32 << 23).saturating_mul(1 << 23), i32::MIN);
115 assert_eq!(100i8.wrapping_add(27), 127);
116 assert_eq!(100i8.wrapping_add(127), -29);
118 assert_eq!(0i8.wrapping_sub(127), -127);
119 assert_eq!((-2i8).wrapping_sub(127), 127);
121 assert_eq!(10i8.wrapping_mul(12), 120);
122 assert_eq!(11i8.wrapping_mul(12), -124);
124 assert_eq!(100u8.wrapping_div(10), 10);
125 assert_eq!((-128i8).wrapping_div(-1), -128);
127 assert_eq!(100i8.wrapping_rem(10), 0);
128 assert_eq!((-128i8).wrapping_rem(-1), 0);
130 assert_eq!(i32::MIN.wrapping_div(-1), i32::MIN);
131 assert_eq!(i32::MIN.wrapping_rem(-1), 0);
133 assert_eq!(100i8.wrapping_neg(), -100);
134 assert_eq!((-128i8).wrapping_neg(), -128);
136 assert_eq!((-1i8).wrapping_shl(7), -128);
137 assert_eq!((-1i8).wrapping_shl(8), -1);
139 assert_eq!((-128i8).wrapping_shr(7), -1);
140 assert_eq!((-128i8).wrapping_shr(8), -128);
142 assert_eq!(100i8.wrapping_abs(), 100);
143 assert_eq!((-100i8).wrapping_abs(), 100);
144 assert_eq!((-128i8).wrapping_abs(), -128);
145 assert_eq!((-128i8).wrapping_abs() as u8, 128);
147 assert_eq!(5i32.overflowing_add(2), (7, false));
148 assert_eq!(i32::MAX.overflowing_add(1), (i32::MIN, true));
150 assert_eq!(5i32.overflowing_sub(2), (3, false));
151 assert_eq!(i32::MIN.overflowing_sub(1), (i32::MAX, true));
153 assert_eq!(5i32.overflowing_mul(2), (10, false));
154 assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));
156 assert_eq!(5i32.overflowing_div(2), (2, false));
157 assert_eq!(i32::MIN.overflowing_div(-1), (i32::MIN, true));
159 assert_eq!(5i32.overflowing_rem(2), (1, false));
160 assert_eq!(i32::MIN.overflowing_rem(-1), (0, true));
162 assert_eq!(2i32.overflowing_neg(), (-2, false));
163 assert_eq!(i32::MIN.overflowing_neg(), (i32::MIN, true));
165 assert_eq!(0x10i32.overflowing_shl(4), (0x100, false));
166 assert_eq!(0x10i32.overflowing_shl(36), (0x100, true));
168 assert_eq!(0x10i32.overflowing_shr(4), (0x1, false));
169 assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));
171 assert_eq!(10i8.overflowing_abs(), (10, false));
172 assert_eq!((-10i8).overflowing_abs(), (10, false));
173 assert_eq!((-128i8).overflowing_abs(), (-128, true));
176 macro_rules! test_log {
177 ($type:ident, $max_log2:expr, $max_log10:expr) => {
178 assert_eq!($type::MIN.checked_ilog2(), None);
179 assert_eq!($type::MIN.checked_ilog10(), None);
180 assert_eq!($type::MAX.checked_ilog2(), Some($max_log2));
181 assert_eq!($type::MAX.checked_ilog10(), Some($max_log10));
182 assert_eq!($type::MAX.ilog2(), $max_log2);
183 assert_eq!($type::MAX.ilog10(), $max_log10);
189 test_log!(i16, 14, 4);
190 test_log!(u16, 15, 4);
191 test_log!(i32, 30, 9);
192 test_log!(u32, 31, 9);
193 test_log!(i64, 62, 18);
194 test_log!(u64, 63, 19);
195 test_log!(i128, 126, 38);
196 test_log!(u128, 127, 38);
198 for i in (1..=i16::MAX).step_by(i8::MAX as usize) {
199 assert_eq!(i.checked_ilog(13), Some((i as f32).log(13.0) as u32));
201 for i in (1..=u16::MAX).step_by(i8::MAX as usize) {
202 assert_eq!(i.checked_ilog(13), Some((i as f32).log(13.0) as u32));