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
104

pub mod common;
use checkito::state::Weight;
use common::*;
use std::collections::HashSet;

#[test]
fn weighted_any() {
    let samples = any((
        Weight::new(1.0, 1),
        Weight::new(10.0, 10),
        Weight::new(100.0, 100),
    ))
    .unify::<i32>()
    .samples(1000)
    .collect::<Vec<_>>();
    let one = samples.iter().filter(|&&value| value == 1).count();
    let ten = samples.iter().filter(|&&value| value == 10).count();
    let hundred = samples.iter().filter(|&&value| value == 100).count();
    assert!(one < ten);
    assert!(ten < hundred);
}

#[test]
fn generates_exhaustively() {
    let generator = &any([1u16..=5, 10u16..=50, 100u16..=500]);
    let set = generator
        .checks(|_| true)
        .flat_map(|result| result.into_item())
        .collect::<HashSet<_>>();

    assert_eq!(
        generator.cardinality(),
        Some((1u16..=5).len() as u128 + (10u16..=50).len() as u128 + (100u16..=500).len() as u128)
    );

    for i in 1u16..=5 {
        assert!(set.contains(&i));
    }
    for i in 10u16..=50 {
        assert!(set.contains(&i));
    }
    for i in 100u16..=500 {
        assert!(set.contains(&i));
    }
}

#[test]
fn uses_random_sampling_when_cardinality_exceeds_iterations() {
    let generator = any([1u16..=5, 10u16..=50, 100u16..=500]);
    let mut checker = generator.clone().checker();
    checker.generate.count = 8;
    checker.generate.seed = 0;
    let values = checker
        .checks(|_| true)
        .flat_map(|result| result.into_item())
        .collect::<Vec<_>>();
    let mut exhaustive = generator.checker();
    exhaustive.generate.count = 8;
    exhaustive.generate.exhaustive = Some(true);
    let exhaustive_values = exhaustive
        .checks(|_| true)
        .flat_map(|result| result.into_item())
        .collect::<Vec<_>>();

    assert_eq!(values.len(), 8);
    assert_eq!(exhaustive_values, vec![1, 2, 3, 4, 5, 10, 11, 12]);
    assert_ne!(values, exhaustive_values);
}

#[test]
fn forces_exhaustive_generation_when_requested() {
    let generator = any([1u16..=5, 10u16..=50, 100u16..=500]);
    let mut checker = generator.checker();
    checker.generate.count = 8;
    checker.generate.exhaustive = Some(true);
    let values = checker
        .checks(|_| true)
        .flat_map(|result| result.into_item())
        .collect::<Vec<_>>();

    assert_eq!(values, vec![1, 2, 3, 4, 5, 10, 11, 12]);
}

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

    #[check(1_000usize..=5_000)]
    fn weighted_any_respects_weight_ordering_for_arbitrary_sample_count(count: usize) {
        let samples = any((
            Weight::new(1.0, 1),
            Weight::new(10.0, 10),
            Weight::new(100.0, 100),
        ))
        .unify::<i32>()
        .samples(count)
        .collect::<Vec<_>>();
        let one = samples.iter().filter(|&&value| value == 1).count();
        let ten = samples.iter().filter(|&&value| value == 10).count();
        let hundred = samples.iter().filter(|&&value| value == 100).count();
        assert!(one <= ten);
        assert!(ten <= hundred);
    }
}