int-interval-set 0.2.0

Integer half-open interval set structures built on top of int-interval.
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

// -----------------------------------------------------------------------------
// This file is generated by `cargo run -p codegen -- --unsigned`.
// Do not edit manually.
// -----------------------------------------------------------------------------

use crate::u128::tests::{
    set::test_support::build,
    test_support::{MID_VALUE, build_from_vec, interval_pair, iv},
};

#[test]
fn search_point_returns_none_on_empty_set() {
    let set = build([]);

    assert_eq!(set.interval_containing_point(u128::MIN), None);
    assert_eq!(set.interval_containing_point(MID_VALUE), None);
    assert_eq!(set.interval_containing_point(u128::MAX), None);
}

#[test]
fn search_point_respects_half_open_bounds() {
    let set = build([(10, 20)]);

    assert_eq!(set.interval_containing_point(9), None);
    assert_eq!(set.interval_containing_point(10), Some(iv(10, 20)));
    assert_eq!(set.interval_containing_point(19), Some(iv(10, 20)));
    assert_eq!(set.interval_containing_point(20), None);
}

#[test]
fn search_point_returns_matching_interval_across_multiple_intervals() {
    let set = build([(10, 20), (30, 40), (50, 60)]);

    assert_eq!(set.interval_containing_point(10), Some(iv(10, 20)));
    assert_eq!(set.interval_containing_point(35), Some(iv(30, 40)));
    assert_eq!(set.interval_containing_point(59), Some(iv(50, 60)));

    assert_eq!(set.interval_containing_point(0), None);
    assert_eq!(set.interval_containing_point(20), None);
    assert_eq!(set.interval_containing_point(45), None);
    assert_eq!(set.interval_containing_point(u128::MAX), None);
}

#[test]
fn search_point_returns_merged_interval_after_canonicalization() {
    let set = build([(0, 5), (5, 10), (12, 20), (18, 30)]);

    assert_eq!(set.as_slice(), &[iv(0, 10), iv(12, 30)]);

    assert_eq!(set.interval_containing_point(0), Some(iv(0, 10)));
    assert_eq!(set.interval_containing_point(9), Some(iv(0, 10)));
    assert_eq!(set.interval_containing_point(10), None);
    assert_eq!(set.interval_containing_point(11), None);
    assert_eq!(set.interval_containing_point(12), Some(iv(12, 30)));
    assert_eq!(set.interval_containing_point(29), Some(iv(12, 30)));
    assert_eq!(set.interval_containing_point(30), None);
}

#[test]
fn search_point_handles_domain_edges() {
    let set = build([(u128::MIN, u128::MIN + 1), (u128::MAX - 1, u128::MAX)]);

    assert_eq!(
        set.interval_containing_point(u128::MIN),
        Some(iv(u128::MIN, u128::MIN + 1))
    );
    assert_eq!(set.interval_containing_point(u128::MIN + 1), None);

    assert_eq!(
        set.interval_containing_point(u128::MAX - 1),
        Some(iv(u128::MAX - 1, u128::MAX))
    );
    assert_eq!(set.interval_containing_point(u128::MAX), None);
}

#[test]
fn search_point_matches_contains_point_predicate() {
    let set = build([(10, 20), (30, 40), (50, 60)]);

    for x in [u128::MIN, 9, 10, 19, 20, 30, 39, 40, 55, 60, u128::MAX] {
        assert_eq!(
            set.interval_containing_point(x).is_some(),
            set.contains_point(x),
            "point = {x}"
        );
    }
}

use proptest::prelude::*;

proptest! {
    #[test]
    fn prop_interval_containing_point_matches_slice_find(
        xs in prop::collection::vec(interval_pair(), 0..64),
        x in any::<u128>(),
    ) {
        let set = build_from_vec(xs);

        let got = set.interval_containing_point(x);

        let expected = set
            .as_slice()
            .iter()
            .copied()
            .find(|iv| iv.contains(x));

        prop_assert_eq!(got, expected);
    }

    #[test]
    fn prop_interval_containing_point_matches_contains_point(
        xs in prop::collection::vec(interval_pair(), 0..64),
        x in any::<u128>(),
    ) {
        let set = build_from_vec(xs);

        prop_assert_eq!(
            set.interval_containing_point(x).is_some(),
            set.contains_point(x)
        );
    }
}