Struct PollingClock 

pub struct PollingClock { /* private fields */ }

A fixed clock whose waits end only as its time reaches them. A backoff or cooldown the code waits out passes as the code arms it: this clock moves the fixed clock to the wait’s end, as the wait’s passing would, so retries run without real time and their timestamps are the waits the code chose. A deadline, which work races, and the idle interval end only when the test moves the clock, as does every wait once hold_waits is set. It records each wait_out it is given.

Implementations

impl PollingClock

pub fn new(clock: Arc<FixedClock>) -> Self

A polling clock over clock, which it moves.

pub fn hold_waits(&self)

End later waits by the test’s moves of the fixed clock alone; a wait armed before ends as its own move reaches it.

pub fn release_waits(&self)

Pass later waits as the code arms them again; a wait armed while they were held still ends only when the fixed clock reaches it.

pub fn holds_waits(&self) -> bool

Whether waits are held.

pub fn waited(&self) -> Vec<Duration>

Each backoff, cooldown or spacing the code armed, in order.

Trait Implementations

impl Clock for PollingClock

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.