dicetest 0.4.0

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
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

use crate::prelude::*;

/// Generates a [`Ok`] or a [`Err`] that contain a value from one of the given generators.
/// [`Ok`] and [`Err`] have the same probability.
///
/// # Examples
///
/// ```
/// 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 ok_die = dice::just_once(42);
/// let err_die = dice::just_once("error");
/// let result_die = dice::result_once(ok_die, err_die);
///
/// let ok_or_err = fate.roll(result_die);
/// ```
pub fn result_once<T, E>(
    ok_die: impl DieOnce<T>,
    err_die: impl DieOnce<E>,
) -> impl DieOnce<Result<T, E>> {
    dice::one_of_die_once().two(ok_die.map_once(Ok), err_die.map_once(Err))
}

/// Generates a [`Ok`] or a [`Err`] that contain a value from one of the given generators.
/// [`Ok`] and [`Err`] have the same probability.
///
/// # Examples
///
/// ```
/// 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 ok_die = dice::just(42);
/// let err_die = dice::just("error");
/// let result_die = dice::result(ok_die, err_die);
///
/// let ok_or_err = fate.roll(result_die);
/// ```
pub fn result<T, E>(ok_die: impl Die<T>, err_die: impl Die<E>) -> impl Die<Result<T, E>> {
    dice::one_of_die().two(ok_die.map(Ok), err_die.map(Err))
}

/// Generates a [`Ok`] or a [`Err`] that contain a value from one of the given generators.
/// The probabilities of [`Ok`] and [`Err`] depend on the given weights.
///
/// # Examples
///
/// ```
/// 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 ok_die = dice::just_once(42);
/// let err_die = dice::just_once("error");
/// let result_die = dice::weighted_result_once((1, ok_die), (10, err_die));
///
/// let probably_err = fate.roll(result_die);
/// ```
pub fn weighted_result_once<T, E>(
    (ok_weight, ok_die): (u32, impl DieOnce<T>),
    (err_weight, err_die): (u32, impl DieOnce<E>),
) -> impl DieOnce<Result<T, E>> {
    dice::weighted_one_of_die_once().two(
        (ok_weight, ok_die.map_once(Ok)),
        (err_weight, err_die.map_once(Err)),
    )
}

/// Generates a [`Ok`] or a [`Err`] that contain a value from one of the given generators.
/// The probabilities of [`Ok`] and [`Err`] depend on the given weights.
///
/// # Examples
///
/// ```
/// 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 ok_die = dice::just(42);
/// let err_die = dice::just("error");
/// let result_die = dice::weighted_result((1, ok_die), (10, err_die));
///
/// let probably_err = fate.roll(result_die);
/// ```
pub fn weighted_result<T, E>(
    (ok_weight, ok_die): (u32, impl Die<T>),
    (err_weight, err_die): (u32, impl Die<E>),
) -> impl Die<Result<T, E>> {
    dice::weighted_one_of_die().two((ok_weight, ok_die.map(Ok)), (err_weight, err_die.map(Err)))
}