Struct urandom::rng::MockRng

pub struct MockRng<I>(pub I);

Random number generator mock.

Produces randomness directly from the given iterator and panics when it runs out of items.

Tuple Fields

0: I

Implementations

impl<'a> MockRng<Copied<Iter<'a, u64>>>

pub fn slice(slice: &'a [u64]) -> Random<Self>

Produces the values from the input slice as the underlying random number generator.

use urandom::rng::MockRng;

let mut rng = MockRng::slice(&[1, 2, 13, 42]);

assert_eq!(rng.next_u64(), 1);
assert_eq!(rng.next_u64(), 2);
assert_eq!(rng.next_u64(), 13);
assert_eq!(rng.next_u64(), 42);

// Any further calls to the MockRng will panic unless the underlying iterator is unbounded.

impl MockRng<Repeat<u64>>

pub fn repeat(value: u64) -> Random<Self>

Produces the same random number repeatedly as the underlying random number generator.

use urandom::rng::MockRng;

let mut rng = MockRng::repeat(42);

assert_eq!(rng.next_u64(), 42);
assert_eq!(rng.next_u64(), 42);
assert_eq!(rng.next_u64(), 42);

Trait Implementations

impl<I: Clone> Clone for MockRng<I>

fn clone(&self) -> MockRng<I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug> Debug for MockRng<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I> Rng for MockRng<I>where
    I: Iterator<Item = u64>,

fn next_u32(&mut self) -> u32

Returns the next u32 in the sequence.

fn next_u64(&mut self) -> u64

Returns the next u64 in the sequence.

fn fill_u32(&mut self, buffer: &mut [u32])

Fills the next u32 elements in the sequence.

fn fill_u64(&mut self, buffer: &mut [u64])

Fills the next u64 elements in the sequence.

fn fill_bytes(&mut self, _buffer: &mut [u8])

Fills the byte slice with uniform random bytes.

fn jump(&mut self)

Advances the internal state significantly.

fn next_f32(&mut self) -> f32

Returns a uniform random f32 in the half-open interval [1.0, 2.0).

fn next_f64(&mut self) -> f64

Returns a uniform random f64 in the half-open interval [1.0, 2.0).