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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so 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<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> SleepProvider for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where SleepR: SleepProvider, TaskR: 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

impl SleepProvider for SimpleMockTimeProvider

impl SleepProvider for MockRuntime

impl SleepProvider for MockSleepProvider

impl<R: Runtime> SleepProvider for MockNetRuntime<R>

impl<R: Runtime> SleepProvider for MockSleepRuntime<R>