Struct MockSleepRuntime

pub struct MockSleepRuntime<R: Runtime> {
    runtime: R,
    sleep: MockSleepProvider,
}

👎Deprecated since 0.29.0

A deprecated wrapper Runtime that overrides SleepProvider for the underlying runtime.

Deprecated

The MockSleepProvider used here has some limitations. See its documentation for more information. Use MockRuntime for new tests.

Fields

runtime: R

👎Deprecated since 0.29.0

The underlying runtime. Most calls get delegated here.

sleep: MockSleepProvider

👎Deprecated since 0.29.0

A MockSleepProvider. Time-related calls get delegated here.

Implementations

impl<R: Runtime> MockSleepRuntime<R>

pub fn new(runtime: R) -> Self

Create a new runtime that wraps runtime, but overrides its view of time with a MockSleepProvider.

pub fn inner(&self) -> &R

Return a reference to the underlying runtime.

pub fn mock_sleep(&self) -> &MockSleepProvider

Return a reference to the MockSleepProvider

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

See MockSleepProvider::advance()

pub fn jump_to(&self, new_wallclock: SystemTime)

See MockSleepProvider::jump_to()

pub fn wait_for<F: Future>(&self, fut: F) -> WaitFor<F>

Run a future under mock time, advancing time forward where necessary until it completes. Users of this function should read the whole of this documentation before using!

NOTE Instead of using this, consider MockRuntime, which will fully isolate the test case (albeit at the cost of demanding manual management of the simulated time).

The returned future will run fut, expecting it to create Sleeping futures (as returned by MockSleepProvider::sleep() and similar functions). When all such created futures have been polled (indicating the future is waiting on them), time will be advanced in order that the first (or only) of said futures returns Ready. This process then repeats until fut returns Ready itself (as in, the returned wrapper future will wait for all created Sleeping futures to be polled, and advance time again).

Note: The above described algorithm interacts poorly with futures that spawn asynchronous background tasks, or otherwise expect work to complete in the background before time is advanced. These futures will need to make use of the SleepProvider::block_advance (and similar) APIs in order to prevent time advancing while said tasks complete; see the documentation for those APIs for more detail.

Panics

Panics if another WaitFor future is already running. (If two ran simultaneously, they would both try and advance the same mock time clock, which would be bad.)

Trait Implementations

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

type ThreadHandle<T: Send + 'static> = <R as Blocking>::ThreadHandle<T>

Future from spawn_blocking

fn spawn_blocking<F, T>(&self, f: F) -> <R as Blocking>::ThreadHandle<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn a thread for blocking IO or CPU-bound work.

fn reenter_block_on<F>(&self, future: F) -> F::Output

where F: Future, F::Output: Send + 'static,

Block on a future, from within Blocking::spawn_blocking

fn blocking_io<F, T>(&self, f: F) -> impl Future<Output = T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Perform some blocking IO from an async future

impl<R: Clone + Runtime> Clone for MockSleepRuntime<R>

fn clone(&self) -> MockSleepRuntime<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

fn now_coarse(&self) -> CoarseInstant

Return the CoarseTimeProvider’s view of the current instant.

impl<R: Debug + Runtime> Debug for MockSleepRuntime<R>

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

Formats the value using the given formatter.

impl<R: Runtime> NetStreamProvider<SocketAddr> for MockSleepRuntime<R>

type Stream = FakeStream

The type for the connections returned by Self::connect().

type Listener = FakeListener<SocketAddr>

The type for the listeners returned by Self::listen().

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, _addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Launch a connection connection to a given socket address.

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, _addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a listener on a given socket address.

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

type Stream = <R as NetStreamProvider>::Stream

The type for the connections returned by Self::connect().

type Listener = <R as NetStreamProvider>::Listener

The type for the listeners returned by Self::listen().

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Launch a connection connection to a given socket address.

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a listener on a given socket address.

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

type SleepFuture = <MockSleepProvider as SleepProvider>::SleepFuture

A future returned by SleepProvider::sleep()

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

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

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<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.

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

fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>

Spawns a future that will be run to completion.

fn status(&self) -> Result<(), SpawnError>

Determines whether the executor is able to spawn new tasks.

impl<R: Runtime> TlsProvider<<R as NetStreamProvider>::Stream> for MockSleepRuntime<R>

type Connector = <R as TlsProvider<<R as NetStreamProvider>::Stream>>::Connector

The Connector object that this provider can return.

type TlsStream = <R as TlsProvider<<R as NetStreamProvider>::Stream>>::TlsStream

The type of the stream returned by that connector.

fn tls_connector(&self) -> Self::Connector

Return a TLS connector for use with this runtime.

fn supports_keying_material_export(&self) -> bool

Return true iff the keying material exporters (RFC 5705) is supported.

impl<R> ToplevelBlockOn for MockSleepRuntime<R>

where R: ToplevelBlockOn + Runtime,

fn block_on<F: Future>(&self, future: F) -> F::Output

Run future until it is ready, and return its output.

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

type UdpSocket = <R as UdpProvider>::UdpSocket

The type of Udp Socket returned by Self::bind()

fn bind<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::UdpSocket>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Bind a local port to send and receive packets from