checkito 5.0.0

A safe, efficient and simple QuickCheck-inspired library to generate shrinkable random data mainly oriented towards generative/property/exploratory testing.
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

pub mod common;
use common::*;

#[test]
fn sampler_with_same_seed_is_reproducible() {
    let mut left = (0u8..=100).sampler();
    left.seed = 7;
    left.count = 64;

    let mut right = (0u8..=100).sampler();
    right.seed = 7;
    right.count = 64;

    assert_eq!(
        left.samples().collect::<Vec<_>>(),
        right.samples().collect::<Vec<_>>()
    );
}

#[test]
fn sampler_sample_respects_size_for_collections() {
    let sampler = Generate::collect::<Vec<_>>(0u8..=u8::MAX).sampler();

    assert_eq!(sampler.sample(0.0), Vec::<u8>::new());
    assert!(sampler.sample(1.0).len() >= sampler.sample(0.0).len());
}

#[test]
fn samples_iterator_supports_exact_size_and_double_ended_iteration() {
    let mut samples = (0u8..=10).samples(6);

    assert_eq!(samples.size_hint(), (6, Some(6)));
    assert_eq!(samples.len(), 6);

    let _ = samples.next().unwrap();
    let _ = samples.next_back().unwrap();
    assert_eq!(samples.len(), 4);

    let _ = samples.nth(1).unwrap();
    assert_eq!(samples.len(), 2);

    let _ = samples.nth_back(0).unwrap();
    assert_eq!(samples.len(), 1);

    let _ = samples.last().unwrap();
}

#[cfg(feature = "check")]
mod check {
    use super::*;

    #[check(0u64..=u64::MAX, 1usize..=64)]
    fn sampler_reproducibility_holds_for_many_seeds(seed: u64, count: usize) {
        let mut left = (0u8..=100).sampler();
        left.seed = seed;
        left.count = count;

        let mut right = (0u8..=100).sampler();
        right.seed = seed;
        right.count = count;

        assert_eq!(
            left.samples().collect::<Vec<_>>(),
            right.samples().collect::<Vec<_>>()
        );
    }

    #[check(0u64..=u64::MAX)]
    fn sampler_single_sample_is_reproducible(seed: u64) {
        let mut left = (0u8..=100).sampler();
        left.seed = seed;
        let mut right = (0u8..=100).sampler();
        right.seed = seed;

        assert_eq!(left.sample(0.0), right.sample(0.0));
        assert_eq!(left.sample(0.5), right.sample(0.5));
        assert_eq!(left.sample(1.0), right.sample(1.0));
    }

    #[check(2usize..=100)]
    fn samples_iterator_has_exact_size_for_arbitrary_count(count: usize) {
        let mut samples = (0u8..=10).samples(count);
        assert_eq!(samples.size_hint(), (count, Some(count)));
        assert_eq!(samples.len(), count);

        let _ = samples.next().unwrap();
        let _ = samples.next_back().unwrap();
        assert_eq!(samples.len(), count - 2);
    }

    #[check(0usize..=200)]
    fn sampler_sample_respects_size_for_arbitrary_count(count: usize) {
        let sampler = Generate::collect::<Vec<_>>(0u8..=u8::MAX).sampler();
        let at_zero = sampler.sample(0.0);
        assert!(at_zero.is_empty());
        let at_one = sampler.sample(1.0);
        assert!(at_one.len() >= at_zero.len());
        // The sampler produces the correct number of samples for this count.
        let mut s = (0u8..=100).sampler();
        s.count = count;
        assert_eq!(s.samples().count(), count);
    }
}