OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto merge of #9203 : thestinger/rust/range_step, r=huonw

This commit is contained in:
bors 2013-09-14 23:00:52 -07:00
parent ccadbd3b7c 48f61ecbf9
commit 36872e4180
11 changed files with 82 additions and 640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/libextra/crypto/md5.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::uint;
use std::iter::range_step;
use cryptoutil::{write_u32_le, read_u32v_le, FixedBuffer, FixedBuffer64, StandardPadding};
use digest::Digest;
@ -86,46 +86,42 @@ impl Md5State {
read_u32v_le(data, input);
// round 1
do uint::range_step(0, 16, 4) |i| {
for i in range_step(0u, 16, 4) {
a = op_f(a, b, c, d, data[i] + C1[i], 7);
d = op_f(d, a, b, c, data[i + 1] + C1[i + 1], 12);
c = op_f(c, d, a, b, data[i + 2] + C1[i + 2], 17);
b = op_f(b, c, d, a, data[i + 3] + C1[i + 3], 22);
true
};
}
// round 2
let mut t = 1;
do uint::range_step(0, 16, 4) |i| {
for i in range_step(0u, 16, 4) {
a = op_g(a, b, c, d, data[t & 0x0f] + C2[i], 5);
d = op_g(d, a, b, c, data[(t + 5) & 0x0f] + C2[i + 1], 9);
c = op_g(c, d, a, b, data[(t + 10) & 0x0f] + C2[i + 2], 14);
b = op_g(b, c, d, a, data[(t + 15) & 0x0f] + C2[i + 3], 20);
t += 20;
true
};
}
// round 3
t = 5;
do uint::range_step(0, 16, 4) |i| {
for i in range_step(0u, 16, 4) {
a = op_h(a, b, c, d, data[t & 0x0f] + C3[i], 4);
d = op_h(d, a, b, c, data[(t + 3) & 0x0f] + C3[i + 1], 11);
c = op_h(c, d, a, b, data[(t + 6) & 0x0f] + C3[i + 2], 16);
b = op_h(b, c, d, a, data[(t + 9) & 0x0f] + C3[i + 3], 23);
t += 12;
true
};
}
// round 4
t = 0;
do uint::range_step(0, 16, 4) |i| {
for i in range_step(0u, 16, 4) {
a = op_i(a, b, c, d, data[t & 0x0f] + C4[i], 6);
d = op_i(d, a, b, c, data[(t + 7) & 0x0f] + C4[i + 1], 10);
c = op_i(c, d, a, b, data[(t + 14) & 0x0f] + C4[i + 2], 15);
b = op_i(b, c, d, a, data[(t + 21) & 0x0f] + C4[i + 3], 21);
t += 28;
true
};
}
self.s0 += a;
self.s1 += b;

22
src/libextra/crypto/sha2.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::uint;
use std::iter::range_step;
use cryptoutil::{write_u64_be, write_u32_be, read_u64v_be, read_u32v_be, add_bytes_to_bits,
add_bytes_to_bits_tuple, FixedBuffer, FixedBuffer128, FixedBuffer64, StandardPadding};
@ -111,7 +111,7 @@ impl Engine512State {
// Putting the message schedule inside the same loop as the round calculations allows for
// the compiler to generate better code.
do uint::range_step(0, 64, 8) |t| {
for t in range_step(0u, 64, 8) {
schedule_round!(t + 16);
schedule_round!(t + 17);
schedule_round!(t + 18);
@ -129,10 +129,9 @@ impl Engine512State {
sha2_round!(d, e, f, g, h, a, b, c, K64, t + 5);
sha2_round!(c, d, e, f, g, h, a, b, K64, t + 6);
sha2_round!(b, c, d, e, f, g, h, a, K64, t + 7);
true
};
}
do uint::range_step(64, 80, 8) |t| {
for t in range_step(64u, 80, 8) {
sha2_round!(a, b, c, d, e, f, g, h, K64, t);
sha2_round!(h, a, b, c, d, e, f, g, K64, t + 1);
sha2_round!(g, h, a, b, c, d, e, f, K64, t + 2);
@ -141,8 +140,7 @@ impl Engine512State {
sha2_round!(d, e, f, g, h, a, b, c, K64, t + 5);
sha2_round!(c, d, e, f, g, h, a, b, K64, t + 6);
sha2_round!(b, c, d, e, f, g, h, a, K64, t + 7);
true
};
}
self.H0 += a;
self.H1 += b;
@ -527,7 +525,7 @@ impl Engine256State {
// Putting the message schedule inside the same loop as the round calculations allows for
// the compiler to generate better code.
do uint::range_step(0, 48, 8) |t| {
for t in range_step(0u, 48, 8) {
schedule_round!(t + 16);
schedule_round!(t + 17);
schedule_round!(t + 18);
@ -545,10 +543,9 @@ impl Engine256State {
sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5);
sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6);
sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7);
true
};
}
do uint::range_step(48, 64, 8) |t| {
for t in range_step(48u, 64, 8) {
sha2_round!(a, b, c, d, e, f, g, h, K32, t);
sha2_round!(h, a, b, c, d, e, f, g, K32, t + 1);
sha2_round!(g, h, a, b, c, d, e, f, K32, t + 2);
@ -557,8 +554,7 @@ impl Engine256State {
sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5);
sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6);
sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7);
true
};
}
self.H0 += a;
self.H1 += b;

7
src/libstd/char.rs
View File

@ -12,7 +12,7 @@
use cast::transmute;
use option::{None, Option, Some};
use i32;
use iter::{Iterator, range_step};
use str::StrSlice;
use unicode::{derived_property, general_category, decompose};
use to_str::ToStr;
@ -286,15 +286,14 @@ pub fn escape_unicode(c: char, f: &fn(char)) {
(c <= '\uffff') { f('u'); 4 }
_ { f('U'); 8 }
);
do i32::range_step(4 * (pad - 1), -1, -4) |offset| {
for offset in range_step::<i32>(4 * (pad - 1), -1, -4) {
unsafe {
match ((c as i32) >> offset) & 0xf {
i @ 0 .. 9 => { f(transmute('0' as i32 + i)); }
i => { f(transmute('a' as i32 + (i - 10))); }
}
}
true
};
}
}
///

58
src/libstd/iter.rs
View File

@ -1790,17 +1790,17 @@ pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> R
RangeInclusive{range: range(start, stop), done: false}
}
impl<A: Add<A, A> + Ord + Clone> Iterator<A> for RangeInclusive<A> {
impl<A: Add<A, A> + Eq + Ord + Clone> Iterator<A> for RangeInclusive<A> {
#[inline]
fn next(&mut self) -> Option<A> {
match self.range.next() {
Some(x) => Some(x),
None => {
if self.done {
None
} else {
if !self.done && self.range.state == self.range.stop {
self.done = true;
Some(self.range.stop.clone())
} else {
None
}
}
}
@ -1829,11 +1829,11 @@ impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for RangeInclu
let result = self.range.stop.clone();
self.range.stop = self.range.stop - self.range.one;
Some(result)
} else if self.done {
None
} else {
} else if !self.done && self.range.state == self.range.stop {
self.done = true;
Some(self.range.stop.clone())
} else {
None
}
}
}
@ -1857,7 +1857,7 @@ pub fn range_step<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A, step: A
impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> {
#[inline]
fn next(&mut self) -> Option<A> {
if (self.rev && self.state > self.stop) || self.state < self.stop {
if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
let result = self.state.clone();
match self.state.checked_add(&self.step) {
Some(x) => self.state = x,
@ -1891,22 +1891,14 @@ pub fn range_step_inclusive<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop:
impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> {
#[inline]
fn next(&mut self) -> Option<A> {
if !self.done {
if (self.rev && self.state > self.stop) || self.state < self.stop {
let result = self.state.clone();
match self.state.checked_add(&self.step) {
Some(x) => self.state = x,
None => self.done = true
}
Some(result)
} else {
if self.state == self.stop {
self.done = true;
Some(self.state.clone())
} else {
None
}
if !self.done && ((self.rev && self.state >= self.stop) ||
(!self.rev && self.state <= self.stop)) {
let result = self.state.clone();
match self.state.checked_add(&self.step) {
Some(x) => self.state = x,
None => self.done = true
}
Some(result)
} else {
None
}
@ -2716,24 +2708,44 @@ mod tests {
}
}
#[test]
fn test_range() {
assert_eq!(range(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4]);
assert_eq!(range(0i, 5).invert().collect::<~[int]>(), ~[4, 3, 2, 1, 0]);
assert_eq!(range(200, -5).collect::<~[int]>(), ~[]);
assert_eq!(range(200, -5).invert().collect::<~[int]>(), ~[]);
assert_eq!(range(200, 200).collect::<~[int]>(), ~[]);
assert_eq!(range(200, 200).invert().collect::<~[int]>(), ~[]);
}
#[test]
fn test_range_inclusive() {
assert_eq!(range_inclusive(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4, 5]);
assert_eq!(range_inclusive(0i, 5).invert().collect::<~[int]>(), ~[5i, 4, 3, 2, 1, 0]);
assert_eq!(range_inclusive(200, -5).collect::<~[int]>(), ~[]);
assert_eq!(range_inclusive(200, -5).invert().collect::<~[int]>(), ~[]);
assert_eq!(range_inclusive(200, 200).collect::<~[int]>(), ~[200]);
assert_eq!(range_inclusive(200, 200).invert().collect::<~[int]>(), ~[200]);
}
#[test]
fn test_range_step() {
assert_eq!(range_step(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15]);
assert_eq!(range_step(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5]);
assert_eq!(range_step(20i, 0, -6).collect::<~[int]>(), ~[20, 14, 8, 2]);
assert_eq!(range_step(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]);
assert_eq!(range_step(200, -5, 1).collect::<~[int]>(), ~[]);
assert_eq!(range_step(200, 200, 1).collect::<~[int]>(), ~[]);
}
#[test]
fn test_range_step_inclusive() {
assert_eq!(range_step_inclusive(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15, 20]);
assert_eq!(range_step_inclusive(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5, 0]);
assert_eq!(range_step_inclusive(20i, 0, -6).collect::<~[int]>(), ~[20, 14, 8, 2]);
assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]);
assert_eq!(range_step_inclusive(200, -5, 1).collect::<~[int]>(), ~[]);
assert_eq!(range_step_inclusive(200, 200, 1).collect::<~[int]>(), ~[200]);
}
#[test]

145
src/libstd/num/int_macros.rs
View File

@ -41,101 +41,6 @@ impl CheckedDiv for $T {
}
}
enum Range { Closed, HalfOpen }
#[inline]
///
/// Iterate through a range with a given step value.
///
/// Let `term` denote the closed interval `[stop-step,stop]` if `r` is Closed;
/// otherwise `term` denotes the half-open interval `[stop-step,stop)`.
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_j == start + step*j`, and `x_n` lies in the interval `term`.
///
/// If no such nonnegative integer `n` exists, then the iteration range
/// is empty.
///
fn range_step_core(start: $T, stop: $T, step: $T, r: Range, it: &fn($T) -> bool) -> bool {
let mut i = start;
if step == 0 {
fail!(~"range_step called with step == 0");
} else if step == (1 as $T) { // elide bounds check to tighten loop
while i < stop {
if !it(i) { return false; }
// no need for overflow check;
// cannot have i + 1 > max_value because i < stop <= max_value
i += (1 as $T);
}
} else if step == (-1 as $T) { // elide bounds check to tighten loop
while i > stop {
if !it(i) { return false; }
// no need for underflow check;
// cannot have i - 1 < min_value because i > stop >= min_value
i -= (1 as $T);
}
} else if step > 0 { // ascending
while i < stop {
if !it(i) { return false; }
// avoiding overflow. break if i + step > max_value
if i > max_value - step { return true; }
i += step;
}
} else { // descending
while i > stop {
if !it(i) { return false; }
// avoiding underflow. break if i + step < min_value
if i < min_value - step { return true; }
i += step;
}
}
match r {
HalfOpen => return true,
Closed => return (i != stop || it(i))
}
}
#[inline]
///
/// Iterate through the range [`start`..`stop`) with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// * `x_i == start + step*i`, and
/// * `n` is the greatest nonnegative integer such that `x_n < stop`
///
/// (If no such `n` exists, then the iteration range is empty.)
///
/// # Arguments
///
/// * `start` - lower bound, inclusive
/// * `stop` - higher bound, exclusive
///
/// # Examples
/// ~~~
/// let mut sum = 0;
/// for int::range(1, 5) |i| {
/// sum += i;
/// }
/// assert!(sum == 10);
/// ~~~
///
pub fn range_step(start: $T, stop: $T, step: $T, it: &fn($T) -> bool) -> bool {
range_step_core(start, stop, step, HalfOpen, it)
}
#[inline]
///
/// Iterate through a range with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_i == start + step*i` and `x_n <= last < step + x_n`.
///
/// (If no such nonnegative integer `n` exists, then the iteration
/// range is empty.)
///
pub fn range_step_inclusive(start: $T, last: $T, step: $T, it: &fn($T) -> bool) -> bool {
range_step_core(start, last, step, Closed, it)
}
impl Num for $T {}
#[cfg(not(test))]
@ -878,56 +783,6 @@ mod tests {
assert!(i64::from_str("-9223372036854775809").is_none());
}
#[test]
fn test_ranges() {
let mut l = ~[];
do range_step(20,26,2) |i| {
l.push(i);
true
};
do range_step(36,30,-2) |i| {
l.push(i);
true
};
do range_step(max_value - 2, max_value, 2) |i| {
l.push(i);
true
};
do range_step(max_value - 3, max_value, 2) |i| {
l.push(i);
true
};
do range_step(min_value + 2, min_value, -2) |i| {
l.push(i);
true
};
do range_step(min_value + 3, min_value, -2) |i| {
l.push(i);
true
};
assert_eq!(l, ~[20,22,24,
36,34,32,
max_value-2,
max_value-3,max_value-1,
min_value+2,
min_value+3,min_value+1]);
// None of the `fail`s should execute.
do range_step(10,0,1) |_i| {
fail!(~"unreachable");
};
do range_step(0,10,-1) |_i| {
fail!(~"unreachable");
};
}
#[test]
#[should_fail]
fn test_range_step_zero_step() {
do range_step(0,10,0) |_i| { true };
}
#[test]
fn test_signed_checked_div() {
assert_eq!(10i.checked_div(&2), Some(5));

151
src/libstd/num/uint_macros.rs
View File

@ -42,101 +42,6 @@ impl CheckedDiv for $T {
}
}
enum Range { Closed, HalfOpen }
#[inline]
///
/// Iterate through a range with a given step value.
///
/// Let `term` denote the closed interval `[stop-step,stop]` if `r` is Closed;
/// otherwise `term` denotes the half-open interval `[stop-step,stop)`.
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_j == start + step*j`, and `x_n` lies in the interval `term`.
///
/// If no such nonnegative integer `n` exists, then the iteration range
/// is empty.
///
fn range_step_core(start: $T, stop: $T, step: $T_SIGNED, r: Range, it: &fn($T) -> bool) -> bool {
let mut i = start;
if step == 0 {
fail!("range_step called with step == 0");
} else if step == (1 as $T_SIGNED) { // elide bounds check to tighten loop
while i < stop {
if !it(i) { return false; }
// no need for overflow check;
// cannot have i + 1 > max_value because i < stop <= max_value
i += (1 as $T);
}
} else if step == (-1 as $T_SIGNED) { // elide bounds check to tighten loop
while i > stop {
if !it(i) { return false; }
// no need for underflow check;
// cannot have i - 1 < min_value because i > stop >= min_value
i -= (1 as $T);
}
} else if step > 0 { // ascending
while i < stop {
if !it(i) { return false; }
// avoiding overflow. break if i + step > max_value
if i > max_value - (step as $T) { return true; }
i += step as $T;
}
} else { // descending
while i > stop {
if !it(i) { return false; }
// avoiding underflow. break if i + step < min_value
if i < min_value + ((-step) as $T) { return true; }
i -= -step as $T;
}
}
match r {
HalfOpen => return true,
Closed => return (i != stop || it(i))
}
}
#[inline]
///
/// Iterate through the range [`start`..`stop`) with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// - `x_i == start + step*i`, and
/// - `n` is the greatest nonnegative integer such that `x_n < stop`
///
/// (If no such `n` exists, then the iteration range is empty.)
///
/// # Arguments
///
/// * `start` - lower bound, inclusive
/// * `stop` - higher bound, exclusive
///
/// # Examples
/// ~~~ {.rust}
/// let nums = [1,2,3,4,5,6,7];
///
/// for uint::range_step(0, nums.len() - 1, 2) |i| {
/// printfln!("%d & %d", nums[i], nums[i+1]);
/// }
/// ~~~
///
pub fn range_step(start: $T, stop: $T, step: $T_SIGNED, it: &fn($T) -> bool) -> bool {
range_step_core(start, stop, step, HalfOpen, it)
}
#[inline]
///
/// Iterate through a range with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_i == start + step*i` and `x_n <= last < step + x_n`.
///
/// (If no such nonnegative integer `n` exists, then the iteration
/// range is empty.)
///
pub fn range_step_inclusive(start: $T, last: $T, step: $T_SIGNED, it: &fn($T) -> bool) -> bool {
range_step_core(start, last, step, Closed, it)
}
impl Num for $T {}
#[cfg(not(test))]
@ -653,62 +558,6 @@ mod tests {
100u.to_str_radix(37u);
}
#[test]
pub fn test_ranges() {
let mut l = ~[];
do range_step(20,26,2) |i| {
l.push(i);
true
};
do range_step(36,30,-2) |i| {
l.push(i);
true
};
do range_step(max_value - 2, max_value, 2) |i| {
l.push(i);
true
};
do range_step(max_value - 3, max_value, 2) |i| {
l.push(i);
true
};
do range_step(min_value + 2, min_value, -2) |i| {
l.push(i);
true
};
do range_step(min_value + 3, min_value, -2) |i| {
l.push(i);
true
};
assert_eq!(l, ~[20,22,24,
36,34,32,
max_value-2,
max_value-3,max_value-1,
min_value+2,
min_value+3,min_value+1]);
// None of the `fail`s should execute.
do range_step(10,0,1) |_i| {
fail!("unreachable");
};
do range_step(0,1,-10) |_i| {
fail!("unreachable");
};
}
#[test]
#[should_fail]
fn test_range_step_zero_step_up() {
do range_step(0,10,0) |_i| { true };
}
#[test]
#[should_fail]
fn test_range_step_zero_step_down() {
do range_step(0,-10,0) |_i| { true };
}
#[test]
fn test_unsigned_checked_div() {
assert_eq!(10u.checked_div(&2), Some(5));

4
src/libstd/os.rs
View File

@ -1895,8 +1895,8 @@ mod tests {
setenv("USERPROFILE", "/home/PaloAlto");
assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
oldhome.iter().advance(|s| { setenv("HOME", *s); true });
olduserprofile.iter().advance(|s| { setenv("USERPROFILE", *s); true });
for s in oldhome.iter() { setenv("HOME", *s) }
for s in olduserprofile.iter() { setenv("USERPROFILE", *s) }
}
#[test]

27
src/libstd/rand.rs
View File

@ -48,7 +48,7 @@ use clone::Clone;
use cmp;
use container::Container;
use int;
use iter::{Iterator, range};
use iter::{Iterator, range, range_step};
use local_data;
use num;
use prelude::*;
@ -748,7 +748,7 @@ impl IsaacRng {
if use_rsl {
macro_rules! memloop (
($arr:expr) => {{
do u32::range_step(0, RAND_SIZE, 8) |i| {
for i in range_step(0u32, RAND_SIZE, 8) {
a+=$arr[i ]; b+=$arr[i+1];
c+=$arr[i+2]; d+=$arr[i+3];
e+=$arr[i+4]; f+=$arr[i+5];
@ -758,22 +758,20 @@ impl IsaacRng {
self.mem[i+2]=c; self.mem[i+3]=d;
self.mem[i+4]=e; self.mem[i+5]=f;
self.mem[i+6]=g; self.mem[i+7]=h;
true
};
}
}}
);
memloop!(self.rsl);
memloop!(self.mem);
} else {
do u32::range_step(0, RAND_SIZE, 8) |i| {
for i in range_step(0u32, RAND_SIZE, 8) {
mix!();
self.mem[i ]=a; self.mem[i+1]=b;
self.mem[i+2]=c; self.mem[i+3]=d;
self.mem[i+4]=e; self.mem[i+5]=f;
self.mem[i+6]=g; self.mem[i+7]=h;
true
};
}
}
self.isaac();
@ -794,7 +792,7 @@ impl IsaacRng {
});
macro_rules! rngstep(
($j:expr, $shift:expr) => {{
let base = base + $j;
let base = $j;
let mix = if $shift < 0 {
a >> -$shift as uint
} else {
@ -813,13 +811,12 @@ impl IsaacRng {
let r = [(0, MIDPOINT), (MIDPOINT, 0)];
for &(mr_offset, m2_offset) in r.iter() {
do uint::range_step(0, MIDPOINT, 4) |base| {
rngstep!(0, 13);
rngstep!(1, -6);
rngstep!(2, 2);
rngstep!(3, -16);
true
};
for i in range_step(0u, MIDPOINT, 4) {
rngstep!(i + 0, 13);
rngstep!(i + 1, -6);
rngstep!(i + 2, 2);
rngstep!(i + 3, -16);
}
}
self.a = a;

28
src/libstd/trie.rs
View File

@ -520,6 +520,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
mod test_map {
use super::*;
use prelude::*;
use iter::range_step;
use uint;
#[test]
@ -538,21 +539,19 @@ mod test_map {
#[test]
fn test_step() {
let mut trie = TrieMap::new();
let n = 300;
let n = 300u;
do uint::range_step(1, n, 2) |x| {
for x in range_step(1u, n, 2) {
assert!(trie.insert(x, x + 1));
assert!(trie.contains_key(&x));
check_integrity(&trie.root);
true
};
}
do uint::range_step(0, n, 2) |x| {
for x in range_step(0u, n, 2) {
assert!(!trie.contains_key(&x));
assert!(trie.insert(x, x + 1));
check_integrity(&trie.root);
true
};
}
for x in range(0u, n) {
assert!(trie.contains_key(&x));
@ -560,19 +559,17 @@ mod test_map {
check_integrity(&trie.root);
}
do uint::range_step(1, n, 2) |x| {
for x in range_step(1u, n, 2) {
assert!(trie.remove(&x));
assert!(!trie.contains_key(&x));
check_integrity(&trie.root);
true
};
}
do uint::range_step(0, n, 2) |x| {
for x in range_step(0u, n, 2) {
assert!(trie.contains_key(&x));
assert!(!trie.insert(x, x + 1));
check_integrity(&trie.root);
true
};
}
}
#[test]
@ -715,11 +712,10 @@ mod test_map {
let value = 42u;
let mut map : TrieMap<uint> = TrieMap::new();
do uint::range_step(0u, last, step as int) |x| {
for x in range_step(0u, last, step) {
assert!(x % step == 0);
map.insert(x, value);
true
};
}
for i in range(0u, last - step) {
let mut lb = map.lower_bound_iter(i);

126
src/test/run-pass/num-range-rev.rs
View File

@ -1,126 +0,0 @@
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::int;
use std::uint;
fn uint_range(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
range(lo, hi).advance(it)
}
fn int_range(lo: int, hi: int, it: &fn(int) -> bool) -> bool {
range(lo, hi).advance(it)
}
fn uint_range_rev(hi: uint, lo: uint, it: &fn(uint) -> bool) -> bool {
range(lo, hi).invert().advance(it)
}
fn int_range_rev(hi: int, lo: int, it: &fn(int) -> bool) -> bool {
range(lo, hi).invert().advance(it)
}
fn int_range_step(a: int, b: int, step: int, it: &fn(int) -> bool) -> bool {
int::range_step(a, b, step, it)
}
fn uint_range_step(a: uint, b: uint, step: int, it: &fn(uint) -> bool) -> bool {
uint::range_step(a, b, step, it)
}
pub fn main() {
// int and uint have same result for
// Sum{100 > i >= 2} == (Sum{1 <= i <= 99} - 1) == n*(n+1)/2 - 1 for n=99
let mut sum = 0u;
do uint_range_rev(100, 2) |i| {
sum += i;
true
};
assert_eq!(sum, 4949);
let mut sum = 0i;
do int_range_rev(100, 2) |i| {
sum += i;
true
};
assert_eq!(sum, 4949);
// elements are visited in correct order
let primes = [2,3,5,7,11];
let mut prod = 1i;
do uint_range_rev(5, 0) |i| {
printfln!("uint 4 downto 0: %u", i);
prod *= int::pow(primes[i], i);
true
};
assert_eq!(prod, 11*11*11*11*7*7*7*5*5*3*1);
let mut prod = 1i;
do int_range_rev(5, 0) |i| {
printfln!("int 4 downto 0: %d", i);
prod *= int::pow(primes[i], i as uint);
true
};
assert_eq!(prod, 11*11*11*11*7*7*7*5*5*3*1);
// range and range_rev are symmetric.
let mut sum_up = 0u;
do uint_range(10, 30) |i| {
sum_up += i;
true
};
let mut sum_down = 0u;
do uint_range_rev(30, 10) |i| {
sum_down += i;
true
};
assert_eq!(sum_up, sum_down);
let mut sum_up = 0;
do int_range(-20, 10) |i| {
sum_up += i;
true
};
let mut sum_down = 0;
do int_range_rev(10, -20) |i| {
sum_down += i;
true
};
assert_eq!(sum_up, sum_down);
// empty ranges
do int_range_rev(10, 10) |_| {
fail!("range should be empty when start == stop");
true
};
do uint_range_rev(0, 1) |_| {
fail!("range should be empty when start-1 underflows");
true
};
// range iterations do not wrap/underflow
let mut uflo_loop_visited = ~[];
do int_range_step(int::min_value+15, int::min_value, -4) |x| {
uflo_loop_visited.push(x - int::min_value);
true
};
assert_eq!(uflo_loop_visited, ~[15, 11, 7, 3]);
let mut uflo_loop_visited = ~[];
do uint_range_step(uint::min_value+15, uint::min_value, -4) |x| {
uflo_loop_visited.push(x - uint::min_value);
true
};
assert_eq!(uflo_loop_visited, ~[15, 11, 7, 3]);
}

132
src/test/run-pass/num-range.rs
View File

@ -1,132 +0,0 @@
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::int;
use std::uint;
fn uint_range(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
range(lo, hi).advance(it)
}
fn int_range(lo: int, hi: int, it: &fn(int) -> bool) -> bool {
range(lo, hi).advance(it)
}
fn int_range_step(a: int, b: int, step: int, it: &fn(int) -> bool) -> bool {
int::range_step(a, b, step, it)
}
fn uint_range_step(a: uint, b: uint, s: int, it: &fn(uint) -> bool) -> bool {
uint::range_step(a, b, s, it)
}
pub fn main() {
println("num-range start");
// int and uint have same result for
// Sum{2 <= i < 100} == (Sum{1 <= i <= 99} - 1) == n*(n+1)/2 - 1 for n=99
let mut sum = 0u;
do uint_range(2, 100) |i| {
sum += i;
true
};
assert_eq!(sum, 4949);
let mut sum = 0i;
do int_range(2, 100) |i| {
sum += i;
true
};
assert_eq!(sum, 4949);
// elements are visited in correct order
let primes = [2,3,5,7];
let mut prod = 1i;
do uint_range(0, 4) |i| {
prod *= int::pow(primes[i], i);
true
};
assert_eq!(prod, 1*3*5*5*7*7*7);
let mut prod = 1i;
do int_range(0, 4) |i| {
prod *= int::pow(primes[i], i as uint);
true
};
assert_eq!(prod, 1*3*5*5*7*7*7);
// empty ranges
do int_range(10, 10) |_| {
fail!("range should be empty when start == stop");
true
};
do uint_range(10, 10) |_| {
fail!("range should be empty when start == stop");
true
};
// range iterations do not wrap/overflow
let mut oflo_loop_visited = ~[];
do uint_range_step(uint::max_value-15, uint::max_value, 4) |x| {
oflo_loop_visited.push(uint::max_value - x);
true
};
assert_eq!(oflo_loop_visited, ~[15, 11, 7, 3]);
let mut oflo_loop_visited = ~[];
do int_range_step(int::max_value-15, int::max_value, 4) |x| {
oflo_loop_visited.push(int::max_value - x);
true
};
assert_eq!(oflo_loop_visited, ~[15, 11, 7, 3]);
// range_step never passes nor visits the stop element
do int_range_step(0, 21, 3) |x| {
assert!(x < 21);
true
};
// range_step_inclusive will never pass stop element, and may skip it.
let mut saw21 = false;
do uint::range_step_inclusive(0, 21, 4) |x| {
assert!(x <= 21);
if x == 21 { saw21 = true; }
true
};
assert!(!saw21);
let mut saw21 = false;
do int::range_step_inclusive(0, 21, 4) |x| {
assert!(x <= 21);
if x == 21 { saw21 = true; }
true
};
assert!(!saw21);
// range_step_inclusive will never pass stop element, but may visit it.
let mut saw21 = false;
do uint::range_step_inclusive(0, 21, 3) |x| {
assert!(x <= 21);
printfln!("saw: %u", x);
if x == 21 { saw21 = true; }
true
};
assert!(saw21);
let mut saw21 = false;
do int::range_step_inclusive(0, 21, 3) |x| {
assert!(x <= 21);
if x == 21 { saw21 = true; }
true
};
assert!(saw21);
}