Struct near_async::test_loop::TestLoop

pub struct TestLoop<Data: 'static, Event: Debug + Send + 'static> {
    pub data: Data,
    /* private fields */
}

Main struct for the Test Loop framework. The Data type should contain all the business logic state that is relevant to the test. The Event type should contain all the possible events that are sent to the event loop.

The convention is that, for single-instance tests,

• Data should be a struct with a derive_more::AsMut and derive_more::AsRef (so that Data implements AsMut and AsRef for each of its fields.)
• Event should be an enum with a derive(EnumTryInto, EnumFrom), so that it implements TryInto and From for each of its variants. and that for multi-instance tests, Data is Vec<SingleData> and Event is (usize, SingleEvent).

Fields

data: Data

Implementations

impl<Data: 'static, Event: Debug + Send + 'static> TestLoop<Data, Event>

pub fn register_delayed_action_handler<T>(&mut self)

where T: 'static, Data: AsMut<T>, Event: TryIntoOrSelf<TestLoopDelayedActionEvent<T>> + From<TestLoopDelayedActionEvent<T>> + 'static,

Shorthand for registering this frequently used handler.

impl<Data: 'static, Event: Debug + Send + 'static> TestLoop<Vec<Data>, (usize, Event)>

pub fn register_delayed_action_handler_for_index<T>(&mut self, idx: usize)

where T: 'static, Data: AsMut<T>, Event: TryIntoOrSelf<TestLoopDelayedActionEvent<T>> + From<TestLoopDelayedActionEvent<T>> + 'static,

Shorthand for registering this frequently used handler for a multi-instance test.

impl<Data, Event: Debug + Send + 'static> TestLoop<Data, Event>

pub fn sender(&self) -> DelaySender<Event>

pub fn clock(&self) -> Clock

pub fn shutting_down(&self) -> Arc<AtomicBool>

pub fn register_handler(&mut self, handler: LoopEventHandler<Data, Event>)

Registers a new event handler to the test loop.

pub fn run_for(&mut self, duration: Duration)

Runs the test loop for the given duration. This function may be called multiple times, but further test handlers may not be registered after the first call.

pub fn run_until( &mut self, condition: impl Fn(&mut Data) -> bool, maximum_duration: Duration, )

Run until the given condition is true, asserting that it happens before the maximum duration is reached.

To maximize logical consistency, the condition is only checked before the clock would advance. If it returns true, execution stops before advancing the clock.

pub fn shutdown_and_drain_remaining_events(self, maximum_duration: Duration)

Used to finish off remaining events that are still in the loop. This can be necessary if the destructor of some components wait for certain condition to become true. Otherwise, the destructors may end up waiting forever. This also helps avoid a panic when destructing TestLoop itself, as it asserts that all events have been handled.

pub fn run_instant(&mut self)

pub fn future_spawner(&self) -> TestLoopFutureSpawner

where Event: From<Arc<TestLoopTask>>,

Trait Implementations

impl<Data: 'static, Event: Debug + Send + 'static> Drop for TestLoop<Data, Event>

fn drop(&mut self)

Executes the destructor for this type.