use std::{
sync::{Arc, Mutex},
time::Duration,
};
use crate::{ParkOutcome, Runtime, WakeReason, park_pair};
#[test]
fn timeout_updates_task_and_runtime_ledgers() {
let runtime = Runtime::new().expect("build runtime");
runtime
.run_scope(|scope| {
let (parker, _unparker) = park_pair();
let mut task = scope.spawn("timer", move || {
parker
.park_timeout(Duration::from_millis(1))
.expect("park with timeout")
})?;
assert_eq!(task.join()?, ParkOutcome::TimedOut);
let snapshot = scope.runtime_snapshot();
let task = snapshot
.tasks
.iter()
.find(|task| task.name == "timer")
.expect("task");
assert_eq!(task.parks, 1);
assert_eq!(task.last_wake, Some(WakeReason::TimedOut));
assert_eq!(snapshot.stats.wakes, 1);
assert_eq!(snapshot.stats.timeouts, 1);
assert_eq!(snapshot.parked, 0);
assert_eq!(snapshot.timers, 0);
Ok(())
})
.expect("scope succeeds");
}
#[test]
fn parked_tasks_do_not_consume_mounts_until_selected() {
let runtime = Runtime::new().expect("build runtime");
let trace = Arc::new(Mutex::new(Vec::new()));
let (parker, unparker) = park_pair();
runtime
.run_scope(|scope| {
let waiter_trace = Arc::clone(&trace);
let mut waiter = scope.spawn("waiter", move || {
waiter_trace.lock().expect("trace").push("before");
parker.park().expect("park");
waiter_trace.lock().expect("trace").push("after");
})?;
crate::support_test::until(|| scope.runtime_snapshot().parked == 1);
let wake_trace = Arc::clone(&trace);
let _ = scope.spawn("wake", move || {
wake_trace.lock().expect("trace").push("wake");
unparker.unpark();
})?;
waiter.join()?;
let waiter = scope
.runtime_snapshot()
.tasks
.into_iter()
.find(|task| task.name == "waiter")
.expect("waiter snapshot");
assert_eq!(waiter.mounts, 2);
Ok(())
})
.expect("scope succeeds");
assert_eq!(&*trace.lock().expect("trace"), &["before", "wake", "after"]);
}
#[test]
fn reclaiming_a_selected_but_unresumed_park_releases_the_active_generation() {
use crate::{
CarrierId, RuntimeConfig, TaskFailure, TaskId, control::Shared, kernel::Kernel,
wait::WaitBegin,
};
use std::sync::Arc;
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let scope = shared.begin_scope().unwrap();
let (parker, waker) = crate::park_pair();
let parker = Arc::new(parker);
let child_parker = Arc::clone(&parker);
shared
.submit(scope, "selected".into(), move || child_parker.park())
.unwrap();
let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
kernel.receive();
kernel.tick().unwrap();
waker.unpark();
kernel.process_wakes().unwrap();
kernel.abort(None, TaskFailure::RuntimeStopped);
let next = parker
.wait
.begin(TaskId::new(99), &kernel.inbox.hub, None)
.expect("old generation reclaimed");
if let WaitBegin::Park(request) = next {
parker.wait.rollback(request.token());
} else {
panic!("expected a fresh generation");
}
}