src/tools/miri/tests/pass/integer-ops.rs

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