rich_range 0.1.0

Range calculation helper.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use rich_range::*;
use test_panic::prelude::*;

const I8_OVF: usize = i8::MAX as usize + 1;
const U8_OVF: usize = u8::MAX as usize + 1;

#[test]
fn forward() {
    let datas = [
        (42_u8, 1, ok(43)),
        (u8::MIN, 1, ok(u8::MIN + 1)),
        (u8::MAX, 1, ng()),
    ];

    for (target, count, tobe) in datas {
        let asis = test_panic(|| Step::forward(target, count));
        assert_eqa!(asis, tobe);
    }
}

#[test]
fn backward() {
    let datas = [
        (42_u8, 1, ok(41)),
        (u8::MIN, 1, ng()),
        (u8::MAX, 1, ok(u8::MAX - 1)),
    ];

    for (target, count, tobe) in datas {
        let asis = test_panic(|| Step::backward(target, count));
        assert_eqa!(asis, tobe);
    }
}

#[test]
fn steps_between() {
    with_normal();
    with_large_type();

    fn with_normal() {
        let datas = [(30, 60, (30, Some(30))), (60, 30, (0, Some(0)))];

        for (start, end, tobe) in datas {
            let asis = Step::steps_between(&start, &end);
            assert_eq!(asis, tobe);
        }
    }

    fn with_large_type() {
        if size_of::<i128>() <= size_of::<usize>() {
            return;
        }

        let result = Step::steps_between(&i128::MIN, &i128::MAX);
        assert_eq!(result, (usize::MAX, None));
    }
}

#[test]
fn forward_checked() {
    with_unsinged();
    with_singed();

    fn with_unsinged() {
        let datas = [
            (0, U8_OVF, None),
            (42_u8, 1, Some(43)),
            (u8::MIN, 1, Some(u8::MIN + 1)),
            (u8::MAX, 1, None),
        ];

        for (target, count, tobe) in datas {
            let asis = Step::forward_checked(target, count);
            assert_eq!(asis, tobe);
        }
    }

    fn with_singed() {
        let datas = [
            (0, U8_OVF, None),
            (-1_i8, I8_OVF, Some((-1 + I8_OVF as isize) as i8)),
            (-42_i8, 1, Some(-41)),
            (i8::MIN, 1, Some(i8::MIN + 1)),
            (i8::MAX, 1, None),
        ];

        for (target, count, tobe) in datas {
            let asis = Step::forward_checked(target, count);
            assert_eq!(asis, tobe);
        }
    }
}

#[test]
fn backward_checked() {
    with_unsinged();
    with_singed();

    fn with_unsinged() {
        let datas = [
            (0, U8_OVF, None),
            (42_u8, 1, Some(41)),
            (u8::MIN, 1, None),
            (u8::MAX, 1, Some(u8::MAX - 1)),
        ];

        for (target, count, tobe) in datas {
            let asis = Step::backward_checked(target, count);
            assert_eq!(asis, tobe);
        }
    }

    fn with_singed() {
        let datas = [
            (0, U8_OVF, None),
            (1_i8, I8_OVF, Some((1 - I8_OVF as isize) as i8)),
            (42_i8, 1, Some(41)),
            (i8::MIN, 1, None),
            (i8::MAX, 1, Some(i8::MAX - 1)),
        ];

        for (target, count, tobe) in datas {
            let asis = Step::backward_checked(target, count);
            assert_eq!(asis, tobe);
        }
    }
}