Struct ManualClock 

pub struct ManualClock { /* private fields */ }

A clock whose time only moves when the test moves it.

The C++ header names “freeze or step time in tests without sleeping” as a reason the abstraction exists, but leaves each test to build its own stub. Providing one here keeps the scene, cursor, and pacing suites from reinventing it — and keeps them from reinventing it differently.

Interior mutability is deliberate: Clock::now takes &self, and a test holding a &dyn Clock still needs to advance it.

use core::time::Duration;
use drmkit_time::{Clock, ManualClock, Timestamp};

let clock = ManualClock::new();
assert_eq!(clock.now(), Timestamp::ZERO);

clock.advance(Duration::from_millis(16));
assert_eq!(clock.now(), Timestamp::from_nanos(16_000_000));

clock.set(Timestamp::from_nanos(1_000));
assert_eq!(clock.now().as_nanos(), 1_000);

Implementations

impl ManualClock

pub const fn new() -> Self

A clock frozen at Timestamp::ZERO.

pub const fn starting_at(start: Timestamp) -> Self

A clock frozen at start.

pub fn advance(&self, delta: Duration)

Move the clock forward by delta. Saturates at u64::MAX nanoseconds.

Saturating rather than wrapping is the whole point: a wrapped counter runs backwards, and every interval taken against it collapses to Duration::ZERO (see Timestamp::saturating_duration_since) — a test clock that silently stalls pacing instead of failing loudly.

pub fn set(&self, at: Timestamp)

Jump the clock to at.

Nothing stops a test from moving it backwards — that is the point of a manual clock — but production code must never observe a clock that does, so keep such tests scoped to the code under test.

Trait Implementations

impl Clock for ManualClock

fn now(&self) -> Timestamp

Sample the clock.

impl Debug for ManualClock

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

Formats the value using the given formatter.

impl Default for ManualClock

fn default() -> Self

Returns the “default value” for a type.