Struct TestContext 

pub struct TestContext<R> { /* private fields */ }

Trait Implementations

impl<R> Bind<NetAddress> for TestContext<R>

where R: Send + 'static,

async fn bind( &mut self, args: BindArgs<NetAddress>, ) -> Result<(), ErrorOf<BindErrorKind>>

impl<R> Debug for TestContext<R>

where UnboundedSender<Query<R>>: Debug,

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

Formats the value using the given formatter.

impl<R> Fork for TestContext<R>

where R: Send + 'static,

async fn fork(&mut self) -> Result<Self, ErrorOf<ForkErrorKind>>

async fn run<F, Fut>(self, fun: F)

where F: FnOnce(Self) -> Fut + Send + 'static, Fut: Future + Send + 'static,

impl<R> InitDone for TestContext<R>

where R: Send,

async fn init_done(&mut self, address: Address)

impl<R> Linking for TestContext<R>

where R: Send,

async fn link(&mut self, peer: Address)

async fn unlink(&mut self, peer: Address)

async fn set_trap_exit(&mut self, enable: bool)

impl<R> Messaging for TestContext<R>

where R: Send,

fn address(&self) -> Address

async fn close(&mut self)

async fn recv(&mut self) -> Result<Envelope, ErrorOf<RecvErrorKind>>

async fn send( &mut self, envelope: Envelope, ) -> Result<(), ErrorOf<SendErrorKind>>

async fn forward( &mut self, to: Address, envelope: Envelope, ) -> Result<(), ErrorOf<SendErrorKind>>

impl<R> Now for TestContext<R>

where R: Send,

type Instant = Instant

fn now(&self) -> Self::Instant

impl<R> Quit for TestContext<R>

where R: Send,

async fn quit_ok(&mut self) -> Never

async fn quit_err<E>(&mut self, reason: E) -> Never

where E: Error + Send + Sync + 'static,

fn quit<E>( &mut self, result: Result<(), E>, ) -> impl Future<Output = Infallible> + Send

where E: Error + Send + Sync + 'static,

impl<R> Start<R> for TestContext<R>

where R: Send,

async fn spawn( &mut self, runnable: R, link: bool, ) -> Result<Address, ErrorOf<SpawnErrorKind>>

async fn start( &mut self, runnable: R, link: bool, start_timeout: Duration, ) -> Result<Address, ErrorOf<StartErrorKind>>

impl<R> Stop for TestContext<R>

where R: Send,

async fn exit(&mut self, peer: Address) -> bool

async fn kill(&mut self, peer: Address) -> bool

fn shutdown( &mut self, peer: Address, stop_timeout: Duration, ) -> impl Future<Output = Result<(), ErrorOf<ShutdownErrorKind>>> + Send

where Self: Watching + Fork + Messaging,

impl<R> Watching for TestContext<R>

where R: Send,

async fn watch(&mut self, peer: Address) -> WatchRef

async fn unwatch(&mut self, watch_ref: WatchRef)