rsbx 2.0.0

Enhanced implementation of SeqBox in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#![cfg(test)]
use integer_utils::IntegerUtils;

#[test]
fn test_round_down_to_multiple_simple_cases() {
    assert_eq!(9, usize::round_down_to_multiple(11, 3));
    assert_eq!(21, usize::round_down_to_multiple(21, 7));
    assert_eq!(100, usize::round_down_to_multiple(100, 10));
    assert_eq!(16, usize::round_down_to_multiple(17, 16));
    assert_eq!(4, usize::round_down_to_multiple(4, 4));
    assert_eq!(77, usize::round_down_to_multiple(77, 77));
    assert_eq!(22, usize::round_down_to_multiple(22, 11));
    assert_eq!(8, usize::round_down_to_multiple(8, 4));
    assert_eq!(16, usize::round_down_to_multiple(16, 4));
}

#[test]
fn test_round_up_to_multiple_simple_cases() {
    assert_eq!(12, usize::round_up_to_multiple(11, 3));
    assert_eq!(21, usize::round_up_to_multiple(21, 7));
    assert_eq!(100, usize::round_up_to_multiple(100, 10));
    assert_eq!(32, usize::round_up_to_multiple(17, 16));
    assert_eq!(4, usize::round_up_to_multiple(4, 4));
    assert_eq!(77, usize::round_up_to_multiple(77, 77));
    assert_eq!(22, usize::round_up_to_multiple(22, 11));
    assert_eq!(8, usize::round_up_to_multiple(8, 4));
    assert_eq!(16, usize::round_up_to_multiple(16, 4));
}

quickcheck! {
    fn qc_round_down_to_multiple(val         : usize,
                                 multiple_of : usize) -> bool {
        let multiple_of = if multiple_of == 0 { 1 } else { multiple_of };

        let res = usize::round_down_to_multiple(val, multiple_of);

        res <= val
            && ((val > 0 && ((val % multiple_of == 0 && res == val)
                             || (val % multiple_of != 0 && res <  val)))
                || val == 0)
            && usize::round_down_to_multiple(val, multiple_of) % multiple_of == 0
    }

    fn qc_round_up_to_multiple(val         : usize,
                               multiple_of : usize) -> bool {
        let multiple_of = if multiple_of == 0 { 1 } else { multiple_of };

        let res = usize::round_up_to_multiple(val, multiple_of);

        res >= val
            && ((val > 0 && ((val % multiple_of == 0 && res == val)
                             || (val % multiple_of != 0 && res >  val)))
                || val == 0)
            && usize::round_up_to_multiple(val, multiple_of) % multiple_of == 0
    }

    fn qc_ensure_at_least(val      : usize,
                          at_least : usize) -> bool {
        usize::ensure_at_least(val, at_least) >= at_least
    }

    fn qc_ensure_at_most(val     : usize,
                         at_most : usize) -> bool {
        usize::ensure_at_most(val, at_most) <= at_most
    }
}