Skip to main content

reifydb_runtime/context/clock/
mod.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2025 ReifyDB
3
4#[cfg(any(reifydb_target = "native", reifydb_target = "dst"))]
5mod native;
6#[cfg(reifydb_target = "wasi")]
7mod wasi;
8#[cfg(reifydb_target = "wasm")]
9mod wasm;
10
11#[cfg(any(reifydb_target = "native", reifydb_target = "dst"))]
12pub use native::{Clock, Instant, MockClock};
13#[cfg(reifydb_target = "wasi")]
14pub use wasi::{Clock, Instant, MockClock};
15#[cfg(reifydb_target = "wasm")]
16pub use wasm::{Clock, Instant, MockClock};
17
18#[cfg(test)]
19mod tests {
20	#[cfg(reifydb_target = "native")]
21	use std::thread;
22
23	use super::*;
24
25	#[test]
26	fn test_real_clock() {
27		let clock = Clock::Real;
28		let t1 = clock.now_millis();
29		// Small busy loop to ensure time passes
30		let mut sum = 0;
31		for i in 0..10000 {
32			sum += i;
33		}
34		let t2 = clock.now_millis();
35		assert!(t2 >= t1, "Time should not go backwards");
36		let _ = sum;
37	}
38
39	#[test]
40	fn test_mock_clock_initial() {
41		let mock = MockClock::from_millis(1000);
42		let clock = Clock::Mock(mock);
43
44		assert_eq!(clock.now_millis(), 1000);
45		assert_eq!(clock.now_micros(), 1_000_000);
46		assert_eq!(clock.now_nanos(), 1_000_000_000);
47	}
48
49	#[test]
50	fn test_mock_clock_set() {
51		let mock = MockClock::from_millis(0);
52		mock.set_millis(5000);
53
54		assert_eq!(mock.now_millis(), 5000);
55
56		mock.set_micros(6_000_000);
57		assert_eq!(mock.now_millis(), 6000);
58	}
59
60	#[test]
61	fn test_mock_clock_advance() {
62		let mock = MockClock::from_millis(1000);
63		let clock = Clock::Mock(mock.clone());
64
65		assert_eq!(clock.now_millis(), 1000);
66
67		mock.advance_millis(500);
68		assert_eq!(clock.now_millis(), 1500);
69
70		mock.advance_micros(500_000);
71		assert_eq!(clock.now_millis(), 2000);
72
73		mock.advance_nanos(500_000_000);
74		assert_eq!(clock.now_millis(), 2500);
75	}
76
77	#[cfg(reifydb_target = "native")]
78	#[test]
79	fn test_mock_clock_thread_safe() {
80		let mock = MockClock::from_millis(1000);
81		let mock_clone = mock.clone();
82
83		let handle = thread::spawn(move || {
84			mock_clone.advance_millis(500);
85			mock_clone.now_millis()
86		});
87
88		let result = handle.join().unwrap();
89		assert_eq!(result, 1500);
90		assert_eq!(mock.now_millis(), 1500);
91	}
92
93	#[test]
94	fn test_nanosecond_precision() {
95		let mock = MockClock::new(1_234_567_890_123_456_789);
96		let clock = Clock::Mock(mock);
97
98		assert_eq!(clock.now_nanos(), 1_234_567_890_123_456_789);
99		assert_eq!(clock.now_micros(), 1_234_567_890_123_456);
100		assert_eq!(clock.now_millis(), 1_234_567_890_123);
101		assert_eq!(clock.now_secs(), 1_234_567_890);
102	}
103}