dicetest 0.3.1

Framework for writing tests with randomly generated test data
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

use crate::prelude::*;

/// Generates an valid index for the given slice.
///
/// # Panics
///
/// Panics if the slice empty.
///
/// # Examples
///
/// This example generates an index without panicking:
///
/// ```
/// use dicetest::prelude::*;
/// use dicetest::{Prng, Limit};
///
/// let mut prng = Prng::from_seed(0x5EED.into());
/// let limit = Limit::default();
/// let mut fate = Fate::new(&mut prng, limit);
///
/// let array = ['a', 'b', 'c'];
/// let index = fate.roll(dice::index_of(&array));
/// assert!(0 <= index && index < array.len());
/// ```
///
/// This example panics:
///
/// ```should_panic
/// use dicetest::prelude::*;
///
/// // Oh no, panic!
/// let _index_die = dice::index_of::<char>(&[]);
/// ```
pub fn index_of<'a, 'b, T>(slice: &'a [T]) -> impl Die<usize> + 'b {
    let len = slice.len();
    dice::uni_usize(0..len)
}

#[cfg(test)]
mod tests {
    use crate::prelude::*;

    #[test]
    fn index_of_generates_valid_index() {
        Dicetest::repeatedly().run(|mut fate| {
            let vec = fate.roll(dice::vec(dice::u8(..), 1..));
            let index = fate.roll(dice::index_of(&vec));

            assert!(index < vec.len());
        })
    }

    #[test]
    fn index_of_calc_stats() {
        Dicetest::repeatedly()
            .passes(0)
            .stats_enabled(true)
            .run(|mut fate| {
                stat!(
                    "index_of(&[1, 2, 3, 4, 5])",
                    "{}",
                    fate.roll(dice::index_of(&[1, 2, 3, 4, 5])),
                );
            })
    }
}