From 6f9afd9be255424b6410e54ea1042b819a414d0f Mon Sep 17 00:00:00 2001 From: berleon Date: Mon, 11 Nov 2013 20:32:43 +0100 Subject: [PATCH] capitalized std::int::min_value, max_value Closes #10010 --- src/libextra/ebml.rs | 4 +- src/libextra/getopts.rs | 2 +- src/libextra/num/bigint.rs | 42 +- src/librustc/driver/session.rs | 2 +- src/librustc/middle/borrowck/move_data.rs | 4 +- src/librustc/middle/dataflow.rs | 4 +- src/librustc/middle/graph.rs | 4 +- src/librustc/middle/lint.rs | 20 +- src/librustc/middle/liveness.rs | 4 +- src/librustc/middle/resolve.rs | 4 +- src/librustc/middle/trans/datum.rs | 2 +- .../typeck/infer/region_inference/mod.rs | 4 +- src/librustdoc/passes.rs | 4 +- src/librustpkg/sha1.rs | 2 +- src/libstd/iter.rs | 26 +- src/libstd/num/cmath.rs | 16 +- src/libstd/num/f32.rs | 4 +- src/libstd/num/f64.rs | 4 +- src/libstd/num/int.rs | 6 +- src/libstd/num/int_macros.rs | 14 +- src/libstd/num/mod.rs | 522 +++++++++--------- src/libstd/num/uint.rs | 6 +- src/libstd/num/uint_macros.rs | 10 +- src/libstd/rand/distributions/range.rs | 4 +- src/libstd/result.rs | 2 +- src/libstd/rt/context.rs | 2 +- src/libstd/rt/io/extensions.rs | 6 +- src/libstd/rt/thread.rs | 2 +- src/libstd/task/spawn.rs | 4 +- src/libstd/trie.rs | 20 +- src/libstd/vec.rs | 4 +- src/libsyntax/ast_util.rs | 4 +- src/libsyntax/parse/comments.rs | 2 +- src/test/run-fail/bounds-check-no-overflow.rs | 4 +- .../bug-2470-bounds-check-overflow-2.rs | 2 +- .../bug-2470-bounds-check-overflow-3.rs | 2 +- src/test/run-pass/deriving-primitive.rs | 4 +- 37 files changed, 386 insertions(+), 386 deletions(-) diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs index f577ed55f9750..5601061dc23f7 100644 --- a/src/libextra/ebml.rs +++ b/src/libextra/ebml.rs @@ -377,7 +377,7 @@ pub mod reader { fn read_u8 (&mut self) -> u8 { doc_as_u8 (self.next_doc(EsU8 )) } fn read_uint(&mut self) -> uint { let v = doc_as_u64(self.next_doc(EsUint)); - if v > (::std::uint::max_value as u64) { + if v > (::std::uint::MAX_VALUE as u64) { fail!("uint {} too large for this architecture", v); } v as uint @@ -397,7 +397,7 @@ pub mod reader { } fn read_int(&mut self) -> int { let v = doc_as_u64(self.next_doc(EsInt)) as i64; - if v > (int::max_value as i64) || v < (int::min_value as i64) { + if v > (int::MAX_VALUE as i64) || v < (int::MIN_VALUE as i64) { debug!("FIXME \\#6122: Removing this makes this function miscompile"); fail!("int {} out of range for this architecture", v); } diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs index 918952132ab05..55d3c2259d04c 100644 --- a/src/libextra/getopts.rs +++ b/src/libextra/getopts.rs @@ -849,7 +849,7 @@ pub mod groups { t("hello", 15, [~"hello"]); t("\nMary had a little lamb\nLittle lamb\n", 15, [~"Mary had a", ~"little lamb", ~"Little lamb"]); - t("\nMary had a little lamb\nLittle lamb\n", ::std::uint::max_value, + t("\nMary had a little lamb\nLittle lamb\n", ::std::uint::MAX_VALUE, [~"Mary had a little lamb\nLittle lamb"]); } } // end groups module diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs index cd5ccc14cafb1..6f30bf75fd25b 100644 --- a/src/libextra/num/bigint.rs +++ b/src/libextra/num/bigint.rs @@ -1187,7 +1187,7 @@ impl ToPrimitive for BigInt { if n < m { Some(-(n as i64)) } else if n == m { - Some(i64::min_value) + Some(i64::MIN_VALUE) } else { None } @@ -1214,7 +1214,7 @@ impl FromPrimitive for BigInt { Some(BigInt::from_biguint(Plus, n)) } } else if n < 0 { - do FromPrimitive::from_u64(u64::max_value - (n as u64) + 1).and_then |n| { + do FromPrimitive::from_u64(u64::MAX_VALUE - (n as u64) + 1).and_then |n| { Some(BigInt::from_biguint(Minus, n)) } } else { @@ -1624,7 +1624,7 @@ mod biguint_tests { check(Zero::zero(), 0); check(One::one(), 1); - check(i64::max_value.to_biguint().unwrap(), i64::max_value); + check(i64::MAX_VALUE.to_biguint().unwrap(), i64::MAX_VALUE); check(BigUint::new(~[ ]), 0); check(BigUint::new(~[ 1 ]), (1 << (0*BigDigit::bits))); @@ -1634,9 +1634,9 @@ mod biguint_tests { check(BigUint::new(~[ 0, 0, 1 ]), (1 << (2*BigDigit::bits))); check(BigUint::new(~[-1, -1, -1 ]), (1 << (3*BigDigit::bits)) - 1); check(BigUint::new(~[ 0, 0, 0, 1 ]), (1 << (3*BigDigit::bits))); - check(BigUint::new(~[-1, -1, -1, -1 >> 1]), i64::max_value); + check(BigUint::new(~[-1, -1, -1, -1 >> 1]), i64::MAX_VALUE); - assert_eq!(i64::min_value.to_biguint(), None); + assert_eq!(i64::MIN_VALUE.to_biguint(), None); assert_eq!(BigUint::new(~[-1, -1, -1, -1 ]).to_i64(), None); assert_eq!(BigUint::new(~[ 0, 0, 0, 0, 1]).to_i64(), None); assert_eq!(BigUint::new(~[-1, -1, -1, -1, -1]).to_i64(), None); @@ -1653,15 +1653,15 @@ mod biguint_tests { check(Zero::zero(), 0); check(One::one(), 1); - check(i64::max_value.to_biguint().unwrap(), i64::max_value); + check(i64::MAX_VALUE.to_biguint().unwrap(), i64::MAX_VALUE); check(BigUint::new(~[ ]), 0); check(BigUint::new(~[ 1 ]), (1 << (0*BigDigit::bits))); check(BigUint::new(~[-1 ]), (1 << (1*BigDigit::bits)) - 1); check(BigUint::new(~[ 0, 1 ]), (1 << (1*BigDigit::bits))); - check(BigUint::new(~[-1, -1 >> 1]), i64::max_value); + check(BigUint::new(~[-1, -1 >> 1]), i64::MAX_VALUE); - assert_eq!(i64::min_value.to_biguint(), None); + assert_eq!(i64::MIN_VALUE.to_biguint(), None); assert_eq!(BigUint::new(~[-1, -1 ]).to_i64(), None); assert_eq!(BigUint::new(~[ 0, 0, 1]).to_i64(), None); assert_eq!(BigUint::new(~[-1, -1, -1]).to_i64(), None); @@ -1678,8 +1678,8 @@ mod biguint_tests { check(Zero::zero(), 0); check(One::one(), 1); - check(u64::min_value.to_biguint().unwrap(), u64::min_value); - check(u64::max_value.to_biguint().unwrap(), u64::max_value); + check(u64::MIN_VALUE.to_biguint().unwrap(), u64::MIN_VALUE); + check(u64::MAX_VALUE.to_biguint().unwrap(), u64::MAX_VALUE); check(BigUint::new(~[ ]), 0); check(BigUint::new(~[ 1 ]), (1 << (0*BigDigit::bits))); @@ -1689,7 +1689,7 @@ mod biguint_tests { check(BigUint::new(~[ 0, 0, 1 ]), (1 << (2*BigDigit::bits))); check(BigUint::new(~[-1, -1, -1 ]), (1 << (3*BigDigit::bits)) - 1); check(BigUint::new(~[ 0, 0, 0, 1]), (1 << (3*BigDigit::bits))); - check(BigUint::new(~[-1, -1, -1, -1]), u64::max_value); + check(BigUint::new(~[-1, -1, -1, -1]), u64::MAX_VALUE); assert_eq!(BigUint::new(~[ 0, 0, 0, 0, 1]).to_u64(), None); assert_eq!(BigUint::new(~[-1, -1, -1, -1, -1]).to_u64(), None); @@ -1706,14 +1706,14 @@ mod biguint_tests { check(Zero::zero(), 0); check(One::one(), 1); - check(u64::min_value.to_biguint().unwrap(), u64::min_value); - check(u64::max_value.to_biguint().unwrap(), u64::max_value); + check(u64::MIN_VALUE.to_biguint().unwrap(), u64::MIN_VALUE); + check(u64::MAX_VALUE.to_biguint().unwrap(), u64::MAX_VALUE); check(BigUint::new(~[ ]), 0); check(BigUint::new(~[ 1 ]), (1 << (0*BigDigit::bits))); check(BigUint::new(~[-1 ]), (1 << (1*BigDigit::bits)) - 1); check(BigUint::new(~[ 0, 1]), (1 << (1*BigDigit::bits))); - check(BigUint::new(~[-1, -1]), u64::max_value); + check(BigUint::new(~[-1, -1]), u64::MAX_VALUE); assert_eq!(BigUint::new(~[ 0, 0, 1]).to_u64(), None); assert_eq!(BigUint::new(~[-1, -1, -1]).to_u64(), None); @@ -2164,11 +2164,11 @@ mod bigint_tests { check(Zero::zero(), 0); check(One::one(), 1); - check(i64::min_value.to_bigint().unwrap(), i64::min_value); - check(i64::max_value.to_bigint().unwrap(), i64::max_value); + check(i64::MIN_VALUE.to_bigint().unwrap(), i64::MIN_VALUE); + check(i64::MAX_VALUE.to_bigint().unwrap(), i64::MAX_VALUE); assert_eq!( - (i64::max_value as u64 + 1).to_bigint().unwrap().to_i64(), + (i64::MAX_VALUE as u64 + 1).to_bigint().unwrap().to_i64(), None); assert_eq!( @@ -2194,15 +2194,15 @@ mod bigint_tests { check(Zero::zero(), 0); check(One::one(), 1); - check(u64::min_value.to_bigint().unwrap(), u64::min_value); - check(u64::max_value.to_bigint().unwrap(), u64::max_value); + check(u64::MIN_VALUE.to_bigint().unwrap(), u64::MIN_VALUE); + check(u64::MAX_VALUE.to_bigint().unwrap(), u64::MAX_VALUE); assert_eq!( BigInt::from_biguint(Plus, BigUint::new(~[1, 2, 3, 4, 5])).to_u64(), None); - let max_value: BigUint = FromPrimitive::from_u64(u64::max_value).unwrap(); - assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None); + let MAX_VALUE: BigUint = FromPrimitive::from_u64(u64::MAX_VALUE).unwrap(); + assert_eq!(BigInt::from_biguint(Minus, MAX_VALUE).to_u64(), None); assert_eq!(BigInt::from_biguint(Minus, BigUint::new(~[1, 2, 3, 4, 5])).to_u64(), None); } diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 57edb355d3265..0c0d198e523cc 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -275,7 +275,7 @@ impl Session_ { pub fn reserve_node_ids(&self, count: uint) -> ast::NodeId { let v = *self.node_id; *self.node_id += count; - if v > (int::max_value as uint) { + if v > (int::MAX_VALUE as uint) { self.bug("Input too large, ran out of node ids!"); } v as int diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index e031420996789..7300e24524a72 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -78,14 +78,14 @@ impl Clone for MovePathIndex { } static InvalidMovePathIndex: MovePathIndex = - MovePathIndex(uint::max_value); + MovePathIndex(uint::MAX_VALUE); /// Index into `MoveData.moves`, used like a pointer #[deriving(Eq)] pub struct MoveIndex(uint); static InvalidMoveIndex: MoveIndex = - MoveIndex(uint::max_value); + MoveIndex(uint::MAX_VALUE); pub struct MovePath { /// Loan path corresponding to this move path diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 299aa65897e6d..883e404ab9e9a 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -213,7 +213,7 @@ impl DataFlowContext { len }; if expanded { - let entry = if self.oper.initial_value() { uint::max_value } else {0}; + let entry = if self.oper.initial_value() { uint::MAX_VALUE } else {0}; do self.words_per_id.times { self.gens.push(0); self.kills.push(0); @@ -905,7 +905,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> { } fn reset(&mut self, bits: &mut [uint]) { - let e = if self.dfcx.oper.initial_value() {uint::max_value} else {0}; + let e = if self.dfcx.oper.initial_value() {uint::MAX_VALUE} else {0}; for b in bits.mut_iter() { *b = e; } } diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 87dce84d23dc5..ce3cccce233f7 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -56,11 +56,11 @@ pub struct Edge { #[deriving(Eq)] pub struct NodeIndex(uint); -pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::max_value); +pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX_VALUE); #[deriving(Eq)] pub struct EdgeIndex(uint); -pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::max_value); +pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX_VALUE); // Use a private field here to guarantee no more instances are created: pub struct Direction { priv repr: uint } diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 21a9b1904dd04..c7d94ced25cab 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -537,21 +537,21 @@ fn check_type_limits(cx: &Context, e: &ast::Expr) { // warnings are consistent between 32- and 64-bit platforms fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) { match int_ty { - ast::ty_i => (i64::min_value, i64::max_value), - ast::ty_i8 => (i8::min_value as i64, i8::max_value as i64), - ast::ty_i16 => (i16::min_value as i64, i16::max_value as i64), - ast::ty_i32 => (i32::min_value as i64, i32::max_value as i64), - ast::ty_i64 => (i64::min_value, i64::max_value) + ast::ty_i => (i64::MIN_VALUE, i64::MAX_VALUE), + ast::ty_i8 => (i8::MIN_VALUE as i64, i8::MAX_VALUE as i64), + ast::ty_i16 => (i16::MIN_VALUE as i64, i16::MAX_VALUE as i64), + ast::ty_i32 => (i32::MIN_VALUE as i64, i32::MAX_VALUE as i64), + ast::ty_i64 => (i64::MIN_VALUE, i64::MAX_VALUE) } } fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) { match uint_ty { - ast::ty_u => (u64::min_value, u64::max_value), - ast::ty_u8 => (u8::min_value as u64, u8::max_value as u64), - ast::ty_u16 => (u16::min_value as u64, u16::max_value as u64), - ast::ty_u32 => (u32::min_value as u64, u32::max_value as u64), - ast::ty_u64 => (u64::min_value, u64::max_value) + ast::ty_u => (u64::MIN_VALUE, u64::MAX_VALUE), + ast::ty_u8 => (u8::MIN_VALUE as u64, u8::MAX_VALUE as u64), + ast::ty_u16 => (u16::MIN_VALUE as u64, u16::MAX_VALUE as u64), + ast::ty_u32 => (u32::MIN_VALUE as u64, u32::MAX_VALUE as u64), + ast::ty_u64 => (u64::MIN_VALUE, u64::MAX_VALUE) } } diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index a370da2893a50..e25475a65a267 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -208,11 +208,11 @@ impl to_str::ToStr for Variable { impl LiveNode { pub fn is_valid(&self) -> bool { - **self != uint::max_value + **self != uint::MAX_VALUE } } -fn invalid_node() -> LiveNode { LiveNode(uint::max_value) } +fn invalid_node() -> LiveNode { LiveNode(uint::MAX_VALUE) } struct CaptureInfo { ln: LiveNode, diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 23fef5e351674..81b8654d7214f 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -4943,7 +4943,7 @@ impl Resolver { j -= 1; for (&k, _) in this.value_ribs[j].bindings.iter() { maybes.push(interner_get(k)); - values.push(uint::max_value); + values.push(uint::MAX_VALUE); } } @@ -4957,7 +4957,7 @@ impl Resolver { } if values.len() > 0 && - values[smallest] != uint::max_value && + values[smallest] != uint::MAX_VALUE && values[smallest] < name.len() + 2 && values[smallest] <= max_distance && name != maybes[smallest] { diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 01cf102275023..c732d7b29c24f 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -753,7 +753,7 @@ impl Datum { // either we were asked to deref a specific number of times, // in which case we should have, or we asked to deref as many // times as we can - assert!(derefs == max || max == uint::max_value); + assert!(derefs == max || max == uint::MAX_VALUE); DatumBlock { bcx: bcx, datum: datum } } diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index e613aa4ba28de..08d4bbd386e64 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -976,7 +976,7 @@ impl RegionVarBindings { // idea is to report errors that derive from independent // regions of the graph, but not those that derive from // overlapping locations. - let mut dup_vec = vec::from_elem(self.num_vars(), uint::max_value); + let mut dup_vec = vec::from_elem(self.num_vars(), uint::MAX_VALUE); let mut opt_graph = None; @@ -1196,7 +1196,7 @@ impl RegionVarBindings { let classification = var_data[node_idx.to_uint()].classification; // check whether we've visited this node on some previous walk - if dup_vec[node_idx.to_uint()] == uint::max_value { + if dup_vec[node_idx.to_uint()] == uint::MAX_VALUE { dup_vec[node_idx.to_uint()] = orig_node_idx.to_uint(); } else if dup_vec[node_idx.to_uint()] != orig_node_idx.to_uint() { state.dup_found = true; diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs index 1e7c42455f241..97943bbacac78 100644 --- a/src/librustdoc/passes.rs +++ b/src/librustdoc/passes.rs @@ -268,7 +268,7 @@ pub fn unindent(s: &str) -> ~str { let lines = s.any_line_iter().collect::<~[&str]>(); let mut saw_first_line = false; let mut saw_second_line = false; - let min_indent = do lines.iter().fold(uint::max_value) |min_indent, line| { + let min_indent = do lines.iter().fold(uint::MAX_VALUE) |min_indent, line| { // After we see the first non-whitespace line, look at // the line we have. If it is not whitespace, and therefore @@ -280,7 +280,7 @@ pub fn unindent(s: &str) -> ~str { !line.is_whitespace(); let min_indent = if ignore_previous_indents { - uint::max_value + uint::MAX_VALUE } else { min_indent }; diff --git a/src/librustpkg/sha1.rs b/src/librustpkg/sha1.rs index d955fd1aa97d0..ca8615c068386 100644 --- a/src/librustpkg/sha1.rs +++ b/src/librustpkg/sha1.rs @@ -600,7 +600,7 @@ mod tests { #[test] #[should_fail] fn test_add_bytes_to_bits_overflow() { - add_bytes_to_bits::(Bounded::max_value(), 1); + add_bytes_to_bits::(Bounded::MAX_VALUE(), 1); } } diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs index 90195efeae9e0..eef2ce4709a6b 100644 --- a/src/libstd/iter.rs +++ b/src/libstd/iter.rs @@ -680,7 +680,7 @@ pub trait DoubleEndedIterator: Iterator { /// of the original iterator. /// /// Note: Random access with inverted indices still only applies to the first - /// `uint::max_value` elements of the original iterator. + /// `uint::MAX_VALUE` elements of the original iterator. #[inline] fn invert(self) -> Invert { Invert{iter: self} @@ -712,7 +712,7 @@ impl<'self, A, T: DoubleEndedIterator<&'self mut A>> MutableDoubleEndedIterator /// /// A `RandomAccessIterator` should be either infinite or a `DoubleEndedIterator`. pub trait RandomAccessIterator: Iterator { - /// Return the number of indexable elements. At most `std::uint::max_value` + /// Return the number of indexable elements. At most `std::uint::MAX_VALUE` /// elements are indexable, even if the iterator represents a longer range. fn indexable(&self) -> uint; @@ -946,7 +946,7 @@ impl> Iterator for Cycle { match self.orig.size_hint() { sz @ (0, Some(0)) => sz, (0, _) => (0, None), - _ => (uint::max_value, None) + _ => (uint::MAX_VALUE, None) } } } @@ -955,7 +955,7 @@ impl> RandomAccessIterator for Cycle #[inline] fn indexable(&self) -> uint { if self.orig.indexable() > 0 { - uint::max_value + uint::MAX_VALUE } else { 0 } @@ -1811,7 +1811,7 @@ impl + Clone> Iterator for Counter { #[inline] fn size_hint(&self) -> (uint, Option) { - (uint::max_value, None) // Too bad we can't specify an infinite lower bound + (uint::MAX_VALUE, None) // Too bad we can't specify an infinite lower bound } } @@ -2037,7 +2037,7 @@ impl Iterator for Repeat { #[inline] fn next(&mut self) -> Option { self.idx(0) } #[inline] - fn size_hint(&self) -> (uint, Option) { (uint::max_value, None) } + fn size_hint(&self) -> (uint, Option) { (uint::MAX_VALUE, None) } } impl DoubleEndedIterator for Repeat { @@ -2047,7 +2047,7 @@ impl DoubleEndedIterator for Repeat { impl RandomAccessIterator for Repeat { #[inline] - fn indexable(&self) -> uint { uint::max_value } + fn indexable(&self) -> uint { uint::MAX_VALUE } #[inline] fn idx(&self, _: uint) -> Option { Some(self.element.clone()) } } @@ -2405,7 +2405,7 @@ mod tests { fn test_cycle() { let cycle_len = 3; let it = count(0u, 1).take(cycle_len).cycle(); - assert_eq!(it.size_hint(), (uint::max_value, None)); + assert_eq!(it.size_hint(), (uint::MAX_VALUE, None)); for (i, x) in it.take(100).enumerate() { assert_eq!(i % cycle_len, x); } @@ -2477,19 +2477,19 @@ mod tests { let v2 = &[10, 11, 12]; let vi = v.iter(); - assert_eq!(c.size_hint(), (uint::max_value, None)); + assert_eq!(c.size_hint(), (uint::MAX_VALUE, None)); assert_eq!(vi.size_hint(), (10, Some(10))); assert_eq!(c.take(5).size_hint(), (5, Some(5))); assert_eq!(c.skip(5).size_hint().second(), None); assert_eq!(c.take_while(|_| false).size_hint(), (0, None)); assert_eq!(c.skip_while(|_| false).size_hint(), (0, None)); - assert_eq!(c.enumerate().size_hint(), (uint::max_value, None)); - assert_eq!(c.chain(vi.map(|&i| i)).size_hint(), (uint::max_value, None)); + assert_eq!(c.enumerate().size_hint(), (uint::MAX_VALUE, None)); + assert_eq!(c.chain(vi.map(|&i| i)).size_hint(), (uint::MAX_VALUE, None)); assert_eq!(c.zip(vi).size_hint(), (10, Some(10))); assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None)); assert_eq!(c.filter(|_| false).size_hint(), (0, None)); - assert_eq!(c.map(|_| 0).size_hint(), (uint::max_value, None)); + assert_eq!(c.map(|_| 0).size_hint(), (uint::MAX_VALUE, None)); assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None)); assert_eq!(vi.take(5).size_hint(), (5, Some(5))); @@ -2876,7 +2876,7 @@ mod tests { assert_eq!(range(0i, 100).size_hint(), (100, Some(100))); // this test is only meaningful when sizeof uint < sizeof u64 - assert_eq!(range(uint::max_value - 1, uint::max_value).size_hint(), (1, Some(1))); + assert_eq!(range(uint::MAX_VALUE - 1, uint::MAX_VALUE).size_hint(), (1, Some(1))); assert_eq!(range(-10i, -1).size_hint(), (9, Some(9))); assert_eq!(range(Foo, Foo).size_hint(), (0, None)); } diff --git a/src/libstd/num/cmath.rs b/src/libstd/num/cmath.rs index 72051a933980e..92db6fa33eb71 100644 --- a/src/libstd/num/cmath.rs +++ b/src/libstd/num/cmath.rs @@ -219,8 +219,8 @@ pub mod c_float_targ_consts { pub static max_10_exp: int = 38; // FIXME (#1433): this is wrong, replace with hexadecimal (%a) staticants // below. - pub static min_value: f32 = 1.175494e-38_f32; - pub static max_value: f32 = 3.402823e+38_f32; + pub static MIN_VALUE: f32 = 1.175494e-38_f32; + pub static MAX_VALUE: f32 = 3.402823e+38_f32; pub static epsilon: f32 = 0.000000_f32; } @@ -234,8 +234,8 @@ pub mod c_double_targ_consts { pub static max_10_exp: int = 308; // FIXME (#1433): this is wrong, replace with hexadecimal (%a) staticants // below. - pub static min_value: f64 = 2.225074e-308_f64; - pub static max_value: f64 = 1.797693e+308_f64; + pub static MIN_VALUE: f64 = 2.225074e-308_f64; + pub static MAX_VALUE: f64 = 1.797693e+308_f64; pub static epsilon: f64 = 2.220446e-16_f64; } @@ -283,8 +283,8 @@ pub mod c_float_targ_consts { pub static max_exp: int = 128; pub static min_10_exp: int = -37; pub static max_10_exp: int = 38; - pub static min_value: c_float = 0x1p-126_f32; - pub static max_value: c_float = 0x1.fffffep+127_f32; + pub static MIN_VALUE: c_float = 0x1p-126_f32; + pub static MAX_VALUE: c_float = 0x1.fffffep+127_f32; pub static epsilon: c_float = 0x1p-23_f32; } @@ -296,8 +296,8 @@ pub mod c_double_targ_consts { pub static max_exp: int = 1024; pub static min_10_exp: int = -307; pub static max_10_exp: int = 308; - pub static min_value: c_double = 0x1p-1022_f64; - pub static max_value: c_double = 0x1.fffffffffffffp+1023_f64; + pub static MIN_VALUE: c_double = 0x1p-1022_f64; + pub static MAX_VALUE: c_double = 0x1.fffffffffffffp+1023_f64; pub static epsilon: c_double = 0x1p-52_f64; } diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index a0dddffd85184..b14bbf7e89f0d 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -576,10 +576,10 @@ impl Real for f32 { impl Bounded for f32 { #[inline] - fn min_value() -> f32 { 1.17549435e-38 } + fn MIN_VALUE() -> f32 { 1.17549435e-38 } #[inline] - fn max_value() -> f32 { 3.40282347e+38 } + fn MAX_VALUE() -> f32 { 3.40282347e+38 } } impl Primitive for f32 { diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 8cb7fa1800186..502f46f234c1d 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -624,10 +624,10 @@ impl RealExt for f64 { impl Bounded for f64 { #[inline] - fn min_value() -> f64 { 2.2250738585072014e-308 } + fn MIN_VALUE() -> f64 { 2.2250738585072014e-308 } #[inline] - fn max_value() -> f64 { 1.7976931348623157e+308 } + fn MAX_VALUE() -> f64 { 1.7976931348623157e+308 } } impl Primitive for f64 { diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs index c5364fa3dab96..d66b6b20bc334 100644 --- a/src/libstd/num/int.rs +++ b/src/libstd/num/int.rs @@ -153,7 +153,7 @@ fn test_pow() { #[test] fn test_overflows() { - assert!((::int::max_value > 0)); - assert!((::int::min_value <= 0)); - assert!((::int::min_value + ::int::max_value + 1 == 0)); + assert!((::int::MAX_VALUE > 0)); + assert!((::int::MIN_VALUE <= 0)); + assert!((::int::MIN_VALUE + ::int::MAX_VALUE + 1 == 0)); } diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index ba1a7a4f912b8..4a49151fe938a 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -28,14 +28,14 @@ pub use cmp::{min, max}; pub static bits : uint = $bits; pub static bytes : uint = ($bits / 8); -pub static min_value: $T = (-1 as $T) << (bits - 1); -// FIXME(#9837): Compute min_value like this so the high bits that shouldn't exist are 0. -pub static max_value: $T = !min_value; +pub static MIN_VALUE: $T = (-1 as $T) << (bits - 1); +// FIXME(#9837): Compute MIN_VALUE like this so the high bits that shouldn't exist are 0. +pub static MAX_VALUE: $T = MIN_VALUE - 1 as $T; impl CheckedDiv for $T { #[inline] fn checked_div(&self, v: &$T) -> Option<$T> { - if *v == 0 || (*self == min_value && *v == -1) { + if *v == 0 || (*self == MIN_VALUE && *v == -1) { None } else { Some(self / *v) @@ -367,10 +367,10 @@ impl Not<$T> for $T { impl Bounded for $T { #[inline] - fn min_value() -> $T { min_value } + fn MIN_VALUE() -> $T { MIN_VALUE } #[inline] - fn max_value() -> $T { max_value } + fn MAX_VALUE() -> $T { MAX_VALUE } } impl Int for $T {} @@ -777,7 +777,7 @@ mod tests { fn test_signed_checked_div() { assert_eq!(10i.checked_div(&2), Some(5)); assert_eq!(5i.checked_div(&0), None); - assert_eq!(int::min_value.checked_div(&-1), None); + assert_eq!(int::MIN_VALUE.checked_div(&-1), None); } } diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 3097a8e138ef0..24e945cb4706c 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -323,8 +323,8 @@ pub trait BitCount { pub trait Bounded { // FIXME (#5527): These should be associated constants - fn min_value() -> Self; - fn max_value() -> Self; + fn MIN_VALUE() -> Self; + fn MAX_VALUE() -> Self; } /// Specifies the available operations common to all of Rust's core numeric primitives. @@ -494,9 +494,9 @@ macro_rules! impl_to_primitive_int_to_int( Some(*self as $DstT) } else { let n = *self as i64; - let min_value: $DstT = Bounded::min_value(); - let max_value: $DstT = Bounded::max_value(); - if min_value as i64 <= n && n <= max_value as i64 { + let MIN_VALUE: $DstT = Bounded::MIN_VALUE(); + let MAX_VALUE: $DstT = Bounded::MAX_VALUE(); + if MIN_VALUE as i64 <= n && n <= MAX_VALUE as i64 { Some(*self as $DstT) } else { None @@ -510,8 +510,8 @@ macro_rules! impl_to_primitive_int_to_uint( ($SrcT:ty, $DstT:ty) => ( { let zero: $SrcT = Zero::zero(); - let max_value: $DstT = Bounded::max_value(); - if zero <= *self && *self as u64 <= max_value as u64 { + let MAX_VALUE: $DstT = Bounded::MAX_VALUE(); + if zero <= *self && *self as u64 <= MAX_VALUE as u64 { Some(*self as $DstT) } else { None @@ -562,8 +562,8 @@ impl_to_primitive_int!(i64) macro_rules! impl_to_primitive_uint_to_int( ($DstT:ty) => ( { - let max_value: $DstT = Bounded::max_value(); - if *self as u64 <= max_value as u64 { + let MAX_VALUE: $DstT = Bounded::MAX_VALUE(); + if *self as u64 <= MAX_VALUE as u64 { Some(*self as $DstT) } else { None @@ -579,8 +579,8 @@ macro_rules! impl_to_primitive_uint_to_uint( Some(*self as $DstT) } else { let zero: $SrcT = Zero::zero(); - let max_value: $DstT = Bounded::max_value(); - if zero <= *self && *self as u64 <= max_value as u64 { + let MAX_VALUE: $DstT = Bounded::MAX_VALUE(); + if zero <= *self && *self as u64 <= MAX_VALUE as u64 { Some(*self as $DstT) } else { None @@ -635,8 +635,8 @@ macro_rules! impl_to_primitive_float_to_float( Some(*self as $DstT) } else { let n = *self as f64; - let max_value: $SrcT = Bounded::max_value(); - if -max_value as f64 <= n && n <= max_value as f64 { + let MAX_VALUE: $SrcT = Bounded::MAX_VALUE(); + if -MAX_VALUE as f64 <= n && n <= MAX_VALUE as f64 { Some(*self as $DstT) } else { None @@ -977,9 +977,9 @@ impl Saturating for T { match self.checked_add(&v) { Some(x) => x, None => if v >= Zero::zero() { - Bounded::max_value() + Bounded::MAX_VALUE() } else { - Bounded::min_value() + Bounded::MIN_VALUE() } } } @@ -989,9 +989,9 @@ impl Saturating for T { match self.checked_sub(&v) { Some(x) => x, None => if v >= Zero::zero() { - Bounded::min_value() + Bounded::MIN_VALUE() } else { - Bounded::max_value() + Bounded::MAX_VALUE() } } } @@ -1104,25 +1104,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_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); #[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_VALUE.to_i32(), Some(int::MIN_VALUE as i32)); } #[cfg(target_word_size = "64")] fn check_word_size() { - assert_eq!(int::min_value.to_i32(), None); + assert_eq!(int::MIN_VALUE.to_i32(), None); } check_word_size(); @@ -1130,67 +1130,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_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); } #[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_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); } #[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_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); } #[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_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); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(i64::min_value.to_int(), None); + assert_eq!(i64::MIN_VALUE.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_VALUE.to_int(), Some(i64::MIN_VALUE as int)); } check_word_size(); @@ -1198,26 +1198,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_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)); #[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_VALUE.to_i32(), Some(int::MAX_VALUE as i32)); + assert_eq!(int::MAX_VALUE.to_u32(), Some(int::MAX_VALUE 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_VALUE.to_i32(), None); + assert_eq!(int::MAX_VALUE.to_u32(), None); } check_word_size(); @@ -1225,69 +1225,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_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)); } #[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_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)); } #[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_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)); } #[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_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)); #[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_VALUE.to_int(), None); + assert_eq!(i64::MAX_VALUE.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_VALUE.to_int(), Some(i64::MAX_VALUE as int)); + assert_eq!(i64::MAX_VALUE.to_uint(), Some(i64::MAX_VALUE as uint)); } check_word_size(); @@ -1295,96 +1295,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_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)); } #[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_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)); } #[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_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)); } #[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_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)); } #[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_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)); } #[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_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)); #[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_VALUE.to_u32(), Some(uint::MAX_VALUE as u32)); + assert_eq!(uint::MAX_VALUE.to_i64(), Some(uint::MAX_VALUE 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_VALUE.to_u32(), None); + assert_eq!(uint::MAX_VALUE.to_i64(), None); } check_word_size(); @@ -1392,53 +1392,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_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)); } #[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_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)); } #[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_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)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(u32::max_value.to_int(), None); + assert_eq!(u32::MAX_VALUE.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_VALUE.to_int(), Some(u32::MAX_VALUE as int)); } check_word_size(); @@ -1446,25 +1446,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_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)); #[cfg(target_word_size = "32")] fn check_word_size() { - assert_eq!(u64::max_value.to_uint(), None); + assert_eq!(u64::MAX_VALUE.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_VALUE.to_uint(), Some(u64::MAX_VALUE as uint)); } check_word_size(); @@ -1472,55 +1472,55 @@ mod tests { #[test] fn test_saturating_add_uint() { - use uint::max_value; + use uint::MAX_VALUE; 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_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); } #[test] fn test_saturating_sub_uint() { - use uint::max_value; + use uint::MAX_VALUE; 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_VALUE-1).saturating_sub(MAX_VALUE), 0); } #[test] fn test_saturating_add_int() { - use int::{min_value,max_value}; + use int::{MIN_VALUE,MAX_VALUE}; 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_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(-5i), -2i); - assert_eq!(min_value.saturating_add(-1i), min_value); - assert_eq!((-2i).saturating_add(-max_value), min_value); + assert_eq!(MIN_VALUE.saturating_add(-1i), MIN_VALUE); + assert_eq!((-2i).saturating_add(-MAX_VALUE), MIN_VALUE); } #[test] fn test_saturating_sub_int() { - use int::{min_value,max_value}; + use int::{MIN_VALUE,MAX_VALUE}; 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_VALUE.saturating_sub(1i), MIN_VALUE); + assert_eq!((-2i).saturating_sub(MAX_VALUE), MIN_VALUE); 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_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); } #[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_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)); assert_eq!(five_less.checked_add(&6), None); assert_eq!(five_less.checked_add(&7), None); } @@ -1539,7 +1539,7 @@ mod tests { #[test] fn test_checked_mul() { - let third = uint::max_value / 3; + let third = uint::MAX_VALUE / 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)); diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index 2ecbb79407e1b..f1d12ab11fa1d 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -227,9 +227,9 @@ fn test_next_power_of_two() { #[test] fn test_overflows() { use uint; - assert!((uint::max_value > 0u)); - assert!((uint::min_value <= 0u)); - assert!((uint::min_value + uint::max_value + 1u == 0u)); + assert!((uint::MAX_VALUE > 0u)); + assert!((uint::MIN_VALUE <= 0u)); + assert!((uint::MIN_VALUE + uint::MAX_VALUE + 1u == 0u)); } #[test] diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 2974b402d4a76..72221c1d07e60 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -29,8 +29,8 @@ pub use cmp::{min, max}; pub static bits : uint = $bits; pub static bytes : uint = ($bits / 8); -pub static min_value: $T = 0 as $T; -pub static max_value: $T = 0 as $T - 1 as $T; +pub static MIN_VALUE: $T = 0 as $T; +pub static MAX_VALUE: $T = 0 as $T - 1 as $T; impl CheckedDiv for $T { #[inline] @@ -229,10 +229,10 @@ impl Not<$T> for $T { impl Bounded for $T { #[inline] - fn min_value() -> $T { min_value } + fn MIN_VALUE() -> $T { MIN_VALUE } #[inline] - fn max_value() -> $T { max_value } + fn MAX_VALUE() -> $T { MAX_VALUE } } impl Int for $T {} @@ -420,7 +420,7 @@ mod tests { assert_eq!(0b0110 as $T, (0b1100 as $T).bitxor(&(0b1010 as $T))); assert_eq!(0b1110 as $T, (0b0111 as $T).shl(&(1 as $T))); assert_eq!(0b0111 as $T, (0b1110 as $T).shr(&(1 as $T))); - assert_eq!(max_value - (0b1011 as $T), (0b1011 as $T).not()); + assert_eq!(MAX_VALUE - (0b1011 as $T), (0b1011 as $T).not()); } #[test] diff --git a/src/libstd/rand/distributions/range.rs b/src/libstd/rand/distributions/range.rs index 1b805a0b8f763..3c7c35a27b866 100644 --- a/src/libstd/rand/distributions/range.rs +++ b/src/libstd/rand/distributions/range.rs @@ -98,7 +98,7 @@ macro_rules! integer_impl { fn construct_range(low: $ty, high: $ty) -> Range<$ty> { let range = high as $unsigned - low as $unsigned; - let unsigned_max: $unsigned = Bounded::max_value(); + let unsigned_max: $unsigned = Bounded::MAX_VALUE(); // this is the largest number that fits into $unsigned // that `range` divides evenly, so, if we've sampled @@ -189,7 +189,7 @@ mod tests { $( let v: &[($ty, $ty)] = [(0, 10), (10, 127), - (Bounded::min_value(), Bounded::max_value())]; + (Bounded::MIN_VALUE(), Bounded::MAX_VALUE())]; for &(low, high) in v.iter() { let mut sampler: Range<$ty> = Range::new(low, high); for _ in range(0, 1000) { diff --git a/src/libstd/result.rs b/src/libstd/result.rs index 03860c8ab2211..8e582346d037b 100644 --- a/src/libstd/result.rs +++ b/src/libstd/result.rs @@ -353,7 +353,7 @@ impl fmt::Default for Result { /// checking for overflow: /// /// fn inc_conditionally(x: uint) -> Result { -/// if x == uint::max_value { return Err("overflow"); } +/// if x == uint::MAX_VALUE { return Err("overflow"); } /// else { return Ok(x+1u); } /// } /// let v = [1u, 2, 3]; diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs index fcc30ded9542a..b2568bb82cd21 100644 --- a/src/libstd/rt/context.rs +++ b/src/libstd/rt/context.rs @@ -111,7 +111,7 @@ impl Context { // If we're going back to one of the original contexts or // something that's possibly not a "normal task", then reset // the stack limit to 0 to make morestack never fail - None => record_stack_bounds(0, uint::max_value), + None => record_stack_bounds(0, uint::MAX_VALUE), } swap_registers(out_regs, in_regs) } diff --git a/src/libstd/rt/io/extensions.rs b/src/libstd/rt/io/extensions.rs index 261792977b3a9..b2cb73ad26d0a 100644 --- a/src/libstd/rt/io/extensions.rs +++ b/src/libstd/rt/io/extensions.rs @@ -415,7 +415,7 @@ mod test { #[test] fn test_read_write_le_mem() { - let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::max_value]; + let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::MAX_VALUE]; let mut writer = MemWriter::new(); for i in uints.iter() { @@ -431,7 +431,7 @@ mod test { #[test] fn test_read_write_be() { - let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::max_value]; + let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::MAX_VALUE]; let mut writer = MemWriter::new(); for i in uints.iter() { @@ -446,7 +446,7 @@ mod test { #[test] fn test_read_be_int_n() { - let ints = [::i32::min_value, -123456, -42, -5, 0, 1, ::i32::max_value]; + let ints = [::i32::MIN_VALUE, -123456, -42, -5, 0, 1, ::i32::MAX_VALUE]; let mut writer = MemWriter::new(); for i in ints.iter() { diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs index 5e535d994f9ef..35057efa8167f 100644 --- a/src/libstd/rt/thread.rs +++ b/src/libstd/rt/thread.rs @@ -44,7 +44,7 @@ impl Thread { extern "C" fn thread_start(trampoline: *libc::c_void) -> rust_thread_return { use rt::context; unsafe { - context::record_stack_bounds(0, uint::max_value); + context::record_stack_bounds(0, uint::MAX_VALUE); let f: ~~fn() = cast::transmute(trampoline); (*f)(); } diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs index b1d72c063ac8e..aa6cf20478ab9 100644 --- a/src/libstd/task/spawn.rs +++ b/src/libstd/task/spawn.rs @@ -201,7 +201,7 @@ fn each_ancestor(list: &mut AncestorList, forward_blk: &fn(TaskGroupInner) -> bool) -> bool { // "Kickoff" call - there was no last generation. - return !coalesce(list, bail_blk, forward_blk, uint::max_value); + return !coalesce(list, bail_blk, forward_blk, uint::MAX_VALUE); // Recursively iterates, and coalesces afterwards if needed. Returns // whether or not unwinding is needed (i.e., !successful iteration). @@ -514,7 +514,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool) })); let a = if supervised { let new_generation = incr_generation(&ancestors); - assert!(new_generation < uint::max_value); + assert!(new_generation < uint::MAX_VALUE); // Child's ancestors start with the spawner. // Build a new node in the ancestor list. AncestorList(Some(Exclusive::new(AncestorNode { diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs index c561fb6cc8a45..e1e6aec675952 100644 --- a/src/libstd/trie.rs +++ b/src/libstd/trie.rs @@ -595,14 +595,14 @@ mod test_map { fn test_each_break() { let mut m = TrieMap::new(); - for x in range(uint::max_value - 10000, uint::max_value).invert() { + for x in range(uint::MAX_VALUE - 10000, uint::MAX_VALUE).invert() { m.insert(x, x / 2); } - let mut n = uint::max_value - 10000; + let mut n = uint::MAX_VALUE - 10000; do m.each |k, v| { - if n == uint::max_value - 5000 { false } else { - assert!(n < uint::max_value - 5000); + if n == uint::MAX_VALUE - 5000 { false } else { + assert!(n < uint::MAX_VALUE - 5000); assert_eq!(*k, n); assert_eq!(*v, n / 2); @@ -635,14 +635,14 @@ mod test_map { fn test_each_reverse_break() { let mut m = TrieMap::new(); - for x in range(uint::max_value - 10000, uint::max_value).invert() { + for x in range(uint::MAX_VALUE - 10000, uint::MAX_VALUE).invert() { m.insert(x, x / 2); } - let mut n = uint::max_value - 1; + let mut n = uint::MAX_VALUE - 1; do m.each_reverse |k, v| { - if n == uint::max_value - 5000 { false } else { - assert!(n > uint::max_value - 5000); + if n == uint::MAX_VALUE - 5000 { false } else { + assert!(n > uint::MAX_VALUE - 5000); assert_eq!(*k, n); assert_eq!(*v, n / 2); @@ -684,8 +684,8 @@ mod test_map { let empty_map : TrieMap = TrieMap::new(); assert_eq!(empty_map.iter().next(), None); - let first = uint::max_value - 10000; - let last = uint::max_value; + let first = uint::MAX_VALUE - 10000; + let last = uint::MAX_VALUE; let mut map = TrieMap::new(); for x in range(first, last).invert() { diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index c2aa4c234d1b7..47d7935b63ea8 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -1025,7 +1025,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { #[inline] fn split_iter(self, pred: &'self fn(&T) -> bool) -> SplitIterator<'self, T> { - self.splitn_iter(uint::max_value, pred) + self.splitn_iter(uint::MAX_VALUE, pred) } #[inline] fn splitn_iter(self, n: uint, pred: &'self fn(&T) -> bool) -> SplitIterator<'self, T> { @@ -1038,7 +1038,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { } #[inline] fn rsplit_iter(self, pred: &'self fn(&T) -> bool) -> RSplitIterator<'self, T> { - self.rsplitn_iter(uint::max_value, pred) + self.rsplitn_iter(uint::MAX_VALUE, pred) } #[inline] fn rsplitn_iter(self, n: uint, pred: &'self fn(&T) -> bool) -> RSplitIterator<'self, T> { diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index ccae25dc012ac..6d2b9571654c5 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -382,8 +382,8 @@ pub struct id_range { impl id_range { pub fn max() -> id_range { id_range { - min: int::max_value, - max: int::min_value, + min: int::MAX_VALUE, + max: int::MIN_VALUE, } } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 38fd65836aaec..960987b5ebfd9 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -78,7 +78,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str { /// remove a "[ \t]*\*" block from each line, if possible fn horizontal_trim(lines: ~[~str]) -> ~[~str] { - let mut i = uint::max_value; + let mut i = uint::MAX_VALUE; let mut can_trim = true; let mut first = true; for line in lines.iter() { diff --git a/src/test/run-fail/bounds-check-no-overflow.rs b/src/test/run-fail/bounds-check-no-overflow.rs index faced3531f582..bca1d4b316475 100644 --- a/src/test/run-fail/bounds-check-no-overflow.rs +++ b/src/test/run-fail/bounds-check-no-overflow.rs @@ -10,10 +10,10 @@ // error-pattern:index out of bounds: the len is 3 but the index is -use std::uint::max_value; +use std::uint::MAX_VALUE; use std::mem::size_of; fn main() { let xs = [1, 2, 3]; - xs[max_value / size_of::() + 1]; + xs[MAX_VALUE / size_of::() + 1]; } diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs index fa8cd005c0456..0fe0d5f1f9b05 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs @@ -21,7 +21,7 @@ fn main() { // length (in bytes), because the scaling of the index will cause it to // wrap around to a small number. - let idx = uint::max_value & !(uint::max_value >> 1u); + let idx = uint::MAX_VALUE & !(uint::MAX_VALUE >> 1u); error!("ov2 idx = 0x%x", idx); // This should fail. diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs index 2a5b454357659..048b8d53646db 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs @@ -23,7 +23,7 @@ fn main() { // This test is only meaningful on 32-bit hosts. - let idx = u64::max_value & !(u64::max_value >> 1u); + let idx = u64::MAX_VALUE & !(u64::MAX_VALUE >> 1u); error!("ov3 idx = 0x%8.8x%8.8x", (idx >> 32) as uint, idx as uint); diff --git a/src/test/run-pass/deriving-primitive.rs b/src/test/run-pass/deriving-primitive.rs index f82d77b28eae9..bc40dfdeec45d 100644 --- a/src/test/run-pass/deriving-primitive.rs +++ b/src/test/run-pass/deriving-primitive.rs @@ -13,14 +13,14 @@ use std::int; #[deriving(Eq, FromPrimitive)] enum A { - Foo = int::max_value, + Foo = int::MAX_VALUE, Bar = 1, Baz = 3, Qux, } pub fn main() { - let x: Option = FromPrimitive::from_int(int::max_value); + let x: Option = FromPrimitive::from_int(int::MAX_VALUE); assert_eq!(x, Some(Foo)); let x: Option = FromPrimitive::from_int(1);