Struct tor_rtmock::time::MockSleepProvider

pub struct MockSleepProvider { /* private fields */ }

A dummy SleepProvider instance for testing.

The MockSleepProvider ignores the current time, and instead keeps its own view of the current Instant and SystemTime. You can advance them in-step by calling advance(), and you can simulate jumps in the system clock by calling jump().

This is not for production use.

Implementations

impl MockSleepProvider

pub fn new(wallclock: SystemTime) -> Self

Create a new MockSleepProvider, starting at a given wall-clock time.

pub async fn advance(&self, dur: Duration)

Advance the simulated timeline forward by dur.

Calling this function will wake any pending futures as appropriate, and yield to the scheduler so they get a chance to run.

Limitations

This function advances time in one big step. We might instead want to advance in small steps and make sure that each step’s futures can get run before the ones scheduled to run after it.

pub fn jump_to(&self, new_wallclock: SystemTime)

Simulate a discontinuity in the system clock, by jumping to new_wallclock.

Panics

Panics if we have already panicked while holding the lock on the internal timer state, and the lock is poisoned.

Trait Implementations

impl Clone for MockSleepProvider

fn clone(&self) -> MockSleepProvider

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MockSleepProvider

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

Formats the value using the given formatter.

impl Default for MockSleepProvider

fn default() -> Self

Returns the “default value” for a type.

impl SleepProvider for MockSleepProvider

type SleepFuture = Sleeping

A future returned by SleepProvider::sleep()

fn sleep(&self, duration: Duration) -> Self::SleepFuture

Return a future that will be ready after duration has elapsed.

fn block_advance<T: Into<String>>(&self, reason: T)

Signify that a test running under mock time shouldn’t advance time yet, with a given unique reason string. This is useful for making sure (mock) time doesn’t advance while things that might require some (real-world) time to complete do so, such as spawning a task on another thread.

fn release_advance<T: Into<String>>(&self, reason: T)

Signify that the reason to withhold time advancing provided in a call to block_advance no longer exists, and it’s fine to move time forward if nothing else is blocking advances.

fn allow_one_advance(&self, dur: Duration)

Allow a test running under mock time to advance time by the provided duration, even if the above block_advance API has been used.

fn now(&self) -> Instant

Return the SleepProvider’s view of the current instant.

fn wallclock(&self) -> SystemTime

Return the SleepProvider’s view of the current wall-clock time.