Struct MockMonitor 

pub struct MockMonitor<T> { /* private fields */ }

Monitor implementation for deterministic tests.

MockMonitor protects a state value like the real monitor implementations, but timeout methods use manually controlled mock elapsed time. Advancing the mock time wakes waiters so they can recheck predicates and timeout budgets.

Implementations

impl<T> MockMonitor<T>

pub fn new(state: T) -> Self

Creates a mock monitor protecting the supplied state value.

Arguments

• state - Initial protected state.

Returns

A mock monitor whose elapsed time starts at zero.

pub fn elapsed(&self) -> Duration

Returns the current mock elapsed time.

Returns

The elapsed time used by timeout waits.

pub fn set_elapsed(&self, elapsed: Duration)

Sets the current mock elapsed time.

This wakes timeout waiters so they can recheck their budgets.

Arguments

• elapsed - New mock elapsed time.

pub fn advance(&self, duration: Duration)

Advances mock elapsed time by a relative duration.

Arguments

• duration - Duration added to the current mock elapsed time.

pub fn reset_elapsed(&self)

Resets mock elapsed time to zero.

pub fn read<R, F>(&self, f: F) -> R

where F: FnOnce(&T) -> R,

Acquires the monitor and reads the protected state.

Arguments

• f - Closure that receives an immutable reference to the state.

Returns

The value returned by the closure.

pub fn write<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Acquires the monitor and mutates the protected state.

This does not notify waiters automatically.

Arguments

• f - Closure that receives a mutable reference to the state.

Returns

The value returned by the closure.

pub fn write_notify_one<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Mutates the protected state and wakes one waiter.

Arguments

• f - Closure that receives a mutable reference to the state.

Returns

The value returned by the closure.

pub fn write_notify_all<R, F>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Mutates the protected state and wakes all waiters.

Arguments

• f - Closure that receives a mutable reference to the state.

Returns

The value returned by the closure.

pub fn notify_one(&self)

Wakes one waiter if one is blocked.

pub fn notify_all(&self)

Wakes all waiters.

Trait Implementations

impl<T> AsRef<MockMonitor<T>> for ArcMockMonitor<T>

fn as_ref(&self) -> &MockMonitor<T>

Returns a reference to the wrapped mock monitor.

impl<T: Send> AsyncConditionWaiter for MockMonitor<T>

Available on crate feature async only.

fn async_wait_until<'a, R, P, F>( &'a self, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, R>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits until the predicate becomes true.

fn async_wait_while<'a, R, P, F>( &'a self, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, R>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits while the predicate remains true.

type State = T

State protected by the monitor.

impl<T: Send> AsyncNotificationWaiter for MockMonitor<T>

Available on crate feature async only.

fn async_wait<'a>(&'a self) -> AsyncMonitorFuture<'a, ()>

Returns a future that resolves after an async notification.

impl<T: Send> AsyncTimeoutConditionWaiter for MockMonitor<T>

Available on crate feature async only.

fn async_wait_until_for<'a, R, P, F>( &'a self, timeout: Duration, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, WaitTimeoutResult<R>>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits until the predicate becomes true or times out.

fn async_wait_while_for<'a, R, P, F>( &'a self, timeout: Duration, predicate: P, action: F, ) -> AsyncMonitorFuture<'a, WaitTimeoutResult<R>>

where R: Send + 'a, P: FnMut(&Self::State) -> bool + Send + 'a, F: FnOnce(&mut Self::State) -> R + Send + 'a,

Returns a future that waits while the predicate remains true or times out.

impl<T: Send> AsyncTimeoutNotificationWaiter for MockMonitor<T>

Available on crate feature async only.

fn async_wait_for<'a>( &'a self, timeout: Duration, ) -> AsyncMonitorFuture<'a, WaitTimeoutStatus>

Returns a future that resolves after notification or mock timeout.

impl<T> ConditionWaiter for MockMonitor<T>

fn wait_until<R, P, F>(&self, predicate: P, action: F) -> R

where P: FnMut(&Self::State) -> bool, F: FnOnce(&mut Self::State) -> R,

Blocks until the predicate becomes true, then runs the action.

fn wait_while<R, P, F>(&self, predicate: P, action: F) -> R

where P: FnMut(&Self::State) -> bool, F: FnOnce(&mut Self::State) -> R,

Blocks while the predicate remains true, then runs the action.

type State = T

State protected by the monitor.

impl<T: Default> Default for MockMonitor<T>

fn default() -> Self

Creates a mock monitor containing T::default().

impl<T> From<T> for MockMonitor<T>

fn from(value: T) -> Self

Creates a mock monitor from an initial state value.

impl<T> NotificationWaiter for MockMonitor<T>

fn wait(&self)

Blocks until a notification happens after this call starts.

impl<T> Notifier for MockMonitor<T>

fn notify_one(&self)

Wakes one waiter if one is blocked.

fn notify_all(&self)

Wakes all waiters.

impl<T> TimeoutConditionWaiter for MockMonitor<T>

fn wait_until_for<R, P, F>( &self, timeout: Duration, predicate: P, action: F, ) -> WaitTimeoutResult<R>

where P: FnMut(&Self::State) -> bool, F: FnOnce(&mut Self::State) -> R,

Blocks until the predicate becomes true or mock elapsed time reaches timeout.

fn wait_while_for<R, P, F>( &self, timeout: Duration, predicate: P, action: F, ) -> WaitTimeoutResult<R>

where P: FnMut(&Self::State) -> bool, F: FnOnce(&mut Self::State) -> R,

Blocks while the predicate remains true or until mock elapsed time reaches timeout.

impl<T> TimeoutNotificationWaiter for MockMonitor<T>

fn wait_for(&self, timeout: Duration) -> WaitTimeoutStatus

Blocks until a notification happens or mock elapsed time reaches timeout.