4 fn test_saturating_add_uint() {
5 assert_eq
!(3_usize
.saturating_add(5_usize
), 8_usize
);
6 assert_eq
!(3_usize
.saturating_add(usize::MAX
- 1), usize::MAX
);
7 assert_eq
!(usize::MAX
.saturating_add(usize::MAX
), usize::MAX
);
8 assert_eq
!((usize::MAX
- 2).saturating_add(1), usize::MAX
- 1);
12 fn test_saturating_sub_uint() {
13 assert_eq
!(5_usize
.saturating_sub(3_usize
), 2_usize
);
14 assert_eq
!(3_usize
.saturating_sub(5_usize
), 0_usize
);
15 assert_eq
!(0_usize
.saturating_sub(1_usize
), 0_usize
);
16 assert_eq
!((usize::MAX
- 1).saturating_sub(usize::MAX
), 0);
20 fn test_saturating_add_int() {
21 assert_eq
!(3i32.saturating_add(5), 8);
22 assert_eq
!(3isize
.saturating_add(isize::MAX
- 1), isize::MAX
);
23 assert_eq
!(isize::MAX
.saturating_add(isize::MAX
), isize::MAX
);
24 assert_eq
!((isize::MAX
- 2).saturating_add(1), isize::MAX
- 1);
25 assert_eq
!(3i32.saturating_add(-5), -2);
26 assert_eq
!(isize::MIN
.saturating_add(-1), isize::MIN
);
27 assert_eq
!((-2isize
).saturating_add(-isize::MAX
), isize::MIN
);
31 fn test_saturating_sub_int() {
32 assert_eq
!(3i32.saturating_sub(5), -2);
33 assert_eq
!(isize::MIN
.saturating_sub(1), isize::MIN
);
34 assert_eq
!((-2isize
).saturating_sub(isize::MAX
), isize::MIN
);
35 assert_eq
!(3i32.saturating_sub(-5), 8);
36 assert_eq
!(3isize
.saturating_sub(-(isize::MAX
- 1)), isize::MAX
);
37 assert_eq
!(isize::MAX
.saturating_sub(-isize::MAX
), isize::MAX
);
38 assert_eq
!((isize::MAX
- 2).saturating_sub(-1), isize::MAX
- 1);
42 fn test_checked_add() {
43 let five_less
= usize::MAX
- 5;
44 assert_eq
!(five_less
.checked_add(0), Some(usize::MAX
- 5));
45 assert_eq
!(five_less
.checked_add(1), Some(usize::MAX
- 4));
46 assert_eq
!(five_less
.checked_add(2), Some(usize::MAX
- 3));
47 assert_eq
!(five_less
.checked_add(3), Some(usize::MAX
- 2));
48 assert_eq
!(five_less
.checked_add(4), Some(usize::MAX
- 1));
49 assert_eq
!(five_less
.checked_add(5), Some(usize::MAX
));
50 assert_eq
!(five_less
.checked_add(6), None
);
51 assert_eq
!(five_less
.checked_add(7), None
);
55 fn test_checked_sub() {
56 assert_eq
!(5_usize
.checked_sub(0), Some(5));
57 assert_eq
!(5_usize
.checked_sub(1), Some(4));
58 assert_eq
!(5_usize
.checked_sub(2), Some(3));
59 assert_eq
!(5_usize
.checked_sub(3), Some(2));
60 assert_eq
!(5_usize
.checked_sub(4), Some(1));
61 assert_eq
!(5_usize
.checked_sub(5), Some(0));
62 assert_eq
!(5_usize
.checked_sub(6), None
);
63 assert_eq
!(5_usize
.checked_sub(7), None
);
67 fn test_checked_mul() {
68 let third
= usize::MAX
/ 3;
69 assert_eq
!(third
.checked_mul(0), Some(0));
70 assert_eq
!(third
.checked_mul(1), Some(third
));
71 assert_eq
!(third
.checked_mul(2), Some(third
* 2));
72 assert_eq
!(third
.checked_mul(3), Some(third
* 3));
73 assert_eq
!(third
.checked_mul(4), None
);
76 macro_rules
! test_is_power_of_two
{
77 ($test_name
:ident
, $T
:ident
) => {
80 assert_eq
!((0 as $T
).is_power_of_two(), false);
81 assert_eq
!((1 as $T
).is_power_of_two(), true);
82 assert_eq
!((2 as $T
).is_power_of_two(), true);
83 assert_eq
!((3 as $T
).is_power_of_two(), false);
84 assert_eq
!((4 as $T
).is_power_of_two(), true);
85 assert_eq
!((5 as $T
).is_power_of_two(), false);
86 assert_eq
!(($T
::MAX
/ 2 + 1).is_power_of_two(), true);
91 test_is_power_of_two
! { test_is_power_of_two_u8, u8 }
92 test_is_power_of_two
! { test_is_power_of_two_u16, u16 }
93 test_is_power_of_two
! { test_is_power_of_two_u32, u32 }
94 test_is_power_of_two
! { test_is_power_of_two_u64, u64 }
95 test_is_power_of_two
! { test_is_power_of_two_uint, usize }
97 macro_rules
! test_next_power_of_two
{
98 ($test_name
:ident
, $T
:ident
) => {
101 assert_eq
!((0 as $T
).next_power_of_two(), 1);
102 let mut next_power
= 1;
103 for i
in 1 as $T
..40 {
104 assert_eq
!(i
.next_power_of_two(), next_power
);
113 test_next_power_of_two
! { test_next_power_of_two_u8, u8 }
114 test_next_power_of_two
! { test_next_power_of_two_u16, u16 }
115 test_next_power_of_two
! { test_next_power_of_two_u32, u32 }
116 test_next_power_of_two
! { test_next_power_of_two_u64, u64 }
117 test_next_power_of_two
! { test_next_power_of_two_uint, usize }
119 macro_rules
! test_checked_next_power_of_two
{
120 ($test_name
:ident
, $T
:ident
) => {
123 assert_eq
!((0 as $T
).checked_next_power_of_two(), Some(1));
124 let smax
= $T
::MAX
>> 1;
125 assert_eq
!(smax
.checked_next_power_of_two(), Some(smax
+ 1));
126 assert_eq
!((smax
+ 1).checked_next_power_of_two(), Some(smax
+ 1));
127 assert_eq
!((smax
+ 2).checked_next_power_of_two(), None
);
128 assert_eq
!(($T
::MAX
- 1).checked_next_power_of_two(), None
);
129 assert_eq
!($T
::MAX
.checked_next_power_of_two(), None
);
130 let mut next_power
= 1;
131 for i
in 1 as $T
..40 {
132 assert_eq
!(i
.checked_next_power_of_two(), Some(next_power
));
141 test_checked_next_power_of_two
! { test_checked_next_power_of_two_u8, u8 }
142 test_checked_next_power_of_two
! { test_checked_next_power_of_two_u16, u16 }
143 test_checked_next_power_of_two
! { test_checked_next_power_of_two_u32, u32 }
144 test_checked_next_power_of_two
! { test_checked_next_power_of_two_u64, u64 }
145 test_checked_next_power_of_two
! { test_checked_next_power_of_two_uint, usize }
149 fn naive_pow
<T
: Mul
<Output
= T
> + Copy
>(one
: T
, base
: T
, exp
: usize) -> T
{
150 (0..exp
).fold(one
, |acc
, _
| acc
* base
)
152 macro_rules
! assert_pow
{
153 (($num
:expr
, $exp
:expr
) => $expected
:expr
) => {{
154 let result
= $num
.pow($exp
);
155 assert_eq
!(result
, $expected
);
156 assert_eq
!(result
, naive_pow(1, $num
, $exp
));
159 assert_pow
!((3u32, 0 ) => 1);
160 assert_pow
!((5u32, 1 ) => 5);
161 assert_pow
!((-4i32, 2 ) => 16);
162 assert_pow
!((8u32, 3 ) => 512);
163 assert_pow
!((2u64, 50) => 1125899906842624);
167 fn test_uint_to_str_overflow() {
168 let mut u8_val
: u8 = 255;
169 assert_eq
!(u8_val
.to_string(), "255");
171 u8_val
= u8_val
.wrapping_add(1);
172 assert_eq
!(u8_val
.to_string(), "0");
174 let mut u16_val
: u16 = 65_535;
175 assert_eq
!(u16_val
.to_string(), "65535");
177 u16_val
= u16_val
.wrapping_add(1);
178 assert_eq
!(u16_val
.to_string(), "0");
180 let mut u32_val
: u32 = 4_294_967_295;
181 assert_eq
!(u32_val
.to_string(), "4294967295");
183 u32_val
= u32_val
.wrapping_add(1);
184 assert_eq
!(u32_val
.to_string(), "0");
186 let mut u64_val
: u64 = 18_446_744_073_709_551_615;
187 assert_eq
!(u64_val
.to_string(), "18446744073709551615");
189 u64_val
= u64_val
.wrapping_add(1);
190 assert_eq
!(u64_val
.to_string(), "0");
193 fn from_str
<T
: crate::str::FromStr
>(t
: &str) -> Option
<T
> {
194 crate::str::FromStr
::from_str(t
).ok()
198 fn test_uint_from_str_overflow() {
199 let mut u8_val
: u8 = 255;
200 assert_eq
!(from_str
::<u8>("255"), Some(u8_val
));
201 assert_eq
!(from_str
::<u8>("256"), None
);
203 u8_val
= u8_val
.wrapping_add(1);
204 assert_eq
!(from_str
::<u8>("0"), Some(u8_val
));
205 assert_eq
!(from_str
::<u8>("-1"), None
);
207 let mut u16_val
: u16 = 65_535;
208 assert_eq
!(from_str
::<u16>("65535"), Some(u16_val
));
209 assert_eq
!(from_str
::<u16>("65536"), None
);
211 u16_val
= u16_val
.wrapping_add(1);
212 assert_eq
!(from_str
::<u16>("0"), Some(u16_val
));
213 assert_eq
!(from_str
::<u16>("-1"), None
);
215 let mut u32_val
: u32 = 4_294_967_295;
216 assert_eq
!(from_str
::<u32>("4294967295"), Some(u32_val
));
217 assert_eq
!(from_str
::<u32>("4294967296"), None
);
219 u32_val
= u32_val
.wrapping_add(1);
220 assert_eq
!(from_str
::<u32>("0"), Some(u32_val
));
221 assert_eq
!(from_str
::<u32>("-1"), None
);
223 let mut u64_val
: u64 = 18_446_744_073_709_551_615;
224 assert_eq
!(from_str
::<u64>("18446744073709551615"), Some(u64_val
));
225 assert_eq
!(from_str
::<u64>("18446744073709551616"), None
);
227 u64_val
= u64_val
.wrapping_add(1);
228 assert_eq
!(from_str
::<u64>("0"), Some(u64_val
));
229 assert_eq
!(from_str
::<u64>("-1"), None
);