precept 0.3.0

A testing utility for fuzzing and fault injection to discover erroneous and interesting states.
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

use rand::Rng;

/// Returns a random number generator that uses the dispatcher for randomness.
///
/// When precept is enabled, this returns an RNG that sources randomness from
/// the dispatcher, enabling deterministic replay. When disabled, it returns
/// the standard random generator.
#[cfg(not(feature = "enabled"))]
pub fn rng() -> impl Rng {
    rand::rng()
}

/// Returns a random number generator that uses the dispatcher for randomness.
///
/// When precept is enabled, this returns an RNG that sources randomness from
/// the dispatcher, enabling deterministic replay. When disabled, it returns
/// the standard random generator.
#[cfg(feature = "enabled")]
pub fn rng() -> impl Rng {
    DispatchRng
}

#[cfg(feature = "enabled")]
struct DispatchRng;

#[cfg(feature = "enabled")]
impl rand::TryRng for DispatchRng {
    type Error = core::convert::Infallible;

    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
        Ok(self.try_next_u64()? as u32)
    }

    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
        Ok(crate::dispatch::get_random())
    }

    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
        rand_core::utils::fill_bytes_via_next_word(dst, || self.try_next_u64())
    }
}

#[cfg(test)]
mod tests {
    use super::rng;
    use rand::RngExt;

    #[test]
    fn rng_generates_primitive_values() {
        let mut rng = rng();

        let _: u8 = rng.random();
        let _: u64 = rng.random();
        let _: bool = rng.random();
    }

    #[test]
    fn rng_can_fill_byte_buffer() {
        let mut rng = rng();
        let mut bytes = [0_u8; 32];

        rng.fill(&mut bytes);
    }
}