range-collections 0.1.0

Sets and maps of ranges, backed by smallvec
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

use std::collections::BTreeSet;
use std::fmt::Debug;

///
/// A support trait for testing any kind of collection.
///
/// Almost anything can be viewed as a collection. E.g. an integer can be viewed as a collection of bit offsets at which it has
/// a boolean value.
///
pub trait TestSamples<K, V> {
    /// produces "interesting" sample points to test a property for.
    fn samples(&self, res: &mut BTreeSet<K>);

    /// gets the value of the collection at position k
    fn at(&self, k: K) -> V;
}

pub fn unary_element_test<C, K, V>(a: &C, r: C, op: impl Fn(V) -> V) -> bool
where
    C: TestSamples<K, V> + Debug + Clone,
    K: Ord + Clone + Debug,
    V: Eq + Debug,
{
    let mut s: BTreeSet<K> = BTreeSet::new();
    a.samples(&mut s);
    r.samples(&mut s);
    s.into_iter().all(|key| {
        let value = a.at(key.clone());
        let actual = op(value);
        let expected = r.at(key.clone());
        if expected != actual {
            println!(
                "expected!=actual at: {:?}. {:?}!={:?}",
                key, expected, actual
            );
            println!("a: {:?}", a);
            println!("r: {:?}", r);
            false
        } else {
            true
        }
    })
}

pub fn binary_element_test<C, K, V>(a: &C, b: &C, r: C, op: impl Fn(V, V) -> V) -> bool
where
    C: TestSamples<K, V> + Debug,
    K: Ord + Clone + Debug,
    V: Eq + Debug,
{
    let mut s: BTreeSet<K> = BTreeSet::new();
    a.samples(&mut s);
    b.samples(&mut s);
    r.samples(&mut s);
    s.into_iter().all(|key| {
        let a_value = a.at(key.clone());
        let b_value = b.at(key.clone());
        let actual = op(a_value, b_value);
        let expected = r.at(key.clone());
        if expected != actual {
            println!(
                "expected!=actual at: {:?}. {:?}!={:?}",
                key, expected, actual
            );
            println!("a: {:?}", a);
            println!("b: {:?}", b);
            println!("r: {:?}", r);
            false
        } else {
            true
        }
    })
}

pub fn binary_property_test<C, K, V>(a: &C, b: &C, r: bool, op: impl Fn(V, V) -> bool) -> bool
where
    C: TestSamples<K, V> + Debug,
    K: Ord + Clone + Debug,
    V: Eq + Debug,
{
    let mut s: BTreeSet<K> = BTreeSet::new();
    a.samples(&mut s);
    b.samples(&mut s);
    if r {
        s.iter().cloned().all(|e| op(a.at(e.clone()), b.at(e)))
    } else {
        s.iter().cloned().any(|e| !op(a.at(e.clone()), b.at(e)))
    }
}