[rustc.git] / src / libcore / tests / num / int_macros.rs

macro_rules! int_module {
    ($T:ident, $T_i:ident) => {
        #[cfg(test)]
        mod tests {
            use core::isize;
            use core::mem;
            use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
            use core::$T_i::*;

            use crate::num;

            #[test]
            fn test_overflows() {
                assert!(MAX > 0);
                assert!(MIN <= 0);
                assert_eq!(MIN + MAX + 1, 0);
            }

            #[test]
            fn test_num() {
                num::test_num(10 as $T, 2 as $T);
            }

            #[test]
            fn test_rem_euclid() {
                assert_eq!((-1 as $T).rem_euclid(MIN), MAX);
            }

            #[test]
            pub fn test_abs() {
                assert_eq!((1 as $T).abs(), 1 as $T);
                assert_eq!((0 as $T).abs(), 0 as $T);
                assert_eq!((-1 as $T).abs(), 1 as $T);
            }

            #[test]
            fn test_signum() {
                assert_eq!((1 as $T).signum(), 1 as $T);
                assert_eq!((0 as $T).signum(), 0 as $T);
                assert_eq!((-0 as $T).signum(), 0 as $T);
                assert_eq!((-1 as $T).signum(), -1 as $T);
            }

            #[test]
            fn test_is_positive() {
                assert!((1 as $T).is_positive());
                assert!(!(0 as $T).is_positive());
                assert!(!(-0 as $T).is_positive());
                assert!(!(-1 as $T).is_positive());
            }

            #[test]
            fn test_is_negative() {
                assert!(!(1 as $T).is_negative());
                assert!(!(0 as $T).is_negative());
                assert!(!(-0 as $T).is_negative());
                assert!((-1 as $T).is_negative());
            }

            #[test]
            fn test_bitwise_operators() {
                assert_eq!(0b1110 as $T, (0b1100 as $T).bitor(0b1010 as $T));
                assert_eq!(0b1000 as $T, (0b1100 as $T).bitand(0b1010 as $T));
                assert_eq!(0b0110 as $T, (0b1100 as $T).bitxor(0b1010 as $T));
                assert_eq!(0b1110 as $T, (0b0111 as $T).shl(1));
                assert_eq!(0b0111 as $T, (0b1110 as $T).shr(1));
                assert_eq!(-(0b11 as $T) - (1 as $T), (0b11 as $T).not());
            }

            const A: $T = 0b0101100;
            const B: $T = 0b0100001;
            const C: $T = 0b1111001;

            const _0: $T = 0;
            const _1: $T = !0;

            #[test]
            fn test_count_ones() {
                assert_eq!(A.count_ones(), 3);
                assert_eq!(B.count_ones(), 2);
                assert_eq!(C.count_ones(), 5);
            }

            #[test]
            fn test_count_zeros() {
                let bits = mem::size_of::<$T>() * 8;
                assert_eq!(A.count_zeros(), bits as u32 - 3);
                assert_eq!(B.count_zeros(), bits as u32 - 2);
                assert_eq!(C.count_zeros(), bits as u32 - 5);
            }

            #[test]
            fn test_leading_trailing_ones() {
                let bits = (mem::size_of::<$T>() * 8) as u32;

                let a: $T = 0b0101_1111;
                assert_eq!(a.trailing_ones(), 5);
                assert_eq!((!a).leading_ones(), bits - 7);

                assert_eq!(a.reverse_bits().leading_ones(), 5);

                assert_eq!(_1.leading_ones(), bits);
                assert_eq!(_1.trailing_ones(), bits);

                assert_eq!((_1 << 1).trailing_ones(), 0);
                assert_eq!(MAX.leading_ones(), 0);

                assert_eq!((_1 << 1).leading_ones(), bits - 1);
                assert_eq!(MAX.trailing_ones(), bits - 1);

                assert_eq!(_0.leading_ones(), 0);
                assert_eq!(_0.trailing_ones(), 0);

                let x: $T = 0b0010_1100;
                assert_eq!(x.leading_ones(), 0);
                assert_eq!(x.trailing_ones(), 0);
            }

            #[test]
            fn test_rotate() {
                assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
                assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
                assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);

                // Rotating these should make no difference
                //
                // We test using 124 bits because to ensure that overlong bit shifts do
                // not cause undefined behaviour. See #10183.
                assert_eq!(_0.rotate_left(124), _0);
                assert_eq!(_1.rotate_left(124), _1);
                assert_eq!(_0.rotate_right(124), _0);
                assert_eq!(_1.rotate_right(124), _1);

                // Rotating by 0 should have no effect
                assert_eq!(A.rotate_left(0), A);
                assert_eq!(B.rotate_left(0), B);
                assert_eq!(C.rotate_left(0), C);
                // Rotating by a multiple of word size should also have no effect
                assert_eq!(A.rotate_left(64), A);
                assert_eq!(B.rotate_left(64), B);
                assert_eq!(C.rotate_left(64), C);
            }

            #[test]
            fn test_swap_bytes() {
                assert_eq!(A.swap_bytes().swap_bytes(), A);
                assert_eq!(B.swap_bytes().swap_bytes(), B);
                assert_eq!(C.swap_bytes().swap_bytes(), C);

                // Swapping these should make no difference
                assert_eq!(_0.swap_bytes(), _0);
                assert_eq!(_1.swap_bytes(), _1);
            }

            #[test]
            fn test_le() {
                assert_eq!($T::from_le(A.to_le()), A);
                assert_eq!($T::from_le(B.to_le()), B);
                assert_eq!($T::from_le(C.to_le()), C);
                assert_eq!($T::from_le(_0), _0);
                assert_eq!($T::from_le(_1), _1);
                assert_eq!(_0.to_le(), _0);
                assert_eq!(_1.to_le(), _1);
            }

            #[test]
            fn test_be() {
                assert_eq!($T::from_be(A.to_be()), A);
                assert_eq!($T::from_be(B.to_be()), B);
                assert_eq!($T::from_be(C.to_be()), C);
                assert_eq!($T::from_be(_0), _0);
                assert_eq!($T::from_be(_1), _1);
                assert_eq!(_0.to_be(), _0);
                assert_eq!(_1.to_be(), _1);
            }

            #[test]
            fn test_signed_checked_div() {
                assert_eq!((10 as $T).checked_div(2), Some(5));
                assert_eq!((5 as $T).checked_div(0), None);
                assert_eq!(isize::MIN.checked_div(-1), None);
            }

            #[test]
            fn test_saturating_abs() {
                assert_eq!((0 as $T).saturating_abs(), 0);
                assert_eq!((123 as $T).saturating_abs(), 123);
                assert_eq!((-123 as $T).saturating_abs(), 123);
                assert_eq!((MAX - 2).saturating_abs(), MAX - 2);
                assert_eq!((MAX - 1).saturating_abs(), MAX - 1);
                assert_eq!(MAX.saturating_abs(), MAX);
                assert_eq!((MIN + 2).saturating_abs(), MAX - 1);
                assert_eq!((MIN + 1).saturating_abs(), MAX);
                assert_eq!(MIN.saturating_abs(), MAX);
            }

            #[test]
            fn test_saturating_neg() {
                assert_eq!((0 as $T).saturating_neg(), 0);
                assert_eq!((123 as $T).saturating_neg(), -123);
                assert_eq!((-123 as $T).saturating_neg(), 123);
                assert_eq!((MAX - 2).saturating_neg(), MIN + 3);
                assert_eq!((MAX - 1).saturating_neg(), MIN + 2);
                assert_eq!(MAX.saturating_neg(), MIN + 1);
                assert_eq!((MIN + 2).saturating_neg(), MAX - 1);
                assert_eq!((MIN + 1).saturating_neg(), MAX);
                assert_eq!(MIN.saturating_neg(), MAX);
            }

            #[test]
            fn test_from_str() {
                fn from_str<T: ::std::str::FromStr>(t: &str) -> Option<T> {
                    ::std::str::FromStr::from_str(t).ok()
                }
                assert_eq!(from_str::<$T>("0"), Some(0 as $T));
                assert_eq!(from_str::<$T>("3"), Some(3 as $T));
                assert_eq!(from_str::<$T>("10"), Some(10 as $T));
                assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
                assert_eq!(from_str::<$T>("00100"), Some(100 as $T));

                assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
                assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
                assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
                assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
                assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));

                assert_eq!(from_str::<$T>(""), None);
                assert_eq!(from_str::<$T>(" "), None);
                assert_eq!(from_str::<$T>("x"), None);
            }

            #[test]
            fn test_from_str_radix() {
                assert_eq!($T::from_str_radix("123", 10), Ok(123 as $T));
                assert_eq!($T::from_str_radix("1001", 2), Ok(9 as $T));
                assert_eq!($T::from_str_radix("123", 8), Ok(83 as $T));
                assert_eq!(i32::from_str_radix("123", 16), Ok(291 as i32));
                assert_eq!(i32::from_str_radix("ffff", 16), Ok(65535 as i32));
                assert_eq!(i32::from_str_radix("FFFF", 16), Ok(65535 as i32));
                assert_eq!($T::from_str_radix("z", 36), Ok(35 as $T));
                assert_eq!($T::from_str_radix("Z", 36), Ok(35 as $T));

                assert_eq!($T::from_str_radix("-123", 10), Ok(-123 as $T));
                assert_eq!($T::from_str_radix("-1001", 2), Ok(-9 as $T));
                assert_eq!($T::from_str_radix("-123", 8), Ok(-83 as $T));
                assert_eq!(i32::from_str_radix("-123", 16), Ok(-291 as i32));
                assert_eq!(i32::from_str_radix("-ffff", 16), Ok(-65535 as i32));
                assert_eq!(i32::from_str_radix("-FFFF", 16), Ok(-65535 as i32));
                assert_eq!($T::from_str_radix("-z", 36), Ok(-35 as $T));
                assert_eq!($T::from_str_radix("-Z", 36), Ok(-35 as $T));

                assert_eq!($T::from_str_radix("Z", 35).ok(), None::<$T>);
                assert_eq!($T::from_str_radix("-9", 2).ok(), None::<$T>);
            }

            #[test]
            fn test_pow() {
                let mut r = 2 as $T;

                assert_eq!(r.pow(2), 4 as $T);
                assert_eq!(r.pow(0), 1 as $T);
                r = -2 as $T;
                assert_eq!(r.pow(2), 4 as $T);
                assert_eq!(r.pow(3), -8 as $T);
            }
        }
    };
}
Commit	Line	Data
d9bb1a4e FG	1	macro_rules! int_module {
	2	($T:ident, $T_i:ident) => {
	3	#[cfg(test)]
	4	mod tests {
	5	use core::isize;
	6	use core::mem;
	7	use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
	8	use core::$T_i::*;
	9
	10	use crate::num;
	11
	12	#[test]
	13	fn test_overflows() {
	14	assert!(MAX > 0);
	15	assert!(MIN <= 0);
	16	assert_eq!(MIN + MAX + 1, 0);
	17	}
	18
	19	#[test]
	20	fn test_num() {
	21	num::test_num(10 as $T, 2 as $T);
	22	}
	23
	24	#[test]
	25	fn test_rem_euclid() {
	26	assert_eq!((-1 as $T).rem_euclid(MIN), MAX);
	27	}
	28
	29	#[test]
	30	pub fn test_abs() {
	31	assert_eq!((1 as $T).abs(), 1 as $T);
	32	assert_eq!((0 as $T).abs(), 0 as $T);
	33	assert_eq!((-1 as $T).abs(), 1 as $T);
	34	}
	35
	36	#[test]
	37	fn test_signum() {
	38	assert_eq!((1 as $T).signum(), 1 as $T);
	39	assert_eq!((0 as $T).signum(), 0 as $T);
	40	assert_eq!((-0 as $T).signum(), 0 as $T);
	41	assert_eq!((-1 as $T).signum(), -1 as $T);
	42	}
	43
	44	#[test]
	45	fn test_is_positive() {
	46	assert!((1 as $T).is_positive());
	47	assert!(!(0 as $T).is_positive());
	48	assert!(!(-0 as $T).is_positive());
	49	assert!(!(-1 as $T).is_positive());
	50	}
	51
	52	#[test]
	53	fn test_is_negative() {
	54	assert!(!(1 as $T).is_negative());
	55	assert!(!(0 as $T).is_negative());
	56	assert!(!(-0 as $T).is_negative());
	57	assert!((-1 as $T).is_negative());
	58	}
	59
	60	#[test]
	61	fn test_bitwise_operators() {
	62	assert_eq!(0b1110 as $T, (0b1100 as $T).bitor(0b1010 as $T));
	63	assert_eq!(0b1000 as $T, (0b1100 as $T).bitand(0b1010 as $T));
	64	assert_eq!(0b0110 as $T, (0b1100 as $T).bitxor(0b1010 as $T));
65	assert_eq!(0b1110 as $T, (0b0111 as $T).shl(1));
66	assert_eq!(0b0111 as $T, (0b1110 as $T).shr(1));
67	assert_eq!(-(0b11 as $T) - (1 as $T), (0b11 as $T).not());
68	}
69
70	const A: $T = 0b0101100;
71	const B: $T = 0b0100001;
72	const C: $T = 0b1111001;
73
74	const _0: $T = 0;
75	const _1: $T = !0;
76
77	#[test]
78	fn test_count_ones() {
79	assert_eq!(A.count_ones(), 3);
80	assert_eq!(B.count_ones(), 2);
81	assert_eq!(C.count_ones(), 5);
82	}
83
84	#[test]
85	fn test_count_zeros() {
86	let bits = mem::size_of::<$T>() * 8;
87	assert_eq!(A.count_zeros(), bits as u32 - 3);
88	assert_eq!(B.count_zeros(), bits as u32 - 2);
89	assert_eq!(C.count_zeros(), bits as u32 - 5);
90	}
91
46de9a89 FG	92	#[test]
	93	fn test_leading_trailing_ones() {
	94	let bits = (mem::size_of::<$T>() * 8) as u32;
	95
	96	let a: $T = 0b0101_1111;
	97	assert_eq!(a.trailing_ones(), 5);
	98	assert_eq!((!a).leading_ones(), bits - 7);
	99
	100	assert_eq!(a.reverse_bits().leading_ones(), 5);
	101
	102	assert_eq!(_1.leading_ones(), bits);
	103	assert_eq!(_1.trailing_ones(), bits);
	104
	105	assert_eq!((_1 << 1).trailing_ones(), 0);
	106	assert_eq!(MAX.leading_ones(), 0);
	107
	108	assert_eq!((_1 << 1).leading_ones(), bits - 1);
	109	assert_eq!(MAX.trailing_ones(), bits - 1);
	110
	111	assert_eq!(_0.leading_ones(), 0);
	112	assert_eq!(_0.trailing_ones(), 0);
	113
	114	let x: $T = 0b0010_1100;
	115	assert_eq!(x.leading_ones(), 0);
	116	assert_eq!(x.trailing_ones(), 0);
	117	}
	118
d9bb1a4e FG	119	#[test]
	120	fn test_rotate() {
	121	assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
	122	assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
	123	assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
	124
	125	// Rotating these should make no difference
	126	//
	127	// We test using 124 bits because to ensure that overlong bit shifts do
	128	// not cause undefined behaviour. See #10183.
	129	assert_eq!(_0.rotate_left(124), _0);
	130	assert_eq!(_1.rotate_left(124), _1);
	131	assert_eq!(_0.rotate_right(124), _0);
	132	assert_eq!(_1.rotate_right(124), _1);
	133
	134	// Rotating by 0 should have no effect
	135	assert_eq!(A.rotate_left(0), A);
	136	assert_eq!(B.rotate_left(0), B);
	137	assert_eq!(C.rotate_left(0), C);
	138	// Rotating by a multiple of word size should also have no effect
	139	assert_eq!(A.rotate_left(64), A);
	140	assert_eq!(B.rotate_left(64), B);
	141	assert_eq!(C.rotate_left(64), C);
	142	}
	143
	144	#[test]
	145	fn test_swap_bytes() {
	146	assert_eq!(A.swap_bytes().swap_bytes(), A);
	147	assert_eq!(B.swap_bytes().swap_bytes(), B);
	148	assert_eq!(C.swap_bytes().swap_bytes(), C);
	149
	150	// Swapping these should make no difference
	151	assert_eq!(_0.swap_bytes(), _0);
	152	assert_eq!(_1.swap_bytes(), _1);
	153	}
	154
	155	#[test]
	156	fn test_le() {
	157	assert_eq!($T::from_le(A.to_le()), A);
	158	assert_eq!($T::from_le(B.to_le()), B);
	159	assert_eq!($T::from_le(C.to_le()), C);
	160	assert_eq!($T::from_le(_0), _0);
	161	assert_eq!($T::from_le(_1), _1);
	162	assert_eq!(_0.to_le(), _0);
	163	assert_eq!(_1.to_le(), _1);
	164	}
	165
	166	#[test]
	167	fn test_be() {
	168	assert_eq!($T::from_be(A.to_be()), A);
	169	assert_eq!($T::from_be(B.to_be()), B);
	170	assert_eq!($T::from_be(C.to_be()), C);
	171	assert_eq!($T::from_be(_0), _0);
	172	assert_eq!($T::from_be(_1), _1);
	173	assert_eq!(_0.to_be(), _0);
	174	assert_eq!(_1.to_be(), _1);
	175	}
	176
	177	#[test]
	178	fn test_signed_checked_div() {
	179	assert_eq!((10 as $T).checked_div(2), Some(5));
	180	assert_eq!((5 as $T).checked_div(0), None);
	181	assert_eq!(isize::MIN.checked_div(-1), None);
	182	}
183
184	#[test]
185	fn test_saturating_abs() {
186	assert_eq!((0 as $T).saturating_abs(), 0);
187	assert_eq!((123 as $T).saturating_abs(), 123);
188	assert_eq!((-123 as $T).saturating_abs(), 123);
189	assert_eq!((MAX - 2).saturating_abs(), MAX - 2);
190	assert_eq!((MAX - 1).saturating_abs(), MAX - 1);
191	assert_eq!(MAX.saturating_abs(), MAX);
192	assert_eq!((MIN + 2).saturating_abs(), MAX - 1);
193	assert_eq!((MIN + 1).saturating_abs(), MAX);
194	assert_eq!(MIN.saturating_abs(), MAX);
195	}
196
197	#[test]
198	fn test_saturating_neg() {
199	assert_eq!((0 as $T).saturating_neg(), 0);
200	assert_eq!((123 as $T).saturating_neg(), -123);
201	assert_eq!((-123 as $T).saturating_neg(), 123);
202	assert_eq!((MAX - 2).saturating_neg(), MIN + 3);
203	assert_eq!((MAX - 1).saturating_neg(), MIN + 2);
204	assert_eq!(MAX.saturating_neg(), MIN + 1);
205	assert_eq!((MIN + 2).saturating_neg(), MAX - 1);
206	assert_eq!((MIN + 1).saturating_neg(), MAX);
207	assert_eq!(MIN.saturating_neg(), MAX);
208	}
209
210	#[test]
211	fn test_from_str() {
212	fn from_str<T: ::std::str::FromStr>(t: &str) -> Option<T> {
213	::std::str::FromStr::from_str(t).ok()
214	}
215	assert_eq!(from_str::<$T>("0"), Some(0 as $T));
216	assert_eq!(from_str::<$T>("3"), Some(3 as $T));
217	assert_eq!(from_str::<$T>("10"), Some(10 as $T));
218	assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
219	assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
220
221	assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
222	assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
223	assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
224	assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
225	assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
226
227	assert_eq!(from_str::<$T>(""), None);
228	assert_eq!(from_str::<$T>(" "), None);
229	assert_eq!(from_str::<$T>("x"), None);
230	}
231
232	#[test]
233	fn test_from_str_radix() {
234	assert_eq!($T::from_str_radix("123", 10), Ok(123 as $T));
235	assert_eq!($T::from_str_radix("1001", 2), Ok(9 as $T));
236	assert_eq!($T::from_str_radix("123", 8), Ok(83 as $T));
237	assert_eq!(i32::from_str_radix("123", 16), Ok(291 as i32));
238	assert_eq!(i32::from_str_radix("ffff", 16), Ok(65535 as i32));
239	assert_eq!(i32::from_str_radix("FFFF", 16), Ok(65535 as i32));
240	assert_eq!($T::from_str_radix("z", 36), Ok(35 as $T));
241	assert_eq!($T::from_str_radix("Z", 36), Ok(35 as $T));
242
243	assert_eq!($T::from_str_radix("-123", 10), Ok(-123 as $T));
244	assert_eq!($T::from_str_radix("-1001", 2), Ok(-9 as $T));
245	assert_eq!($T::from_str_radix("-123", 8), Ok(-83 as $T));
246	assert_eq!(i32::from_str_radix("-123", 16), Ok(-291 as i32));
247	assert_eq!(i32::from_str_radix("-ffff", 16), Ok(-65535 as i32));
248	assert_eq!(i32::from_str_radix("-FFFF", 16), Ok(-65535 as i32));
249	assert_eq!($T::from_str_radix("-z", 36), Ok(-35 as $T));
250	assert_eq!($T::from_str_radix("-Z", 36), Ok(-35 as $T));
251
252	assert_eq!($T::from_str_radix("Z", 35).ok(), None::<$T>);
253	assert_eq!($T::from_str_radix("-9", 2).ok(), None::<$T>);
254	}
255
256	#[test]
257	fn test_pow() {
258	let mut r = 2 as $T;
259
260	assert_eq!(r.pow(2), 4 as $T);
261	assert_eq!(r.pow(0), 1 as $T);
262	r = -2 as $T;
263	assert_eq!(r.pow(2), 4 as $T);
264	assert_eq!(r.pow(3), -8 as $T);
265	}
1a4d82fc	266	}
d9bb1a4e	267	};
1a4d82fc	268	}