use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::Notify;
#[derive(Clone)]
pub struct MockClock {
inner: Arc<MockClockInner>,
}
struct MockClockInner {
elapsed_ms: AtomicU64,
notify: Notify,
timers: std::sync::Mutex<Vec<TimerEntry>>,
}
struct TimerEntry {
deadline_ms: u64,
notify: Arc<Notify>,
fired: bool,
}
impl MockClock {
pub fn new() -> Self {
Self {
inner: Arc::new(MockClockInner {
elapsed_ms: AtomicU64::new(0),
notify: Notify::new(),
timers: std::sync::Mutex::new(Vec::new()),
}),
}
}
pub fn elapsed(&self) -> Duration {
Duration::from_millis(self.inner.elapsed_ms.load(Ordering::SeqCst))
}
pub fn elapsed_ms(&self) -> u64 {
self.inner.elapsed_ms.load(Ordering::SeqCst)
}
pub fn advance(&self, duration: Duration) {
let ms = duration.as_millis() as u64;
self.advance_ms(ms);
}
pub fn advance_ms(&self, ms: u64) {
let new_time = self.inner.elapsed_ms.fetch_add(ms, Ordering::SeqCst) + ms;
let mut timers = self.inner.timers.lock().unwrap();
for timer in timers.iter_mut() {
if !timer.fired && timer.deadline_ms <= new_time {
timer.fired = true;
timer.notify.notify_one();
}
}
timers.retain(|t| !t.fired);
self.inner.notify.notify_waiters();
}
pub fn advance_to_ms(&self, target_ms: u64) {
let current = self.inner.elapsed_ms.load(Ordering::SeqCst);
if target_ms > current {
self.advance_ms(target_ms - current);
}
}
pub fn register_timer(&self, delay: Duration) -> Arc<Notify> {
let deadline_ms = self.elapsed_ms() + delay.as_millis() as u64;
let notify = Arc::new(Notify::new());
let mut timers = self.inner.timers.lock().unwrap();
timers.push(TimerEntry {
deadline_ms,
notify: notify.clone(),
fired: false,
});
notify
}
pub async fn wait_for_advance(&self) {
self.inner.notify.notified().await;
}
pub fn pending_timer_count(&self) -> usize {
self.inner.timers.lock().unwrap().len()
}
pub fn next_timer_deadline_ms(&self) -> Option<u64> {
self.inner
.timers
.lock()
.unwrap()
.iter()
.filter(|t| !t.fired)
.map(|t| t.deadline_ms)
.min()
}
pub fn fire_next_timer(&self) -> bool {
if let Some(deadline) = self.next_timer_deadline_ms() {
self.advance_to_ms(deadline);
true
} else {
false
}
}
pub fn fire_all_timers(&self) -> usize {
let max_deadline = {
let timers = self.inner.timers.lock().unwrap();
timers
.iter()
.filter(|t| !t.fired)
.map(|t| t.deadline_ms)
.max()
};
if let Some(deadline) = max_deadline {
let count = self.pending_timer_count();
self.advance_to_ms(deadline);
count
} else {
0
}
}
pub fn reset(&self) {
self.inner.elapsed_ms.store(0, Ordering::SeqCst);
self.inner.timers.lock().unwrap().clear();
}
}
impl Default for MockClock {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_initial_state() {
let clock = MockClock::new();
assert_eq!(clock.elapsed(), Duration::ZERO);
assert_eq!(clock.elapsed_ms(), 0);
assert_eq!(clock.pending_timer_count(), 0);
}
#[test]
fn test_advance() {
let clock = MockClock::new();
clock.advance(Duration::from_secs(5));
assert_eq!(clock.elapsed(), Duration::from_secs(5));
clock.advance_ms(3000);
assert_eq!(clock.elapsed_ms(), 8000);
}
#[test]
fn test_advance_to() {
let clock = MockClock::new();
clock.advance_ms(5000);
clock.advance_to_ms(10000);
assert_eq!(clock.elapsed_ms(), 10000);
clock.advance_to_ms(3000);
assert_eq!(clock.elapsed_ms(), 10000);
}
#[test]
fn test_timer_fires_on_advance() {
let clock = MockClock::new();
let notify = clock.register_timer(Duration::from_secs(5));
assert_eq!(clock.pending_timer_count(), 1);
clock.advance(Duration::from_secs(3));
assert_eq!(clock.pending_timer_count(), 1);
clock.advance(Duration::from_secs(3));
assert_eq!(clock.pending_timer_count(), 0);
let _ = notify;
}
#[test]
fn test_fire_next_timer() {
let clock = MockClock::new();
let _t1 = clock.register_timer(Duration::from_secs(10));
let _t2 = clock.register_timer(Duration::from_secs(5));
assert!(clock.fire_next_timer());
assert_eq!(clock.elapsed_ms(), 5000);
assert_eq!(clock.pending_timer_count(), 1);
assert!(clock.fire_next_timer());
assert_eq!(clock.elapsed_ms(), 10000);
assert_eq!(clock.pending_timer_count(), 0);
assert!(!clock.fire_next_timer());
}
#[test]
fn test_fire_all_timers() {
let clock = MockClock::new();
let _t1 = clock.register_timer(Duration::from_secs(3));
let _t2 = clock.register_timer(Duration::from_secs(7));
let _t3 = clock.register_timer(Duration::from_secs(5));
let fired = clock.fire_all_timers();
assert_eq!(fired, 3);
assert_eq!(clock.elapsed_ms(), 7000);
assert_eq!(clock.pending_timer_count(), 0);
}
#[test]
fn test_reset() {
let clock = MockClock::new();
clock.advance_ms(5000);
let _timer = clock.register_timer(Duration::from_secs(10));
clock.reset();
assert_eq!(clock.elapsed_ms(), 0);
assert_eq!(clock.pending_timer_count(), 0);
}
#[test]
fn test_clone_shares_state() {
let clock = MockClock::new();
let clock2 = clock.clone();
clock.advance_ms(1000);
assert_eq!(clock2.elapsed_ms(), 1000);
}
}