use std::{
cell::Cell,
hint::black_box,
mem,
panic::{AssertUnwindSafe, catch_unwind},
rc::Rc,
};
use super::{FiberCore, ForcedUnwind, Outcome, Placement};
use crate::{MappedStack, STACK_ALIGNMENT, Suspension, arch};
fn place(entry: impl FnOnce()) -> (MappedStack, Placement) {
let stack = MappedStack::new(64 * 1024, 0).expect("allocate stack");
let placement = unsafe { FiberCore::place(&stack, entry) };
(stack, placement)
}
fn core(placement: &Placement) -> &FiberCore {
unsafe { placement.core.as_ref() }
}
#[test]
fn the_control_block_and_entry_sit_above_an_aligned_first_frame() {
let captured = [7u8; 40];
let (stack, placement) = place(move || {
black_box(captured);
});
let block = placement.core.as_ptr() as usize;
assert!(block + mem::size_of::<FiberCore>() <= stack.base().get());
assert_eq!(block % mem::align_of::<FiberCore>(), 0);
assert!(
placement.frame_top + 40 <= block,
"the entry storage sits between"
);
assert_eq!(placement.frame_top % STACK_ALIGNMENT, 0);
assert!(placement.frame_top - arch::FRAME_LEN > stack.limit().get() + stack.guard_len());
}
#[test]
fn an_oversized_entry_is_rejected_before_anything_is_written() {
let captured = [0u8; 70_000];
let result = catch_unwind(AssertUnwindSafe(|| {
place(move || {
black_box(captured);
})
}));
assert!(
result.is_err(),
"a 70000 byte entry cannot fit on a 64 KiB stack"
);
}
#[test]
fn every_block_receives_a_distinct_nonzero_cookie() {
let (_first_stack, first) = place(|| {});
let (_second_stack, second) = place(|| {});
assert_ne!(core(&first).cookie(), 0);
assert_ne!(core(&first).cookie(), core(&second).cookie());
}
#[test]
fn shared_outcomes_round_trip_through_the_block() {
let (_stack, placement) = place(|| {});
let core = core(&placement);
core.report(Outcome::Suspended(Suspension::YieldNow));
assert!(matches!(
core.take_outcome(),
Outcome::Suspended(Suspension::YieldNow)
));
}
#[test]
fn only_the_matching_forced_unwind_token_is_suppressed() {
let (_stack, placement) = place(|| {});
let core = core(&placement);
let own = Box::new(ForcedUnwind::new(core.cookie()));
assert!(matches!(core.classify(own), Outcome::Unwound));
let foreign = Box::new(ForcedUnwind::new(core.cookie() + 1));
assert!(matches!(core.classify(foreign), Outcome::Panicked(_)));
let user = Box::new("user panic");
assert!(matches!(core.classify(user), Outcome::Panicked(_)));
}
#[test]
fn the_entry_is_taken_once_and_dropped_when_unused() {
let drops = Rc::new(Cell::new(0));
struct Counted(Rc<Cell<u32>>);
impl Drop for Counted {
fn drop(&mut self) {
self.0.set(self.0.get() + 1);
}
}
let captured = Counted(Rc::clone(&drops));
let (_stack, placement) = place(move || drop(captured));
let entry = core(&placement).take_entry();
assert!(entry.is_some());
assert!(core(&placement).take_entry().is_none());
drop(entry);
assert_eq!(drops.get(), 1);
}
#[test]
fn cookies_are_unique_across_carriers_and_sequential_within_one() {
fn cookies() -> Vec<u64> {
let stack = MappedStack::new(64 * 1024, 0).expect("allocate stack");
(0..3)
.map(|_| {
let placement = unsafe { FiberCore::place(&stack, || {}) };
core(&placement).cookie()
})
.collect()
}
let here = cookies();
let there = std::thread::spawn(cookies).join().expect("carrier thread");
assert_eq!(here[1], here[0] + 1);
assert_eq!(here[2], here[1] + 1);
assert_eq!(there[1], there[0] + 1);
let mut all = [here, there].concat();
all.sort_unstable();
all.dedup();
assert_eq!(all.len(), 6, "cookies collided across carriers");
assert!(all.iter().all(|cookie| *cookie != 0));
}