From 988e4f0a1c2802921375271bdc19f03650c024d2 Mon Sep 17 00:00:00 2001 From: Chris Wong Date: Sat, 25 Jan 2014 20:37:51 +1300 Subject: Uppercase numeric constants The following are renamed: * `min_value` => `MIN` * `max_value` => `MAX` * `bits` => `BITS` * `bytes` => `BYTES` Fixes #10010. --- src/libstd/num/mod.rs | 490 +++++++++++++++++++++++++------------------------- 1 file changed, 245 insertions(+), 245 deletions(-) (limited to 'src/libstd/num/mod.rs') diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 34dd313d442..478029b8561 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -1159,25 +1159,25 @@ mod tests { #[test] fn test_cast_range_int_min() { - assert_eq!(int::min_value.to_int(), Some(int::min_value as int)); - assert_eq!(int::min_value.to_i8(), None); - assert_eq!(int::min_value.to_i16(), None); - // int::min_value.to_i32() is word-size specific - assert_eq!(int::min_value.to_i64(), Some(int::min_value as i64)); - assert_eq!(int::min_value.to_uint(), None); - assert_eq!(int::min_value.to_u8(), None); - assert_eq!(int::min_value.to_u16(), None); - assert_eq!(int::min_value.to_u32(), None); - assert_eq!(int::min_value.to_u64(), None); + assert_eq!(int::MIN.to_int(), Some(int::MIN as int)); + assert_eq!(int::MIN.to_i8(), None); + assert_eq!(int::MIN.to_i16(), None); + // int::MIN.to_i32() is word-size specific + assert_eq!(int::MIN.to_i64(), Some(int::MIN as i64)); + assert_eq!(int::MIN.to_uint(), None); + assert_eq!(int::MIN.to_u8(), None); + assert_eq!(int::MIN.to_u16(), None); + assert_eq!(int::MIN.to_u32(), None); + assert_eq!(int::MIN.to_u64(), None); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(int::min_value.to_i32(), Some(int::min_value as i32)); + assert_eq!(int::MIN.to_i32(), Some(int::MIN as i32)); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(int::min_value.to_i32(), None); + assert_eq!(int::MIN.to_i32(), None); } check_word_size(); @@ -1185,67 +1185,67 @@ mod tests { #[test] fn test_cast_range_i8_min() { - assert_eq!(i8::min_value.to_int(), Some(i8::min_value as int)); - assert_eq!(i8::min_value.to_i8(), Some(i8::min_value as i8)); - assert_eq!(i8::min_value.to_i16(), Some(i8::min_value as i16)); - assert_eq!(i8::min_value.to_i32(), Some(i8::min_value as i32)); - assert_eq!(i8::min_value.to_i64(), Some(i8::min_value as i64)); - assert_eq!(i8::min_value.to_uint(), None); - assert_eq!(i8::min_value.to_u8(), None); - assert_eq!(i8::min_value.to_u16(), None); - assert_eq!(i8::min_value.to_u32(), None); - assert_eq!(i8::min_value.to_u64(), None); + assert_eq!(i8::MIN.to_int(), Some(i8::MIN as int)); + assert_eq!(i8::MIN.to_i8(), Some(i8::MIN as i8)); + assert_eq!(i8::MIN.to_i16(), Some(i8::MIN as i16)); + assert_eq!(i8::MIN.to_i32(), Some(i8::MIN as i32)); + assert_eq!(i8::MIN.to_i64(), Some(i8::MIN as i64)); + assert_eq!(i8::MIN.to_uint(), None); + assert_eq!(i8::MIN.to_u8(), None); + assert_eq!(i8::MIN.to_u16(), None); + assert_eq!(i8::MIN.to_u32(), None); + assert_eq!(i8::MIN.to_u64(), None); } #[test] fn test_cast_range_i16_min() { - assert_eq!(i16::min_value.to_int(), Some(i16::min_value as int)); - assert_eq!(i16::min_value.to_i8(), None); - assert_eq!(i16::min_value.to_i16(), Some(i16::min_value as i16)); - assert_eq!(i16::min_value.to_i32(), Some(i16::min_value as i32)); - assert_eq!(i16::min_value.to_i64(), Some(i16::min_value as i64)); - assert_eq!(i16::min_value.to_uint(), None); - assert_eq!(i16::min_value.to_u8(), None); - assert_eq!(i16::min_value.to_u16(), None); - assert_eq!(i16::min_value.to_u32(), None); - assert_eq!(i16::min_value.to_u64(), None); + assert_eq!(i16::MIN.to_int(), Some(i16::MIN as int)); + assert_eq!(i16::MIN.to_i8(), None); + assert_eq!(i16::MIN.to_i16(), Some(i16::MIN as i16)); + assert_eq!(i16::MIN.to_i32(), Some(i16::MIN as i32)); + assert_eq!(i16::MIN.to_i64(), Some(i16::MIN as i64)); + assert_eq!(i16::MIN.to_uint(), None); + assert_eq!(i16::MIN.to_u8(), None); + assert_eq!(i16::MIN.to_u16(), None); + assert_eq!(i16::MIN.to_u32(), None); + assert_eq!(i16::MIN.to_u64(), None); } #[test] fn test_cast_range_i32_min() { - assert_eq!(i32::min_value.to_int(), Some(i32::min_value as int)); - assert_eq!(i32::min_value.to_i8(), None); - assert_eq!(i32::min_value.to_i16(), None); - assert_eq!(i32::min_value.to_i32(), Some(i32::min_value as i32)); - assert_eq!(i32::min_value.to_i64(), Some(i32::min_value as i64)); - assert_eq!(i32::min_value.to_uint(), None); - assert_eq!(i32::min_value.to_u8(), None); - assert_eq!(i32::min_value.to_u16(), None); - assert_eq!(i32::min_value.to_u32(), None); - assert_eq!(i32::min_value.to_u64(), None); + assert_eq!(i32::MIN.to_int(), Some(i32::MIN as int)); + assert_eq!(i32::MIN.to_i8(), None); + assert_eq!(i32::MIN.to_i16(), None); + assert_eq!(i32::MIN.to_i32(), Some(i32::MIN as i32)); + assert_eq!(i32::MIN.to_i64(), Some(i32::MIN as i64)); + assert_eq!(i32::MIN.to_uint(), None); + assert_eq!(i32::MIN.to_u8(), None); + assert_eq!(i32::MIN.to_u16(), None); + assert_eq!(i32::MIN.to_u32(), None); + assert_eq!(i32::MIN.to_u64(), None); } #[test] fn test_cast_range_i64_min() { - // i64::min_value.to_int() is word-size specific - assert_eq!(i64::min_value.to_i8(), None); - assert_eq!(i64::min_value.to_i16(), None); - assert_eq!(i64::min_value.to_i32(), None); - assert_eq!(i64::min_value.to_i64(), Some(i64::min_value as i64)); - assert_eq!(i64::min_value.to_uint(), None); - assert_eq!(i64::min_value.to_u8(), None); - assert_eq!(i64::min_value.to_u16(), None); - assert_eq!(i64::min_value.to_u32(), None); - assert_eq!(i64::min_value.to_u64(), None); + // i64::MIN.to_int() is word-size specific + assert_eq!(i64::MIN.to_i8(), None); + assert_eq!(i64::MIN.to_i16(), None); + assert_eq!(i64::MIN.to_i32(), None); + assert_eq!(i64::MIN.to_i64(), Some(i64::MIN as i64)); + assert_eq!(i64::MIN.to_uint(), None); + assert_eq!(i64::MIN.to_u8(), None); + assert_eq!(i64::MIN.to_u16(), None); + assert_eq!(i64::MIN.to_u32(), None); + assert_eq!(i64::MIN.to_u64(), None); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(i64::min_value.to_int(), None); + assert_eq!(i64::MIN.to_int(), None); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(i64::min_value.to_int(), Some(i64::min_value as int)); + assert_eq!(i64::MIN.to_int(), Some(i64::MIN as int)); } check_word_size(); @@ -1253,26 +1253,26 @@ mod tests { #[test] fn test_cast_range_int_max() { - assert_eq!(int::max_value.to_int(), Some(int::max_value as int)); - assert_eq!(int::max_value.to_i8(), None); - assert_eq!(int::max_value.to_i16(), None); - // int::max_value.to_i32() is word-size specific - assert_eq!(int::max_value.to_i64(), Some(int::max_value as i64)); - assert_eq!(int::max_value.to_u8(), None); - assert_eq!(int::max_value.to_u16(), None); - // int::max_value.to_u32() is word-size specific - assert_eq!(int::max_value.to_u64(), Some(int::max_value as u64)); + assert_eq!(int::MAX.to_int(), Some(int::MAX as int)); + assert_eq!(int::MAX.to_i8(), None); + assert_eq!(int::MAX.to_i16(), None); + // int::MAX.to_i32() is word-size specific + assert_eq!(int::MAX.to_i64(), Some(int::MAX as i64)); + assert_eq!(int::MAX.to_u8(), None); + assert_eq!(int::MAX.to_u16(), None); + // int::MAX.to_u32() is word-size specific + assert_eq!(int::MAX.to_u64(), Some(int::MAX as u64)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(int::max_value.to_i32(), Some(int::max_value as i32)); - assert_eq!(int::max_value.to_u32(), Some(int::max_value as u32)); + assert_eq!(int::MAX.to_i32(), Some(int::MAX as i32)); + assert_eq!(int::MAX.to_u32(), Some(int::MAX as u32)); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(int::max_value.to_i32(), None); - assert_eq!(int::max_value.to_u32(), None); + assert_eq!(int::MAX.to_i32(), None); + assert_eq!(int::MAX.to_u32(), None); } check_word_size(); @@ -1280,69 +1280,69 @@ mod tests { #[test] fn test_cast_range_i8_max() { - assert_eq!(i8::max_value.to_int(), Some(i8::max_value as int)); - assert_eq!(i8::max_value.to_i8(), Some(i8::max_value as i8)); - assert_eq!(i8::max_value.to_i16(), Some(i8::max_value as i16)); - assert_eq!(i8::max_value.to_i32(), Some(i8::max_value as i32)); - assert_eq!(i8::max_value.to_i64(), Some(i8::max_value as i64)); - assert_eq!(i8::max_value.to_uint(), Some(i8::max_value as uint)); - assert_eq!(i8::max_value.to_u8(), Some(i8::max_value as u8)); - assert_eq!(i8::max_value.to_u16(), Some(i8::max_value as u16)); - assert_eq!(i8::max_value.to_u32(), Some(i8::max_value as u32)); - assert_eq!(i8::max_value.to_u64(), Some(i8::max_value as u64)); + assert_eq!(i8::MAX.to_int(), Some(i8::MAX as int)); + assert_eq!(i8::MAX.to_i8(), Some(i8::MAX as i8)); + assert_eq!(i8::MAX.to_i16(), Some(i8::MAX as i16)); + assert_eq!(i8::MAX.to_i32(), Some(i8::MAX as i32)); + assert_eq!(i8::MAX.to_i64(), Some(i8::MAX as i64)); + assert_eq!(i8::MAX.to_uint(), Some(i8::MAX as uint)); + assert_eq!(i8::MAX.to_u8(), Some(i8::MAX as u8)); + assert_eq!(i8::MAX.to_u16(), Some(i8::MAX as u16)); + assert_eq!(i8::MAX.to_u32(), Some(i8::MAX as u32)); + assert_eq!(i8::MAX.to_u64(), Some(i8::MAX as u64)); } #[test] fn test_cast_range_i16_max() { - assert_eq!(i16::max_value.to_int(), Some(i16::max_value as int)); - assert_eq!(i16::max_value.to_i8(), None); - assert_eq!(i16::max_value.to_i16(), Some(i16::max_value as i16)); - assert_eq!(i16::max_value.to_i32(), Some(i16::max_value as i32)); - assert_eq!(i16::max_value.to_i64(), Some(i16::max_value as i64)); - assert_eq!(i16::max_value.to_uint(), Some(i16::max_value as uint)); - assert_eq!(i16::max_value.to_u8(), None); - assert_eq!(i16::max_value.to_u16(), Some(i16::max_value as u16)); - assert_eq!(i16::max_value.to_u32(), Some(i16::max_value as u32)); - assert_eq!(i16::max_value.to_u64(), Some(i16::max_value as u64)); + assert_eq!(i16::MAX.to_int(), Some(i16::MAX as int)); + assert_eq!(i16::MAX.to_i8(), None); + assert_eq!(i16::MAX.to_i16(), Some(i16::MAX as i16)); + assert_eq!(i16::MAX.to_i32(), Some(i16::MAX as i32)); + assert_eq!(i16::MAX.to_i64(), Some(i16::MAX as i64)); + assert_eq!(i16::MAX.to_uint(), Some(i16::MAX as uint)); + assert_eq!(i16::MAX.to_u8(), None); + assert_eq!(i16::MAX.to_u16(), Some(i16::MAX as u16)); + assert_eq!(i16::MAX.to_u32(), Some(i16::MAX as u32)); + assert_eq!(i16::MAX.to_u64(), Some(i16::MAX as u64)); } #[test] fn test_cast_range_i32_max() { - assert_eq!(i32::max_value.to_int(), Some(i32::max_value as int)); - assert_eq!(i32::max_value.to_i8(), None); - assert_eq!(i32::max_value.to_i16(), None); - assert_eq!(i32::max_value.to_i32(), Some(i32::max_value as i32)); - assert_eq!(i32::max_value.to_i64(), Some(i32::max_value as i64)); - assert_eq!(i32::max_value.to_uint(), Some(i32::max_value as uint)); - assert_eq!(i32::max_value.to_u8(), None); - assert_eq!(i32::max_value.to_u16(), None); - assert_eq!(i32::max_value.to_u32(), Some(i32::max_value as u32)); - assert_eq!(i32::max_value.to_u64(), Some(i32::max_value as u64)); + assert_eq!(i32::MAX.to_int(), Some(i32::MAX as int)); + assert_eq!(i32::MAX.to_i8(), None); + assert_eq!(i32::MAX.to_i16(), None); + assert_eq!(i32::MAX.to_i32(), Some(i32::MAX as i32)); + assert_eq!(i32::MAX.to_i64(), Some(i32::MAX as i64)); + assert_eq!(i32::MAX.to_uint(), Some(i32::MAX as uint)); + assert_eq!(i32::MAX.to_u8(), None); + assert_eq!(i32::MAX.to_u16(), None); + assert_eq!(i32::MAX.to_u32(), Some(i32::MAX as u32)); + assert_eq!(i32::MAX.to_u64(), Some(i32::MAX as u64)); } #[test] fn test_cast_range_i64_max() { - // i64::max_value.to_int() is word-size specific - assert_eq!(i64::max_value.to_i8(), None); - assert_eq!(i64::max_value.to_i16(), None); - assert_eq!(i64::max_value.to_i32(), None); - assert_eq!(i64::max_value.to_i64(), Some(i64::max_value as i64)); - // i64::max_value.to_uint() is word-size specific - assert_eq!(i64::max_value.to_u8(), None); - assert_eq!(i64::max_value.to_u16(), None); - assert_eq!(i64::max_value.to_u32(), None); - assert_eq!(i64::max_value.to_u64(), Some(i64::max_value as u64)); + // i64::MAX.to_int() is word-size specific + assert_eq!(i64::MAX.to_i8(), None); + assert_eq!(i64::MAX.to_i16(), None); + assert_eq!(i64::MAX.to_i32(), None); + assert_eq!(i64::MAX.to_i64(), Some(i64::MAX as i64)); + // i64::MAX.to_uint() is word-size specific + assert_eq!(i64::MAX.to_u8(), None); + assert_eq!(i64::MAX.to_u16(), None); + assert_eq!(i64::MAX.to_u32(), None); + assert_eq!(i64::MAX.to_u64(), Some(i64::MAX as u64)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(i64::max_value.to_int(), None); - assert_eq!(i64::max_value.to_uint(), None); + assert_eq!(i64::MAX.to_int(), None); + assert_eq!(i64::MAX.to_uint(), None); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(i64::max_value.to_int(), Some(i64::max_value as int)); - assert_eq!(i64::max_value.to_uint(), Some(i64::max_value as uint)); + assert_eq!(i64::MAX.to_int(), Some(i64::MAX as int)); + assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as uint)); } check_word_size(); @@ -1350,96 +1350,96 @@ mod tests { #[test] fn test_cast_range_uint_min() { - assert_eq!(uint::min_value.to_int(), Some(uint::min_value as int)); - assert_eq!(uint::min_value.to_i8(), Some(uint::min_value as i8)); - assert_eq!(uint::min_value.to_i16(), Some(uint::min_value as i16)); - assert_eq!(uint::min_value.to_i32(), Some(uint::min_value as i32)); - assert_eq!(uint::min_value.to_i64(), Some(uint::min_value as i64)); - assert_eq!(uint::min_value.to_uint(), Some(uint::min_value as uint)); - assert_eq!(uint::min_value.to_u8(), Some(uint::min_value as u8)); - assert_eq!(uint::min_value.to_u16(), Some(uint::min_value as u16)); - assert_eq!(uint::min_value.to_u32(), Some(uint::min_value as u32)); - assert_eq!(uint::min_value.to_u64(), Some(uint::min_value as u64)); + assert_eq!(uint::MIN.to_int(), Some(uint::MIN as int)); + assert_eq!(uint::MIN.to_i8(), Some(uint::MIN as i8)); + assert_eq!(uint::MIN.to_i16(), Some(uint::MIN as i16)); + assert_eq!(uint::MIN.to_i32(), Some(uint::MIN as i32)); + assert_eq!(uint::MIN.to_i64(), Some(uint::MIN as i64)); + assert_eq!(uint::MIN.to_uint(), Some(uint::MIN as uint)); + assert_eq!(uint::MIN.to_u8(), Some(uint::MIN as u8)); + assert_eq!(uint::MIN.to_u16(), Some(uint::MIN as u16)); + assert_eq!(uint::MIN.to_u32(), Some(uint::MIN as u32)); + assert_eq!(uint::MIN.to_u64(), Some(uint::MIN as u64)); } #[test] fn test_cast_range_u8_min() { - assert_eq!(u8::min_value.to_int(), Some(u8::min_value as int)); - assert_eq!(u8::min_value.to_i8(), Some(u8::min_value as i8)); - assert_eq!(u8::min_value.to_i16(), Some(u8::min_value as i16)); - assert_eq!(u8::min_value.to_i32(), Some(u8::min_value as i32)); - assert_eq!(u8::min_value.to_i64(), Some(u8::min_value as i64)); - assert_eq!(u8::min_value.to_uint(), Some(u8::min_value as uint)); - assert_eq!(u8::min_value.to_u8(), Some(u8::min_value as u8)); - assert_eq!(u8::min_value.to_u16(), Some(u8::min_value as u16)); - assert_eq!(u8::min_value.to_u32(), Some(u8::min_value as u32)); - assert_eq!(u8::min_value.to_u64(), Some(u8::min_value as u64)); + assert_eq!(u8::MIN.to_int(), Some(u8::MIN as int)); + assert_eq!(u8::MIN.to_i8(), Some(u8::MIN as i8)); + assert_eq!(u8::MIN.to_i16(), Some(u8::MIN as i16)); + assert_eq!(u8::MIN.to_i32(), Some(u8::MIN as i32)); + assert_eq!(u8::MIN.to_i64(), Some(u8::MIN as i64)); + assert_eq!(u8::MIN.to_uint(), Some(u8::MIN as uint)); + assert_eq!(u8::MIN.to_u8(), Some(u8::MIN as u8)); + assert_eq!(u8::MIN.to_u16(), Some(u8::MIN as u16)); + assert_eq!(u8::MIN.to_u32(), Some(u8::MIN as u32)); + assert_eq!(u8::MIN.to_u64(), Some(u8::MIN as u64)); } #[test] fn test_cast_range_u16_min() { - assert_eq!(u16::min_value.to_int(), Some(u16::min_value as int)); - assert_eq!(u16::min_value.to_i8(), Some(u16::min_value as i8)); - assert_eq!(u16::min_value.to_i16(), Some(u16::min_value as i16)); - assert_eq!(u16::min_value.to_i32(), Some(u16::min_value as i32)); - assert_eq!(u16::min_value.to_i64(), Some(u16::min_value as i64)); - assert_eq!(u16::min_value.to_uint(), Some(u16::min_value as uint)); - assert_eq!(u16::min_value.to_u8(), Some(u16::min_value as u8)); - assert_eq!(u16::min_value.to_u16(), Some(u16::min_value as u16)); - assert_eq!(u16::min_value.to_u32(), Some(u16::min_value as u32)); - assert_eq!(u16::min_value.to_u64(), Some(u16::min_value as u64)); + assert_eq!(u16::MIN.to_int(), Some(u16::MIN as int)); + assert_eq!(u16::MIN.to_i8(), Some(u16::MIN as i8)); + assert_eq!(u16::MIN.to_i16(), Some(u16::MIN as i16)); + assert_eq!(u16::MIN.to_i32(), Some(u16::MIN as i32)); + assert_eq!(u16::MIN.to_i64(), Some(u16::MIN as i64)); + assert_eq!(u16::MIN.to_uint(), Some(u16::MIN as uint)); + assert_eq!(u16::MIN.to_u8(), Some(u16::MIN as u8)); + assert_eq!(u16::MIN.to_u16(), Some(u16::MIN as u16)); + assert_eq!(u16::MIN.to_u32(), Some(u16::MIN as u32)); + assert_eq!(u16::MIN.to_u64(), Some(u16::MIN as u64)); } #[test] fn test_cast_range_u32_min() { - assert_eq!(u32::min_value.to_int(), Some(u32::min_value as int)); - assert_eq!(u32::min_value.to_i8(), Some(u32::min_value as i8)); - assert_eq!(u32::min_value.to_i16(), Some(u32::min_value as i16)); - assert_eq!(u32::min_value.to_i32(), Some(u32::min_value as i32)); - assert_eq!(u32::min_value.to_i64(), Some(u32::min_value as i64)); - assert_eq!(u32::min_value.to_uint(), Some(u32::min_value as uint)); - assert_eq!(u32::min_value.to_u8(), Some(u32::min_value as u8)); - assert_eq!(u32::min_value.to_u16(), Some(u32::min_value as u16)); - assert_eq!(u32::min_value.to_u32(), Some(u32::min_value as u32)); - assert_eq!(u32::min_value.to_u64(), Some(u32::min_value as u64)); + assert_eq!(u32::MIN.to_int(), Some(u32::MIN as int)); + assert_eq!(u32::MIN.to_i8(), Some(u32::MIN as i8)); + assert_eq!(u32::MIN.to_i16(), Some(u32::MIN as i16)); + assert_eq!(u32::MIN.to_i32(), Some(u32::MIN as i32)); + assert_eq!(u32::MIN.to_i64(), Some(u32::MIN as i64)); + assert_eq!(u32::MIN.to_uint(), Some(u32::MIN as uint)); + assert_eq!(u32::MIN.to_u8(), Some(u32::MIN as u8)); + assert_eq!(u32::MIN.to_u16(), Some(u32::MIN as u16)); + assert_eq!(u32::MIN.to_u32(), Some(u32::MIN as u32)); + assert_eq!(u32::MIN.to_u64(), Some(u32::MIN as u64)); } #[test] fn test_cast_range_u64_min() { - assert_eq!(u64::min_value.to_int(), Some(u64::min_value as int)); - assert_eq!(u64::min_value.to_i8(), Some(u64::min_value as i8)); - assert_eq!(u64::min_value.to_i16(), Some(u64::min_value as i16)); - assert_eq!(u64::min_value.to_i32(), Some(u64::min_value as i32)); - assert_eq!(u64::min_value.to_i64(), Some(u64::min_value as i64)); - assert_eq!(u64::min_value.to_uint(), Some(u64::min_value as uint)); - assert_eq!(u64::min_value.to_u8(), Some(u64::min_value as u8)); - assert_eq!(u64::min_value.to_u16(), Some(u64::min_value as u16)); - assert_eq!(u64::min_value.to_u32(), Some(u64::min_value as u32)); - assert_eq!(u64::min_value.to_u64(), Some(u64::min_value as u64)); + assert_eq!(u64::MIN.to_int(), Some(u64::MIN as int)); + assert_eq!(u64::MIN.to_i8(), Some(u64::MIN as i8)); + assert_eq!(u64::MIN.to_i16(), Some(u64::MIN as i16)); + assert_eq!(u64::MIN.to_i32(), Some(u64::MIN as i32)); + assert_eq!(u64::MIN.to_i64(), Some(u64::MIN as i64)); + assert_eq!(u64::MIN.to_uint(), Some(u64::MIN as uint)); + assert_eq!(u64::MIN.to_u8(), Some(u64::MIN as u8)); + assert_eq!(u64::MIN.to_u16(), Some(u64::MIN as u16)); + assert_eq!(u64::MIN.to_u32(), Some(u64::MIN as u32)); + assert_eq!(u64::MIN.to_u64(), Some(u64::MIN as u64)); } #[test] fn test_cast_range_uint_max() { - assert_eq!(uint::max_value.to_int(), None); - assert_eq!(uint::max_value.to_i8(), None); - assert_eq!(uint::max_value.to_i16(), None); - assert_eq!(uint::max_value.to_i32(), None); - // uint::max_value.to_i64() is word-size specific - assert_eq!(uint::max_value.to_u8(), None); - assert_eq!(uint::max_value.to_u16(), None); - // uint::max_value.to_u32() is word-size specific - assert_eq!(uint::max_value.to_u64(), Some(uint::max_value as u64)); + assert_eq!(uint::MAX.to_int(), None); + assert_eq!(uint::MAX.to_i8(), None); + assert_eq!(uint::MAX.to_i16(), None); + assert_eq!(uint::MAX.to_i32(), None); + // uint::MAX.to_i64() is word-size specific + assert_eq!(uint::MAX.to_u8(), None); + assert_eq!(uint::MAX.to_u16(), None); + // uint::MAX.to_u32() is word-size specific + assert_eq!(uint::MAX.to_u64(), Some(uint::MAX as u64)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(uint::max_value.to_u32(), Some(uint::max_value as u32)); - assert_eq!(uint::max_value.to_i64(), Some(uint::max_value as i64)); + assert_eq!(uint::MAX.to_u32(), Some(uint::MAX as u32)); + assert_eq!(uint::MAX.to_i64(), Some(uint::MAX as i64)); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(uint::max_value.to_u32(), None); - assert_eq!(uint::max_value.to_i64(), None); + assert_eq!(uint::MAX.to_u32(), None); + assert_eq!(uint::MAX.to_i64(), None); } check_word_size(); @@ -1447,53 +1447,53 @@ mod tests { #[test] fn test_cast_range_u8_max() { - assert_eq!(u8::max_value.to_int(), Some(u8::max_value as int)); - assert_eq!(u8::max_value.to_i8(), None); - assert_eq!(u8::max_value.to_i16(), Some(u8::max_value as i16)); - assert_eq!(u8::max_value.to_i32(), Some(u8::max_value as i32)); - assert_eq!(u8::max_value.to_i64(), Some(u8::max_value as i64)); - assert_eq!(u8::max_value.to_uint(), Some(u8::max_value as uint)); - assert_eq!(u8::max_value.to_u8(), Some(u8::max_value as u8)); - assert_eq!(u8::max_value.to_u16(), Some(u8::max_value as u16)); - assert_eq!(u8::max_value.to_u32(), Some(u8::max_value as u32)); - assert_eq!(u8::max_value.to_u64(), Some(u8::max_value as u64)); + assert_eq!(u8::MAX.to_int(), Some(u8::MAX as int)); + assert_eq!(u8::MAX.to_i8(), None); + assert_eq!(u8::MAX.to_i16(), Some(u8::MAX as i16)); + assert_eq!(u8::MAX.to_i32(), Some(u8::MAX as i32)); + assert_eq!(u8::MAX.to_i64(), Some(u8::MAX as i64)); + assert_eq!(u8::MAX.to_uint(), Some(u8::MAX as uint)); + assert_eq!(u8::MAX.to_u8(), Some(u8::MAX as u8)); + assert_eq!(u8::MAX.to_u16(), Some(u8::MAX as u16)); + assert_eq!(u8::MAX.to_u32(), Some(u8::MAX as u32)); + assert_eq!(u8::MAX.to_u64(), Some(u8::MAX as u64)); } #[test] fn test_cast_range_u16_max() { - assert_eq!(u16::max_value.to_int(), Some(u16::max_value as int)); - assert_eq!(u16::max_value.to_i8(), None); - assert_eq!(u16::max_value.to_i16(), None); - assert_eq!(u16::max_value.to_i32(), Some(u16::max_value as i32)); - assert_eq!(u16::max_value.to_i64(), Some(u16::max_value as i64)); - assert_eq!(u16::max_value.to_uint(), Some(u16::max_value as uint)); - assert_eq!(u16::max_value.to_u8(), None); - assert_eq!(u16::max_value.to_u16(), Some(u16::max_value as u16)); - assert_eq!(u16::max_value.to_u32(), Some(u16::max_value as u32)); - assert_eq!(u16::max_value.to_u64(), Some(u16::max_value as u64)); + assert_eq!(u16::MAX.to_int(), Some(u16::MAX as int)); + assert_eq!(u16::MAX.to_i8(), None); + assert_eq!(u16::MAX.to_i16(), None); + assert_eq!(u16::MAX.to_i32(), Some(u16::MAX as i32)); + assert_eq!(u16::MAX.to_i64(), Some(u16::MAX as i64)); + assert_eq!(u16::MAX.to_uint(), Some(u16::MAX as uint)); + assert_eq!(u16::MAX.to_u8(), None); + assert_eq!(u16::MAX.to_u16(), Some(u16::MAX as u16)); + assert_eq!(u16::MAX.to_u32(), Some(u16::MAX as u32)); + assert_eq!(u16::MAX.to_u64(), Some(u16::MAX as u64)); } #[test] fn test_cast_range_u32_max() { - // u32::max_value.to_int() is word-size specific - assert_eq!(u32::max_value.to_i8(), None); - assert_eq!(u32::max_value.to_i16(), None); - assert_eq!(u32::max_value.to_i32(), None); - assert_eq!(u32::max_value.to_i64(), Some(u32::max_value as i64)); - assert_eq!(u32::max_value.to_uint(), Some(u32::max_value as uint)); - assert_eq!(u32::max_value.to_u8(), None); - assert_eq!(u32::max_value.to_u16(), None); - assert_eq!(u32::max_value.to_u32(), Some(u32::max_value as u32)); - assert_eq!(u32::max_value.to_u64(), Some(u32::max_value as u64)); + // u32::MAX.to_int() is word-size specific + assert_eq!(u32::MAX.to_i8(), None); + assert_eq!(u32::MAX.to_i16(), None); + assert_eq!(u32::MAX.to_i32(), None); + assert_eq!(u32::MAX.to_i64(), Some(u32::MAX as i64)); + assert_eq!(u32::MAX.to_uint(), Some(u32::MAX as uint)); + assert_eq!(u32::MAX.to_u8(), None); + assert_eq!(u32::MAX.to_u16(), None); + assert_eq!(u32::MAX.to_u32(), Some(u32::MAX as u32)); + assert_eq!(u32::MAX.to_u64(), Some(u32::MAX as u64)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(u32::max_value.to_int(), None); + assert_eq!(u32::MAX.to_int(), None); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(u32::max_value.to_int(), Some(u32::max_value as int)); + assert_eq!(u32::MAX.to_int(), Some(u32::MAX as int)); } check_word_size(); @@ -1501,25 +1501,25 @@ mod tests { #[test] fn test_cast_range_u64_max() { - assert_eq!(u64::max_value.to_int(), None); - assert_eq!(u64::max_value.to_i8(), None); - assert_eq!(u64::max_value.to_i16(), None); - assert_eq!(u64::max_value.to_i32(), None); - assert_eq!(u64::max_value.to_i64(), None); - // u64::max_value.to_uint() is word-size specific - assert_eq!(u64::max_value.to_u8(), None); - assert_eq!(u64::max_value.to_u16(), None); - assert_eq!(u64::max_value.to_u32(), None); - assert_eq!(u64::max_value.to_u64(), Some(u64::max_value as u64)); + assert_eq!(u64::MAX.to_int(), None); + assert_eq!(u64::MAX.to_i8(), None); + assert_eq!(u64::MAX.to_i16(), None); + assert_eq!(u64::MAX.to_i32(), None); + assert_eq!(u64::MAX.to_i64(), None); + // u64::MAX.to_uint() is word-size specific + assert_eq!(u64::MAX.to_u8(), None); + assert_eq!(u64::MAX.to_u16(), None); + assert_eq!(u64::MAX.to_u32(), None); + assert_eq!(u64::MAX.to_u64(), Some(u64::MAX as u64)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(u64::max_value.to_uint(), None); + assert_eq!(u64::MAX.to_uint(), None); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(u64::max_value.to_uint(), Some(u64::max_value as uint)); + assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as uint)); } check_word_size(); @@ -1527,55 +1527,55 @@ mod tests { #[test] fn test_saturating_add_uint() { - use uint::max_value; + use uint::MAX; assert_eq!(3u.saturating_add(5u), 8u); - assert_eq!(3u.saturating_add(max_value-1), max_value); - assert_eq!(max_value.saturating_add(max_value), max_value); - assert_eq!((max_value-2).saturating_add(1), max_value-1); + assert_eq!(3u.saturating_add(MAX-1), MAX); + assert_eq!(MAX.saturating_add(MAX), MAX); + assert_eq!((MAX-2).saturating_add(1), MAX-1); } #[test] fn test_saturating_sub_uint() { - use uint::max_value; + use uint::MAX; assert_eq!(5u.saturating_sub(3u), 2u); assert_eq!(3u.saturating_sub(5u), 0u); assert_eq!(0u.saturating_sub(1u), 0u); - assert_eq!((max_value-1).saturating_sub(max_value), 0); + assert_eq!((MAX-1).saturating_sub(MAX), 0); } #[test] fn test_saturating_add_int() { - use int::{min_value,max_value}; + use int::{MIN,MAX}; assert_eq!(3i.saturating_add(5i), 8i); - assert_eq!(3i.saturating_add(max_value-1), max_value); - assert_eq!(max_value.saturating_add(max_value), max_value); - assert_eq!((max_value-2).saturating_add(1), max_value-1); + assert_eq!(3i.saturating_add(MAX-1), MAX); + assert_eq!(MAX.saturating_add(MAX), MAX); + assert_eq!((MAX-2).saturating_add(1), MAX-1); assert_eq!(3i.saturating_add(-5i), -2i); - assert_eq!(min_value.saturating_add(-1i), min_value); - assert_eq!((-2i).saturating_add(-max_value), min_value); + assert_eq!(MIN.saturating_add(-1i), MIN); + assert_eq!((-2i).saturating_add(-MAX), MIN); } #[test] fn test_saturating_sub_int() { - use int::{min_value,max_value}; + use int::{MIN,MAX}; assert_eq!(3i.saturating_sub(5i), -2i); - assert_eq!(min_value.saturating_sub(1i), min_value); - assert_eq!((-2i).saturating_sub(max_value), min_value); + assert_eq!(MIN.saturating_sub(1i), MIN); + assert_eq!((-2i).saturating_sub(MAX), MIN); assert_eq!(3i.saturating_sub(-5i), 8i); - assert_eq!(3i.saturating_sub(-(max_value-1)), max_value); - assert_eq!(max_value.saturating_sub(-max_value), max_value); - assert_eq!((max_value-2).saturating_sub(-1), max_value-1); + assert_eq!(3i.saturating_sub(-(MAX-1)), MAX); + assert_eq!(MAX.saturating_sub(-MAX), MAX); + assert_eq!((MAX-2).saturating_sub(-1), MAX-1); } #[test] fn test_checked_add() { - let five_less = uint::max_value - 5; - assert_eq!(five_less.checked_add(&0), Some(uint::max_value - 5)); - assert_eq!(five_less.checked_add(&1), Some(uint::max_value - 4)); - assert_eq!(five_less.checked_add(&2), Some(uint::max_value - 3)); - assert_eq!(five_less.checked_add(&3), Some(uint::max_value - 2)); - assert_eq!(five_less.checked_add(&4), Some(uint::max_value - 1)); - assert_eq!(five_less.checked_add(&5), Some(uint::max_value)); + let five_less = uint::MAX - 5; + assert_eq!(five_less.checked_add(&0), Some(uint::MAX - 5)); + assert_eq!(five_less.checked_add(&1), Some(uint::MAX - 4)); + assert_eq!(five_less.checked_add(&2), Some(uint::MAX - 3)); + assert_eq!(five_less.checked_add(&3), Some(uint::MAX - 2)); + assert_eq!(five_less.checked_add(&4), Some(uint::MAX - 1)); + assert_eq!(five_less.checked_add(&5), Some(uint::MAX)); assert_eq!(five_less.checked_add(&6), None); assert_eq!(five_less.checked_add(&7), None); } @@ -1594,7 +1594,7 @@ mod tests { #[test] fn test_checked_mul() { - let third = uint::max_value / 3; + let third = uint::MAX / 3; assert_eq!(third.checked_mul(&0), Some(0)); assert_eq!(third.checked_mul(&1), Some(third)); assert_eq!(third.checked_mul(&2), Some(third * 2)); -- cgit 1.4.1-3-g733a5