Struct RecordingClock 

pub struct RecordingClock<S> { /* private fields */ }

A clock that keeps every value reported into one watch, for a test that checks steps a host reading the watch could miss. A report reads its clock just before it sends, so what the watch holds at each reading, with what it holds at the end, is every value sent, in order. Time and waits are clock’s.

Implementations

impl<S: Clone + PartialEq> RecordingClock<S>

pub fn new(clock: ClockRef) -> Self

Keep time by clock; nothing is recorded until Self::watch.

pub fn watch(&self, watch: Receiver<Option<Progress<S>>>)

Record the values reported into watch, from now on, in place of the watch an earlier part of the operation reported into, whose newest value is recorded first: a join reports the scan that finds its keys through its own owner, then the loading of the store it publishes through the store’s.

pub fn watch_progress(&self, progress: ProgressWatch<S>)

Record the values an owner’s operation reports into progress, from now on.

pub fn on_record(&self, hook: impl Fn(&Progress<S>) + Send + Sync + 'static)

Call hook with each value as it is recorded, on the thread that read the clock: when that is the reporting work’s, the work waits until hook returns.

pub fn seen(&self) -> Vec<Progress<S>>

Every value reported so far, in order.

Trait Implementations

impl<S: Clone + PartialEq + Send + Sync> Clock for RecordingClock<S>

Available on crate feature test-utils only.

fn now(&self) -> SystemTime

The wall clock’s current time.

fn elapsed(&self) -> Duration

Monotonic time since an arbitrary origin, counting time the system spent asleep (§16.6). Readings never decrease within a process; only differences between two readings of one clock mean anything.

fn deadline( &self, duration: Duration, ) -> Pin<Box<dyn Future<Output = ()> + Send>>

End once duration of elapsed time has passed: a deadline that work races, such as a sign-in’s wait for its callback or a stalled transfer’s, or an interval, such as the idle time between passes. System clocks use the runtime’s monotonic timer; controlled clocks wake only when their supplied time advances.

fn wait_out(&self, wait: Duration) -> Pin<Box<dyn Future<Output = ()> + Send>>

Wait out wait before trying again: a backoff, a provider’s cooldown, or the spacing between requests the code chose. It passes as a deadline of the same length does; a test’s clock may move its time to the wait’s end as the code arms it, since no work races it.

fn sleep_until( &self, at: SystemTime, ) -> Pin<Box<dyn Future<Output = Result<(), WallTimerError>> + Send>>

Wait until the wall clock reads at or later, however it gets there: by running, or by being set past it (§13.2). A time already reached ends the wait at once, and a clock set back moves the wait’s end with it. The clock itself says when it reaches at; nothing reads it again on a timer. A clock that can’t say fails the wait.