Skip to main content

unityrs_testkit/
rng.rs

1//! A tiny deterministic generator (`SplitMix64`) for "no panic on garbage"
2//! tests: every package mutates the builders' output with it, seeded, so a
3//! failure reproduces from its seed. No dependency, no global state.
4
5/// `SplitMix64`.
6#[derive(Clone, Debug, PartialEq, Eq)]
7pub struct Rng(u64);
8
9impl Rng {
10    /// A generator from a seed.
11    #[must_use]
12    pub fn new(seed: u64) -> Self {
13        Self(seed)
14    }
15
16    /// The next 64 bits.
17    pub fn next_u64(&mut self) -> u64 {
18        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
19        let mut z = self.0;
20        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
21        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
22        z ^ (z >> 31)
23    }
24
25    /// A value in `0..n` (0 when `n` is 0).
26    pub fn below(&mut self, n: usize) -> usize {
27        if n == 0 {
28            return 0;
29        }
30        usize::try_from(self.next_u64() % u64::try_from(n).unwrap_or(u64::MAX)).unwrap_or(0)
31    }
32
33    /// Flips `count` random bits of `data`.
34    pub fn flip_bits(&mut self, data: &mut [u8], count: usize) {
35        for _ in 0..count {
36            let i = self.below(data.len());
37            let bit = self.below(8);
38            if let Some(b) = data.get_mut(i) {
39                *b ^= 1 << bit;
40            }
41        }
42    }
43
44    /// `data` cut at a random length.
45    pub fn truncate(&mut self, data: &mut Vec<u8>) {
46        let n = self.below(data.len().saturating_add(1));
47        data.truncate(n);
48    }
49}
50
51#[cfg(test)]
52mod tests {
53    use super::Rng;
54
55    #[test]
56    fn deterministic() {
57        let (mut a, mut b) = (Rng::new(7), Rng::new(7));
58        assert_eq!(a.next_u64(), b.next_u64());
59        let mut v = vec![0u8; 16];
60        a.flip_bits(&mut v, 5);
61        let mut w = vec![0u8; 16];
62        b.flip_bits(&mut w, 5);
63        assert_eq!(v, w);
64        assert_eq!(Rng::new(1).below(0), 0);
65    }
66}