Struct TestExecutor 

pub struct TestExecutor {
    pub clock: Arc<VirtualClock>,
    pub runtime: Arc<StepRuntime>,
    /* private fields */
}

The controlled executor of one test: a single-threaded pool plus the clock and runtime handle every cache instance under test shares.

Fields

clock: Arc<VirtualClock>

The virtual clock to share with every instance under test.

runtime: Arc<StepRuntime>

The runtime handle to pass to every instance under test.

Implementations

impl TestExecutor

pub fn new(wall_ms: i64) -> Self

A fresh pool with its clock at wall_ms; replayed histories use WALL_EPOCH_MS.

pub fn poll_count(&self) -> u64

Actual task polls performed by this executor. A zero-time verification drain must leave this count unchanged when every task is already blocked.

pub fn block_on<R: 'static>( &mut self, future: impl Future<Output = R> + 'static, ) -> R

Run a future to completion on the pool, draining detached work as it is spawned. Panics if the future stays blocked once nothing is runnable: it would be waiting on a gate only the test can release.

pub fn spawn(&self, task: impl Future<Output = ()> + 'static)

Spawn driver-owned work onto the pool.

pub fn drain(&mut self)

Run until every task is blocked on a gate, an undelivered timer or a scope gate and nothing is runnable, including deferred work that becomes runnable once everything else has stalled.

pub fn advance(&mut self, ms: i64, deliver: bool)

Advance elapsed and wall time by ms. With deliver, scheduler time moves too and every timer due on the way fires in order, draining after each; without it the clocks jump silently.

pub fn advance_micros(&mut self, micros: i64)

Advance by fractional microseconds without delivering timers (the local-clock profile’s environment ticks).

Trait Implementations

impl Debug for TestExecutor

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

Formats the value using the given formatter.