arranged 0.1.2

Statically bounds-checked (machine-word-abstracting? TBD) ranged types as zero or low-runtime overhead abstractions providing safe (no unintentional overflow) arithmetic.
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

use arith_traits::{IMinMax, IWrappingOps};
use assert2::assert;

use crate::{Ranged, RiI8};

#[test]
fn subtracting_non_wrapping_ranged_values_of_same_type_yields_expected_difference() {
    // Given
    type OneToOneHundred = RiI8<1, 100>;
    let sut = Ranged::<OneToOneHundred>::from(43);
    let b = Ranged::<OneToOneHundred>::from(1);
    let expected = Ranged::<OneToOneHundred>::from(42);

    // When
    let result = sut.wrapping_sub(b);

    // Then
    assert!(result == expected);
}

#[test]
fn subtracting_non_wrapping_ranged_values_of_different_types_yields_expected_difference() {
    // Given
    type TwoToOneHundredAndOne = RiI8<2, 101>;
    type ZeroToNine = RiI8<0, 9>;
    let sut = Ranged::<TwoToOneHundredAndOne>::from(43);
    let b = Ranged::<ZeroToNine>::from(1);
    let expected = Ranged::<TwoToOneHundredAndOne>::from(42);

    // When
    let result = sut.wrapping_sub(b);

    // Then
    assert!(result == expected);
}

#[test]
fn subtracting_wrapping_ranged_values_of_same_type_yields_expected_difference() {
    // Given
    type ThirteenToNinetySeven = RiI8<13, 97>;
    let sut = Ranged::<ThirteenToNinetySeven>::from(ThirteenToNinetySeven::MIN);
    let b = Ranged::<ThirteenToNinetySeven>::from(ThirteenToNinetySeven::MAX);
    let expected = Ranged::<ThirteenToNinetySeven>::from(86);

    // When
    let result = sut.wrapping_sub(b);

    // Then
    assert!(result == expected);
}

#[test]
fn subtracting_wrapping_ranged_values_of_different_types_yields_expected_difference() {
    // Given
    type ThirteenToNinetySeven = RiI8<13, 97>;
    type ThreeToThree = RiI8<3, 3>;
    let sut = Ranged::<ThirteenToNinetySeven>::from(ThirteenToNinetySeven::MIN);
    let b = Ranged::<ThreeToThree>::from(3);
    let expected = Ranged::<ThirteenToNinetySeven>::from(ThirteenToNinetySeven::MAX - 2);

    // When
    let result = sut.wrapping_sub(b);

    // Then
    assert!(result == expected);
}

#[test]
fn subtracting_wrapping_negative_ranged_values_of_different_types_yields_expected_difference() {
    // Given
    type NegativeNinetySevenToNegativeThirteen = RiI8<-97, -13>;
    type NegativeTenToThree = RiI8<-10, 3>;
    let sut = Ranged::<NegativeNinetySevenToNegativeThirteen>::from(NegativeNinetySevenToNegativeThirteen::MAX);
    let b = Ranged::<NegativeTenToThree>::from(-1);
    let expected = Ranged::<NegativeNinetySevenToNegativeThirteen>::from(NegativeNinetySevenToNegativeThirteen::MIN);

    // When
    let result = sut.wrapping_sub(b);

    // Then
    assert!(result == expected);
}