Struct DynTimeProvider

pub(crate) struct DynTimeProvider(Impl);

Type-erased SleepProvider and CoarseTimeProvider

Useful where time is needed, but we don’t want a runtime type parameter.

Tuple Fields

0: Impl

Implementations

impl DynTimeProvider

pub fn new<R>(runtime: R) -> DynTimeProvider

where R: SleepProvider + CoarseTimeProvider,

Create a new DynTimeProvider from a concrete runtime type

Trait Implementations

impl Clone for DynTimeProvider

fn clone(&self) -> DynTimeProvider

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CoarseTimeProvider for DynTimeProvider

fn now_coarse(&self) -> CoarseInstant

Return the CoarseTimeProvider’s view of the current instant.

impl Debug for DynTimeProvider

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

Formats the value using the given formatter.

impl SleepProvider for DynTimeProvider

type SleepFuture = Pin<Box<dyn Future<Output = ()> + Send>>

A future returned by [SleepProvider::sleep()]

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.

fn block_advance<R>(&self, reason: R)

where R: Into<String>,

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<R>(&self, reason: R)

where R: Into<String>,

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, duration: 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 sleep(&self, duration: Duration) -> Pin<Box<dyn Future<Output = ()> + Send>>

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