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

// -----------------------------------------------------------------------------
// 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 basic_empty_set_has_empty_shape() {
    let set = build([]);

    assert!(set.is_empty());
    assert_eq!(set.interval_count(), 0);
    assert_eq!(set.as_slice(), &[]);
    assert_eq!(set.iter_intervals().collect::<Vec<_>>(), Vec::new());
}

#[test]
fn basic_interval_count_counts_canonical_intervals() {
    let set = build([(0, 5), (5, 10), (20, 30), (40, 50)]);

    assert_eq!(set.interval_count(), 3);
    assert_eq!(set.as_slice(), &[iv(0, 10), iv(20, 30), iv(40, 50)]);
}

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

    assert_eq!(set.as_slice(), &[iv(0, 20), iv(30, 40), iv(50, 60)]);
}

#[test]
fn basic_iter_intervals_yields_canonical_intervals_in_order() {
    let set = build([(10, 20), (0, 5), (5, 8), (30, 40)]);

    let got = set.iter_intervals().collect::<Vec<_>>();

    assert_eq!(got, vec![iv(0, 8), iv(10, 20), iv(30, 40)]);
}

#[test]
fn basic_clone_preserves_logical_content() {
    let set = build([(0, 10), (20, 30)]);
    let cloned = set.clone();

    assert_eq!(cloned.as_slice(), set.as_slice());
    assert_eq!(cloned.interval_count(), set.interval_count());
    assert_eq!(cloned.is_empty(), set.is_empty());
}

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

    assert_eq!(set.interval_count(), 4);
    assert_eq!(
        set.as_slice(),
        &[
            iv(u128::MIN, u128::MIN + 1),
            iv(u128::MIN + 2, u128::MIN + 3),
            iv(MID_VALUE, MID_VALUE + 1),
            iv(u128::MAX - 1, u128::MAX),
        ]
    );
}

#[test]
fn basic_is_empty_is_false_after_any_interval() {
    let set = build([(100, 101)]);

    assert!(!set.is_empty());
    assert_eq!(set.interval_count(), 1);
    assert_eq!(set.as_slice(), &[iv(100, 101)]);
}

use proptest::prelude::*;

proptest! {
    #[test]
    fn prop_basic_accessors_are_consistent(
        xs in prop::collection::vec(interval_pair(), 0..64)
    ) {
        let set = build_from_vec(xs);

        let slice = set.as_slice();
        let iterated = set.iter_intervals().collect::<Vec<_>>();

        prop_assert_eq!(iterated.as_slice(), slice);
        prop_assert_eq!(set.interval_count() as usize, slice.len());
        prop_assert_eq!(set.is_empty(), slice.is_empty());
    }

    #[test]
    fn prop_basic_clone_preserves_accessors(
        xs in prop::collection::vec(interval_pair(), 0..64)
    ) {
        let set = build_from_vec(xs);
        let cloned = set.clone();

        prop_assert_eq!(cloned.as_slice(), set.as_slice());
        prop_assert_eq!(
            cloned.iter_intervals().collect::<Vec<_>>(),
            set.iter_intervals().collect::<Vec<_>>()
        );
        prop_assert_eq!(cloned.interval_count(), set.interval_count());
        prop_assert_eq!(cloned.is_empty(), set.is_empty());
    }
}