Struct MockClock

Source

pub struct MockClock { /* private fields */ }

Expand description

A controllable clock implementation for testing.

MockClock allows you to manually control the passage of time, making it ideal for testing time-dependent code. It uses MonotonicClock as its internal time base to ensure stability during tests.

§Features

Set the clock to a specific time
Advance the clock by a duration
Automatically advance time on each call
Reset to initial state

§Thread Safety

This type is thread-safe, using Arc<Mutex<>> internally to protect its mutable state.

§Examples

use qubit_clock::{Clock, ControllableClock, MockClock};
use chrono::{DateTime, Duration, Utc};

let clock = MockClock::new();

// Set to a specific time
let fixed_time = DateTime::parse_from_rfc3339(
    "2024-01-01T00:00:00Z"
).unwrap().with_timezone(&Utc);
clock.set_time(fixed_time);
assert_eq!(clock.time(), fixed_time);

// Advance by 1 hour
clock.add_duration(Duration::hours(1));
assert_eq!(clock.time(), fixed_time + Duration::hours(1));

// Reset to initial state
clock.reset();

§Author

Haixing Hu

Implementations§

Source §

impl MockClock

Source

pub fn new() -> Self

Creates a new MockClock.

The clock is initialized with the current system time and uses a MonotonicClock as its internal time base.

§Returns

A new MockClock instance.

§Examples

use qubit_clock::MockClock;

let clock = MockClock::new();

Source

pub fn add_millis(&self, millis: i64, add_every_time: bool)

Adds a fixed amount of milliseconds to the clock.

§Arguments

millis - The number of milliseconds to add.
add_every_time - If true, the specified milliseconds will be added on every call to millis(). If false, the milliseconds are added only once.

§Examples

use qubit_clock::{Clock, MockClock};

let clock = MockClock::new();
let before = clock.millis();

// Add 1000ms once
clock.add_millis(1000, false);
assert_eq!(clock.millis(), before + 1000);

// Add 100ms on every call
clock.add_millis(100, true);
let t1 = clock.millis();
let t2 = clock.millis();
assert_eq!(t2 - t1, 100);

Source

pub fn advance_millis(&self, millis: i64)

Advances the clock by a fixed amount once.

This method updates the offset used by millis() and time() without enabling auto-advance.

§Arguments

millis - The milliseconds to add once.

§Examples

use qubit_clock::{Clock, MockClock};

let clock = MockClock::new();
let before = clock.millis();
clock.advance_millis(1000);
assert_eq!(clock.millis(), before + 1000);

Source

pub fn set_auto_advance_millis(&self, millis: i64)

Enables auto-advance on each read operation.

After calling this method, each call to millis() or time() will advance the clock by millis.

§Arguments

millis - The milliseconds to advance on each read.

§Examples

use qubit_clock::{Clock, MockClock};

let clock = MockClock::new();
clock.set_auto_advance_millis(100);
let t1 = clock.millis();
let t2 = clock.millis();
assert_eq!(t2 - t1, 100);

Source

pub fn clear_auto_advance(&self)

Disables auto-advance behavior.

This method clears the per-read advance setting. Subsequent read operations will no longer mutate the clock state.

§Examples

use qubit_clock::{Clock, MockClock};

let clock = MockClock::new();
clock.set_auto_advance_millis(100);
let _ = clock.millis();
clock.clear_auto_advance();
let t1 = clock.millis();
let t2 = clock.millis();
assert!((t2 - t1).abs() < 10);