Trait SleepProvider

pub trait SleepProvider:
    Clone
    + Send
    + Sync
    + 'static {
    type SleepFuture: Future<Output = ()> + Send + 'static;

    // Required method
    fn sleep(&self, duration: Duration) -> Self::SleepFuture;

    // Provided methods
    fn now(&self) -> Instant { ... }
    fn wallclock(&self) -> SystemTime { ... }
    fn block_advance<T: Into<String>>(&self, _reason: T) { ... }
    fn release_advance<T: Into<String>>(&self, _reason: T) { ... }
    fn allow_one_advance(&self, _dur: Duration) { ... }
}

Trait for a runtime that can wait until a timer has expired.

Every SleepProvider also implements SleepProviderExt; see that trait for other useful functions.

Required Associated Types

type SleepFuture: Future<Output = ()> + Send + 'static

A future returned by SleepProvider::sleep()

Required Methods

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

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

Provided Methods

fn now(&self) -> Instant

Return the SleepProvider’s view of the current instant.

(This is the same as Instant::now, if not running in test mode.)

fn wallclock(&self) -> SystemTime

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

(This is the same as SystemTime::now, if not running in test mode.)

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.

Call release_advance with the same reason string in order to unblock.

This method is only for testing: it should never have any effect when invoked on non-testing runtimes.

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.

This method is only for testing: it should never have any effect when invoked on non-testing runtimes.

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.

This method is only for testing: it should never have any effect when invoked on non-testing runtimes.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl SleepProvider for AsyncStd

Available on (crate features native-tls or rustls) and (crate features async-std or tokio) and crate feature async-std only.

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

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

Implementors

impl SleepProvider for AsyncStdNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature async-std only.

type SleepFuture = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, NativeTlsProvider, AsyncStd> as SleepProvider>::SleepFuture

impl SleepProvider for AsyncStdRustlsRuntime

Available on (crate features native-tls or rustls) and crate feature async-std only.

type SleepFuture = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, RustlsProvider, AsyncStd> as SleepProvider>::SleepFuture

impl SleepProvider for DynTimeProvider

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

impl SleepProvider for PreferredRuntime

type SleepFuture = <TokioNativeTlsRuntime as SleepProvider>::SleepFuture

impl SleepProvider for TokioNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type SleepFuture = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as SleepProvider>::SleepFuture

impl SleepProvider for TokioRustlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type SleepFuture = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as SleepProvider>::SleepFuture

impl<SpawnR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> SleepProvider for CompoundRuntime<SpawnR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where SleepR: SleepProvider, SpawnR: Clone + Send + Sync + 'static, CoarseTimeR: Clone + Send + Sync + 'static, TcpR: Clone + Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Clone + Send + Sync + 'static, UdpR: Clone + Send + Sync + 'static,

type SleepFuture = <SleepR as SleepProvider>::SleepFuture