vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use std::time::{Duration, Instant};

use vthread_stack::ParkToken;

use super::TimerQueue;

#[test]
fn deadlines_are_returned_in_monotonic_order() {
    let now = Instant::now();
    let early = ParkToken::new(1, 1);
    let late = ParkToken::new(2, 1);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(late, now + Duration::from_secs(2)));
    assert!(timers.schedule(early, now + Duration::from_secs(1)));

    assert_eq!(timers.next_deadline(), Some(now + Duration::from_secs(1)));
    assert_eq!(
        timers.pop_expired(now + Duration::from_millis(1500)),
        vec![early]
    );
    assert_eq!(timers.active_count(), 1);
    assert_eq!(timers.pop_expired(now + Duration::from_secs(3)), vec![late]);
}

#[test]
fn cancellation_removes_the_earliest_deadline() {
    let now = Instant::now();
    let cancelled = ParkToken::new(1, 1);
    let active = ParkToken::new(2, 1);
    let mut timers = TimerQueue::new();
    timers.schedule(cancelled, now + Duration::from_secs(1));
    timers.schedule(active, now + Duration::from_secs(2));
    assert!(timers.cancel(cancelled));

    assert_eq!(timers.next_deadline(), Some(now + Duration::from_secs(2)));
    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(3)),
        vec![active]
    );
    assert_eq!(timers.active_count(), 0);
}

#[test]
fn cancellation_releases_storage_behind_a_live_earlier_deadline() {
    let now = Instant::now();
    let early = ParkToken::new(1, 1);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(early, now + Duration::from_secs(1)));

    for generation in 1..=256 {
        let later = ParkToken::new(2, generation);
        assert!(timers.schedule(later, now + Duration::from_secs(60)));
        assert!(timers.cancel(later));
    }

    assert_eq!(timers.next_deadline(), Some(now + Duration::from_secs(1)));
    assert_eq!(timers.active_count(), 1);
    assert_eq!(
        timers.deadlines.len(),
        1,
        "cancelled entries must not accumulate"
    );
    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(60)),
        vec![early]
    );
}

#[test]
fn duplicate_registration_preserves_the_original_deadline() {
    let now = Instant::now();
    let token = ParkToken::new(1, 1);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(token, now + Duration::from_secs(1)));
    assert!(!timers.schedule(token, now + Duration::from_secs(2)));

    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(1)),
        vec![token]
    );
    assert!(timers.pop_expired(now + Duration::from_secs(2)).is_empty());
    assert_eq!(timers.active_count(), 0);
}

#[test]
fn cancellation_is_exact_for_tokens_sharing_a_deadline() {
    let now = Instant::now();
    let old = ParkToken::new(1, 1);
    let current = ParkToken::new(1, 2);
    let other = ParkToken::new(2, 1);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(old, now));
    assert!(timers.schedule(current, now));
    assert!(timers.schedule(other, now));
    assert!(timers.cancel(old));
    assert!(!timers.cancel(old));

    assert_eq!(timers.pop_expired(now), vec![current, other]);
    assert_eq!(timers.active_count(), 0);
    assert_eq!(timers.next_deadline(), None);
}