use crate::{CarrierId, RuntimeConfig, TaskFailure, control::Shared, kernel::Kernel};
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
struct DropCount(Arc<AtomicUsize>);
impl Drop for DropCount {
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
#[test]
fn fault_cleanup_keeps_both_the_pending_packet_and_queued_packets_owned() {
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let scope = shared.begin_scope().expect("scope");
let drops = Arc::new(AtomicUsize::new(0));
for _ in 0..2 {
let guard = DropCount(Arc::clone(&drops));
shared
.submit(scope, "unstarted".into(), move || drop(guard))
.expect("submit");
}
let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
kernel.pending = kernel.inbox.pop();
kernel.abort(None, TaskFailure::CarrierFailed);
assert_eq!(drops.load(Ordering::SeqCst), 2);
assert_eq!(shared.snapshot().active, 0);
assert!(
shared
.snapshot()
.tasks
.iter()
.all(|task| task.failure == Some(TaskFailure::CarrierFailed))
);
}
#[test]
fn fault_cleanup_reclaims_every_batch_drained_packet() {
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let scope = shared.begin_scope().expect("scope");
let drops = Arc::new(AtomicUsize::new(0));
for _ in 0..3 {
let guard = DropCount(Arc::clone(&drops));
shared
.submit(scope, "drained".into(), move || drop(guard))
.expect("submit");
}
let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
assert_eq!(kernel.inbox.drain_into(&mut kernel.incoming, 3), 3);
kernel.abort(None, TaskFailure::CarrierFailed);
assert!(kernel.incoming.is_empty());
assert_eq!(drops.load(Ordering::SeqCst), 3);
assert_eq!(shared.snapshot().active, 0);
}
#[test]
fn delayed_abort_for_an_old_scope_preserves_every_new_scope_queue() {
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let old = shared.begin_scope().expect("old scope");
shared.finish_scope(old);
let current = shared.begin_scope().expect("new scope");
let (parker, _unparker) = crate::park_pair();
shared
.submit(current, "parked".into(), move || parker.park())
.expect("parked");
shared
.submit(current, "ready".into(), || ())
.expect("ready");
let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
kernel.receive();
kernel.tick(true).expect("park the first task");
shared
.submit(current, "queued".into(), || ())
.expect("queued");
kernel.abort(Some(old), TaskFailure::ScopeStalled);
let snapshot = shared.snapshot();
assert_eq!(snapshot.active, 3);
assert_eq!(snapshot.parked, 1);
assert_eq!(snapshot.runnable, 2);
assert!(snapshot.tasks.iter().all(|task| task.failure.is_none()));
kernel.abort(None, TaskFailure::RuntimeStopped);
}
#[test]
fn selective_abort_keeps_a_retained_in_flight_task_located() {
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let retained = shared.begin_scope().expect("retained scope");
let aborted = shared
.begin_owned(crate::ScopeOptions::default(), true)
.expect("aborted scope");
shared
.submit(retained, "retained".into(), || ())
.expect("retained task");
shared
.submit(aborted, "aborted".into(), || ())
.expect("aborted task");
let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
kernel.receive();
kernel.in_flight = kernel.ready.pop_front();
let retained_key = kernel.in_flight.expect("retained in-flight task");
kernel.abort(Some(aborted), TaskFailure::ScopeStalled);
assert_eq!(kernel.in_flight, Some(retained_key));
assert!(kernel.ready.is_empty());
assert_eq!(shared.snapshot().active, 1);
kernel.abort(None, TaskFailure::RuntimeStopped);
}
#[test]
fn selective_abort_reclaims_a_middle_wake_exactly_once() {
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let retained = shared.begin_scope().unwrap();
let aborted = shared
.begin_owned(crate::ScopeOptions::default(), true)
.unwrap();
for (index, scope) in [retained, aborted, retained, retained]
.into_iter()
.enumerate()
{
shared
.submit(scope, format!("wake-{index}"), || ())
.unwrap();
}
let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
kernel.receive();
let tasks = (0..4)
.map(|_| kernel.ready.pop_front().unwrap())
.collect::<Vec<_>>();
for task in tasks {
kernel.ready.push_wake(task);
}
assert!(kernel.abort(Some(aborted), TaskFailure::ScopeStalled));
assert_eq!(shared.scope_report(aborted).aborted, 1);
assert_eq!(kernel.ready.len(), 3);
kernel.abort(None, TaskFailure::RuntimeStopped);
}
#[test]
fn selective_abort_restores_in_flight_identity_beside_wakes() {
let shared = Arc::new(Shared::new(RuntimeConfig::default()));
let retained = shared.begin_scope().unwrap();
let aborted = shared
.begin_owned(crate::ScopeOptions::default(), true)
.unwrap();
for index in 0..3 {
shared
.submit(retained, format!("retained-{index}"), || ())
.unwrap();
}
let mut kernel = Kernel::new(shared, CarrierId(0));
kernel.receive();
kernel.in_flight = kernel.ready.pop_front();
let retained = kernel.in_flight;
let wakes = (0..2)
.map(|_| kernel.ready.pop_front().unwrap())
.collect::<Vec<_>>();
for task in wakes {
kernel.ready.push_wake(task);
}
assert!(kernel.abort(Some(aborted), TaskFailure::ScopeStalled));
assert_eq!(kernel.in_flight, retained);
assert_eq!(kernel.ready.len(), 2);
kernel.abort(None, TaskFailure::RuntimeStopped);
}