int-interval 0.9.0

A small, no_std half-open interval algebra library for primitive integer types.
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
128
129
130

// -----------------------------------------------------------------------------
// @generated by xtask/codegen (unsigned)
// DO NOT EDIT MANUALLY.
// Changes will be overwritten.
// -----------------------------------------------------------------------------

use super::*;

mod about_midpoint {
    use super::*;

    mod unit_tests {
        use super::*;

        fn span(lo: u32, hi: u32) -> U32CO {
            U32CO::try_new(lo, hi).unwrap()
        }

        #[test]
        fn midpoint_basic() {
            let iv = span(10, 20);
            assert_eq!(iv.midpoint(), 15);

            let iv2 = span(0, 2);
            assert_eq!(iv2.midpoint(), 1);

            let iv3 = span(0, u32::MAX);
            assert_eq!(iv3.midpoint(), (0 + ((u32::MAX - 0) / 2)));
        }

        #[test]
        fn checked_from_midpoint_len_basic() {
            let mid = 10;
            let len = 5;
            let iv = U32CO::checked_from_midpoint_len(mid, len).unwrap();
            assert_eq!(iv.len(), len);
            assert_eq!(iv.midpoint(), mid);

            // len=0 returns None
            assert!(U32CO::checked_from_midpoint_len(mid, 0).is_none());

            // overflow start returns None
            assert!(U32CO::checked_from_midpoint_len(0, 5).is_none());

            // overflow end returns None
            assert!(U32CO::checked_from_midpoint_len(u32::MAX, 10).is_none());
        }

        #[test]
        fn saturating_from_midpoint_len_basic() {
            let mid = 10;
            let len = 5;
            let iv = U32CO::saturating_from_midpoint_len(mid, len).unwrap();
            assert_eq!(iv.len(), len);
            assert_eq!(iv.midpoint(), mid);

            // len=0 returns None
            assert!(U32CO::saturating_from_midpoint_len(mid, 0).is_none());

            // saturating start
            let iv2 = U32CO::saturating_from_midpoint_len(0, 5).unwrap();
            assert_eq!(iv2.start(), 0);
            assert_eq!(iv2.len(), 5);

            // saturating end
            let iv3 = U32CO::saturating_from_midpoint_len(u32::MAX, 10).unwrap();
            assert!(iv3.end_excl() <= u32::MAX);
        }
    }

    mod prop_tests {
        use std::{vec, vec::Vec};

        use super::*;
        use proptest::prelude::*;

        fn edge_values() -> Vec<u32> {
            let mut v = vec![u32::MIN, u32::MAX, 0, 1];
            if u32::MIN < u32::MAX {
                v.push(u32::MIN.saturating_add(1));
                v.push(u32::MAX.saturating_sub(1));
            }
            v.sort_unstable();
            v.dedup();
            v
        }

        fn edge_scalar() -> impl Strategy<Value = u32> {
            prop::sample::select(edge_values())
        }

        fn mixed_scalar() -> impl Strategy<Value = u32> {
            prop_oneof! {
                3 => edge_scalar(),
                7 => any::<u32>(),
            }
        }

        proptest! {
            #[test]
            fn midpoint_rounds_down(x in mixed_scalar(), y in mixed_scalar()) {
                let lo = x.min(y);
                let hi = x.max(y).saturating_add(1); // ensure non-empty
                if let Some(iv) = U32CO::try_new(lo, hi) {
                    let mp = iv.midpoint();
                    // midpoint in interval and closer to start
                    prop_assert!(mp >= iv.start() && mp <= iv.end_incl());
                    prop_assert_eq!(mp, iv.start() + (iv.len() / 2));
                }
            }

            #[test]
            fn checked_from_midpoint_len_inverse(mid in mixed_scalar(), len in 1u32..20) {
                if let Some(iv) = U32CO::checked_from_midpoint_len(mid, len) {
                    prop_assert_eq!(iv.len(), len);
                    prop_assert_eq!(iv.midpoint(), mid);
                }
            }

            #[test]
            fn saturating_from_midpoint_len_safety(mid in mixed_scalar(), len in 1u32..20) {
                if let Some(iv) = U32CO::saturating_from_midpoint_len(mid, len) {
                    // start < end_excl invariant
                    prop_assert!(iv.start() < iv.end_excl());
                    prop_assert_eq!(iv.midpoint(), iv.start() + (iv.len()/2));
                }
            }
        }
    }
}