Struct tor_rtmock::MockSleepRuntime

pub struct MockSleepRuntime<R: Runtime> { /* private fields */ }

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.

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> BlockOn for MockSleepRuntime<R>

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

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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> 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> TcpProvider for MockSleepRuntime<R>

type TcpStream = <R as TcpProvider>::TcpStream

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

type TcpListener = <R as TcpProvider>::TcpListener

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

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

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

Launch a TCP connection to a given socket address.

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

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

Open a TCP listener on a given socket address.

impl<R: Runtime> TlsProvider<<R as TcpProvider>::TcpStream> for MockSleepRuntime<R>

type Connector = <R as TlsProvider<<R as TcpProvider>::TcpStream>>::Connector

The Connector object that this provider can return.

type TlsStream = <R as TlsProvider<<R as TcpProvider>::TcpStream>>::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.

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