use core::mem::size_of;
use std::io;
use std::sync::atomic::{AtomicU64, Ordering};
use bstack::{
BStack, BStackAllocator, BStackRange, FirstFitBStackAllocator, GhostTreeBstackAllocator,
};
use crate::types::compiled::block::{BlockHeader, HEADER_SIZE};
use crate::types::compiled::rc::build_control_payload;
use crate::types::compiled::rc::{
CTRL_BACKPTR_OFFSET, CTRL_DATA_OFFSET, CTRL_STRONG_OFFSET, CTRL_WEAK_OFFSET,
};
use crate::{
AutoDrop, BStackBlock, BStackBlockVec, BStackCast, BStackCastAs, BStackCastInto, BStackDeque,
BStackDrop, BStackOwned, BStackRaiiAllocator, BStackRc, BStackRef, BStackShared,
BStackWeakable, EightCC, TryClone, TryCloneIn, bstack_block, bstack_cast, bstack_enum,
bstack_move, dealloc_range,
};
fn nn(off: u64) -> crate::primitives::NonNullOffset {
crate::primitives::NonNullOffset::from_field(off).unwrap()
}
fn alloc_block<A: BStackRaiiAllocator>(
allocator: &A,
tag: EightCC,
size: u64,
) -> io::Result<BStackRange> {
let mut slice = allocator.alloc(size)?;
let header = BlockHeader { size, tag };
if let Err(e) = slice.write(bytemuck::bytes_of(&header)) {
let _ = allocator.dealloc(slice);
return Err(e);
}
Ok(slice.as_range())
}
static COUNTER: AtomicU64 = AtomicU64::new(0);
struct TempStack {
path: std::path::PathBuf,
}
impl TempStack {
fn new() -> Self {
let n = COUNTER.fetch_add(1, Ordering::Relaxed);
let mut path = std::env::temp_dir();
path.push(format!(
"bstack_raii_test_{}_{n}.bstack",
std::process::id()
));
let _ = std::fs::remove_file(&path);
TempStack { path }
}
fn open(&self) -> BStack {
BStack::open(&self.path).unwrap()
}
fn allocator(&self) -> FirstFitBStackAllocator {
FirstFitBStackAllocator::new(self.open()).unwrap()
}
fn ghost_allocator(&self) -> GhostTreeBstackAllocator {
GhostTreeBstackAllocator::new(self.open()).unwrap()
}
}
impl Drop for TempStack {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
fn assert_teardown_reclaims<T: BStackDrop>(
alloc: &FirstFitBStackAllocator,
mut build: impl FnMut() -> T,
) {
build().bstack_drop(alloc).unwrap();
let base = alloc.len().unwrap();
build().bstack_drop(alloc).unwrap();
assert_eq!(
alloc.len().unwrap(),
base,
"teardown leaked (non-recursive?)"
);
}
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct TestOnDisk {
header: BlockHeader,
ctrl: u64,
}
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct TestControl {
header: BlockHeader,
strong: u64,
weak: u64,
x: u64,
}
#[derive(Clone, Copy)]
struct TestBlock(BStackRange);
impl BStackCast for TestBlock {
fn eightcc() -> EightCC {
EightCC::from_name("TESTDATA")
}
}
impl BStackDrop for TestBlock {
fn bstack_drop<A: BStackRaiiAllocator>(self, allocator: &A) -> io::Result<()> {
unsafe { dealloc_range(allocator, self.0) }
}
}
impl BStackBlock for TestBlock {
type OnDisk = TestOnDisk;
unsafe fn from_range(range: BStackRange) -> Self {
TestBlock(range)
}
fn range(&self) -> BStackRange {
self.0
}
}
impl BStackWeakable for TestBlock {
type Control = TestControl;
fn control_eightcc() -> EightCC {
ctrl_tag()
}
}
fn ctrl_tag() -> EightCC {
EightCC::from_name("TESTCTRL")
}
fn alloc_control<A: BStackRaiiAllocator>(
allocator: &A,
ctrl_tag: EightCC,
data: BStackRange,
control_size: u64,
) -> io::Result<BStackRange> {
let slice = allocator.alloc(control_size)?;
let ctrl = slice.as_range();
let payload = build_control_payload(ctrl_tag, data.start());
let backptr_off = data.start() + CTRL_BACKPTR_OFFSET;
let backptr = ctrl.start().to_le_bytes();
let writes: [(u64, &[u8]); 2] = [(ctrl.start(), &payload), (backptr_off, &backptr)];
if let Err(e) = allocator.stack().set_batched(writes) {
let _ = allocator.dealloc(slice);
return Err(e);
}
Ok(ctrl)
}
fn build_rc_weak(alloc: &FirstFitBStackAllocator) -> (BStackRange, BStackRange) {
let data = alloc_block(alloc, TestBlock::eightcc(), size_of::<TestOnDisk>() as u64).unwrap();
let ctrl = alloc_control(alloc, ctrl_tag(), data, size_of::<TestControl>() as u64).unwrap();
(data, ctrl)
}
fn rc_of<'a>(
alloc: &'a FirstFitBStackAllocator,
data: BStackRange,
ctrl: BStackRange,
) -> BStackRc<'a, TestBlock, FirstFitBStackAllocator> {
unsafe { BStackRc::from_raw(BStackRef::from_range(data), Some(ctrl), alloc) }
}
#[test]
fn refcount_ops() {
let tmp = TempStack::new();
let stack = tmp.open();
let _pad = stack.push(0u64.to_le_bytes()).unwrap();
let off = stack.push(1u64.to_le_bytes()).unwrap();
assert_ne!(off, 0);
assert_eq!(crate::io_core::refcount::load(&stack, nn(off)).unwrap(), 1);
assert_eq!(
crate::io_core::refcount::fetch_add(&stack, nn(off), 5).unwrap(),
1
); assert_eq!(crate::io_core::refcount::load(&stack, nn(off)).unwrap(), 6);
assert_eq!(
crate::io_core::refcount::fetch_sub(&stack, nn(off), 2).unwrap(),
6
);
assert_eq!(crate::io_core::refcount::load(&stack, nn(off)).unwrap(), 4);
assert_eq!(
crate::io_core::refcount::increment_if_nonzero(&stack, nn(off)).unwrap(),
Some(5)
);
assert_eq!(
crate::io_core::refcount::fetch_sub(&stack, nn(off), 5).unwrap(),
5
);
assert_eq!(crate::io_core::refcount::load(&stack, nn(off)).unwrap(), 0);
assert_eq!(
crate::io_core::refcount::increment_if_nonzero(&stack, nn(off)).unwrap(),
None
);
assert_eq!(crate::io_core::refcount::load(&stack, nn(off)).unwrap(), 0);
assert!(crate::io_core::refcount::fetch_sub(&stack, nn(off), 1).is_err());
}
#[test]
fn rc_weak_lifecycle() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let dsize = size_of::<TestOnDisk>() as u64;
let (data, ctrl) = build_rc_weak(&alloc);
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
let weak_off = ctrl.start() + CTRL_WEAK_OFFSET;
let load = |o: u64| crate::io_core::refcount::load(alloc.stack(), nn(o)).unwrap();
assert_eq!(load(strong_off), 1);
assert_eq!(load(weak_off), 1);
assert_eq!(load(data.start() + CTRL_BACKPTR_OFFSET), ctrl.start());
assert_eq!(load(ctrl.start() + CTRL_DATA_OFFSET), data.start());
let rc = rc_of(&alloc, data, ctrl);
let rc2 = rc.try_clone().unwrap();
assert_eq!(load(strong_off), 2);
let weak = rc.downgrade().unwrap();
assert_eq!(load(weak_off), 2);
drop(rc2);
assert_eq!(load(strong_off), 1);
let rc3 = weak.upgrade().unwrap().expect("still alive");
assert_eq!(load(strong_off), 2);
drop(rc3);
assert_eq!(load(strong_off), 1);
drop(rc);
assert_eq!(load(strong_off), 0);
assert_eq!(load(weak_off), 1);
assert!(weak.upgrade().unwrap().is_none());
let reused = alloc_block(&alloc, TestBlock::eightcc(), dsize).unwrap();
assert_eq!(reused.start(), data.start());
unsafe { dealloc_range(&alloc, reused).unwrap() };
drop(weak);
}
#[test]
fn concurrent_clone_drop() {
const THREADS: usize = 8;
const ITERS: usize = 500;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let (data, ctrl) = build_rc_weak(&alloc);
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
let rc = rc_of(&alloc, data, ctrl);
std::thread::scope(|s| {
for _ in 0..THREADS {
let rc = &rc;
s.spawn(move || {
for _ in 0..ITERS {
let clone = rc.try_clone().unwrap();
drop(clone);
}
});
}
});
assert_eq!(
crate::io_core::refcount::load(alloc.stack(), nn(strong_off)).unwrap(),
1
);
drop(rc);
}
#[test]
fn concurrent_upgrade_downgrade() {
const THREADS: usize = 8;
const ITERS: usize = 400;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let (data, ctrl) = build_rc_weak(&alloc);
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
let weak_off = ctrl.start() + CTRL_WEAK_OFFSET;
let rc = rc_of(&alloc, data, ctrl);
let weak = rc.downgrade().unwrap();
std::thread::scope(|s| {
for _ in 0..THREADS {
let rc = &rc;
let weak = &weak;
s.spawn(move || {
for _ in 0..ITERS {
if let Some(upgraded) = weak.upgrade().unwrap() {
drop(upgraded);
}
drop(rc.try_clone().unwrap());
}
});
}
});
assert_eq!(
crate::io_core::refcount::load(alloc.stack(), nn(strong_off)).unwrap(),
1
);
assert_eq!(
crate::io_core::refcount::load(alloc.stack(), nn(weak_off)).unwrap(),
2
);
drop(weak); drop(rc); }
#[bstack_block]
struct MacroLeaf {
val: u32,
}
#[bstack_block]
struct MacroParent {
#[bstack_owned]
child: MacroLeaf,
tag: u32,
}
#[test]
fn macro_recursive_drop() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let leaf_size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let parent_size = size_of::<<MacroParent as BStackBlock>::OnDisk>() as u64;
assert_teardown_reclaims(&alloc, || {
let leaf = alloc_block(&alloc, MacroLeaf::eightcc(), leaf_size).unwrap();
let parent = alloc_block(&alloc, MacroParent::eightcc(), parent_size).unwrap();
alloc
.stack()
.set(parent.start() + HEADER_SIZE, leaf.start().to_le_bytes())
.unwrap();
unsafe { BStackOwned::from_raw(<MacroParent as BStackBlock>::from_range(parent)) }
});
}
#[test]
fn macro_recursive_drop_on_bulk_allocator() {
let tmp = TempStack::new();
let alloc = tmp.ghost_allocator();
let build = || {
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
MacroParent::new(&alloc, leaf, 7).unwrap()
};
build().bstack_drop(&alloc).unwrap();
let base = alloc.len().unwrap();
build().bstack_drop(&alloc).unwrap();
assert_eq!(
alloc.len().unwrap(),
base,
"bulk teardown leaked (child not freed by dealloc_bulk?)"
);
}
#[test]
fn autodrop_guard_frees_on_scope_exit() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let leaf = alloc_block(&alloc, MacroLeaf::eightcc(), size).unwrap();
let handle = unsafe { <MacroLeaf as BStackBlock>::from_range(leaf) };
let guard = unsafe { AutoDrop::from_raw(BStackOwned::from_raw(handle), &alloc) };
drop(guard);
let reused = alloc_block(&alloc, MacroLeaf::eightcc(), size).unwrap();
assert_eq!(reused.start(), leaf.start());
unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[test]
fn bare_handle_frees_only_when_asked() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let leaf = alloc_block(&alloc, MacroLeaf::eightcc(), size).unwrap();
let handle = unsafe { <MacroLeaf as BStackBlock>::from_range(leaf) };
let other = alloc_block(&alloc, MacroLeaf::eightcc(), size).unwrap();
assert_ne!(other.start(), leaf.start());
unsafe { BStackOwned::from_raw(handle) }
.bstack_drop(&alloc)
.unwrap();
let reused = alloc_block(&alloc, MacroLeaf::eightcc(), size).unwrap();
assert_eq!(reused.start(), leaf.start());
unsafe { dealloc_range(&alloc, reused).unwrap() };
unsafe { dealloc_range(&alloc, other).unwrap() };
}
#[bstack_block(rc, weak)]
struct MacroShared {
#[bstack_owned]
child: MacroLeaf,
}
#[test]
fn macro_rc_weak_with_child() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let leaf_size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let data_size = size_of::<<MacroShared as BStackBlock>::OnDisk>() as u64;
let ctrl_size = size_of::<<MacroShared as BStackWeakable>::Control>() as u64;
let leaf = alloc_block(&alloc, MacroLeaf::eightcc(), leaf_size).unwrap();
let data = alloc_block(&alloc, MacroShared::eightcc(), data_size).unwrap();
alloc
.stack()
.set(data.start() + HEADER_SIZE + 8, leaf.start().to_le_bytes())
.unwrap();
let ctrl = alloc_control(&alloc, ctrl_tag(), data, ctrl_size).unwrap();
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
let weak_off = ctrl.start() + CTRL_WEAK_OFFSET;
let load = |o: u64| crate::io_core::refcount::load(alloc.stack(), nn(o)).unwrap();
assert_eq!(load(strong_off), 1);
assert_eq!(load(weak_off), 1);
let rc = unsafe {
BStackRc::<MacroShared, _>::from_raw(BStackRef::from_range(data), Some(ctrl), &alloc)
};
let rc2 = rc.try_clone().unwrap();
assert_eq!(load(strong_off), 2);
let weak = rc.downgrade().unwrap();
assert_eq!(load(weak_off), 2);
drop(rc2);
drop(rc);
assert_eq!(load(strong_off), 0);
assert_eq!(load(weak_off), 1);
assert!(weak.upgrade().unwrap().is_none());
drop(weak);
let reused = alloc_block(&alloc, MacroLeaf::eightcc(), leaf_size).unwrap();
assert_eq!(reused.start(), leaf.start());
unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[bstack_block(rc, weak)]
struct MacroStrongChild {
val: u32,
}
#[bstack_block]
struct MacroStrongParent {
#[bstack_strong]
s: MacroStrongChild,
}
#[test]
fn macro_strong_child() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let child_data_size = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let child_ctrl_size = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let parent_size = size_of::<<MacroStrongParent as BStackBlock>::OnDisk>() as u64;
let child = alloc_block(&alloc, MacroStrongChild::eightcc(), child_data_size).unwrap();
let child_ctrl = alloc_control(&alloc, ctrl_tag(), child, child_ctrl_size).unwrap();
let strong_off = child_ctrl.start() + CTRL_STRONG_OFFSET;
crate::io_core::refcount::fetch_add(alloc.stack(), nn(strong_off), 1).unwrap();
let parent = alloc_block(&alloc, MacroStrongParent::eightcc(), parent_size).unwrap();
alloc
.stack()
.set(parent.start() + HEADER_SIZE, child.start().to_le_bytes())
.unwrap();
let owned =
unsafe { BStackOwned::from_raw(<MacroStrongParent as BStackBlock>::from_range(parent)) };
owned.bstack_drop(&alloc).unwrap();
assert_eq!(
crate::io_core::refcount::load(alloc.stack(), nn(strong_off)).unwrap(),
1
);
MacroStrongChild::drop_strong_ref(unsafe { BStackRef::from_range(child) }, &alloc).unwrap();
let mut ranges = Vec::new();
let mut hit = false;
for _ in 0..8 {
let r = alloc_block(&alloc, MacroStrongChild::eightcc(), child_data_size).unwrap();
if r.start() == child.start() {
hit = true;
}
ranges.push(r);
}
for r in ranges {
unsafe { dealloc_range(&alloc, r).unwrap() };
}
assert!(hit, "child data slot was not reclaimed on strong -> 0");
}
#[test]
fn macro_new_and_accessors() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
assert_eq!(leaf.handle().get_val(stack).unwrap(), 42);
let parent = MacroParent::new(&alloc, leaf, 7).unwrap();
assert_eq!(parent.handle().get_tag(stack).unwrap(), 7);
let child = parent.handle().get_child(stack).unwrap();
assert_eq!(child.get_val(stack).unwrap(), 42);
parent.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_clone_deep_owned() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let parent = MacroParent::new(&alloc, leaf, 7).unwrap();
let orig_child = parent.handle().get_child(stack).unwrap();
let clone = parent.try_clone_in(&alloc).unwrap();
assert_eq!(clone.handle().get_tag(stack).unwrap(), 7);
assert_eq!(
clone
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
42
);
assert_ne!(
clone.handle().range().start(),
parent.handle().range().start()
);
assert_ne!(
clone.handle().get_child(stack).unwrap().range().start(),
orig_child.range().start()
);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
parent
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
42
);
parent.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_deep_clone_on_bulk_allocator() {
let tmp = TempStack::new();
let alloc = tmp.ghost_allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let parent = MacroParent::new(&alloc, leaf, 7).unwrap();
let orig_child = parent.handle().get_child(stack).unwrap();
let clone = parent.try_clone_in(&alloc).unwrap();
assert_eq!(clone.handle().get_tag(stack).unwrap(), 7);
assert_eq!(
clone
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
42
);
assert_ne!(
clone.handle().range().start(),
parent.handle().range().start()
);
assert_ne!(
clone.handle().get_child(stack).unwrap().range().start(),
orig_child.range().start()
);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
parent
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
42
);
parent.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_deep_clone_on_bulk_allocator_no_leak() {
let tmp = TempStack::new();
let alloc = tmp.ghost_allocator();
let stack = alloc.stack();
let build = || {
let leaf = MacroLeaf::new(&alloc, 1).unwrap();
MacroParent::new(&alloc, leaf, 2).unwrap()
};
let p0 = build();
p0.try_clone_in(&alloc)
.unwrap()
.bstack_drop(&alloc)
.unwrap();
p0.bstack_drop(&alloc).unwrap();
let base = stack.len().unwrap();
let p = build();
let c = p.try_clone_in(&alloc).unwrap();
c.bstack_drop(&alloc).unwrap();
p.bstack_drop(&alloc).unwrap();
assert_eq!(
stack.len().unwrap(),
base,
"two-pass bulk clone leaked or double-allocated"
);
}
#[test]
fn macro_clone_bumps_shared_refcount() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let rc = MacroStrongChild::new(&alloc, 5).unwrap();
let rc_keep = rc.try_clone().unwrap();
let parent = MacroStrongParent::new(&alloc, rc).unwrap();
let s_data =
crate::io_core::refcount::load(stack, nn(parent.handle().range().start() + HEADER_SIZE))
.unwrap();
let ctrl = crate::io_core::refcount::load(stack, nn(s_data + CTRL_BACKPTR_OFFSET)).unwrap();
let strong_off = ctrl + CTRL_STRONG_OFFSET;
assert_eq!(
crate::io_core::refcount::load(stack, nn(strong_off)).unwrap(),
2
);
let clone = parent.try_clone_in(&alloc).unwrap();
assert_eq!(
crate::io_core::refcount::load(stack, nn(strong_off)).unwrap(),
3
);
clone.bstack_drop(&alloc).unwrap();
parent.bstack_drop(&alloc).unwrap();
assert_eq!(
crate::io_core::refcount::load(stack, nn(strong_off)).unwrap(),
1
);
assert_eq!(rc_keep.handle().get_val(stack).unwrap(), 5);
drop(rc_keep);
}
#[test]
fn macro_new_rc_weak() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 99).unwrap();
let rc = MacroShared::new(&alloc, leaf).unwrap();
assert_eq!(
rc.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
99
);
let rc2 = rc.try_clone().unwrap();
let weak = rc.downgrade().unwrap();
drop(rc2);
drop(rc);
assert!(weak.upgrade().unwrap().is_none());
drop(weak);
}
#[test]
fn macro_new_rc_weak_on_bulk_allocator() {
let tmp = TempStack::new();
let alloc = tmp.ghost_allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 7).unwrap();
let rc = MacroShared::new(&alloc, leaf).unwrap();
assert_eq!(
rc.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
7
);
let rc2 = rc.try_clone().unwrap();
let weak = rc.downgrade().unwrap();
drop(rc2);
drop(rc);
assert!(weak.upgrade().unwrap().is_none());
drop(weak);
}
#[bstack_block(rc, weak)]
struct WNode {
#[bstack_weak]
back: WNode,
val: u32,
}
#[test]
fn macro_weak_field_cycle() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let a = WNode::new(&alloc, 1).unwrap();
let b = WNode::new(&alloc, 2).unwrap();
let a_data = a.handle().range().start();
b.handle().set_back(&alloc, a.downgrade().unwrap()).unwrap();
let up = b.handle().get_back(&alloc).unwrap().expect("a is alive");
assert_eq!(up.handle().get_val(alloc.stack()).unwrap(), 1);
drop(up);
drop(a);
assert!(b.handle().get_back(&alloc).unwrap().is_none());
drop(b);
let reused = alloc_block(
&alloc,
WNode::eightcc(),
size_of::<<WNode as BStackBlock>::OnDisk>() as u64,
)
.unwrap();
assert_eq!(reused.start(), a_data);
unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[test]
fn macro_bstack_move() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 55).unwrap();
let leaf_off = leaf.handle().range().start();
let parent = MacroParent::new(&alloc, leaf, 7).unwrap();
let (child, tag) = bstack_move!(parent, &alloc).unwrap();
assert_eq!(tag, 7);
assert_eq!(child.handle().range().start(), leaf_off);
assert_eq!(child.handle().get_val(stack).unwrap(), 55);
child.bstack_drop(&alloc).unwrap();
let reused = alloc_block(
&alloc,
MacroLeaf::eightcc(),
size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64,
)
.unwrap();
assert_eq!(reused.start(), leaf_off);
unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[bstack_block]
struct MoveHolder {
#[bstack_strong]
s: MacroStrongChild,
#[bstack_weak]
w: WNode,
n: u32,
}
#[test]
fn macro_bstack_move_shared() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let sc = MacroStrongChild::new(&alloc, 88).unwrap(); let wt = WNode::new(&alloc, 3).unwrap();
let holder = MoveHolder::new(&alloc, sc, 5).unwrap();
holder
.handle()
.set_w(&alloc, wt.downgrade().unwrap())
.unwrap();
let (moved_s, moved_w, n) = bstack_move!(holder, &alloc).unwrap();
assert_eq!(n, 5);
assert_eq!(moved_s.handle().get_val(stack).unwrap(), 88);
let up = moved_w
.as_ref()
.unwrap()
.upgrade()
.unwrap()
.expect("wt alive");
assert_eq!(up.handle().get_val(stack).unwrap(), 3);
drop(up);
drop(moved_s); drop(moved_w); drop(wt); }
#[bstack_block]
struct SomeAbstractThing {
x: u32,
}
#[bstack_block]
struct ABlock {
x: u32,
}
#[bstack_block(tag = "OVR")]
struct Overridden {
x: u32,
}
#[bstack_block(rc, weak)]
struct TagCtrl {
x: u32,
}
#[bstack_block(tag = "SAME")]
struct SameA {
x: u32,
}
#[bstack_block(tag = "SAME")]
struct SameB {
x: u32,
}
#[bstack_block(tag = "TOOLONGTAG12", allow(overlong_tag))]
struct Truncated {
x: u32,
}
#[test]
fn macro_tag_generation() {
let t = SomeAbstractThing::eightcc().0;
assert_eq!(&t[0..3], b"SAT");
assert!(t[3..].iter().all(|&b| b & 0x80 != 0));
assert_eq!(&ABlock::eightcc().0[0..2], b"AB");
let o = Overridden::eightcc().0;
assert_eq!(&o[0..3], b"OVR");
assert!(o[3..].iter().all(|&b| b & 0x80 != 0));
let a = SameA::eightcc().0;
let b = SameB::eightcc().0;
assert_eq!(&a[0..4], b"SAME");
assert_eq!(&b[0..4], b"SAME");
assert_ne!(a[4..], b[4..]);
assert_eq!(&Truncated::eightcc().0, b"TOOLONGT");
}
#[test]
fn macro_control_tag_differs_in_reserved_bit() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let rc = TagCtrl::new(&alloc, 1).unwrap();
let data_off = rc.handle().range().start();
let mut buf = [0u8; 8];
stack
.get_into(data_off + CTRL_BACKPTR_OFFSET, &mut buf)
.unwrap();
let ctrl_off = u64::from_le_bytes(buf);
let mut ctrl_tag = [0u8; 8];
stack.get_into(ctrl_off + 8, &mut ctrl_tag).unwrap();
let data_tag = TagCtrl::eightcc().0; assert_eq!(&data_tag[0..2], b"TC");
assert_eq!(&ctrl_tag[0..2], b"TC");
assert_eq!(ctrl_tag[2..7], data_tag[2..7]);
assert_eq!(ctrl_tag[7], data_tag[7] ^ 0x40);
assert_ne!(ctrl_tag, data_tag);
drop(rc);
}
#[test]
fn macro_cast() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 9).unwrap();
let sl = leaf.handle().as_slice(stack);
assert_eq!(
sl.cast_as::<MacroLeaf>()
.unwrap()
.unwrap()
.get_val(stack)
.unwrap(),
9
);
assert!(sl.cast_as::<MacroParent>().unwrap().is_none()); assert!(bstack_cast!(sl as MacroLeaf).unwrap().is_some());
assert!(bstack_cast!(sl as MacroParent).unwrap().is_none());
let slice = bstack_cast!(leaf.auto(&alloc) as BStackOwnedSlice);
let slice = match slice.cast_into::<MacroParent>() {
Ok(_) => panic!("tag should not match"),
Err(e) => e.into_slice(),
};
let owned = bstack_cast!(slice as BStackOwned<MacroLeaf, _>).unwrap();
assert_eq!(owned.handle().get_val(stack).unwrap(), 9);
owned.bstack_drop(&alloc).unwrap(); }
#[bstack_block(rc)]
struct RcHolder {
#[bstack_owned]
leaf: MacroLeaf,
n: u32,
}
#[bstack_block(rc, weak)]
struct RcwHolder {
#[bstack_owned]
leaf: MacroLeaf,
n: u32,
}
#[test]
fn macro_bstack_move_rc() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 5).unwrap();
let leaf_off = leaf.handle().range().start();
let rc = RcHolder::new(&alloc, leaf, 7).unwrap();
let clone = rc.try_clone().unwrap(); let rc = match bstack_move!(rc).unwrap() {
Ok(_) => panic!("must not move a shared block"),
Err(rc) => rc, };
drop(clone);
let (moved_leaf, n) = bstack_move!(rc).unwrap().ok().expect("sole owner");
assert_eq!(n, 7);
assert_eq!(moved_leaf.handle().get_val(stack).unwrap(), 5);
moved_leaf.bstack_drop(&alloc).unwrap();
let reused = alloc_block(
&alloc,
MacroLeaf::eightcc(),
size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64,
)
.unwrap();
assert_eq!(reused.start(), leaf_off);
unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[test]
fn macro_bstack_move_rc_weak() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 9).unwrap();
let rc = RcwHolder::new(&alloc, leaf, 3).unwrap();
let weak = rc.downgrade().unwrap();
let (moved_leaf, n) = bstack_move!(rc).unwrap().ok().expect("sole strong owner");
assert_eq!(n, 3);
assert_eq!(moved_leaf.handle().get_val(stack).unwrap(), 9);
assert!(weak.upgrade().unwrap().is_none());
moved_leaf.bstack_drop(&alloc).unwrap(); drop(weak); }
#[bstack_block]
struct OptHolder {
#[bstack_owned]
child: Option<MacroLeaf>,
n: u32,
}
#[test]
fn macro_option_owned() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let leaf_off = leaf.handle().range().start();
let holder = OptHolder::new(&alloc, Some(leaf), 7).unwrap();
assert_eq!(holder.handle().get_n(stack).unwrap(), 7);
let got = holder.handle().get_child(stack).unwrap();
assert_eq!(got.unwrap().get_val(stack).unwrap(), 42);
let (moved_child, n) = bstack_move!(holder, &alloc).unwrap();
assert_eq!(n, 7);
assert_eq!(
moved_child
.as_ref()
.unwrap()
.handle()
.get_val(stack)
.unwrap(),
42
);
moved_child.unwrap().bstack_drop(&alloc).unwrap();
let reused = alloc_block(
&alloc,
MacroLeaf::eightcc(),
size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64,
)
.unwrap();
assert_eq!(reused.start(), leaf_off);
unsafe { dealloc_range(&alloc, reused).unwrap() };
let empty = OptHolder::new(&alloc, None, 9).unwrap();
assert_eq!(empty.handle().get_n(stack).unwrap(), 9);
assert!(empty.handle().get_child(stack).unwrap().is_none());
empty.bstack_drop(&alloc).unwrap();
}
#[test]
fn bstack_vec_grow_and_free() {
use crate::BStackVec;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let mut v = BStackVec::<u8, _>::from_slice(&alloc, b"hello").unwrap();
assert_eq!(v.len().unwrap(), 5);
assert_eq!(v.to_vec().unwrap(), b"hello");
let before = v.descriptor().data_size;
for &b in b", world!" {
v.push(b).unwrap();
}
assert!(v.descriptor().data_size >= before); assert_eq!(v.to_vec().unwrap(), b"hello, world!");
assert_eq!(v.len().unwrap(), 13);
v.bstack_drop().unwrap();
let v2 = BStackVec::<u8, _>::from_slice(&alloc, b"again").unwrap();
assert_eq!(v2.to_vec().unwrap(), b"again");
v2.bstack_drop().unwrap();
let mut nums = BStackVec::<u32, _>::from_slice(&alloc, &[1u32, 2, 3]).unwrap();
nums.push(4).unwrap();
assert_eq!(nums.to_vec().unwrap(), vec![1u32, 2, 3, 4]);
assert_eq!(nums.len().unwrap(), 4);
nums.bstack_drop().unwrap();
}
#[test]
fn vec_len_zero_sized_element_does_not_divide_by_zero() {
use crate::BStackVec;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let v = BStackVec::<(), _>::new(&alloc).unwrap();
assert_eq!(v.len().unwrap(), 0);
assert!(v.is_empty().unwrap());
}
#[cfg(feature = "fault-injection")]
#[test]
fn vec_push_element_atomic_under_fault() {
use crate::BStackVec;
use bstack::fault::FaultPolicy;
use std::sync::Arc;
struct FailNthSet {
seen: AtomicU64,
target: u64,
}
impl FaultPolicy for FailNthSet {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "set" && self.seen.fetch_add(1, Ordering::SeqCst) == self.target {
Some(io::Error::other("injected mid-push fault"))
} else {
None
}
}
}
const E: [u64; 3] = [
0x1111_1111_1111_1111,
0x2222_2222_2222_2222,
0x3333_3333_3333_3333,
];
const FAULTED: u64 = 0x4444_4444_4444_4444; const RECOVER: u64 = 0xAAAA_AAAA_AAAA_AAAA;
for target in 0..3u64 {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mut v = BStackVec::<u64, _>::from_slice(&alloc, &E[..2]).unwrap();
v.push(E[2]).unwrap();
assert_eq!(v.to_vec().unwrap(), E.to_vec());
stack.set_fault_policy(Some(Arc::new(FailNthSet {
seen: AtomicU64::new(0),
target,
})));
let _ = v.push(FAULTED);
stack.set_fault_policy(None);
v.push(RECOVER).unwrap();
for e in v.to_vec().unwrap() {
assert!(
e == E[0] || e == E[1] || e == E[2] || e == FAULTED || e == RECOVER,
"torn element 0x{e:016x} after fault at set #{target}",
);
}
v.bstack_drop().unwrap();
}
}
#[cfg(feature = "fault-injection")]
#[test]
fn ctor_failure_hands_back_consumed_child() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
struct FailNth {
seen: AtomicU64,
target: u64,
}
impl FaultPolicy for FailNth {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if (op == "alloc" || op == "set")
&& self.seen.fetch_add(1, Ordering::SeqCst) == self.target
{
Some(io::Error::other("injected ctor fault"))
} else {
None
}
}
}
for target in 0..6u64 {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let _ = MacroLeaf::new(&alloc, 1).unwrap().bstack_drop(&alloc);
let baseline = alloc.len().unwrap();
let mut faults = 0u32;
for _ in 0..40 {
let child = MacroLeaf::new(&alloc, 0xABCD).unwrap();
alloc.stack().set_fault_policy(Some(Arc::new(FailNth {
seen: AtomicU64::new(0),
target,
})));
let result = MacroParent::new(&alloc, child, 7);
alloc.stack().set_fault_policy(None);
match result {
Ok(parent) => {
parent.bstack_drop(&alloc).unwrap();
}
Err(e) => {
faults += 1;
let (child,) = e.fields.expect("child must be handed back");
child.bstack_drop(&alloc).unwrap();
}
}
}
if faults == 0 {
continue; }
let grown = alloc.len().unwrap().saturating_sub(baseline);
let child_sz = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
assert!(
grown < 4 * child_sz,
"ctor fault at op #{target} orphaned children: file grew {grown} bytes over {faults} faults (child = {child_sz} bytes)",
);
}
}
#[cfg(feature = "fault-injection")]
#[test]
fn push_owned_hands_child_back_on_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
struct FailFirst {
armed: AtomicU64,
}
impl FaultPolicy for FailFirst {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if matches!(op, "set" | "swap" | "cas" | "realloc" | "set_batched")
&& self
.armed
.compare_exchange(1, 0, Ordering::SeqCst, Ordering::SeqCst)
.is_ok()
{
Some(io::Error::other("injected push fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mut v = BStackBlockVec::<MacroLeaf, _>::new(&alloc).unwrap();
v.push_owned(MacroLeaf::new(&alloc, 1).unwrap()).unwrap();
let child = MacroLeaf::new(&alloc, 0xBEEF).unwrap();
stack.set_fault_policy(Some(Arc::new(FailFirst {
armed: AtomicU64::new(1),
})));
let result = v.push_owned(child);
stack.set_fault_policy(None);
let err = result.expect_err("faulted push must fail");
let child = err
.value
.expect("a failed push hands the consumed child back, not None");
assert_eq!(child.handle().get_val(stack).unwrap(), 0xBEEF);
child.bstack_drop(&alloc).unwrap();
assert_eq!(v.len().unwrap(), 1);
v.bstack_drop().unwrap();
}
#[bstack_block]
struct Record {
name: String,
tags: Vec<u32>,
id: u64,
}
#[test]
fn macro_vec_string_fields() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let rec = Record::new(&alloc, "hello", &[1u32, 2, 3], 42).unwrap();
assert_eq!(rec.handle().get_id(stack).unwrap(), 42);
assert_eq!(
rec.handle().get_name(&alloc).unwrap().to_vec().unwrap(),
b"hello"
);
assert_eq!(
rec.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3]
);
let mut tags = rec.handle().get_tags(&alloc).unwrap();
tags.push(4).unwrap();
assert_eq!(
rec.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3, 4],
);
rec.bstack_drop(&alloc).unwrap();
let rec2 = Record::new(&alloc, "again", &[9u32], 1).unwrap();
assert_eq!(
rec2.handle().get_name(&alloc).unwrap().to_vec().unwrap(),
b"again"
);
assert_eq!(
rec2.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![9u32]
);
rec2.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct GenVec<T> {
data: Vec<T>,
}
#[test]
fn macro_generic_vec_element_param_compiles_and_roundtrips() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let h = GenVec::<u32>::new(&alloc, &[10u32, 20, 30]).unwrap();
assert_eq!(
h.handle().get_data(&alloc).unwrap().to_vec().unwrap(),
vec![10u32, 20, 30]
);
h.bstack_drop(&alloc).unwrap();
}
#[test]
fn clone_wal_lock_reentry_errs_instead_of_deadlocking() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
assert!(
crate::io_core::wal::test_reentrant_acquire_is_rejected(&alloc),
"same-file clone re-entry must be rejected, not deadlock"
);
assert!(
crate::io_core::wal::test_reentrant_acquire_is_rejected(&alloc),
"the held-set must be cleaned up after the outer lock drops"
);
}
#[test]
fn clone_build_size_mismatch_errors_instead_of_oob_write() {
use crate::ClonePlan;
use bstack::BStackRange;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let mut plan = ClonePlan::for_build_test(vec![BStackRange::new(4096, 24)]);
assert_eq!(plan.alloc_raw(&alloc, 24).unwrap().len(), 24);
let mut plan = ClonePlan::for_build_test(vec![BStackRange::new(4096, 24)]);
let err = plan.alloc_raw(&alloc, 192).unwrap_err();
assert!(err.to_string().contains("size mismatch"), "got: {err}");
let mut plan = ClonePlan::for_build_test(vec![BStackRange::new(4096, 24)]);
plan.alloc_raw(&alloc, 24).unwrap();
let err = plan.alloc_raw(&alloc, 24).unwrap_err();
assert!(
err.to_string().contains("block-count mismatch"),
"got: {err}"
);
}
#[test]
fn macro_vec_field_push_growth_reclaims_old() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let rec = Record::new(&alloc, "hi", &[1u32, 2, 3], 0).unwrap();
let old = rec.handle().get_tags(&alloc).unwrap().descriptor();
let mut tags = rec.handle().get_tags(&alloc).unwrap();
tags.push(4).unwrap();
let new = rec.handle().get_tags(&alloc).unwrap().descriptor();
assert_ne!(new.data_off, old.data_off); assert_eq!(
rec.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3, 4]
);
let probe = alloc_block(&alloc, MacroLeaf::eightcc(), old.data_size).unwrap();
assert_eq!(probe.start(), old.data_off.get());
unsafe { dealloc_range(&alloc, probe).unwrap() };
rec.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_vec_bstack_move() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let rec = Record::new(&alloc, "movable", &[7u32, 8], 5).unwrap();
let (name, tags, id) = bstack_move!(rec, &alloc).unwrap();
assert_eq!(id, 5);
assert_eq!(name.to_vec().unwrap(), b"movable");
assert_eq!(tags.to_vec().unwrap(), vec![7u32, 8]);
name.bstack_drop().unwrap();
tags.bstack_drop().unwrap();
}
#[bstack_block]
struct Tree {
#[bstack_owned]
kids: Vec<MacroLeaf>,
label: u32,
}
#[test]
fn macro_owned_block_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let kids = vec![
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
MacroLeaf::new(&alloc, 30).unwrap(),
];
let tree = Tree::new(&alloc, kids, 7).unwrap();
assert_eq!(tree.handle().get_label(stack).unwrap(), 7);
let v = tree.handle().get_kids(&alloc).unwrap();
assert_eq!(v.len().unwrap(), 3);
let vals: Vec<u32> = v
.to_vec()
.unwrap()
.iter()
.map(|k| k.get_val(stack).unwrap())
.collect();
assert_eq!(vals, vec![10, 20, 30]);
assert_eq!(v.get(1).unwrap().unwrap().get_val(stack).unwrap(), 20);
assert!(v.get(3).unwrap().is_none());
tree.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
let kids = vec![
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
MacroLeaf::new(&alloc, 30).unwrap(),
];
Tree::new(&alloc, kids, 7).unwrap()
});
}
#[test]
fn macro_owned_block_vec_move() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let kids = vec![
MacroLeaf::new(&alloc, 1).unwrap(),
MacroLeaf::new(&alloc, 2).unwrap(),
];
let tree = Tree::new(&alloc, kids, 9).unwrap();
let (kids_vec, label) = bstack_move!(tree, &alloc).unwrap();
assert_eq!(label, 9);
assert_eq!(kids_vec.len().unwrap(), 2);
assert_eq!(kids_vec.get(0).unwrap().unwrap().get_val(stack).unwrap(), 1);
kids_vec.bstack_drop().unwrap();
}
#[test]
fn macro_clone_pod_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let rec = Record::new(&alloc, "hello", &[1u32, 2, 3], 42).unwrap();
let orig_name_off = rec.handle().get_name(&alloc).unwrap().descriptor().data_off;
let clone = rec.try_clone_in(&alloc).unwrap();
assert_eq!(clone.handle().get_id(stack).unwrap(), 42);
assert_eq!(
clone.handle().get_name(&alloc).unwrap().to_vec().unwrap(),
b"hello"
);
assert_eq!(
clone.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3]
);
let clone_name_off = clone
.handle()
.get_name(&alloc)
.unwrap()
.descriptor()
.data_off;
assert_ne!(clone_name_off, orig_name_off);
let mut ct = clone.handle().get_tags(&alloc).unwrap();
ct.push(99).unwrap();
assert_eq!(
clone.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3, 99]
);
assert_eq!(
rec.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3]
);
clone.bstack_drop(&alloc).unwrap();
rec.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_clone_pod_vec_on_bulk_allocator() {
let tmp = TempStack::new();
let alloc = tmp.ghost_allocator();
let stack = alloc.stack();
let rec = Record::new(&alloc, "hello", &[1u32, 2, 3], 42).unwrap();
let orig_name_off = rec.handle().get_name(&alloc).unwrap().descriptor().data_off;
let clone = rec.try_clone_in(&alloc).unwrap();
assert_eq!(clone.handle().get_id(stack).unwrap(), 42);
assert_eq!(
clone.handle().get_name(&alloc).unwrap().to_vec().unwrap(),
b"hello"
);
assert_eq!(
clone.handle().get_tags(&alloc).unwrap().to_vec().unwrap(),
vec![1u32, 2, 3]
);
let clone_name_off = clone
.handle()
.get_name(&alloc)
.unwrap()
.descriptor()
.data_off;
assert_ne!(clone_name_off, orig_name_off);
clone.bstack_drop(&alloc).unwrap();
rec.bstack_drop(&alloc).unwrap();
let base = stack.len().unwrap();
let r = Record::new(&alloc, "world", &[7u32, 8], 1).unwrap();
let c = r.try_clone_in(&alloc).unwrap();
c.bstack_drop(&alloc).unwrap();
r.bstack_drop(&alloc).unwrap();
assert_eq!(
stack.len().unwrap(),
base,
"two-pass bulk vec clone leaked or double-allocated"
);
}
#[test]
fn macro_clone_owned_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let kids = vec![
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
];
let tree = Tree::new(&alloc, kids, 7).unwrap();
let orig_first = tree
.handle()
.get_kids(&alloc)
.unwrap()
.get(0)
.unwrap()
.unwrap()
.range()
.start();
let clone = tree.try_clone_in(&alloc).unwrap();
let cv = clone.handle().get_kids(&alloc).unwrap();
assert_eq!(cv.len().unwrap(), 2);
let vals: Vec<u32> = cv
.to_vec()
.unwrap()
.iter()
.map(|k| k.get_val(stack).unwrap())
.collect();
assert_eq!(vals, vec![10, 20]);
let clone_first = cv.get(0).unwrap().unwrap().range().start();
assert_ne!(clone_first, orig_first);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
tree.handle()
.get_kids(&alloc)
.unwrap()
.get(0)
.unwrap()
.unwrap()
.get_val(stack)
.unwrap(),
10
);
tree.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_clone_strong_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 100).unwrap();
let a_keep = a.try_clone().unwrap();
let a_data = a_keep.handle().range().start();
let b = MacroStrongChild::new(&alloc, 200).unwrap();
let b_keep = b.try_clone().unwrap();
let b_data = b_keep.handle().range().start();
let list = StrongList::new(&alloc, vec![a, b], 3).unwrap();
assert_eq!(strong_of(stack, a_data), 2); assert_eq!(strong_of(stack, b_data), 2);
let clone = list.try_clone_in(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 3);
assert_eq!(strong_of(stack, b_data), 3);
clone.bstack_drop(&alloc).unwrap();
list.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 1);
assert_eq!(strong_of(stack, b_data), 1);
assert_eq!(a_keep.handle().get_val(stack).unwrap(), 100);
drop(a_keep);
drop(b_keep);
}
#[bstack_block]
struct StrongList {
#[bstack_strong]
items: Vec<MacroStrongChild>,
n: u32,
}
fn strong_of(stack: &BStack, data_off: u64) -> u64 {
let mut buf = [0u8; 8];
stack
.get_into(data_off + CTRL_BACKPTR_OFFSET, &mut buf)
.unwrap();
let ctrl = u64::from_le_bytes(buf);
crate::io_core::refcount::load(stack, nn(ctrl + CTRL_STRONG_OFFSET)).unwrap()
}
#[test]
fn macro_strong_block_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 100).unwrap(); let b = MacroStrongChild::new(&alloc, 200).unwrap();
let a_clone = a.try_clone().unwrap(); let a_data = a_clone.handle().range().start();
let list = StrongList::new(&alloc, vec![a, b], 3).unwrap();
assert_eq!(strong_of(stack, a_data), 2);
let v = list.handle().get_items(&alloc).unwrap();
assert_eq!(v.len().unwrap(), 2);
assert_eq!(v.get(0).unwrap().unwrap().get_val(stack).unwrap(), 100);
list.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 1);
assert_eq!(a_clone.handle().get_val(stack).unwrap(), 100);
drop(a_clone); }
#[bstack_block]
struct WeakList {
#[bstack_weak]
watchers: Vec<MacroStrongChild>,
n: u32,
}
#[test]
fn macro_weak_block_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 1).unwrap(); let b = MacroStrongChild::new(&alloc, 2).unwrap();
let list = WeakList::new(
&alloc,
vec![a.downgrade().unwrap(), b.downgrade().unwrap()],
5,
)
.unwrap();
let v = list.handle().get_watchers(&alloc).unwrap();
assert_eq!(v.len().unwrap(), 2);
let up = v.upgrade(0).unwrap().expect("a alive");
assert_eq!(up.handle().get_val(stack).unwrap(), 1);
drop(up);
drop(a);
let v = list.handle().get_watchers(&alloc).unwrap();
assert!(v.upgrade(0).unwrap().is_none());
assert!(v.upgrade(1).unwrap().is_some());
list.bstack_drop(&alloc).unwrap();
drop(b);
}
#[bstack_block]
struct RefList {
#[bstack_ref]
links: Vec<MacroLeaf>,
n: u32,
}
#[test]
fn macro_ref_block_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroLeaf::new(&alloc, 7).unwrap();
let b = MacroLeaf::new(&alloc, 8).unwrap();
let refs = vec![
unsafe { BStackRef::from_range(a.handle().range()) },
unsafe { BStackRef::from_range(b.handle().range()) },
];
let list = RefList::new(&alloc, refs, 9).unwrap();
let v = list.handle().get_links(&alloc).unwrap();
assert_eq!(v.len().unwrap(), 2);
assert_eq!(v.get(1).unwrap().unwrap().get_val(stack).unwrap(), 8);
list.bstack_drop(&alloc).unwrap();
assert_eq!(a.handle().get_val(stack).unwrap(), 7); assert_eq!(b.handle().get_val(stack).unwrap(), 8);
a.bstack_drop(&alloc).unwrap();
b.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct OptVec {
tags: Option<Vec<u32>>,
name: Option<String>,
id: u64,
}
#[test]
fn macro_option_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = OptVec::new(&alloc, Some(&[1u32, 2, 3][..]), Some("hi"), 7).unwrap();
assert_eq!(a.handle().get_id(stack).unwrap(), 7);
assert_eq!(
a.handle()
.get_tags(&alloc)
.unwrap()
.expect("some")
.to_vec()
.unwrap(),
vec![1u32, 2, 3]
);
assert_eq!(
a.handle()
.get_name(&alloc)
.unwrap()
.expect("some")
.to_vec()
.unwrap(),
b"hi"
);
let (tags, name, id) = bstack_move!(a, &alloc).unwrap();
assert_eq!(id, 7);
tags.unwrap().bstack_drop().unwrap();
name.unwrap().bstack_drop().unwrap();
let b = OptVec::new(&alloc, None, None, 9).unwrap();
assert_eq!(b.handle().get_id(stack).unwrap(), 9);
assert!(b.handle().get_tags(&alloc).unwrap().is_none());
assert!(b.handle().get_name(&alloc).unwrap().is_none());
b.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
enum Node {
Empty,
Num(u32),
#[bstack_ref]
Link(MacroLeaf),
#[bstack_owned]
Child(MacroLeaf),
}
#[test]
fn macro_enum_basic() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf_size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let e = Node::new(&alloc, NodeData::Empty).unwrap();
assert!(matches!(e.handle().read(&alloc).unwrap(), NodeView::Empty));
e.bstack_drop(&alloc).unwrap();
let e = Node::new(&alloc, NodeData::Num(42)).unwrap();
match e.handle().read(&alloc).unwrap() {
NodeView::Num(n) => assert_eq!(n, 42),
_ => panic!("expected Num"),
}
e.bstack_drop(&alloc).unwrap();
let leaf = MacroLeaf::new(&alloc, 7).unwrap();
let leaf_off = leaf.handle().range().start();
let e = Node::new(&alloc, NodeData::Child(leaf)).unwrap();
match e.handle().read(&alloc).unwrap() {
NodeView::Child(c) => assert_eq!(c.get_val(stack).unwrap(), 7),
_ => panic!("expected Child"),
}
e.bstack_drop(&alloc).unwrap();
let reused = alloc_block(&alloc, MacroLeaf::eightcc(), leaf_size).unwrap();
assert_eq!(reused.start(), leaf_off); unsafe { dealloc_range(&alloc, reused).unwrap() };
let keep = MacroLeaf::new(&alloc, 9).unwrap();
let link = unsafe { BStackRef::from_range(keep.handle().range()) };
let e = Node::new(&alloc, NodeData::Link(link)).unwrap();
match e.handle().read(&alloc).unwrap() {
NodeView::Link(l) => assert_eq!(l.get_val(stack).unwrap(), 9),
_ => panic!("expected Link"),
}
e.bstack_drop(&alloc).unwrap();
assert_eq!(keep.handle().get_val(stack).unwrap(), 9); keep.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct EnumHolder {
#[bstack_owned]
node: Node,
tag: u32,
}
#[test]
fn macro_enum_as_field() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 5).unwrap();
let node = Node::new(&alloc, NodeData::Child(leaf)).unwrap();
let holder = EnumHolder::new(&alloc, node, 3).unwrap();
assert_eq!(holder.handle().get_tag(stack).unwrap(), 3);
let node = holder.handle().get_node(stack).unwrap();
match node.read(&alloc).unwrap() {
NodeView::Child(c) => assert_eq!(c.get_val(stack).unwrap(), 5),
_ => panic!("expected Child"),
}
holder.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
let leaf = MacroLeaf::new(&alloc, 5).unwrap();
let node = Node::new(&alloc, NodeData::Child(leaf)).unwrap();
EnumHolder::new(&alloc, node, 3).unwrap()
});
}
#[bstack_enum(rc)]
enum RcNode {
Empty,
Val(u32),
#[bstack_owned]
Child(MacroLeaf),
}
#[test]
fn macro_enum_rc() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf_size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let leaf = MacroLeaf::new(&alloc, 4).unwrap();
let leaf_off = leaf.handle().range().start();
let rc = RcNode::new(&alloc, RcNodeData::Child(leaf)).unwrap(); let rc2 = rc.try_clone().unwrap();
match rc.handle().read(&alloc).unwrap() {
RcNodeView::Child(c) => assert_eq!(c.get_val(stack).unwrap(), 4),
_ => panic!("expected Child"),
}
drop(rc); drop(rc2);
let reused = alloc_block(&alloc, MacroLeaf::eightcc(), leaf_size).unwrap();
assert_eq!(reused.start(), leaf_off); unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[test]
fn macro_enum_rc_val_variant() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let rc = RcNode::new(&alloc, RcNodeData::Val(7)).unwrap();
match rc.handle().read(&alloc).unwrap() {
RcNodeView::Val(v) => assert_eq!(v, 7),
_ => panic!("expected Val"),
}
drop(rc);
}
#[bstack_enum(rc, weak)]
enum RcwNode {
Nil,
#[bstack_owned]
One(MacroLeaf),
}
#[test]
fn macro_enum_rc_weak() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 8).unwrap();
let rc = RcwNode::new(&alloc, RcwNodeData::One(leaf)).unwrap(); let weak = rc.downgrade().unwrap();
match rc.handle().read(&alloc).unwrap() {
RcwNodeView::One(c) => assert_eq!(c.get_val(stack).unwrap(), 8),
_ => panic!("expected One"),
}
let up = weak.upgrade().unwrap().expect("alive");
assert!(matches!(
up.handle().read(&alloc).unwrap(),
RcwNodeView::One(_)
));
drop(up);
drop(rc);
assert!(weak.upgrade().unwrap().is_none());
drop(weak); }
#[bstack_enum]
enum DefKind {
Num(u32),
#[default]
Nothing,
#[bstack_owned]
Child(MacroLeaf),
}
#[bstack_enum]
enum DefKindRc {
#[default]
Nil,
#[bstack_strong]
Shared(MacroStrongChild),
}
#[test]
fn macro_enum_default_variant() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
assert!(matches!(DefKindData::default(), DefKindData::Nothing));
let e = DefKind::new(&alloc, DefKindData::default()).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
DefKindView::Nothing
));
e.bstack_drop(&alloc).unwrap();
let e = DefKind::new(&alloc, DefKindData::Num(7)).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
DefKindView::Num(7)
));
e.bstack_drop(&alloc).unwrap();
let leaf = MacroLeaf::new(&alloc, 3).unwrap();
let e = DefKind::new(&alloc, DefKindData::Child(leaf)).unwrap();
match e.handle().read(&alloc).unwrap() {
DefKindView::Child(c) => assert_eq!(c.get_val(stack).unwrap(), 3),
_ => panic!("expected Child"),
}
e.bstack_drop(&alloc).unwrap();
let e = DefKindRc::new(&alloc, Default::default()).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
DefKindRcView::Nil
));
e.bstack_drop(&alloc).unwrap();
let child = MacroStrongChild::new(&alloc, 11).unwrap();
let e = DefKindRc::new(&alloc, DefKindRcData::Shared(child)).unwrap();
match e.handle().read(&alloc).unwrap() {
DefKindRcView::Shared(c) => assert_eq!(c.get_val(stack).unwrap(), 11),
_ => panic!("expected Shared"),
}
e.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
enum Cell {
Nil,
#[bstack_strong]
Shared(MacroStrongChild),
#[bstack_weak]
Watch(MacroStrongChild),
}
#[test]
fn macro_enum_strong_weak_variants() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let child = MacroStrongChild::new(&alloc, 11).unwrap(); let keep = child.try_clone().unwrap(); let cell = Cell::new(&alloc, CellData::Shared(child)).unwrap(); match cell.handle().read(&alloc).unwrap() {
CellView::Shared(c) => assert_eq!(c.get_val(stack).unwrap(), 11),
_ => panic!("expected Shared"),
}
cell.bstack_drop(&alloc).unwrap(); assert_eq!(keep.handle().get_val(stack).unwrap(), 11); drop(keep);
let owner = MacroStrongChild::new(&alloc, 22).unwrap(); let cell = Cell::new(&alloc, CellData::Watch(owner.downgrade().unwrap())).unwrap();
match cell.handle().read(&alloc).unwrap() {
CellView::Watch(Some(up)) => assert_eq!(up.handle().get_val(stack).unwrap(), 22),
_ => panic!("expected a live Watch"),
}
drop(owner);
assert!(matches!(
cell.handle().read(&alloc).unwrap(),
CellView::Watch(None)
));
cell.bstack_drop(&alloc).unwrap();
let cell = Cell::new(&alloc, CellData::Nil).unwrap();
assert!(matches!(cell.handle().read(&alloc).unwrap(), CellView::Nil));
cell.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_clone_enum() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let e = Node::new(&alloc, NodeData::Num(42)).unwrap();
let c = e.try_clone_in(&alloc).unwrap();
assert_ne!(c.handle().range().start(), e.handle().range().start());
match c.handle().read(&alloc).unwrap() {
NodeView::Num(n) => assert_eq!(n, 42),
_ => panic!("expected Num"),
}
c.bstack_drop(&alloc).unwrap();
e.bstack_drop(&alloc).unwrap();
let leaf = MacroLeaf::new(&alloc, 7).unwrap();
let e = Node::new(&alloc, NodeData::Child(leaf)).unwrap();
let orig_child_off = match e.handle().read(&alloc).unwrap() {
NodeView::Child(ch) => ch.range().start(),
_ => panic!("expected Child"),
};
let c = e.try_clone_in(&alloc).unwrap();
let clone_child_off = match c.handle().read(&alloc).unwrap() {
NodeView::Child(ch) => {
assert_eq!(ch.get_val(stack).unwrap(), 7);
ch.range().start()
}
_ => panic!("expected Child"),
};
assert_ne!(clone_child_off, orig_child_off); c.bstack_drop(&alloc).unwrap();
match e.handle().read(&alloc).unwrap() {
NodeView::Child(ch) => assert_eq!(ch.get_val(stack).unwrap(), 7), _ => panic!("expected Child"),
}
e.bstack_drop(&alloc).unwrap();
let keep = MacroLeaf::new(&alloc, 9).unwrap();
let link = unsafe { BStackRef::from_range(keep.handle().range()) };
let e = Node::new(&alloc, NodeData::Link(link)).unwrap();
let c = e.try_clone_in(&alloc).unwrap();
match c.handle().read(&alloc).unwrap() {
NodeView::Link(l) => {
assert_eq!(l.get_val(stack).unwrap(), 9);
assert_eq!(l.range().start(), keep.handle().range().start()); }
_ => panic!("expected Link"),
}
c.bstack_drop(&alloc).unwrap();
e.bstack_drop(&alloc).unwrap();
assert_eq!(keep.handle().get_val(stack).unwrap(), 9); keep.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_clone_enum_shared() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let child = MacroStrongChild::new(&alloc, 11).unwrap();
let keep = child.try_clone().unwrap();
let data = keep.handle().range().start();
let cell = Cell::new(&alloc, CellData::Shared(child)).unwrap();
assert_eq!(strong_of(stack, data), 2);
let clone = cell.try_clone_in(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 3);
clone.bstack_drop(&alloc).unwrap();
cell.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 1);
assert_eq!(keep.handle().get_val(stack).unwrap(), 11);
drop(keep);
}
#[test]
fn macro_enum_move() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 5).unwrap();
let node = Node::new(&alloc, NodeData::Child(leaf)).unwrap();
match bstack_move!(node, &alloc).unwrap() {
NodeData::Child(owned_leaf) => {
assert_eq!(owned_leaf.handle().get_val(stack).unwrap(), 5); owned_leaf.bstack_drop(&alloc).unwrap();
}
_ => panic!("expected Child"),
}
let node = Node::new(&alloc, NodeData::Num(9)).unwrap();
assert!(matches!(
bstack_move!(node, &alloc).unwrap(),
NodeData::Num(9)
));
let node = Node::new(&alloc, NodeData::Empty).unwrap();
assert!(matches!(
bstack_move!(node, &alloc).unwrap(),
NodeData::Empty
));
let keep = MacroLeaf::new(&alloc, 3).unwrap();
let link = unsafe { BStackRef::from_range(keep.handle().range()) };
let node = Node::new(&alloc, NodeData::Link(link)).unwrap();
match bstack_move!(node, &alloc).unwrap() {
NodeData::Link(r) => {
assert_eq!(r.into_range().start(), keep.handle().range().start());
}
_ => panic!("expected Link"),
}
assert_eq!(keep.handle().get_val(stack).unwrap(), 3); keep.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_enum_move_shared() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let child = MacroStrongChild::new(&alloc, 11).unwrap();
let keep = child.try_clone().unwrap();
let cell = Cell::new(&alloc, CellData::Shared(child)).unwrap();
match bstack_move!(cell, &alloc).unwrap() {
CellData::Shared(rc) => {
assert_eq!(rc.handle().get_val(stack).unwrap(), 11);
drop(rc); }
_ => panic!("expected Shared"),
}
assert_eq!(keep.handle().get_val(stack).unwrap(), 11); drop(keep);
let owner = MacroStrongChild::new(&alloc, 22).unwrap();
let cell = Cell::new(&alloc, CellData::Watch(owner.downgrade().unwrap())).unwrap();
match bstack_move!(cell, &alloc).unwrap() {
CellData::Watch(w) => {
assert_eq!(
w.upgrade()
.unwrap()
.expect("alive")
.handle()
.get_val(stack)
.unwrap(),
22
);
drop(w);
}
_ => panic!("expected Watch"),
}
drop(owner);
}
#[test]
fn macro_enum_cast() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let node = Node::new(&alloc, NodeData::Num(7)).unwrap();
let slice = node.handle().as_slice(stack);
let n = bstack_cast!(slice as Node).unwrap().expect("tag matches");
assert!(matches!(n.read(&alloc).unwrap(), NodeView::Num(7)));
assert!(slice.cast_as::<MacroLeaf>().unwrap().is_none());
let owned_slice = bstack_cast!(node.auto(&alloc) as BStackOwnedSlice);
let back = bstack_cast!(owned_slice as BStackOwned<Node, _>).unwrap();
assert!(matches!(
back.handle().read(&alloc).unwrap(),
NodeView::Num(7)
));
back.bstack_drop(&alloc).unwrap();
}
#[bstack_enum(repr(u64))]
enum Aligned {
X(u32),
#[bstack_owned]
Y(MacroLeaf),
}
#[test]
fn macro_enum_repr_aligned() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
assert_eq!(size_of::<<Aligned as BStackBlock>::OnDisk>(), 32);
let e = Aligned::new(&alloc, AlignedData::X(77)).unwrap();
match e.handle().read(&alloc).unwrap() {
AlignedView::X(n) => assert_eq!(n, 77),
_ => panic!("expected X"),
}
e.bstack_drop(&alloc).unwrap();
let leaf = MacroLeaf::new(&alloc, 3).unwrap();
let e = Aligned::new(&alloc, AlignedData::Y(leaf)).unwrap();
match e.handle().read(&alloc).unwrap() {
AlignedView::Y(c) => assert_eq!(c.get_val(stack).unwrap(), 3),
_ => panic!("expected Y"),
}
e.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
enum Status {
Ok = 200,
NotFound = 404,
Error = 500,
}
#[bstack_enum]
enum Temp {
Freezing = -40,
Zero = 0,
Boiling = 100,
}
#[test]
fn macro_enum_discriminant_inference() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
assert_eq!(size_of::<<Status as BStackBlock>::OnDisk>(), 18);
let e = Status::new(&alloc, StatusData::Ok).unwrap();
assert!(matches!(e.handle().read(&alloc).unwrap(), StatusView::Ok));
e.bstack_drop(&alloc).unwrap();
let e = Status::new(&alloc, StatusData::NotFound).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
StatusView::NotFound
));
e.bstack_drop(&alloc).unwrap();
let e = Status::new(&alloc, StatusData::Error).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
StatusView::Error
));
e.bstack_drop(&alloc).unwrap();
assert_eq!(size_of::<<Temp as BStackBlock>::OnDisk>(), 17);
let e = Temp::new(&alloc, TempData::Freezing).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
TempView::Freezing
));
e.bstack_drop(&alloc).unwrap();
let e = Temp::new(&alloc, TempData::Boiling).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
TempView::Boiling
));
e.bstack_drop(&alloc).unwrap();
}
#[bstack_enum(tag = "EN", ctrl_tag = "ec", rc, weak)]
enum TaggedEnum {
A,
B(u32),
}
#[bstack_enum(tag = "WAYTOOLONGENUMTAG", allow(overlong_tag))]
enum LongTagEnum {
A,
}
#[test]
fn macro_enum_tags() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
assert_eq!(&TaggedEnum::eightcc().0[0..2], b"EN");
assert_eq!(&LongTagEnum::eightcc().0, b"WAYTOOLO");
let rc = TaggedEnum::new(&alloc, TaggedEnumData::A).unwrap();
let data_off = rc.handle().range().start();
let mut buf = [0u8; 8];
stack
.get_into(data_off + CTRL_BACKPTR_OFFSET, &mut buf)
.unwrap();
let ctrl_off = u64::from_le_bytes(buf);
let mut ctag = [0u8; 8];
stack.get_into(ctrl_off + 8, &mut ctag).unwrap();
assert_eq!(&ctag[0..2], b"ec");
drop(rc);
}
#[bstack_enum]
enum Shape {
Empty,
Point(i32, i32), Rect { w: u32, h: u32 }, Tagged(u8, u16, u8), }
#[test]
fn macro_enum_pod_aggregate_variants() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
assert_eq!(size_of::<<Shape as BStackBlock>::OnDisk>(), 25);
let e = Shape::new(&alloc, ShapeData::Point(3, -4)).unwrap();
match e.handle().read(&alloc).unwrap() {
ShapeView::Point(x, y) => assert_eq!((x, y), (3, -4)),
_ => panic!("expected Point"),
}
e.bstack_drop(&alloc).unwrap();
let e = Shape::new(&alloc, ShapeData::Rect { w: 100, h: 200 }).unwrap();
match e.handle().read(&alloc).unwrap() {
ShapeView::Rect { w, h } => assert_eq!((w, h), (100, 200)),
_ => panic!("expected Rect"),
}
e.bstack_drop(&alloc).unwrap();
let e = Shape::new(&alloc, ShapeData::Tagged(1, 258, 255)).unwrap();
match e.handle().read(&alloc).unwrap() {
ShapeView::Tagged(a, b, c) => assert_eq!((a, b, c), (1, 258, 255)),
_ => panic!("expected Tagged"),
}
e.bstack_drop(&alloc).unwrap();
let e = Shape::new(&alloc, ShapeData::Empty).unwrap();
assert!(matches!(e.handle().read(&alloc).unwrap(), ShapeView::Empty));
e.bstack_drop(&alloc).unwrap();
let e = Shape::new(&alloc, ShapeData::Point(7, 8)).unwrap();
match bstack_move!(e, &alloc).unwrap() {
ShapeData::Point(x, y) => assert_eq!((x, y), (7, 8)),
_ => panic!("expected Point"),
}
}
#[bstack_block]
struct PodFeat {
maybe: Option<core::num::NonZeroU32>, wrap: core::num::Wrapping<u32>, pair: (u8, u8), mixed: (u16, i32),
n: u64,
}
#[test]
#[allow(clippy::type_complexity)] fn macro_pod_option_and_tuple_fields() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let f = PodFeat::new(
&alloc,
core::num::NonZeroU32::new(7),
core::num::Wrapping(42),
(1, 2),
(300, -5),
99,
)
.unwrap();
assert_eq!(
f.handle().get_maybe(stack).unwrap(),
core::num::NonZeroU32::new(7)
);
assert_eq!(
f.handle().get_wrap(stack).unwrap(),
core::num::Wrapping(42u32)
);
assert_eq!(f.handle().get_pair(stack).unwrap(), (1u8, 2u8));
assert_eq!(f.handle().get_mixed(stack).unwrap(), (300u16, -5i32));
assert_eq!(f.handle().get_n(stack).unwrap(), 99);
let (maybe, wrap, pair, mixed, n): (
Option<core::num::NonZeroU32>,
core::num::Wrapping<u32>,
(u8, u8),
(u16, i32),
u64,
) = bstack_move!(f, &alloc).unwrap();
assert_eq!(maybe, core::num::NonZeroU32::new(7));
assert_eq!(wrap, core::num::Wrapping(42));
assert_eq!(pair, (1, 2));
assert_eq!(mixed, (300, -5));
assert_eq!(n, 99);
let g = PodFeat::new(&alloc, None, core::num::Wrapping(0), (0, 0), (0, 0), 0).unwrap();
assert!(g.handle().get_maybe(stack).unwrap().is_none());
g.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct Marker;
#[bstack_block]
struct Rgb(u8, u8, u8);
#[test]
fn macro_unit_and_tuple_structs() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
assert_eq!(size_of::<<Marker as BStackBlock>::OnDisk>(), 16);
let m = Marker::new(&alloc).unwrap();
let () = bstack_move!(m, &alloc).unwrap();
let c = Rgb::new(&alloc, 10, 20, 30).unwrap();
assert_eq!(c.handle().get_field0(stack).unwrap(), 10);
assert_eq!(c.handle().get_field1(stack).unwrap(), 20);
assert_eq!(c.handle().get_field2(stack).unwrap(), 30);
let (r, g, b) = bstack_move!(c, &alloc).unwrap();
assert_eq!((r, g, b), (10, 20, 30));
}
#[bstack_block]
struct EmbChild {
#[bstack_owned]
leaf: MacroLeaf,
n: u32,
}
#[bstack_block]
struct EmbHolder {
#[embed]
child: EmbChild,
tag: u32,
}
#[bstack_enum]
enum EmbEnum {
Empty,
#[embed]
Wrap(EmbChild),
}
#[test]
fn macro_embed_struct_and_enum() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let child = EmbChild::new(&alloc, leaf, 7).unwrap();
let holder = EmbHolder::new(&alloc, child, 99).unwrap();
assert_eq!(holder.handle().get_tag(stack).unwrap(), 99);
let c = holder.handle().get_child().unwrap(); assert_eq!(c.get_n(stack).unwrap(), 7);
assert_eq!(c.get_leaf(stack).unwrap().get_val(stack).unwrap(), 42);
holder.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let child = EmbChild::new(&alloc, leaf, 7).unwrap();
EmbHolder::new(&alloc, child, 99).unwrap()
});
let leaf = MacroLeaf::new(&alloc, 5).unwrap();
let child = EmbChild::new(&alloc, leaf, 8).unwrap();
let holder = EmbHolder::new(&alloc, child, 1).unwrap();
let (moved, tag) = bstack_move!(holder, &alloc).unwrap();
assert_eq!(tag, 1);
assert_eq!(
moved
.handle()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
5
);
moved.bstack_drop(&alloc).unwrap();
let leaf = MacroLeaf::new(&alloc, 3).unwrap();
let child = EmbChild::new(&alloc, leaf, 9).unwrap();
let e = EmbEnum::new(&alloc, EmbEnumData::Wrap(child)).unwrap();
match e.handle().read(&alloc).unwrap() {
EmbEnumView::Wrap(c) => assert_eq!(c.get_leaf(stack).unwrap().get_val(stack).unwrap(), 3),
_ => panic!("expected Wrap"),
}
let moved = match bstack_move!(e, &alloc).unwrap() {
EmbEnumData::Wrap(c) => c,
_ => panic!("expected Wrap"),
};
assert_eq!(moved.handle().get_n(stack).unwrap(), 9);
moved.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_clone_embed() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let child = EmbChild::new(&alloc, leaf, 7).unwrap();
let holder = EmbHolder::new(&alloc, child, 99).unwrap();
let orig_leaf_off = holder
.handle()
.get_child()
.unwrap()
.get_leaf(stack)
.unwrap()
.range()
.start();
let clone = holder.try_clone_in(&alloc).unwrap();
assert_eq!(clone.handle().get_tag(stack).unwrap(), 99);
let cc = clone.handle().get_child().unwrap();
assert_eq!(cc.get_n(stack).unwrap(), 7);
assert_eq!(cc.get_leaf(stack).unwrap().get_val(stack).unwrap(), 42);
let clone_leaf_off = cc.get_leaf(stack).unwrap().range().start();
assert_ne!(clone_leaf_off, orig_leaf_off);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
holder
.handle()
.get_child()
.unwrap()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
42
);
holder.bstack_drop(&alloc).unwrap();
let leaf = MacroLeaf::new(&alloc, 3).unwrap();
let child = EmbChild::new(&alloc, leaf, 9).unwrap();
let e = EmbEnum::new(&alloc, EmbEnumData::Wrap(child)).unwrap();
let orig_off = match e.handle().read(&alloc).unwrap() {
EmbEnumView::Wrap(c) => c.get_leaf(stack).unwrap().range().start(),
_ => panic!("expected Wrap"),
};
let ce = e.try_clone_in(&alloc).unwrap();
let clone_off = match ce.handle().read(&alloc).unwrap() {
EmbEnumView::Wrap(c) => {
assert_eq!(c.get_leaf(stack).unwrap().get_val(stack).unwrap(), 3);
c.get_leaf(stack).unwrap().range().start()
}
_ => panic!("expected Wrap"),
};
assert_ne!(clone_off, orig_off); ce.bstack_drop(&alloc).unwrap();
match e.handle().read(&alloc).unwrap() {
EmbEnumView::Wrap(c) => assert_eq!(c.get_leaf(stack).unwrap().get_val(stack).unwrap(), 3),
_ => panic!("expected Wrap"),
}
e.bstack_drop(&alloc).unwrap();
}
#[test]
fn wal_finish_rolls_forward_committed() {
use crate::io_core::wal::{HeldLock, finish};
use crate::io_core::wal::{WalEntry, WalLog, WalStatus};
let tmp = TempStack::new();
let alloc = tmp.allocator(); let v1 = alloc.alloc(64).unwrap().as_range();
let v2 = alloc.alloc(64).unwrap().as_range();
let mut log = WalLog::with_capacity(2);
log.append(WalEntry::dealloc(WalStatus::Pending, v1));
log.append(WalEntry::dealloc(WalStatus::Pending, v2));
HeldLock::acquire(&alloc)
.unwrap()
.persist(&alloc, &log, WalStatus::Complete)
.unwrap();
assert_eq!(finish(&alloc).unwrap(), 2);
assert_eq!(finish(&alloc).unwrap(), 0);
let reused = alloc.alloc(64).unwrap().as_range();
assert!(reused.start() == v1.start() || reused.start() == v2.start());
}
#[test]
fn wal_finish_abandons_uncommitted() {
use crate::io_core::wal::{HeldLock, finish};
use crate::io_core::wal::{WalEntry, WalLog, WalStatus};
let tmp = TempStack::new();
let alloc = tmp.allocator();
let v1 = alloc.alloc(64).unwrap().as_range();
let mut log = WalLog::with_capacity(1);
log.append(WalEntry::dealloc(WalStatus::Pending, v1));
HeldLock::acquire(&alloc)
.unwrap()
.persist(&alloc, &log, WalStatus::Pending)
.unwrap();
assert_eq!(finish(&alloc).unwrap(), 0);
assert_eq!(finish(&alloc).unwrap(), 0);
}
#[test]
fn wal_anchor_trait_reclaims_via_finish() {
use crate::io_core::wal::{HeldLock, finish};
use crate::io_core::wal::{WalEntry, WalLog, WalStatus};
let tmp = TempStack::new();
let alloc = tmp.allocator(); let orphan = alloc.alloc(64).unwrap().as_range();
let mut log = WalLog::with_capacity(1);
log.append(WalEntry::alloc(WalStatus::Pending, orphan));
HeldLock::acquire(&alloc)
.unwrap()
.persist(&alloc, &log, WalStatus::Pending)
.unwrap();
assert_eq!(finish(&alloc).unwrap(), 1);
assert_eq!(alloc.alloc(64).unwrap().as_range().start(), orphan.start());
}
#[test]
fn wal_finish_reclaims_abandoned_allocs() {
use crate::io_core::wal::{HeldLock, finish};
use crate::io_core::wal::{WalEntry, WalLog, WalStatus};
let tmp = TempStack::new();
let alloc = tmp.allocator();
let a1 = alloc.alloc(64).unwrap().as_range();
let a2 = alloc.alloc(64).unwrap().as_range();
let mut log = WalLog::with_capacity(2);
log.append(WalEntry::alloc(WalStatus::Pending, a1));
log.append(WalEntry::alloc(WalStatus::Pending, a2));
HeldLock::acquire(&alloc)
.unwrap()
.persist(&alloc, &log, WalStatus::Pending)
.unwrap();
assert_eq!(finish(&alloc).unwrap(), 2);
let reused = alloc.alloc(64).unwrap().as_range();
assert!(reused.start() == a1.start() || reused.start() == a2.start());
let keep = alloc.alloc(64).unwrap().as_range();
let mut log2 = WalLog::with_capacity(1);
log2.append(WalEntry::alloc(WalStatus::Pending, keep));
HeldLock::acquire(&alloc)
.unwrap()
.persist(&alloc, &log2, WalStatus::Complete)
.unwrap();
assert_eq!(finish(&alloc).unwrap(), 0);
}
#[test]
fn wal_clone_descent_orphans_reclaimed_by_finish() {
use crate::ClonePlan;
use crate::io_core::wal::finish;
let tmp = TempStack::new();
let alloc = tmp.allocator(); let base = alloc.len().unwrap();
{
let mut plan = ClonePlan::new();
let _a = plan.alloc_raw(&alloc, 48).unwrap();
let _b = plan.alloc_raw(&alloc, 64).unwrap();
}
assert!(
alloc.len().unwrap() > base,
"descent allocated its blocks (+ the WAL block)"
);
assert_eq!(
finish(&alloc).unwrap(),
2,
"both mid-descent orphans reclaimed"
);
assert_eq!(finish(&alloc).unwrap(), 0);
}
#[test]
fn wal_finish_reclaims_foreign_orphan_via_registry() {
use crate::io_core::wal::{HeldLock, finish};
use crate::io_core::wal::{WalEntry, WalLog, WalStatus};
use crate::registry;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let foreign_alloc = foreign.allocator();
let orphan = foreign_alloc.alloc(64).unwrap().as_range();
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let fid = registry::attach(&foreign.path, foreign_alloc).unwrap();
assert!(!fid.is_self());
let mut log = WalLog::with_capacity(1);
log.append(WalEntry::dealloc_in(WalStatus::Pending, fid, orphan));
HeldLock::acquire(&home_alloc)
.unwrap()
.persist(&home_alloc, &log, WalStatus::Complete)
.unwrap();
assert_eq!(finish(&home_alloc).unwrap(), 1);
let reused = registry::with_host(fid, |host| host.alloc(64).unwrap().start()).unwrap();
assert_eq!(reused, orphan.start());
let orphan2 = registry::with_host(fid, |host| host.alloc(64).unwrap().start()).unwrap();
registry::detach(fid);
let mut log2 = WalLog::with_capacity(1);
log2.append(WalEntry::dealloc_in(
WalStatus::Pending,
fid,
BStackRange::new(orphan2, 64),
));
HeldLock::acquire(&home_alloc)
.unwrap()
.persist(&home_alloc, &log2, WalStatus::Complete)
.unwrap();
assert_eq!(finish(&home_alloc).unwrap(), 1);
}
#[bstack_block]
struct PodArr {
xs: [u16; 4],
tag: u32,
}
#[test]
fn macro_pod_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let p = PodArr::new(&alloc, [1u16, 2, 3, 4], 9).unwrap();
assert_eq!(p.handle().get_xs(stack).unwrap(), [1u16, 2, 3, 4]);
assert_eq!(p.handle().get_tag(stack).unwrap(), 9);
p.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct ArrHolder {
#[bstack_owned]
leaves: [MacroLeaf; 3],
tag: u32,
}
#[test]
fn macro_owned_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let l0 = MacroLeaf::new(&alloc, 10).unwrap();
let l1 = MacroLeaf::new(&alloc, 20).unwrap();
let l2 = MacroLeaf::new(&alloc, 30).unwrap();
let h = ArrHolder::new(&alloc, [l0, l1, l2], 7).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 7);
let arr = h.handle().get_leaves(stack).unwrap(); assert_eq!(arr[0].get_val(stack).unwrap(), 10);
assert_eq!(arr[1].get_val(stack).unwrap(), 20);
assert_eq!(arr[2].get_val(stack).unwrap(), 30);
h.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
let l0 = MacroLeaf::new(&alloc, 10).unwrap();
let l1 = MacroLeaf::new(&alloc, 20).unwrap();
let l2 = MacroLeaf::new(&alloc, 30).unwrap();
ArrHolder::new(&alloc, [l0, l1, l2], 7).unwrap()
});
}
#[test]
fn macro_owned_array_clone() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = ArrHolder::new(
&alloc,
[
MacroLeaf::new(&alloc, 1).unwrap(),
MacroLeaf::new(&alloc, 2).unwrap(),
MacroLeaf::new(&alloc, 3).unwrap(),
],
0,
)
.unwrap();
let clone = h.try_clone_in(&alloc).unwrap();
let carr = clone.handle().get_leaves(stack).unwrap();
let oarr = h.handle().get_leaves(stack).unwrap();
assert_eq!(carr[1].get_val(stack).unwrap(), 2);
assert_ne!(carr[0].range().start(), oarr[0].range().start());
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_leaves(stack).unwrap()[2]
.get_val(stack)
.unwrap(),
3
);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct RefArrHolder {
#[bstack_ref]
refs: [MacroLeaf; 2],
}
#[test]
fn macro_ref_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let l0 = MacroLeaf::new(&alloc, 1).unwrap();
let l1 = MacroLeaf::new(&alloc, 2).unwrap();
let r0 = unsafe { BStackRef::from_range(l0.handle().range()) };
let r1 = unsafe { BStackRef::from_range(l1.handle().range()) };
let h = RefArrHolder::new(&alloc, [r0, r1]).unwrap();
let arr = h.handle().get_refs(stack).unwrap();
assert_eq!(arr[0].get_val(stack).unwrap(), 1);
assert_eq!(arr[1].get_val(stack).unwrap(), 2);
h.bstack_drop(&alloc).unwrap();
assert_eq!(l0.handle().get_val(stack).unwrap(), 1);
l0.bstack_drop(&alloc).unwrap();
l1.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct StrongArrHolder {
#[bstack_strong]
shared: [MacroStrongChild; 2],
}
#[test]
fn macro_strong_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c0 = MacroStrongChild::new(&alloc, 5).unwrap();
let c1 = MacroStrongChild::new(&alloc, 6).unwrap();
let keep0 = c0.try_clone().unwrap();
let h = StrongArrHolder::new(&alloc, [c0, c1]).unwrap();
let arr = h.handle().get_shared(stack).unwrap();
assert_eq!(arr[0].get_val(stack).unwrap(), 5);
let d0 = arr[0].range().start();
let ctrl0 = crate::io_core::refcount::load(stack, nn(d0 + CTRL_BACKPTR_OFFSET)).unwrap();
let strong0 = ctrl0 + CTRL_STRONG_OFFSET;
let before = crate::io_core::refcount::load(stack, nn(strong0)).unwrap(); let clone = h.try_clone_in(&alloc).unwrap();
assert_eq!(
crate::io_core::refcount::load(stack, nn(strong0)).unwrap(),
before + 1
);
clone.bstack_drop(&alloc).unwrap();
h.bstack_drop(&alloc).unwrap();
assert_eq!(
crate::io_core::refcount::load(stack, nn(strong0)).unwrap(),
before - 1
);
assert_eq!(keep0.handle().get_val(stack).unwrap(), 5);
drop(keep0);
}
#[test]
fn macro_owned_array_move() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = ArrHolder::new(
&alloc,
[
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
MacroLeaf::new(&alloc, 30).unwrap(),
],
7,
)
.unwrap();
let (leaves, tag) = bstack_move!(h, &alloc).unwrap();
assert_eq!(tag, 7);
assert_eq!(leaves[0].handle().get_val(stack).unwrap(), 10);
assert_eq!(leaves[2].handle().get_val(stack).unwrap(), 30);
for l in leaves {
l.bstack_drop(&alloc).unwrap();
}
}
#[bstack_block]
struct WeakArrHolder {
#[bstack_weak]
weaks: [MacroStrongChild; 2],
}
#[test]
fn macro_weak_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c0 = MacroStrongChild::new(&alloc, 5).unwrap();
let c1 = MacroStrongChild::new(&alloc, 6).unwrap();
let h = WeakArrHolder::new(&alloc).unwrap();
let arr = h.handle().get_weaks(&alloc).unwrap();
assert!(arr[0].is_none() && arr[1].is_none());
h.handle()
.set_weaks(&alloc, 0, c0.downgrade().unwrap())
.unwrap();
h.handle()
.set_weaks(&alloc, 1, c1.downgrade().unwrap())
.unwrap();
let arr = h.handle().get_weaks(&alloc).unwrap();
assert_eq!(arr[0].as_ref().unwrap().handle().get_val(stack).unwrap(), 5);
assert_eq!(arr[1].as_ref().unwrap().handle().get_val(stack).unwrap(), 6);
drop(arr);
let clone = h.try_clone_in(&alloc).unwrap();
let carr = clone.handle().get_weaks(&alloc).unwrap();
assert_eq!(
carr[0].as_ref().unwrap().handle().get_val(stack).unwrap(),
5
);
drop(carr);
clone.bstack_drop(&alloc).unwrap();
h.bstack_drop(&alloc).unwrap();
assert_eq!(c0.handle().get_val(stack).unwrap(), 5);
assert_eq!(c1.handle().get_val(stack).unwrap(), 6);
drop(c0);
drop(c1);
}
#[bstack_block]
struct OptArrHolder {
#[bstack_owned]
leaves: [Option<MacroLeaf>; 3],
}
#[test]
fn macro_owned_option_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf_size = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
let l0 = MacroLeaf::new(&alloc, 10).unwrap();
let l2 = MacroLeaf::new(&alloc, 30).unwrap();
let off0 = l0.handle().range().start();
let h = OptArrHolder::new(&alloc, [Some(l0), None, Some(l2)]).unwrap();
let arr = h.handle().get_leaves(stack).unwrap(); assert_eq!(arr[0].as_ref().unwrap().get_val(stack).unwrap(), 10);
assert!(arr[1].is_none());
assert_eq!(arr[2].as_ref().unwrap().get_val(stack).unwrap(), 30);
let clone = h.try_clone_in(&alloc).unwrap();
let carr = clone.handle().get_leaves(stack).unwrap();
assert_eq!(carr[0].as_ref().unwrap().get_val(stack).unwrap(), 10);
assert!(carr[1].is_none());
assert_ne!(
carr[0].as_ref().unwrap().range().start(),
arr[0].as_ref().unwrap().range().start()
);
clone.bstack_drop(&alloc).unwrap();
let (moved,) = bstack_move!(h, &alloc).unwrap();
assert_eq!(
moved[2].as_ref().unwrap().handle().get_val(stack).unwrap(),
30
);
assert!(moved[1].is_none());
for o in moved.into_iter().flatten() {
o.bstack_drop(&alloc).unwrap();
}
let reused = alloc_block(&alloc, MacroLeaf::eightcc(), leaf_size).unwrap();
let _ = off0;
unsafe { dealloc_range(&alloc, reused).unwrap() };
}
#[bstack_block]
struct OptRefArrHolder {
#[bstack_ref]
refs: [Option<MacroLeaf>; 2],
}
#[test]
fn macro_ref_option_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let l0 = MacroLeaf::new(&alloc, 1).unwrap();
let r0 = unsafe { BStackRef::from_range(l0.handle().range()) };
let h = OptRefArrHolder::new(&alloc, [Some(r0), None]).unwrap();
let arr = h.handle().get_refs(stack).unwrap(); assert_eq!(arr[0].as_ref().unwrap().get_val(stack).unwrap(), 1);
assert!(arr[1].is_none());
h.bstack_drop(&alloc).unwrap(); assert_eq!(l0.handle().get_val(stack).unwrap(), 1);
l0.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct PodOptArr {
xs: [Option<core::num::NonZeroU32>; 3],
}
#[test]
fn macro_pod_option_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let p = PodOptArr::new(
&alloc,
[
core::num::NonZeroU32::new(5),
None,
core::num::NonZeroU32::new(9),
],
)
.unwrap();
let arr = p.handle().get_xs(stack).unwrap(); assert_eq!(arr[0].map(|n| n.get()), Some(5));
assert!(arr[1].is_none());
assert_eq!(arr[2].map(|n| n.get()), Some(9));
p.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct EmbArrHolder {
#[embed]
kids: [EmbChild; 2],
tag: u32,
}
#[test]
fn macro_embed_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let k0 = EmbChild::new(&alloc, MacroLeaf::new(&alloc, 10).unwrap(), 1).unwrap();
let k1 = EmbChild::new(&alloc, MacroLeaf::new(&alloc, 20).unwrap(), 2).unwrap();
let h = EmbArrHolder::new(&alloc, [k0, k1], 99).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 99);
let kids = h.handle().get_kids().unwrap();
assert_eq!(kids[0].get_n(stack).unwrap(), 1);
assert_eq!(kids[0].get_leaf(stack).unwrap().get_val(stack).unwrap(), 10);
assert_eq!(kids[1].get_leaf(stack).unwrap().get_val(stack).unwrap(), 20);
let clone = h.try_clone_in(&alloc).unwrap();
let ckids = clone.handle().get_kids().unwrap();
assert_eq!(
ckids[1].get_leaf(stack).unwrap().get_val(stack).unwrap(),
20
);
assert_ne!(
ckids[0].get_leaf(stack).unwrap().range().start(),
kids[0].get_leaf(stack).unwrap().range().start()
);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_kids().unwrap()[1]
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
20
);
let (moved, tag) = bstack_move!(h, &alloc).unwrap();
assert_eq!(tag, 99);
assert_eq!(
moved[0]
.handle()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
10
);
for m in moved {
m.bstack_drop(&alloc).unwrap();
}
}
#[bstack_enum]
enum ArrEnum {
Empty,
#[bstack_owned]
Leaves([MacroLeaf; 2]),
}
#[test]
fn macro_enum_owned_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let e = ArrEnum::new(
&alloc,
ArrEnumData::Leaves([
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
ArrEnumView::Leaves(arr) => {
assert_eq!(arr[0].get_val(stack).unwrap(), 10);
assert_eq!(arr[1].get_val(stack).unwrap(), 20);
}
_ => panic!("expected Leaves"),
}
let clone = e.try_clone_in(&alloc).unwrap();
match clone.handle().read(&alloc).unwrap() {
ArrEnumView::Leaves(arr) => assert_eq!(arr[0].get_val(stack).unwrap(), 10),
_ => panic!("expected Leaves"),
}
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
ArrEnumData::Leaves(arr) => {
assert_eq!(arr[1].handle().get_val(stack).unwrap(), 20);
for l in arr {
l.bstack_drop(&alloc).unwrap();
}
}
_ => panic!("expected Leaves"),
}
}
#[bstack_enum]
enum RefArrEnum {
Empty,
#[bstack_ref]
Refs([MacroLeaf; 2]),
}
#[test]
fn macro_enum_ref_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let l0 = MacroLeaf::new(&alloc, 1).unwrap();
let l1 = MacroLeaf::new(&alloc, 2).unwrap();
let e = RefArrEnum::new(
&alloc,
RefArrEnumData::Refs([
unsafe { BStackRef::from_range(l0.handle().range()) },
unsafe { BStackRef::from_range(l1.handle().range()) },
]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
RefArrEnumView::Refs(arr) => {
assert_eq!(arr[0].get_val(stack).unwrap(), 1);
assert_eq!(arr[1].get_val(stack).unwrap(), 2);
}
_ => panic!("expected Refs"),
}
e.bstack_drop(&alloc).unwrap(); assert_eq!(l0.handle().get_val(stack).unwrap(), 1);
l0.bstack_drop(&alloc).unwrap();
l1.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
enum StrongArrEnum {
Empty,
#[bstack_strong]
Shared([MacroStrongChild; 2]),
}
#[test]
fn macro_enum_strong_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c0 = MacroStrongChild::new(&alloc, 5).unwrap();
let c1 = MacroStrongChild::new(&alloc, 6).unwrap();
let keep0 = c0.try_clone().unwrap();
let e = StrongArrEnum::new(&alloc, StrongArrEnumData::Shared([c0, c1])).unwrap();
match e.handle().read(&alloc).unwrap() {
StrongArrEnumView::Shared(arr) => assert_eq!(arr[0].get_val(stack).unwrap(), 5),
_ => panic!("expected Shared"),
}
let clone = e.try_clone_in(&alloc).unwrap();
clone.bstack_drop(&alloc).unwrap();
e.bstack_drop(&alloc).unwrap();
assert_eq!(keep0.handle().get_val(stack).unwrap(), 5);
drop(keep0);
}
#[bstack_enum]
enum WeakArrEnum {
Empty,
#[bstack_weak]
Weaks([MacroStrongChild; 2]),
}
#[test]
fn macro_enum_weak_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c0 = MacroStrongChild::new(&alloc, 5).unwrap();
let c1 = MacroStrongChild::new(&alloc, 6).unwrap();
let e = WeakArrEnum::new(
&alloc,
WeakArrEnumData::Weaks([c0.downgrade().unwrap(), c1.downgrade().unwrap()]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
WeakArrEnumView::Weaks(arr) => {
assert_eq!(arr[0].as_ref().unwrap().handle().get_val(stack).unwrap(), 5);
assert_eq!(arr[1].as_ref().unwrap().handle().get_val(stack).unwrap(), 6);
}
_ => panic!("expected Weaks"),
}
e.bstack_drop(&alloc).unwrap(); assert_eq!(c0.handle().get_val(stack).unwrap(), 5);
drop(c0);
drop(c1);
}
#[bstack_enum]
enum PodArrEnum {
Empty,
Bytes([u16; 3]),
}
#[test]
fn macro_enum_pod_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let e = PodArrEnum::new(&alloc, PodArrEnumData::Bytes([7, 8, 9])).unwrap();
match e.handle().read(&alloc).unwrap() {
PodArrEnumView::Bytes(a) => assert_eq!(a, [7u16, 8, 9]),
_ => panic!("expected Bytes"),
}
e.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct OwnedGrid {
#[bstack_owned]
grid: [[MacroLeaf; 2]; 2],
tag: u32,
}
#[test]
fn macro_owned_nested_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mk = |v| MacroLeaf::new(&alloc, v).unwrap();
let h = OwnedGrid::new(&alloc, [[mk(1), mk(2)], [mk(3), mk(4)]], 7).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 7);
let g = h.handle().get_grid(stack).unwrap(); assert_eq!(g[0][0].get_val(stack).unwrap(), 1);
assert_eq!(g[0][1].get_val(stack).unwrap(), 2);
assert_eq!(g[1][0].get_val(stack).unwrap(), 3);
assert_eq!(g[1][1].get_val(stack).unwrap(), 4);
let clone = h.try_clone_in(&alloc).unwrap();
let cg = clone.handle().get_grid(stack).unwrap();
assert_eq!(cg[1][1].get_val(stack).unwrap(), 4);
assert_ne!(cg[0][0].range().start(), g[0][0].range().start());
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_grid(stack).unwrap()[1][0]
.get_val(stack)
.unwrap(),
3
);
let (moved, tag) = bstack_move!(h, &alloc).unwrap();
assert_eq!(tag, 7);
assert_eq!(moved[1][1].handle().get_val(stack).unwrap(), 4);
for row in moved {
for m in row {
m.bstack_drop(&alloc).unwrap();
}
}
}
#[bstack_block]
struct RefCube {
#[bstack_ref]
cube: [[[MacroLeaf; 2]; 1]; 2],
}
#[test]
fn macro_ref_nested3_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaves: Vec<_> = (0..4).map(|v| MacroLeaf::new(&alloc, v).unwrap()).collect();
let r = |i: usize| unsafe { BStackRef::from_range(leaves[i].handle().range()) };
let h = RefCube::new(&alloc, [[[r(0), r(1)]], [[r(2), r(3)]]]).unwrap();
let c = h.handle().get_cube(stack).unwrap(); assert_eq!(c[0][0][0].get_val(stack).unwrap(), 0);
assert_eq!(c[0][0][1].get_val(stack).unwrap(), 1);
assert_eq!(c[1][0][0].get_val(stack).unwrap(), 2);
assert_eq!(c[1][0][1].get_val(stack).unwrap(), 3);
h.bstack_drop(&alloc).unwrap();
for l in leaves {
assert!(l.handle().get_val(stack).unwrap() < 4);
l.bstack_drop(&alloc).unwrap();
}
}
#[bstack_block]
struct EmbGrid {
#[embed]
kids: [[EmbChild; 2]; 1],
tag: u32,
}
#[test]
fn macro_embed_nested_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let k = |v| EmbChild::new(&alloc, MacroLeaf::new(&alloc, v).unwrap(), v).unwrap();
let h = EmbGrid::new(&alloc, [[k(10), k(20)]], 5).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 5);
let g = h.handle().get_kids().unwrap(); assert_eq!(g[0][0].get_leaf(stack).unwrap().get_val(stack).unwrap(), 10);
assert_eq!(g[0][1].get_leaf(stack).unwrap().get_val(stack).unwrap(), 20);
let clone = h.try_clone_in(&alloc).unwrap();
let cg = clone.handle().get_kids().unwrap();
assert_eq!(
cg[0][1].get_leaf(stack).unwrap().get_val(stack).unwrap(),
20
);
assert_ne!(
cg[0][0].get_leaf(stack).unwrap().range().start(),
g[0][0].get_leaf(stack).unwrap().range().start()
);
clone.bstack_drop(&alloc).unwrap();
let (moved, tag) = bstack_move!(h, &alloc).unwrap();
assert_eq!(tag, 5);
assert_eq!(
moved[0][0]
.handle()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
10
);
for row in moved {
for m in row {
m.bstack_drop(&alloc).unwrap();
}
}
}
#[bstack_enum]
enum OptArrEnum {
Empty,
#[bstack_owned]
Slots([Option<MacroLeaf>; 3]),
}
#[test]
fn macro_enum_owned_option_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let e = OptArrEnum::new(
&alloc,
OptArrEnumData::Slots([
Some(MacroLeaf::new(&alloc, 10).unwrap()),
None,
Some(MacroLeaf::new(&alloc, 30).unwrap()),
]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
OptArrEnumView::Slots(arr) => {
assert_eq!(arr[0].map(|h| h.get_val(stack).unwrap()), Some(10));
assert!(arr[1].is_none());
assert_eq!(arr[2].map(|h| h.get_val(stack).unwrap()), Some(30));
}
_ => panic!("expected Slots"),
}
let clone = e.try_clone_in(&alloc).unwrap();
match clone.handle().read(&alloc).unwrap() {
OptArrEnumView::Slots(arr) => {
assert_eq!(arr[2].map(|h| h.get_val(stack).unwrap()), Some(30));
assert!(arr[1].is_none());
}
_ => panic!("expected Slots"),
}
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
OptArrEnumData::Slots(arr) => {
assert_eq!(
arr[0].as_ref().map(|h| h.handle().get_val(stack).unwrap()),
Some(10)
);
assert!(arr[1].is_none());
for slot in arr.into_iter().flatten() {
slot.bstack_drop(&alloc).unwrap();
}
}
_ => panic!("expected Slots"),
}
}
#[bstack_enum]
enum EmbArrEnum {
Empty,
#[embed]
Kids([EmbChild; 2]),
}
#[test]
fn macro_enum_embed_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let k = |v| EmbChild::new(&alloc, MacroLeaf::new(&alloc, v).unwrap(), v).unwrap();
let e = EmbArrEnum::new(&alloc, EmbArrEnumData::Kids([k(10), k(20)])).unwrap();
match e.handle().read(&alloc).unwrap() {
EmbArrEnumView::Kids(arr) => {
assert_eq!(arr[0].get_leaf(stack).unwrap().get_val(stack).unwrap(), 10);
assert_eq!(arr[1].get_leaf(stack).unwrap().get_val(stack).unwrap(), 20);
}
_ => panic!("expected Kids"),
}
let clone = e.try_clone_in(&alloc).unwrap();
match clone.handle().read(&alloc).unwrap() {
EmbArrEnumView::Kids(arr) => {
assert_eq!(arr[1].get_leaf(stack).unwrap().get_val(stack).unwrap(), 20)
}
_ => panic!("expected Kids"),
}
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
EmbArrEnumData::Kids(arr) => {
assert_eq!(
arr[0]
.handle()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
10
);
for m in arr {
m.bstack_drop(&alloc).unwrap();
}
}
_ => panic!("expected Kids"),
}
}
#[bstack_enum]
enum NestArrEnum {
Empty,
#[bstack_owned]
Grid([[MacroLeaf; 2]; 2]),
}
#[test]
fn macro_enum_owned_nested_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mk = |v| MacroLeaf::new(&alloc, v).unwrap();
let e = NestArrEnum::new(
&alloc,
NestArrEnumData::Grid([[mk(1), mk(2)], [mk(3), mk(4)]]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
NestArrEnumView::Grid(g) => {
assert_eq!(g[0][0].get_val(stack).unwrap(), 1);
assert_eq!(g[1][1].get_val(stack).unwrap(), 4);
}
_ => panic!("expected Grid"),
}
let clone = e.try_clone_in(&alloc).unwrap();
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
NestArrEnumData::Grid(g) => {
assert_eq!(g[1][0].handle().get_val(stack).unwrap(), 3);
for row in g {
for m in row {
m.bstack_drop(&alloc).unwrap();
}
}
}
_ => panic!("expected Grid"),
}
}
#[bstack_block]
struct PodVecArr {
rows: [Vec<u32>; 2],
tag: u32,
}
#[test]
fn macro_pod_vec_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = PodVecArr::new(&alloc, [&[1u32, 2][..], &[3, 4, 5][..]], 9).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 9);
let rows = h.handle().get_rows(&alloc).unwrap(); assert_eq!(rows[0].to_vec().unwrap(), vec![1u32, 2]);
assert_eq!(rows[1].to_vec().unwrap(), vec![3u32, 4, 5]);
let mut rows_mut = h.handle().get_rows(&alloc).unwrap();
rows_mut[0].push(99).unwrap();
assert_eq!(
h.handle().get_rows(&alloc).unwrap()[0].to_vec().unwrap(),
vec![1u32, 2, 99]
);
assert_eq!(
h.handle().get_rows(&alloc).unwrap()[1].to_vec().unwrap(),
vec![3u32, 4, 5]
);
let clone = h.try_clone_in(&alloc).unwrap();
let crows = clone.handle().get_rows(&alloc).unwrap();
assert_eq!(crows[1].to_vec().unwrap(), vec![3u32, 4, 5]);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_rows(&alloc).unwrap()[1].to_vec().unwrap(),
vec![3u32, 4, 5]
);
let (moved, tag) = bstack_move!(h, &alloc).unwrap();
assert_eq!(tag, 9);
assert_eq!(moved[1].to_vec().unwrap(), vec![3u32, 4, 5]);
for v in moved {
v.bstack_drop().unwrap();
}
}
#[bstack_block]
struct RefVecArr {
#[bstack_ref]
lists: [Vec<MacroLeaf>; 2],
}
#[test]
fn macro_ref_vec_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaves: Vec<_> = (0..4).map(|v| MacroLeaf::new(&alloc, v).unwrap()).collect();
let r = |i: usize| unsafe { BStackRef::from_range(leaves[i].handle().range()) };
let h = RefVecArr::new(&alloc, [vec![r(0), r(1)], vec![r(2), r(3)]]).unwrap();
let ls = h.handle().get_lists(&alloc).unwrap(); assert_eq!(ls[0].len().unwrap(), 2);
assert_eq!(ls[0].get(1).unwrap().unwrap().get_val(stack).unwrap(), 1);
assert_eq!(ls[1].get(0).unwrap().unwrap().get_val(stack).unwrap(), 2);
h.bstack_drop(&alloc).unwrap();
for l in leaves {
assert!(l.handle().get_val(stack).unwrap() < 4);
l.bstack_drop(&alloc).unwrap();
}
}
#[bstack_block]
struct OwnedVecArr {
#[bstack_owned]
groups: [Vec<MacroLeaf>; 2],
tag: u32,
}
#[test]
fn macro_owned_vec_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let g0 = vec![
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 11).unwrap(),
];
let g1 = vec![MacroLeaf::new(&alloc, 20).unwrap()];
let h = OwnedVecArr::new(&alloc, [g0, g1], 7).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 7);
let gs = h.handle().get_groups(&alloc).unwrap();
assert_eq!(gs[0].len().unwrap(), 2);
assert_eq!(gs[0].get(0).unwrap().unwrap().get_val(stack).unwrap(), 10);
assert_eq!(gs[1].get(0).unwrap().unwrap().get_val(stack).unwrap(), 20);
let clone = h.try_clone_in(&alloc).unwrap();
let cgs = clone.handle().get_groups(&alloc).unwrap();
assert_eq!(cgs[0].get(1).unwrap().unwrap().get_val(stack).unwrap(), 11);
assert_ne!(
cgs[0].get(0).unwrap().unwrap().range().start(),
gs[0].get(0).unwrap().unwrap().range().start()
);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_groups(&alloc).unwrap()[1]
.get(0)
.unwrap()
.unwrap()
.get_val(stack)
.unwrap(),
20
);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct OptVecArr {
slots: [Option<Vec<u32>>; 3],
}
#[test]
fn macro_option_vec_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let h = OptVecArr::new(&alloc, [Some(&[1u32, 2][..]), None, Some(&[9][..])]).unwrap();
let s = h.handle().get_slots(&alloc).unwrap(); assert_eq!(s[0].as_ref().unwrap().to_vec().unwrap(), vec![1u32, 2]);
assert!(s[1].is_none());
assert_eq!(s[2].as_ref().unwrap().to_vec().unwrap(), vec![9u32]);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct RefVecOfArr {
#[bstack_ref]
rows: Vec<[MacroLeaf; 2]>,
tag: u32,
}
#[test]
fn macro_ref_vec_of_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaves: Vec<_> = (0..4).map(|v| MacroLeaf::new(&alloc, v).unwrap()).collect();
let r = |i: usize| unsafe { BStackRef::from_range(leaves[i].handle().range()) };
let h = RefVecOfArr::new(&alloc, vec![[r(0), r(1)], [r(2), r(3)]], 7).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 7);
let rows = h.handle().get_rows(&alloc).unwrap(); assert_eq!(rows.len(), 2);
assert_eq!(rows[0][0].get_val(stack).unwrap(), 0);
assert_eq!(rows[0][1].get_val(stack).unwrap(), 1);
assert_eq!(rows[1][0].get_val(stack).unwrap(), 2);
assert_eq!(rows[1][1].get_val(stack).unwrap(), 3);
let clone = h.try_clone_in(&alloc).unwrap();
let crows = clone.handle().get_rows(&alloc).unwrap();
assert_eq!(
crows[1][0].range().start(),
rows[1][0].range().start() );
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_rows(&alloc).unwrap()[0][1]
.get_val(stack)
.unwrap(),
1
);
h.bstack_drop(&alloc).unwrap();
for l in leaves {
assert!(l.handle().get_val(stack).unwrap() < 4);
l.bstack_drop(&alloc).unwrap();
}
}
#[bstack_block]
struct OwnedVecOfArr {
#[bstack_owned]
rows: Vec<[MacroLeaf; 2]>,
tag: u32,
}
#[test]
fn macro_owned_vec_of_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mk = |v| MacroLeaf::new(&alloc, v).unwrap();
let h = OwnedVecOfArr::new(&alloc, vec![[mk(1), mk(2)], [mk(3), mk(4)]], 7).unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 7);
let rows = h.handle().get_rows(&alloc).unwrap(); assert_eq!(rows.len(), 2);
assert_eq!(rows[0][0].get_val(stack).unwrap(), 1);
assert_eq!(rows[0][1].get_val(stack).unwrap(), 2);
assert_eq!(rows[1][0].get_val(stack).unwrap(), 3);
assert_eq!(rows[1][1].get_val(stack).unwrap(), 4);
let clone = h.try_clone_in(&alloc).unwrap();
let crows = clone.handle().get_rows(&alloc).unwrap();
assert_eq!(crows[1][1].get_val(stack).unwrap(), 4);
assert_ne!(crows[0][0].range().start(), rows[0][0].range().start());
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
h.handle().get_rows(&alloc).unwrap()[1][0]
.get_val(stack)
.unwrap(),
3
);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct StrongVecOfArr {
#[bstack_strong]
groups: Vec<[MacroStrongChild; 2]>,
}
#[test]
fn macro_strong_vec_of_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 10).unwrap();
let b = MacroStrongChild::new(&alloc, 20).unwrap();
let a_keep = a.try_clone().unwrap(); let a_data = a_keep.handle().range().start();
let h = StrongVecOfArr::new(&alloc, vec![[a, b]]).unwrap();
assert_eq!(strong_of(stack, a_data), 2);
let g = h.handle().get_groups(&alloc).unwrap(); assert_eq!(g[0][0].get_val(stack).unwrap(), 10);
assert_eq!(g[0][1].get_val(stack).unwrap(), 20);
let clone = h.try_clone_in(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 3); clone.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 2);
h.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 1); drop(a_keep);
}
#[bstack_block]
struct WeakVecOfArr {
#[bstack_weak]
groups: Vec<[MacroStrongChild; 2]>,
}
#[test]
fn macro_weak_vec_of_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 1).unwrap();
let b = MacroStrongChild::new(&alloc, 2).unwrap();
let h = WeakVecOfArr::new(
&alloc,
vec![[a.downgrade().unwrap(), b.downgrade().unwrap()]],
)
.unwrap();
let g = h.handle().get_groups(&alloc).unwrap(); assert_eq!(
g[0][0].as_ref().unwrap().handle().get_val(stack).unwrap(),
1
);
assert!(g[0][1].as_ref().is_some());
drop(g);
drop(a);
let g = h.handle().get_groups(&alloc).unwrap();
assert!(g[0][0].is_none());
assert!(g[0][1].is_some());
drop(g);
h.bstack_drop(&alloc).unwrap();
drop(b);
}
#[bstack_enum]
enum OwnedVecEnum {
Empty,
#[bstack_owned]
Items(Vec<MacroLeaf>),
}
#[test]
fn macro_enum_owned_vec() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let items = BStackBlockVec::from_handles(
&alloc,
vec![
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
],
)
.unwrap();
let e = OwnedVecEnum::new(&alloc, OwnedVecEnumData::Items(items)).unwrap();
match e.handle().read(&alloc).unwrap() {
OwnedVecEnumView::Items(v) => {
assert_eq!(v.len().unwrap(), 2);
assert_eq!(v.get(0).unwrap().unwrap().get_val(stack).unwrap(), 10);
assert_eq!(v.get(1).unwrap().unwrap().get_val(stack).unwrap(), 20);
}
_ => panic!("expected Items"),
}
let clone = e.try_clone_in(&alloc).unwrap();
match clone.handle().read(&alloc).unwrap() {
OwnedVecEnumView::Items(v) => {
assert_eq!(v.get(1).unwrap().unwrap().get_val(stack).unwrap(), 20)
}
_ => panic!("expected Items"),
}
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
OwnedVecEnumData::Items(v) => {
assert_eq!(v.get(0).unwrap().unwrap().get_val(stack).unwrap(), 10);
v.bstack_drop().unwrap();
}
_ => panic!("expected Items"),
}
}
#[bstack_enum]
enum RefVecArrEnum {
Empty,
#[bstack_ref]
Rows(Vec<[MacroLeaf; 2]>),
}
#[test]
fn macro_enum_ref_vec_of_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaves: Vec<_> = (0..4).map(|v| MacroLeaf::new(&alloc, v).unwrap()).collect();
let r = |i: usize| unsafe { BStackRef::from_range(leaves[i].handle().range()) };
let e = RefVecArrEnum::new(
&alloc,
RefVecArrEnumData::Rows(vec![[r(0), r(1)], [r(2), r(3)]]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
RefVecArrEnumView::Rows(v) => {
assert_eq!(v.len(), 2);
assert_eq!(v[0][0].get_val(stack).unwrap(), 0);
assert_eq!(v[1][1].get_val(stack).unwrap(), 3);
}
_ => panic!("expected Rows"),
}
e.bstack_drop(&alloc).unwrap();
for l in leaves {
assert!(l.handle().get_val(stack).unwrap() < 4);
l.bstack_drop(&alloc).unwrap();
}
}
#[bstack_enum]
enum OwnedVecArrEnum {
Empty,
#[bstack_owned]
Grid(Vec<[MacroLeaf; 2]>),
}
#[test]
fn macro_enum_owned_vec_of_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mk = |v| MacroLeaf::new(&alloc, v).unwrap();
let e = OwnedVecArrEnum::new(
&alloc,
OwnedVecArrEnumData::Grid(vec![[mk(1), mk(2)], [mk(3), mk(4)]]),
)
.unwrap();
match e.handle().read(&alloc).unwrap() {
OwnedVecArrEnumView::Grid(v) => {
assert_eq!(v.len(), 2);
assert_eq!(v[0][0].get_val(stack).unwrap(), 1);
assert_eq!(v[1][1].get_val(stack).unwrap(), 4);
}
_ => panic!("expected Grid"),
}
let clone = e.try_clone_in(&alloc).unwrap();
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
OwnedVecArrEnumData::Grid(v) => {
assert_eq!(v[1][0].handle().get_val(stack).unwrap(), 3);
for row in v {
for m in row {
m.bstack_drop(&alloc).unwrap();
}
}
}
_ => panic!("expected Grid"),
}
}
#[bstack_enum]
enum StrongVecEnum {
Empty,
#[bstack_strong]
Items(Vec<MacroStrongChild>),
}
#[test]
fn macro_enum_strong_vec_rc() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 10).unwrap();
let a_keep = a.try_clone().unwrap(); let a_data = a_keep.handle().range().start();
let items = crate::BStackStrongVec::from_handles(&alloc, vec![a]).unwrap();
let e = StrongVecEnum::new(&alloc, StrongVecEnumData::Items(items)).unwrap();
assert_eq!(strong_of(stack, a_data), 2);
let clone = e.try_clone_in(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 3);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 2);
e.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, a_data), 1); drop(a_keep);
}
#[bstack_enum]
enum PodVecEnum {
Empty,
Nums(Vec<u32>),
Text(String),
}
#[test]
fn macro_enum_pod_vec() {
use crate::BStackVec;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let nums = BStackVec::<u32, _>::from_slice(&alloc, &[1u32, 2, 3]).unwrap();
let e = PodVecEnum::new(&alloc, PodVecEnumData::Nums(nums)).unwrap();
match e.handle().read(&alloc).unwrap() {
PodVecEnumView::Nums(v) => assert_eq!(v.to_vec().unwrap(), vec![1u32, 2, 3]),
_ => panic!("expected Nums"),
}
let clone = e.try_clone_in(&alloc).unwrap();
match clone.handle().read(&alloc).unwrap() {
PodVecEnumView::Nums(v) => assert_eq!(v.to_vec().unwrap(), vec![1u32, 2, 3]),
_ => panic!("expected Nums"),
}
clone.bstack_drop(&alloc).unwrap();
match bstack_move!(e, &alloc).unwrap() {
PodVecEnumData::Nums(v) => {
assert_eq!(v.to_vec().unwrap(), vec![1u32, 2, 3]);
v.bstack_drop().unwrap();
}
_ => panic!("expected Nums"),
}
let text = BStackVec::<u8, _>::from_slice(&alloc, b"hello").unwrap();
let e2 = PodVecEnum::new(&alloc, PodVecEnumData::Text(text)).unwrap();
match e2.handle().read(&alloc).unwrap() {
PodVecEnumView::Text(v) => assert_eq!(v.to_vec().unwrap(), b"hello"),
_ => panic!("expected Text"),
}
e2.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct RefBox<T> {
#[bstack_ref]
item: T,
tag: u64,
}
#[test]
fn macro_generic_ref_box() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let r = unsafe { BStackRef::from_range(leaf.handle().range()) };
let b = RefBox::<MacroLeaf>::new(&alloc, r, 7).unwrap();
assert_eq!(b.handle().get_tag(stack).unwrap(), 7);
assert_eq!(
b.handle().get_item(stack).unwrap().get_val(stack).unwrap(),
42
);
let clone = b.try_clone_in(&alloc).unwrap();
assert_eq!(
clone.handle().get_item(stack).unwrap().range().start(),
b.handle().get_item(stack).unwrap().range().start()
);
assert_ne!(clone.handle().range().start(), b.handle().range().start());
clone.bstack_drop(&alloc).unwrap();
b.bstack_drop(&alloc).unwrap();
assert_eq!(leaf.handle().get_val(stack).unwrap(), 42);
leaf.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_generic_distinct_tags() {
assert_ne!(
<RefBox<MacroLeaf> as BStackCast>::eightcc(),
<RefBox<MacroStrongChild> as BStackCast>::eightcc(),
);
assert_ne!(
<RefBox<MacroLeaf> as BStackCast>::eightcc(),
<MacroLeaf as BStackCast>::eightcc(),
);
}
#[bstack_block]
struct Pair<A, B> {
#[bstack_owned]
first: A,
#[bstack_owned]
second: B,
}
#[bstack_block]
struct PairA {
a: u32,
}
#[bstack_block]
struct PairB {
b: u64,
c: u64,
}
#[test]
fn macro_generic_permuted_tags_distinct() {
assert_ne!(
<Pair<PairA, PairB> as BStackCast>::eightcc(),
<Pair<PairB, PairA> as BStackCast>::eightcc(),
);
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let x = Pair::<PairA, PairB>::new(
&alloc,
PairA::new(&alloc, 1).unwrap(),
PairB::new(&alloc, 2, 3).unwrap(),
)
.unwrap();
let sl = x.handle().as_slice(stack);
assert!(
bstack_cast!(sl as Pair<PairB, PairA>).unwrap().is_none(),
"permuted cast must be rejected by the distinct tag"
);
assert!(bstack_cast!(sl as Pair<PairA, PairB>).unwrap().is_some());
x.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_generic_move_cast() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 9).unwrap();
let r = unsafe { BStackRef::from_range(leaf.handle().range()) };
let b = RefBox::<MacroLeaf>::new(&alloc, r, 3).unwrap();
let sl = b.handle().as_slice(stack);
let back = bstack_cast!(sl as RefBox<MacroLeaf>)
.unwrap()
.expect("same tag");
assert_eq!(back.get_item(stack).unwrap().get_val(stack).unwrap(), 9);
let (item, tag) = bstack_move!(b, &alloc).unwrap();
assert_eq!(tag, 3);
assert_eq!(item.into_range().start(), leaf.handle().range().start());
leaf.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct StrongBox<T> {
#[bstack_strong]
item: T,
tag: u64,
}
#[test]
fn macro_generic_strong_box() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c = MacroStrongChild::new(&alloc, 10).unwrap();
let keep = c.try_clone().unwrap(); let data = keep.handle().range().start();
let b = StrongBox::<MacroStrongChild>::new(&alloc, c, 5).unwrap();
assert_eq!(strong_of(stack, data), 2); assert_eq!(b.handle().get_tag(stack).unwrap(), 5);
let clone = b.try_clone_in(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 3);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 2);
b.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 1); drop(keep);
}
#[bstack_block]
struct WeakBox<T> {
#[bstack_weak]
item: T,
}
#[test]
fn macro_generic_weak_box() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c = MacroStrongChild::new(&alloc, 7).unwrap();
let b = WeakBox::<MacroStrongChild>::new(&alloc).unwrap();
b.handle().set_item(&alloc, c.downgrade().unwrap()).unwrap();
let up = b.handle().get_item(&alloc).unwrap().expect("alive");
assert_eq!(up.handle().get_val(stack).unwrap(), 7);
drop(up);
drop(c); assert!(b.handle().get_item(&alloc).unwrap().is_none());
b.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct OwnedBox<T> {
#[bstack_owned]
item: T,
tag: u64,
}
#[test]
fn macro_generic_owned_box() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let b = OwnedBox::<MacroLeaf>::new(&alloc, leaf, 7).unwrap();
assert_eq!(b.handle().get_tag(stack).unwrap(), 7);
assert_eq!(
b.handle().get_item(stack).unwrap().get_val(stack).unwrap(),
42
);
let clone = b.try_clone_in(&alloc).unwrap();
let citem = clone.handle().get_item(stack).unwrap();
assert_eq!(citem.get_val(stack).unwrap(), 42);
assert_ne!(
citem.range().start(),
b.handle().get_item(stack).unwrap().range().start()
);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(
b.handle().get_item(stack).unwrap().get_val(stack).unwrap(),
42
);
b.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
OwnedBox::<MacroLeaf>::new(&alloc, leaf, 7).unwrap()
});
}
#[bstack_block]
struct OwnsEnumG<T> {
#[bstack_owned]
e: T,
n: u32,
}
#[bstack_block]
struct OwnedVecG<T> {
#[bstack_owned]
items: Vec<T>,
}
#[bstack_block]
struct OwnedArrG<T> {
#[bstack_owned]
items: [T; 2],
}
#[test]
fn macro_generic_owns_enum() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let e = ArrEnum::new(
&alloc,
ArrEnumData::Leaves([
MacroLeaf::new(&alloc, 1).unwrap(),
MacroLeaf::new(&alloc, 2).unwrap(),
]),
)
.unwrap();
let b = OwnsEnumG::<ArrEnum>::new(&alloc, e, 9).unwrap();
let clone = b.try_clone_in(&alloc).unwrap();
match clone.handle().get_e(stack).unwrap().read(&alloc).unwrap() {
ArrEnumView::Leaves(a) => assert_eq!(a[1].get_val(stack).unwrap(), 2),
_ => panic!("expected Leaves"),
}
clone.bstack_drop(&alloc).unwrap();
b.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct PodBoxG<T> {
item: T,
tag: u64,
}
#[test]
fn macro_generic_pod_box() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let b = PodBoxG::<u32>::new(&alloc, 42u32, 7).unwrap();
assert_eq!(b.handle().get_item(stack).unwrap(), 42);
assert_eq!(b.handle().get_tag(stack).unwrap(), 7);
let clone = b.try_clone_in(&alloc).unwrap();
assert_eq!(clone.handle().get_item(stack).unwrap(), 42);
clone.bstack_drop(&alloc).unwrap();
assert_ne!(
<PodBoxG<u32> as BStackCast>::eightcc(),
<PodBoxG<u64> as BStackCast>::eightcc(),
);
let (item, tag) = bstack_move!(b, &alloc).unwrap();
assert_eq!((item, tag), (42u32, 7u64));
}
#[bstack_block]
struct EmbBoxG<T> {
#[embed]
item: T,
tag: u32,
}
#[test]
fn macro_generic_emb_box() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let child = EmbChild::new(&alloc, MacroLeaf::new(&alloc, 10).unwrap(), 1).unwrap();
let b = EmbBoxG::<EmbChild>::new(&alloc, child, 99).unwrap();
assert_eq!(b.handle().get_tag(stack).unwrap(), 99);
assert_eq!(
b.handle()
.get_item()
.unwrap()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
10
);
let clone = b.try_clone_in(&alloc).unwrap();
assert_eq!(
clone
.handle()
.get_item()
.unwrap()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
10
);
assert_ne!(
clone
.handle()
.get_item()
.unwrap()
.get_leaf(stack)
.unwrap()
.range()
.start(),
b.handle()
.get_item()
.unwrap()
.get_leaf(stack)
.unwrap()
.range()
.start()
);
clone.bstack_drop(&alloc).unwrap();
let (moved, tag) = bstack_move!(b, &alloc).unwrap();
assert_eq!(tag, 99);
assert_eq!(
moved
.handle()
.get_leaf(stack)
.unwrap()
.get_val(stack)
.unwrap(),
10
);
moved.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
enum BoxEnumG<T> {
Empty,
Tag(u32),
#[bstack_owned]
Item(T),
}
#[test]
fn macro_generic_enum_owned() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 42).unwrap();
let e = BoxEnumG::<MacroLeaf>::new(&alloc, BoxEnumGData::Item(leaf)).unwrap();
match e.handle().read(&alloc).unwrap() {
BoxEnumGView::Item(l) => assert_eq!(l.get_val(stack).unwrap(), 42),
_ => panic!("expected Item"),
}
let clone = e.try_clone_in(&alloc).unwrap();
match clone.handle().read(&alloc).unwrap() {
BoxEnumGView::Item(l) => assert_eq!(l.get_val(stack).unwrap(), 42),
_ => panic!("expected Item"),
}
clone.bstack_drop(&alloc).unwrap();
assert_ne!(
<BoxEnumG<MacroLeaf> as BStackCast>::eightcc(),
<BoxEnumG<MacroStrongChild> as BStackCast>::eightcc(),
);
match bstack_move!(e, &alloc).unwrap() {
BoxEnumGData::Item(owned) => {
assert_eq!(owned.handle().get_val(stack).unwrap(), 42);
owned.bstack_drop(&alloc).unwrap();
}
_ => panic!("expected Item"),
}
}
#[test]
fn macro_generic_enum_tag_variant() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let e = BoxEnumG::<MacroLeaf>::new(&alloc, BoxEnumGData::Tag(99)).unwrap();
match e.handle().read(&alloc).unwrap() {
BoxEnumGView::Tag(t) => assert_eq!(t, 99),
_ => panic!("expected Tag"),
}
e.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
enum StrongEnumG<T> {
Empty,
#[bstack_strong]
S(T),
}
#[test]
fn macro_generic_enum_strong() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c = MacroStrongChild::new(&alloc, 5).unwrap();
let keep = c.try_clone().unwrap(); let data = keep.handle().range().start();
let e = StrongEnumG::<MacroStrongChild>::new(&alloc, StrongEnumGData::S(c)).unwrap();
assert_eq!(strong_of(stack, data), 2);
let clone = e.try_clone_in(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 3);
clone.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 2);
e.bstack_drop(&alloc).unwrap();
assert_eq!(strong_of(stack, data), 1);
drop(keep);
}
#[bstack_block]
struct RefArrN<T, const N: usize> {
#[bstack_ref]
arr: [T; N],
tag: u64,
}
#[bstack_block]
struct OwnArrN<T, const N: usize> {
#[bstack_owned]
arr: [T; N],
}
#[bstack_block]
struct PodArrN<const N: usize> {
xs: [u16; N],
tag: u32,
}
#[test]
fn macro_generic_const_ref_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let leaves: Vec<_> = (0..3).map(|v| MacroLeaf::new(&alloc, v).unwrap()).collect();
let r = |i: usize| unsafe { BStackRef::from_range(leaves[i].handle().range()) };
let b = RefArrN::<MacroLeaf, 3>::new(&alloc, [r(0), r(1), r(2)], 9).unwrap();
assert_eq!(b.handle().get_tag(stack).unwrap(), 9);
let arr = b.handle().get_arr(stack).unwrap(); assert_eq!(arr[0].get_val(stack).unwrap(), 0);
assert_eq!(arr[2].get_val(stack).unwrap(), 2);
assert_ne!(
<RefArrN<MacroLeaf, 3> as BStackCast>::eightcc(),
<RefArrN<MacroLeaf, 4> as BStackCast>::eightcc(),
);
b.bstack_drop(&alloc).unwrap();
for l in leaves {
assert!(l.handle().get_val(stack).unwrap() < 3);
l.bstack_drop(&alloc).unwrap();
}
}
#[test]
fn macro_generic_const_owned_pod_array() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mk = |v| MacroLeaf::new(&alloc, v).unwrap();
let o = OwnArrN::<MacroLeaf, 2>::new(&alloc, [mk(10), mk(20)]).unwrap();
let a = o.handle().get_arr(stack).unwrap();
assert_eq!(a[1].get_val(stack).unwrap(), 20);
let clone = o.try_clone_in(&alloc).unwrap();
assert_ne!(
clone.handle().get_arr(stack).unwrap()[0].range().start(),
a[0].range().start()
);
clone.bstack_drop(&alloc).unwrap();
o.bstack_drop(&alloc).unwrap();
let p = PodArrN::<4>::new(&alloc, [1u16, 2, 3, 4], 7).unwrap();
assert_eq!(p.handle().get_xs(stack).unwrap(), [1u16, 2, 3, 4]);
assert_eq!(p.handle().get_tag(stack).unwrap(), 7);
p.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn wal_clone_reclaims_orphans_on_commit_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
struct FailFirstInplaceGen(AtomicBool);
impl FaultPolicy for FailFirstInplaceGen {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "inplace_gen" && !self.0.swap(true, Ordering::SeqCst) {
Some(io::Error::other("injected clone-commit fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let src = {
let alloc = tmp.allocator(); let leaf = MacroLeaf::new(&alloc, 7).unwrap();
MacroParent::new(&alloc, leaf, 1).unwrap()
};
let mut prev: Option<u64> = None;
for i in 0..30 {
{
let alloc = tmp.allocator();
let stack = alloc.stack();
stack.set_fault_policy(Some(Arc::new(FailFirstInplaceGen(AtomicBool::new(false)))));
let r = src.try_clone_in(&alloc);
stack.set_fault_policy(None);
assert!(r.is_err(), "injected fault must fail the clone commit");
}
let alloc = tmp.allocator();
crate::io_core::wal::finish(&alloc).unwrap();
let len = alloc.len().unwrap();
if i >= 3 {
assert_eq!(len, prev.unwrap(), "faulted clone leaked at iter {i}");
}
prev = Some(len);
}
let alloc = tmp.allocator();
let stack = alloc.stack();
let cl = src.try_clone_in(&alloc).unwrap();
assert_eq!(
cl.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
7
);
cl.bstack_drop(&alloc).unwrap();
src.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn wal_clone_reclaims_bulk_orphans_on_commit_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
struct FailFirstInplaceGen(AtomicBool);
impl FaultPolicy for FailFirstInplaceGen {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "inplace_gen" && !self.0.swap(true, Ordering::SeqCst) {
Some(io::Error::other("injected bulk clone-commit fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.ghost_allocator();
let stack = alloc.stack();
let leaf = MacroLeaf::new(&alloc, 7).unwrap();
let src = MacroParent::new(&alloc, leaf, 1).unwrap();
let mut prev: Option<u64> = None;
for i in 0..30 {
stack.set_fault_policy(Some(Arc::new(FailFirstInplaceGen(AtomicBool::new(false)))));
let r = src.try_clone_in(&alloc);
stack.set_fault_policy(None);
assert!(r.is_err(), "injected fault must fail the bulk clone commit");
let len = stack.len().unwrap();
if i >= 3 {
assert_eq!(len, prev.unwrap(), "faulted bulk clone leaked at iter {i}");
}
prev = Some(len);
}
let cl = src.try_clone_in(&alloc).unwrap();
assert_eq!(
cl.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
7
);
cl.bstack_drop(&alloc).unwrap();
src.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn wal_teardown_reclaims_on_free_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
struct FailSetAfterCommit {
committed: AtomicBool,
fired: AtomicBool,
}
impl FaultPolicy for FailSetAfterCommit {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "inplace_gen" {
self.committed.store(true, Ordering::SeqCst);
return None;
}
if op == "set"
&& self.committed.load(Ordering::SeqCst)
&& !self.fired.swap(true, Ordering::SeqCst)
{
return Some(io::Error::other("injected teardown free fault"));
}
None
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let build = |a: &_| {
let list = crate::BStackLinkedList::<MacroLeaf>::new(a).unwrap();
for v in 0..5u32 {
list.push_back(a, MacroLeaf::new(a, v).unwrap()).unwrap();
}
list
};
build(&alloc).bstack_drop(&alloc).unwrap();
let list1 = build(&alloc);
let peak = stack.len().unwrap();
stack.set_fault_policy(Some(Arc::new(FailSetAfterCommit {
committed: AtomicBool::new(false),
fired: AtomicBool::new(false),
})));
let r = list1.bstack_drop(&alloc);
stack.set_fault_policy(None);
assert!(r.is_err(), "the injected fault must interrupt the teardown");
assert!(
crate::io_core::wal::finish(&alloc).unwrap() > 0,
"finish should reclaim the committed teardown's slices"
);
let list2 = build(&alloc);
let after = stack.len().unwrap();
assert!(
after <= peak,
"teardown crash leaked: file grew {peak} -> {after}"
);
list2.bstack_drop(&alloc).unwrap();
}
#[test]
fn registry_paths_persist_and_live_host_round_trips() {
use crate::registry::{FileId, FileRegistry};
use std::sync::Arc;
let reg_file = TempStack::new();
let foreign = TempStack::new();
let ghost = std::env::temp_dir().join("bstack_raii_registry_ghost.bstack");
{
let reg = FileRegistry::open(®_file.path).unwrap();
let id_a = reg.register_path(&foreign.path).unwrap();
assert_eq!(id_a, FileId::from_u64(1).unwrap());
assert!(!id_a.is_self());
assert_eq!(reg.register_path(&foreign.path).unwrap(), id_a);
let id_g = reg.register_path(&ghost).unwrap();
assert_eq!(id_g.get(), 2);
assert_eq!(reg.id_of(&foreign.path), Some(id_a));
assert_eq!(reg.path_of(id_g).as_deref(), Some(ghost.as_path()));
assert!(FileId::SELF.is_self());
assert!(reg.path_of(FileId::SELF).is_none());
assert!(reg.with_host(FileId::SELF, |_| ()).is_none());
let host: Arc<dyn crate::registry::BStackRaiiHost> = Arc::new(foreign.allocator());
let id = reg.attach(&foreign.path, host).unwrap();
assert_eq!(id, id_a);
assert!(reg.is_live(id));
let block = reg
.with_host(id, |h| {
let r = h.alloc(64).unwrap();
h.stack().set(r.start(), [1, 2, 3, 4, 5, 6, 7, 8]).unwrap();
let mut buf = [0u8; 8];
h.stack().get_into(r.start(), &mut buf).unwrap();
assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7, 8]);
r
})
.expect("host is live");
reg.with_host(id, |h| unsafe { h.dealloc(block).unwrap() })
.expect("host is live");
reg.detach(id);
assert!(!reg.is_live(id));
assert!(reg.with_host(id, |_| ()).is_none());
}
{
let reg = FileRegistry::open(®_file.path).unwrap();
assert_eq!(reg.id_of(&foreign.path).map(FileId::get), Some(1));
assert_eq!(reg.id_of(&ghost).map(FileId::get), Some(2));
assert_eq!(
reg.path_of(FileId::from_u64(1).unwrap()).as_deref(),
Some(foreign.path.as_path())
);
assert!(!reg.is_live(FileId::from_u64(1).unwrap()));
}
let _ = std::fs::remove_file(&ghost);
}
#[bstack_block]
struct MutPod {
#[bstack_mut]
n: u64,
tag: u32, }
#[bstack_block]
struct MutRef {
#[bstack_mut]
#[bstack_ref]
target: MacroLeaf,
}
#[test]
fn macro_bstack_mut_pod_set_and_raw_slice() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let b = MutPod::new(&alloc, 10, 7).unwrap();
assert_eq!(b.handle().get_n(stack).unwrap(), 10);
assert_eq!(b.handle().get_tag(stack).unwrap(), 7);
b.handle().set_n(stack, 42).unwrap();
assert_eq!(b.handle().get_n(stack).unwrap(), 42);
assert_eq!(b.handle().get_tag(stack).unwrap(), 7);
let slice = unsafe { b.handle().raw_n_slice(stack) }.unwrap();
assert_eq!(slice.len(), 8);
let bytes = slice.read().unwrap();
assert_eq!(u64::from_le_bytes(bytes[..8].try_into().unwrap()), 42);
let mut w = unsafe { b.handle().raw_n_slice(stack) }.unwrap();
w.write(99u64.to_le_bytes()).unwrap();
assert_eq!(b.handle().get_n(stack).unwrap(), 99);
b.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_bstack_mut_ref_repoints() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroLeaf::new(&alloc, 111).unwrap();
let c = MacroLeaf::new(&alloc, 222).unwrap();
let holder = MutRef::new(&alloc, unsafe { BStackRef::from_range(a.handle().range()) }).unwrap();
assert_eq!(
holder
.handle()
.get_target(stack)
.unwrap()
.get_val(stack)
.unwrap(),
111
);
holder
.handle()
.set_target(stack, unsafe { BStackRef::from_range(c.handle().range()) })
.unwrap();
assert_eq!(
holder
.handle()
.get_target(stack)
.unwrap()
.get_val(stack)
.unwrap(),
222
);
holder.bstack_drop(&alloc).unwrap();
assert_eq!(a.handle().get_val(stack).unwrap(), 111);
assert_eq!(c.handle().get_val(stack).unwrap(), 222);
a.bstack_drop(&alloc).unwrap();
c.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutOwned {
#[bstack_mut]
#[bstack_owned]
child: MacroLeaf,
}
#[bstack_block]
struct MutStrong {
#[bstack_mut]
#[bstack_strong]
s: MacroStrongChild,
}
#[test]
fn macro_bstack_mut_ref_replace_returns_old() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroLeaf::new(&alloc, 111).unwrap();
let c = MacroLeaf::new(&alloc, 222).unwrap();
let holder = MutRef::new(&alloc, unsafe { BStackRef::from_range(a.handle().range()) }).unwrap();
let old = holder
.handle()
.replace_target(stack, unsafe { BStackRef::from_range(c.handle().range()) })
.unwrap();
assert_eq!(
holder
.handle()
.get_target(stack)
.unwrap()
.get_val(stack)
.unwrap(),
222
);
let old_leaf = unsafe { <MacroLeaf as BStackBlock>::from_range(old.into_range()) };
assert_eq!(old_leaf.get_val(stack).unwrap(), 111);
holder.bstack_drop(&alloc).unwrap();
a.bstack_drop(&alloc).unwrap();
c.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_bstack_mut_owned_replace_moves_old_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroLeaf::new(&alloc, 1).unwrap();
let holder = MutOwned::new(&alloc, a).unwrap();
assert_eq!(
holder
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
1
);
let b = MacroLeaf::new(&alloc, 2).unwrap();
let old = holder.handle().replace_child(stack, b).unwrap();
assert_eq!(
holder
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
2
);
assert_eq!(old.handle().get_val(stack).unwrap(), 1);
old.bstack_drop(&alloc).unwrap();
holder.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn macro_bstack_mut_replace_hands_new_value_back_on_commit_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
struct FailFirstSet(AtomicBool);
impl FaultPolicy for FailFirstSet {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "swap" && !self.0.swap(true, Ordering::SeqCst) {
Some(io::Error::other("injected replace-commit fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroLeaf::new(&alloc, 1).unwrap();
let holder = MutOwned::new(&alloc, a).unwrap();
let b = MacroLeaf::new(&alloc, 2).unwrap();
let b_off = b.handle().range().start();
stack.set_fault_policy(Some(Arc::new(FailFirstSet(AtomicBool::new(false)))));
let r = holder.handle().replace_child(stack, b);
stack.set_fault_policy(None);
let err = match r {
Ok(_) => panic!("injected fault must fail the replace commit"),
Err(e) => e,
};
let back = err.value.expect("new value must be handed back, not lost");
assert_eq!(back.handle().range().start(), b_off);
assert_eq!(back.handle().get_val(stack).unwrap(), 2);
assert_eq!(
holder
.handle()
.get_child(stack)
.unwrap()
.get_val(stack)
.unwrap(),
1
);
back.bstack_drop(&alloc).unwrap();
holder.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn macro_weak_setter_hands_new_weak_back_on_commit_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
struct FailFirstSet(AtomicBool);
impl FaultPolicy for FailFirstSet {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "swap" && !self.0.swap(true, Ordering::SeqCst) {
Some(io::Error::other("injected weak-setter commit fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let load = |o: u64| crate::io_core::refcount::load(stack, nn(o)).unwrap();
let a = WNode::new(&alloc, 1).unwrap(); let b = WNode::new(&alloc, 2).unwrap();
let a_ctrl = load(a.handle().range().start() + CTRL_BACKPTR_OFFSET);
let weak_off = a_ctrl + CTRL_WEAK_OFFSET;
assert_eq!(load(weak_off), 1);
let w = a.downgrade().unwrap();
assert_eq!(load(weak_off), 2);
stack.set_fault_policy(Some(Arc::new(FailFirstSet(AtomicBool::new(false)))));
let r = b.handle().set_back(&alloc, w);
stack.set_fault_policy(None);
let err = r.expect_err("injected fault must fail the weak-setter commit");
let w = err.value.expect("weak setter hands the consumed weak back");
assert_eq!(
load(weak_off),
2,
"the handed-back weak must still hold its count"
);
assert!(b.handle().get_back(&alloc).unwrap().is_none());
drop(w);
assert_eq!(load(weak_off), 1);
drop(a); drop(b);
}
#[test]
fn macro_bstack_mut_strong_replace_moves_count_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 1).unwrap(); let holder = MutStrong::new(&alloc, a).unwrap(); assert_eq!(
holder
.handle()
.get_s(stack)
.unwrap()
.get_val(stack)
.unwrap(),
1
);
let b = MacroStrongChild::new(&alloc, 2).unwrap();
let old_a = holder.handle().replace_s(&alloc, b).unwrap();
assert_eq!(
holder
.handle()
.get_s(stack)
.unwrap()
.get_val(stack)
.unwrap(),
2
);
assert_eq!(old_a.handle().get_val(stack).unwrap(), 1);
drop(old_a);
holder.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn macro_strong_replace_hands_old_offset_back_when_recon_reads_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
struct FailReconRead {
swapped: AtomicBool,
fired: AtomicBool,
}
impl FaultPolicy for FailReconRead {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "swap" {
self.swapped.store(true, Ordering::SeqCst);
return None;
}
if matches!(op, "get" | "get_into")
&& self.swapped.load(Ordering::SeqCst)
&& !self.fired.swap(true, Ordering::SeqCst)
{
Some(io::Error::other("injected old-recon read fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 111).unwrap(); let a_data = a.handle().range().start();
let holder = MutStrong::new(&alloc, a).unwrap(); let b = MacroStrongChild::new(&alloc, 222).unwrap();
stack.set_fault_policy(Some(Arc::new(FailReconRead {
swapped: AtomicBool::new(false),
fired: AtomicBool::new(false),
})));
let r = holder.handle().replace_s(&alloc, b);
stack.set_fault_policy(None);
let err = match r {
::core::result::Result::Ok(_) => panic!("the post-commit recon read must fault"),
::core::result::Result::Err(e) => e,
};
assert_eq!(
holder
.handle()
.get_s(stack)
.unwrap_or_else(|e| panic!("{e}"))
.get_val(stack)
.unwrap(),
222
);
assert!(err.value.is_none());
assert_eq!(err.raw_old.len(), 1);
assert_eq!(err.raw_old[0].start(), a_data);
let a_ref = unsafe { BStackRef::<MacroStrongChild>::from_range(err.raw_old[0]) };
let (data, ctrl) =
<MacroStrongChild as crate::BStackShared>::strong_parts(a_ref, &alloc).unwrap();
let old_a = unsafe { crate::BStackRc::from_raw(data, ctrl, &alloc) };
assert_eq!(old_a.handle().get_val(stack).unwrap(), 111);
drop(old_a);
holder.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutTup {
#[bstack_mut]
t: (u32, u64),
tag: u32,
}
#[test]
fn macro_bstack_mut_pod_tuple_set() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let b = MutTup::new(&alloc, (1u32, 2u64), 7).unwrap();
assert_eq!(b.handle().get_t(stack).unwrap(), (1, 2));
b.handle().set_t(stack, (9, 99)).unwrap();
assert_eq!(b.handle().get_t(stack).unwrap(), (9, 99));
assert_eq!(b.handle().get_tag(stack).unwrap(), 7);
b.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutOwnedArr {
#[bstack_mut]
#[bstack_owned]
xs: [MacroLeaf; 3],
}
#[test]
fn macro_bstack_mut_owned_array_replace_at_moves_old_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = MutOwnedArr::new(
&alloc,
[
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
MacroLeaf::new(&alloc, 30).unwrap(),
],
)
.unwrap();
let newc = MacroLeaf::new(&alloc, 200).unwrap();
let old = h.handle().replace_xs_at(&alloc, 1, newc).unwrap();
assert_eq!(old.handle().get_val(stack).unwrap(), 20); old.bstack_drop(&alloc).unwrap();
let arr = h.handle().get_xs(stack).unwrap();
assert_eq!(arr[0].get_val(stack).unwrap(), 10);
assert_eq!(arr[1].get_val(stack).unwrap(), 200);
assert_eq!(arr[2].get_val(stack).unwrap(), 30);
let stray = MacroLeaf::new(&alloc, 0).unwrap();
match h.handle().replace_xs_at(&alloc, 3, stray) {
Ok(_) => panic!("expected an out-of-bounds error"),
Err(e) => e.value.unwrap().bstack_drop(&alloc).unwrap(),
}
h.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
MutOwnedArr::new(
&alloc,
[
MacroLeaf::new(&alloc, 1).unwrap(),
MacroLeaf::new(&alloc, 2).unwrap(),
MacroLeaf::new(&alloc, 3).unwrap(),
],
)
.unwrap()
});
}
#[test]
fn macro_bstack_mut_owned_array_replace_whole_moves_old_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = MutOwnedArr::new(
&alloc,
[
MacroLeaf::new(&alloc, 10).unwrap(),
MacroLeaf::new(&alloc, 20).unwrap(),
MacroLeaf::new(&alloc, 30).unwrap(),
],
)
.unwrap();
let old = h
.handle()
.replace_xs(
&alloc,
[
MacroLeaf::new(&alloc, 1).unwrap(),
MacroLeaf::new(&alloc, 2).unwrap(),
MacroLeaf::new(&alloc, 3).unwrap(),
],
)
.unwrap();
assert_eq!(old[0].handle().get_val(stack).unwrap(), 10);
assert_eq!(old[2].handle().get_val(stack).unwrap(), 30);
for o in old {
o.bstack_drop(&alloc).unwrap();
}
let arr = h.handle().get_xs(stack).unwrap();
assert_eq!(arr[0].get_val(stack).unwrap(), 1);
assert_eq!(arr[2].get_val(stack).unwrap(), 3);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutRefArr {
#[bstack_mut]
#[bstack_ref]
xs: [MacroLeaf; 2],
}
#[test]
fn macro_bstack_mut_ref_array_set_and_replace() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let l0 = MacroLeaf::new(&alloc, 1).unwrap();
let l1 = MacroLeaf::new(&alloc, 2).unwrap();
let l2 = MacroLeaf::new(&alloc, 3).unwrap();
let rng = |l: &BStackOwned<MacroLeaf>| unsafe { BStackRef::from_range(l.handle().range()) };
let h = MutRefArr::new(&alloc, [rng(&l0), rng(&l1)]).unwrap();
h.handle().set_xs_at(&alloc, 0, rng(&l2)).unwrap();
assert_eq!(
h.handle().get_xs(stack).unwrap()[0].get_val(stack).unwrap(),
3
);
let old = h.handle().replace_xs_at(&alloc, 1, rng(&l0)).unwrap();
let old_leaf = unsafe { <MacroLeaf as BStackBlock>::from_range(old.into_range()) };
assert_eq!(old_leaf.get_val(stack).unwrap(), 2);
assert_eq!(
h.handle().get_xs(stack).unwrap()[1].get_val(stack).unwrap(),
1
);
h.handle().set_xs(&alloc, [rng(&l1), rng(&l2)]).unwrap();
let arr = h.handle().get_xs(stack).unwrap();
assert_eq!(arr[0].get_val(stack).unwrap(), 2);
assert_eq!(arr[1].get_val(stack).unwrap(), 3);
h.bstack_drop(&alloc).unwrap();
for (l, v) in [(&l0, 1), (&l1, 2), (&l2, 3)] {
assert_eq!(l.handle().get_val(stack).unwrap(), v);
}
l0.bstack_drop(&alloc).unwrap();
l1.bstack_drop(&alloc).unwrap();
l2.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutStrongArr {
#[bstack_mut]
#[bstack_strong]
xs: [MacroStrongChild; 2],
}
#[test]
fn macro_bstack_mut_strong_array_replace_at_moves_count_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c0 = MacroStrongChild::new(&alloc, 5).unwrap(); let c1 = MacroStrongChild::new(&alloc, 6).unwrap();
let h = MutStrongArr::new(&alloc, [c0, c1]).unwrap();
let b = MacroStrongChild::new(&alloc, 50).unwrap();
let old = h.handle().replace_xs_at(&alloc, 0, b).unwrap();
assert_eq!(old.handle().get_val(stack).unwrap(), 5);
assert_eq!(
h.handle().get_xs(stack).unwrap()[0].get_val(stack).unwrap(),
50
);
drop(old);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutOptArr {
#[bstack_mut]
#[bstack_owned]
xs: [Option<MacroLeaf>; 2],
}
#[test]
fn macro_bstack_mut_owned_option_array_replace_at() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = MutOptArr::new(&alloc, [Some(MacroLeaf::new(&alloc, 10).unwrap()), None]).unwrap();
let old = h
.handle()
.replace_xs_at(&alloc, 0, Some(MacroLeaf::new(&alloc, 100).unwrap()))
.unwrap();
assert_eq!(old.unwrap().handle().get_val(stack).unwrap(), 10);
let was_none = h
.handle()
.replace_xs_at(&alloc, 1, Some(MacroLeaf::new(&alloc, 200).unwrap()))
.unwrap();
assert!(was_none.is_none());
let old0 = h.handle().replace_xs_at(&alloc, 0, None).unwrap();
old0.unwrap().bstack_drop(&alloc).unwrap();
let arr = h.handle().get_xs(stack).unwrap();
assert!(arr[0].is_none());
assert_eq!(arr[1].as_ref().unwrap().get_val(stack).unwrap(), 200);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutNestedArr {
#[bstack_mut]
#[bstack_owned]
grid: [[MacroLeaf; 2]; 2],
}
#[test]
fn macro_bstack_mut_owned_nested_array_replace() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mk = |v: u32| MacroLeaf::new(&alloc, v).unwrap();
let h = MutNestedArr::new(&alloc, [[mk(1), mk(2)], [mk(3), mk(4)]]).unwrap();
let old = h.handle().replace_grid_at(&alloc, 3, mk(40)).unwrap();
assert_eq!(old.handle().get_val(stack).unwrap(), 4);
old.bstack_drop(&alloc).unwrap();
let g = h.handle().get_grid(stack).unwrap();
assert_eq!(g[1][1].get_val(stack).unwrap(), 40);
assert_eq!(g[0][0].get_val(stack).unwrap(), 1);
let old_grid = h
.handle()
.replace_grid(&alloc, [[mk(5), mk(6)], [mk(7), mk(8)]])
.unwrap();
assert_eq!(old_grid[0][0].handle().get_val(stack).unwrap(), 1);
assert_eq!(old_grid[1][1].handle().get_val(stack).unwrap(), 40);
for row in old_grid {
for o in row {
o.bstack_drop(&alloc).unwrap();
}
}
assert_eq!(
h.handle().get_grid(stack).unwrap()[1][0]
.get_val(stack)
.unwrap(),
7
);
h.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutVecHolder {
#[bstack_mut]
#[bstack_owned]
xs: Vec<MacroLeaf>,
}
#[test]
fn macro_bstack_mut_vec_annotation_is_accepted_noop() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let h = MutVecHolder::new(&alloc, vec![MacroLeaf::new(&alloc, 1).unwrap()]).unwrap();
let mut v = h.handle().get_xs(&alloc).unwrap();
v.push_owned(MacroLeaf::new(&alloc, 2).unwrap()).unwrap();
assert_eq!(v.len().unwrap(), 2);
let reread = h.handle().get_xs(&alloc).unwrap();
assert_eq!(reread.len().unwrap(), 2);
assert_eq!(reread.get(1).unwrap().unwrap().get_val(stack).unwrap(), 2);
h.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn block_vec_push_owned_hands_child_back_when_offset_push_fails() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
struct FailFirstSet {
fired: AtomicBool,
}
impl FaultPolicy for FailFirstSet {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if matches!(op, "set" | "swap") && !self.fired.swap(true, Ordering::SeqCst) {
Some(io::Error::other("injected offset-push fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let mut v = BStackBlockVec::from_handles(
&alloc,
(0..4u32)
.map(|i| MacroLeaf::new(&alloc, i).unwrap())
.collect(),
)
.unwrap();
v.push_owned(MacroLeaf::new(&alloc, 100).unwrap()).unwrap();
MacroLeaf::new(&alloc, 0)
.unwrap()
.bstack_drop(&alloc)
.unwrap();
let baseline = stack.len().unwrap();
for i in 0..200u32 {
let child = MacroLeaf::new(&alloc, 1000 + i).unwrap();
stack.set_fault_policy(Some(Arc::new(FailFirstSet {
fired: AtomicBool::new(false),
})));
let r = v.push_owned(child);
stack.set_fault_policy(None);
let child = r
.expect_err("expected the injected offset-push fault")
.value;
let child = child.expect("push_owned hands the consumed child back");
assert_eq!(child.handle().get_val(stack).unwrap(), 1000 + i);
child.bstack_drop(&alloc).unwrap();
}
let grown = stack.len().unwrap().saturating_sub(baseline);
let child_sz = size_of::<<MacroLeaf as BStackBlock>::OnDisk>() as u64;
assert!(
grown < 4 * child_sz,
"push_owned failed to return its consumed child: file grew {grown} bytes over 200 faults",
);
v.bstack_drop().unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn stdlib_push_hands_value_back_on_commit_error() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
struct FailFirstInplaceGen(AtomicBool);
impl FaultPolicy for FailFirstInplaceGen {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "inplace_gen" && !self.0.swap(true, Ordering::SeqCst) {
Some(io::Error::other("injected list-commit fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let list = crate::BStackLinkedList::<MacroLeaf>::new(&alloc).unwrap();
let value = MacroLeaf::new(&alloc, 7).unwrap();
let val_off = value.handle().range().start();
stack.set_fault_policy(Some(Arc::new(FailFirstInplaceGen(AtomicBool::new(false)))));
let r = list.push_back(&alloc, value);
stack.set_fault_policy(None);
let value = r.expect_err("expected the injected commit fault").value;
let value = value.expect("push_back hands the consumed value back");
assert_eq!(value.handle().range().start(), val_off);
assert_eq!(value.handle().get_val(stack).unwrap(), 7);
value.bstack_drop(&alloc).unwrap();
let reuse = MacroLeaf::new(&alloc, 8).unwrap();
assert_eq!(
reuse.handle().range().start(),
val_off,
"the handed-back value block should be freeable and its slot reusable"
);
reuse.bstack_drop(&alloc).unwrap();
list.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
#[bstack_mut]
enum MutPodState {
Idle,
Active(u32),
Failed(i64),
}
#[test]
fn macro_bstack_mut_enum_pod_set() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let e = MutPodState::new(&alloc, MutPodStateData::Idle).unwrap();
assert!(matches!(
e.handle().read(&alloc).unwrap(),
MutPodStateView::Idle
));
e.handle().set(&alloc, MutPodStateData::Active(7)).unwrap();
match e.handle().read(&alloc).unwrap() {
MutPodStateView::Active(n) => assert_eq!(n, 7),
_ => panic!("expected Active"),
}
e.handle().set(&alloc, MutPodStateData::Failed(-3)).unwrap();
match e.handle().read(&alloc).unwrap() {
MutPodStateView::Failed(n) => assert_eq!(n, -3),
_ => panic!("expected Failed"),
}
e.bstack_drop(&alloc).unwrap();
}
#[bstack_enum]
#[bstack_mut]
enum MutOwnedNode {
Empty,
Num(u32),
#[bstack_owned]
Child(MacroLeaf),
}
#[test]
fn macro_bstack_mut_enum_owned_replace_moves_old_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let e = MutOwnedNode::new(
&alloc,
MutOwnedNodeData::Child(MacroLeaf::new(&alloc, 7).unwrap()),
)
.unwrap();
let old = e
.handle()
.replace(
&alloc,
MutOwnedNodeData::Child(MacroLeaf::new(&alloc, 70).unwrap()),
)
.unwrap();
match old {
MutOwnedNodeData::Child(o) => {
assert_eq!(o.handle().get_val(stack).unwrap(), 7);
o.bstack_drop(&alloc).unwrap(); }
_ => panic!("expected old Child"),
}
match e.handle().read(&alloc).unwrap() {
MutOwnedNodeView::Child(c) => assert_eq!(c.get_val(stack).unwrap(), 70),
_ => panic!("expected Child"),
}
let old2 = e
.handle()
.replace(&alloc, MutOwnedNodeData::Num(5))
.unwrap();
match old2 {
MutOwnedNodeData::Child(o) => o.bstack_drop(&alloc).unwrap(),
_ => panic!("expected old Child"),
}
assert!(matches!(
e.handle().read(&alloc).unwrap(),
MutOwnedNodeView::Num(5)
));
e.bstack_drop(&alloc).unwrap();
assert_teardown_reclaims(&alloc, || {
MutOwnedNode::new(
&alloc,
MutOwnedNodeData::Child(MacroLeaf::new(&alloc, 1).unwrap()),
)
.unwrap()
});
}
#[bstack_enum]
#[bstack_mut]
enum MutStrongNode {
Empty,
#[bstack_strong]
Shared(MacroStrongChild),
}
#[test]
fn macro_bstack_mut_enum_strong_replace_moves_count_out() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let c = MacroStrongChild::new(&alloc, 5).unwrap(); let e = MutStrongNode::new(&alloc, MutStrongNodeData::Shared(c)).unwrap();
match e.handle().read(&alloc).unwrap() {
MutStrongNodeView::Shared(child) => assert_eq!(child.get_val(stack).unwrap(), 5),
_ => panic!("expected Shared"),
}
let b = MacroStrongChild::new(&alloc, 50).unwrap();
let old = e
.handle()
.replace(&alloc, MutStrongNodeData::Shared(b))
.unwrap();
match old {
MutStrongNodeData::Shared(rc) => {
assert_eq!(rc.handle().get_val(stack).unwrap(), 5);
drop(rc); }
_ => panic!("expected old Shared"),
}
let old2 = e
.handle()
.replace(&alloc, MutStrongNodeData::Empty)
.unwrap();
match old2 {
MutStrongNodeData::Shared(rc) => drop(rc),
_ => panic!("expected old Shared"),
}
assert!(matches!(
e.handle().read(&alloc).unwrap(),
MutStrongNodeView::Empty
));
e.bstack_drop(&alloc).unwrap();
}
#[cfg(feature = "fault-injection")]
#[test]
fn macro_enum_replace_hands_old_offset_back_when_recon_reads_fault() {
use bstack::fault::FaultPolicy;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
struct FailReconRead {
swapped: AtomicBool,
fired: AtomicBool,
}
impl FaultPolicy for FailReconRead {
fn next_fault(&self, op: &'static str, _seq: u64) -> Option<io::Error> {
if op == "swap" {
self.swapped.store(true, Ordering::SeqCst);
return None;
}
if matches!(op, "get" | "get_into")
&& self.swapped.load(Ordering::SeqCst)
&& !self.fired.swap(true, Ordering::SeqCst)
{
Some(io::Error::other("injected old-recon read fault"))
} else {
None
}
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = MacroStrongChild::new(&alloc, 111).unwrap(); let a_data = a.handle().range().start();
let e = MutStrongNode::new(&alloc, MutStrongNodeData::Shared(a)).unwrap();
let b = MacroStrongChild::new(&alloc, 222).unwrap();
stack.set_fault_policy(Some(Arc::new(FailReconRead {
swapped: AtomicBool::new(false),
fired: AtomicBool::new(false),
})));
let r = e.handle().replace(&alloc, MutStrongNodeData::Shared(b));
stack.set_fault_policy(None);
let err = match r {
Ok(_) => panic!("the post-commit old-recon read must fault"),
Err(e) => e,
};
assert!(err.value.is_none());
assert_eq!(
err.raw_old.len(),
1,
"the old strong block must be handed back"
);
assert_eq!(err.raw_old[0].start(), a_data);
let a_ref = unsafe { BStackRef::<MacroStrongChild>::from_range(err.raw_old[0]) };
let (data, ctrl) =
<MacroStrongChild as crate::BStackShared>::strong_parts(a_ref, &alloc).unwrap();
let old_a = unsafe { crate::BStackRc::from_raw(data, ctrl, &alloc) };
assert_eq!(old_a.handle().get_val(stack).unwrap(), 111);
drop(old_a);
match e.handle().read(&alloc).unwrap() {
MutStrongNodeView::Shared(child) => assert_eq!(child.get_val(stack).unwrap(), 222),
_ => panic!("expected Shared(222)"),
}
e.bstack_drop(&alloc).unwrap();
}
#[bstack_block]
struct MutFornOwned {
#[bstack_mut]
#[bstack_owned]
link: Foreign<MacroLeaf>,
}
#[test]
fn macro_bstack_mut_foreign_owned_replace_moves_target_out() {
use crate::registry::FileId;
use crate::{Foreign, ForeignOwned};
let tmp = TempStack::new();
let local = tmp.allocator();
let stack = local.stack();
let self_leaf = |v: u32| {
let l = MacroLeaf::new(&local, v).unwrap();
let off = l.handle().range().start();
let _ = l.into_inner();
off
};
let a_off = self_leaf(10);
let b_off = self_leaf(20);
let h = MutFornOwned::new(&local, unsafe {
Foreign::<MacroLeaf>::new(FileId::SELF, a_off)
})
.unwrap();
assert_eq!(
h.handle()
.get_link(stack)
.unwrap()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(10)
);
let new = unsafe { ForeignOwned::from_foreign(Foreign::<MacroLeaf>::new(FileId::SELF, b_off)) };
let old = h.handle().replace_link(&local, new).unwrap();
assert!(old.is_self());
assert_eq!(
old.as_foreign()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(10)
);
old.bstack_drop(&local).unwrap();
assert_eq!(
h.handle()
.get_link(stack)
.unwrap()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(20)
);
h.bstack_drop(&local).unwrap(); }
#[bstack_block]
struct MutFornRef {
#[bstack_mut]
#[bstack_ref]
r: Foreign<MacroLeaf>,
}
#[test]
fn macro_bstack_mut_foreign_ref_set_and_replace() {
use crate::Foreign;
use crate::registry::FileId;
let tmp = TempStack::new();
let local = tmp.allocator();
let stack = local.stack();
let a = MacroLeaf::new(&local, 1).unwrap();
let b = MacroLeaf::new(&local, 2).unwrap();
let c = MacroLeaf::new(&local, 3).unwrap();
let fr = |l: &BStackOwned<MacroLeaf>| unsafe {
Foreign::<MacroLeaf>::new(FileId::SELF, l.handle().range().start())
};
let h = MutFornRef::new(&local, fr(&a)).unwrap();
assert_eq!(
h.handle()
.get_r(stack)
.unwrap()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(1)
);
h.handle().set_r(&local, fr(&b)).unwrap();
assert_eq!(
h.handle()
.get_r(stack)
.unwrap()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(2)
);
let old = h.handle().replace_r(&local, fr(&c)).unwrap();
assert_eq!(
old.with(&local, |t, fs| t.get_val(fs).unwrap()).unwrap(),
Some(2)
);
assert_eq!(
h.handle()
.get_r(stack)
.unwrap()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(3)
);
h.bstack_drop(&local).unwrap();
for (l, v) in [(&a, 1), (&b, 2), (&c, 3)] {
assert_eq!(l.handle().get_val(stack).unwrap(), v);
}
a.bstack_drop(&local).unwrap();
b.bstack_drop(&local).unwrap();
c.bstack_drop(&local).unwrap();
}
#[bstack_block]
struct MutFornOpt {
#[bstack_mut]
#[bstack_owned]
link: Option<Foreign<MacroLeaf>>,
}
#[test]
fn macro_bstack_mut_foreign_owned_option_replace() {
use crate::registry::FileId;
use crate::{Foreign, ForeignOwned};
let tmp = TempStack::new();
let local = tmp.allocator();
let stack = local.stack();
let self_leaf = |v: u32| {
let l = MacroLeaf::new(&local, v).unwrap();
let off = l.handle().range().start();
let _ = l.into_inner();
off
};
let some_owned = |off: u64| unsafe {
ForeignOwned::from_foreign(Foreign::<MacroLeaf>::new(FileId::SELF, off))
};
let h = MutFornOpt::new(&local, None).unwrap();
assert!(h.handle().get_link(stack).unwrap().is_none());
let was = h
.handle()
.replace_link(&local, Some(some_owned(self_leaf(10))))
.unwrap();
assert!(was.is_none());
assert_eq!(
h.handle()
.get_link(stack)
.unwrap()
.unwrap()
.with(&local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(10)
);
let old = h
.handle()
.replace_link(&local, Some(some_owned(self_leaf(20))))
.unwrap();
old.expect("old Some").bstack_drop(&local).unwrap();
let old2 = h.handle().replace_link(&local, None).unwrap();
old2.expect("old Some").bstack_drop(&local).unwrap();
assert!(h.handle().get_link(stack).unwrap().is_none());
h.bstack_drop(&local).unwrap(); }
#[bstack_block]
struct MutFornStrong {
#[bstack_mut]
#[bstack_strong]
link: Foreign<MacroStrongChild>,
}
#[test]
fn macro_bstack_mut_foreign_strong_replace_moves_count_out() {
use crate::registry::FileId;
use crate::{Foreign, ForeignRc};
let tmp = TempStack::new();
let local = tmp.allocator();
let self_strong = |v: u32| {
let c = MacroStrongChild::new(&local, v).unwrap(); let (d, _c) = c.into_raw();
d.into_range().start()
};
let a_off = self_strong(5);
let b_off = self_strong(50);
let h = MutFornStrong::new(&local, unsafe {
Foreign::<MacroStrongChild>::new(FileId::SELF, a_off)
})
.unwrap();
let new =
unsafe { ForeignRc::from_foreign(Foreign::<MacroStrongChild>::new(FileId::SELF, b_off)) };
let old = h.handle().replace_link(&local, new).unwrap();
assert!(old.is_self());
old.bstack_drop(&local).unwrap();
h.bstack_drop(&local).unwrap();
}
#[bstack_block]
struct MutFornWeak {
#[bstack_mut]
#[bstack_weak]
link: Foreign<MacroStrongChild>,
}
#[test]
fn macro_bstack_mut_foreign_weak_replace_moves_weak_out() {
use crate::registry::FileId;
use crate::{Foreign, ForeignWeak};
let tmp = TempStack::new();
let local = tmp.allocator();
let c = MacroStrongChild::new(&local, 5).unwrap();
let self_weak = || {
let w = c.downgrade().unwrap();
w.into_raw().into_range().start()
};
let h = MutFornWeak::new(&local, unsafe {
Foreign::<MacroStrongChild>::new(FileId::SELF, self_weak())
})
.unwrap();
let new = unsafe {
ForeignWeak::from_foreign(Foreign::<MacroStrongChild>::new(FileId::SELF, self_weak()))
};
let old = h.handle().replace_link(&local, new).unwrap();
assert!(old.is_self());
old.bstack_drop(&local).unwrap();
h.bstack_drop(&local).unwrap(); drop(c); }
#[test]
fn foreign_is_zero_cost_16_bytes_and_detach_semantics() {
use crate::Foreign;
use crate::registry::FileId;
assert_eq!(core::mem::size_of::<Foreign<'static, MacroLeaf>>(), 16);
let ext = unsafe { Foreign::<MacroLeaf>::new(FileId::from_u64(3).unwrap(), 64) };
assert!(!ext.is_self());
assert!(ext.detach().is_some());
let selfp = unsafe { Foreign::<MacroLeaf>::new(FileId::SELF, 64) };
assert!(selfp.is_self());
assert!(selfp.detach().is_none());
}
#[test]
fn foreign_resolves_across_files_and_self() {
use crate::Foreign;
use crate::registry::{FileId, FileRegistry};
use std::sync::Arc;
let reg_file = TempStack::new();
let foreign_file = TempStack::new();
let local_file = TempStack::new();
let reg = FileRegistry::open(®_file.path).unwrap();
let local = local_file.allocator();
let foreign_alloc = foreign_file.allocator();
let leaf = MacroLeaf::new(&foreign_alloc, 77).unwrap();
let off = leaf.handle().range().start();
let id = reg
.attach(&foreign_file.path, Arc::new(foreign_alloc))
.unwrap();
let fp = unsafe { Foreign::<MacroLeaf>::new(id, off) };
assert_eq!(
fp.with_in(®, &local, |t, stack| t.get_val(stack).unwrap())
.unwrap(),
Some(77)
);
reg.detach(id);
assert_eq!(
fp.with_in(®, &local, |t, stack| t.get_val(stack).unwrap())
.unwrap_err()
.kind(),
io::ErrorKind::NotFound
);
let lleaf = MacroLeaf::new(&local, 9).unwrap();
let selfp = unsafe { Foreign::<MacroLeaf>::new(FileId::SELF, lleaf.handle().range().start()) };
assert!(selfp.is_self());
assert_eq!(
selfp
.with_in(®, &local, |t, stack| t.get_val(stack).unwrap())
.unwrap(),
Some(9)
);
lleaf.bstack_drop(&local).unwrap();
}
#[bstack_block]
struct ForeignHolder {
tag: u32,
#[bstack_owned]
owned_link: Foreign<MacroLeaf>,
#[bstack_ref]
maybe: Option<Foreign<MacroLeaf>>,
}
#[test]
fn macro_foreign_field() {
use crate::Foreign;
use crate::registry::FileRegistry;
use std::sync::Arc;
let reg_file = TempStack::new();
let foreign_file = TempStack::new();
let local_file = TempStack::new();
let reg = FileRegistry::open(®_file.path).unwrap();
let local = local_file.allocator();
let stack = local.stack();
let foreign_alloc = foreign_file.allocator();
let leaf = MacroLeaf::new(&foreign_alloc, 88).unwrap();
let off = leaf.handle().range().start();
let id = reg
.attach(&foreign_file.path, Arc::new(foreign_alloc))
.unwrap();
let h = ForeignHolder::new(
&local,
5,
unsafe { Foreign::<MacroLeaf>::new(id, off) },
None,
)
.unwrap();
assert_eq!(h.handle().get_tag(stack).unwrap(), 5);
assert_eq!(
h.handle()
.get_owned_link(stack)
.unwrap()
.with_in(®, &local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(88)
);
assert!(h.handle().get_maybe(stack).unwrap().is_none());
let h2 = ForeignHolder::new(
&local,
5,
unsafe { Foreign::<MacroLeaf>::new(id, off) },
Some(unsafe { Foreign::<MacroLeaf>::new(id, off) }),
)
.unwrap();
let m = h2.handle().get_maybe(stack).unwrap().expect("Some link");
assert_eq!(
m.with_in(®, &local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(88)
);
let _ = (h, h2);
}
#[test]
fn macro_foreign_field_bstack_move() {
use crate::Foreign;
use crate::registry::FileRegistry;
use std::sync::Arc;
let reg_file = TempStack::new();
let foreign_file = TempStack::new();
let local_file = TempStack::new();
let reg = FileRegistry::open(®_file.path).unwrap();
let local = local_file.allocator();
let foreign_alloc = foreign_file.allocator();
let leaf = MacroLeaf::new(&foreign_alloc, 88).unwrap();
let off = leaf.handle().range().start();
let id = reg
.attach(&foreign_file.path, Arc::new(foreign_alloc))
.unwrap();
let h = ForeignHolder::new(
&local,
5,
unsafe { Foreign::<MacroLeaf>::new(id, off) },
Some(unsafe { Foreign::<MacroLeaf>::new(id, off) }),
)
.unwrap();
let (tag, owned_link, maybe): (
u32,
crate::ForeignOwned<MacroLeaf>,
Option<Foreign<MacroLeaf>>,
) = bstack_move!(h, &local).unwrap();
assert_eq!(tag, 5);
assert_eq!(
owned_link
.as_foreign()
.with_in(®, &local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(88)
);
assert_eq!(
maybe
.expect("Some link")
.with_in(®, &local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(88)
);
let relinquished = owned_link.into_foreign();
assert_eq!(
relinquished
.with_in(®, &local, |t, fs| t.get_val(fs).unwrap())
.unwrap(),
Some(88)
);
let _ = leaf;
}
#[bstack_block]
struct ForeignStrongHolder {
tag: u32,
#[bstack_strong]
link: Foreign<MacroStrongChild>,
}
#[bstack_block]
struct ForeignWeakHolder {
tag: u32,
#[bstack_weak]
link: Foreign<MacroStrongChild>,
}
#[bstack_block]
struct ForeignVecHolder {
tag: u32,
#[bstack_owned]
links: Vec<Foreign<MacroLeaf>>,
}
#[bstack_block]
struct ForeignArrHolder {
tag: u32,
#[bstack_owned]
links: [Foreign<MacroLeaf>; 3],
}
#[bstack_block]
struct ForeignStrongVecHolder {
tag: u32,
#[bstack_strong]
links: Vec<Foreign<MacroStrongChild>>,
}
#[bstack_block]
struct GenForeign<T> {
tag: u32,
#[bstack_owned]
link: Foreign<T>,
}
#[bstack_block]
struct GenForeignVec<T> {
#[bstack_owned]
links: Vec<Foreign<T>>,
}
#[bstack_block]
struct GenForeignTup<T> {
tag: u32,
#[bstack_owned]
pair: (u32, Foreign<T>),
}
#[bstack_enum]
enum GenForeignEnum<T> {
Empty,
#[bstack_owned]
Far(Foreign<T>),
}
#[bstack_block]
struct CursedArr8 {
tag: u32,
#[bstack_owned]
slots: [Option<Foreign<MacroLeaf>>; 8],
}
#[bstack_block]
struct CursedNestedArr {
#[bstack_strong]
grid: [[Foreign<MacroStrongChild>; 2]; 3],
}
#[bstack_block]
struct CursedMix {
#[bstack_owned]
maybe_owned: Option<Vec<Foreign<MacroLeaf>>>,
#[bstack_ref]
refs: Vec<Foreign<MacroLeaf>>,
#[bstack_weak]
maybe_weak: Option<Foreign<MacroStrongChild>>,
#[bstack_owned]
one: Foreign<MacroLeaf>,
#[bstack_owned]
deep: Option<Vec<Option<Foreign<MacroLeaf>>>>,
}
#[bstack_block]
struct OptForeignVecHolder {
#[bstack_owned]
links: Vec<Option<Foreign<MacroLeaf>>>,
}
#[bstack_enum]
enum ForeignEnum {
Nothing,
Local(u32),
#[bstack_owned]
Far(Foreign<MacroLeaf>),
}
#[bstack_enum]
enum ForeignStrongEnum {
Empty,
#[bstack_strong]
S(Foreign<MacroStrongChild>),
}
#[bstack_enum]
enum ForeignContainerEnum {
Empty,
#[bstack_owned]
Many(Vec<Foreign<MacroLeaf>>),
#[bstack_owned]
Fixed([Foreign<MacroLeaf>; 2]),
}
#[bstack_enum]
enum ForeignTupEnum {
Empty,
#[bstack_owned]
Pair((u32, Foreign<MacroLeaf>, Option<Foreign<MacroLeaf>>)),
}
#[bstack_block]
struct ForeignTupHolder {
tag: u32,
#[bstack_owned]
pair: (u32, Foreign<MacroLeaf>),
#[bstack_owned]
maybe: (u16, Option<Foreign<MacroLeaf>>, u8),
}
#[test]
fn macro_foreign_owned_teardown_reclaims_across_files() {
use crate::Foreign;
use crate::registry;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let foreign_alloc = foreign.allocator();
let base = foreign_alloc.len().unwrap();
let leaf = MacroLeaf::new(&foreign_alloc, 88).unwrap();
let off = leaf.handle().range().start();
let grown = foreign_alloc.len().unwrap();
assert!(grown > base, "target should have grown the foreign file");
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let fid = registry::attach(&foreign.path, foreign_alloc).unwrap();
assert!(!fid.is_self());
let h = ForeignHolder::new(
&home_alloc,
7,
unsafe { Foreign::<MacroLeaf>::new(fid, off) },
None,
)
.unwrap();
h.bstack_drop(&home_alloc).unwrap();
let after = registry::with_host(fid, |host| host.stack().len().unwrap()).unwrap();
assert!(
after <= base,
"foreign owned target was not reclaimed on teardown: {after} > {base}"
);
registry::detach(fid);
}
#[test]
fn foreign_owned_move_then_bstack_drop_reclaims_across_files() {
use crate::Foreign;
use crate::registry;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let foreign_alloc = foreign.allocator();
let base = foreign_alloc.len().unwrap();
let leaf = MacroLeaf::new(&foreign_alloc, 88).unwrap();
let off = leaf.handle().range().start();
let grown = foreign_alloc.len().unwrap();
assert!(grown > base, "target should have grown the foreign file");
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let fid = registry::attach(&foreign.path, foreign_alloc).unwrap();
let h = ForeignHolder::new(
&home_alloc,
7,
unsafe { Foreign::<MacroLeaf>::new(fid, off) },
None,
)
.unwrap();
let (_, owned_link, _maybe): (
u32,
crate::ForeignOwned<MacroLeaf>,
Option<Foreign<MacroLeaf>>,
) = bstack_move!(h, &home_alloc).unwrap();
owned_link.bstack_drop(&home_alloc).unwrap();
let after = registry::with_host(fid, |host| host.stack().len().unwrap()).unwrap();
assert!(
after <= base,
"ForeignOwned::bstack_drop did not reclaim the target: {after} > {base}"
);
registry::detach(fid);
let _ = leaf;
}
#[test]
fn foreign_self_pointer_resolves_on_read_and_reencodes_on_write() {
use crate::registry::{home_relative_repr, resolve_self_repr};
use crate::{Foreign, WidePtr, registry};
use std::sync::Arc;
let file_a = TempStack::new();
let arc_a = Arc::new(file_a.allocator());
let file_b = TempStack::new();
let arc_b = Arc::new(file_b.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let id_a = reg.attach(&file_a.path, arc_a.clone()).unwrap();
let id_b = reg.attach(&file_b.path, arc_b.clone()).unwrap();
assert_ne!(id_a.as_u64(), id_b.as_u64());
let leaf = MacroLeaf::new(&*arc_a, 42).unwrap().into_inner();
let off = leaf.range().start();
let self_repr = WidePtr::from_raw(0, 0, off);
let resolved = resolve_self_repr(self_repr, arc_a.stack()).unwrap();
assert_eq!(resolved.file_id(), id_a.as_u64());
assert_eq!(resolved.offset().get(), off);
assert_eq!(home_relative_repr(resolved, arc_a.stack()).file_id(), 0);
let into_b = home_relative_repr(resolved, arc_b.stack());
assert_eq!(
into_b.file_id(),
id_a.as_u64(),
"cross-file pointer keeps A's identity"
);
assert_ne!(into_b.file_id(), 0);
let explicit_a = unsafe { Foreign::<MacroLeaf>::new(id_a, off) };
let holder = MutFornRef::new(&*arc_a, explicit_a).unwrap();
let read_back = holder.handle().get_r(arc_a.stack()).unwrap();
assert!(
!read_back.is_self(),
"the accessor resolves a SELF slot to explicit"
);
assert_eq!(read_back.file_id(), id_a);
reg.detach(id_a);
reg.detach(id_b);
}
#[test]
fn foreign_owned_into_local_owned_self_resolves_and_frees() {
use crate::Foreign;
use crate::registry::FileId;
let tmp = TempStack::new();
let alloc = tmp.allocator();
{
let g = MacroLeaf::new(&alloc, 0).unwrap();
g.bstack_drop(&alloc).unwrap();
}
let base = alloc.len().unwrap();
let leaf = MacroLeaf::new(&alloc, 88).unwrap().into_inner();
let off = leaf.range().start();
let h = ForeignHolder::new(
&alloc,
3,
unsafe { Foreign::<MacroLeaf>::new(FileId::SELF, off) },
None,
)
.unwrap();
let (_, owned, _): (
u32,
crate::ForeignOwned<MacroLeaf>,
Option<Foreign<MacroLeaf>>,
) = bstack_move!(h, &alloc).unwrap();
assert!(owned.is_self());
let local = owned.into_local(&alloc).unwrap();
assert_eq!(local.handle().get_val(alloc.stack()).unwrap(), 88);
local.bstack_drop(&alloc).unwrap();
assert!(
alloc.len().unwrap() <= base,
"into_local + bstack_drop must reclaim the target"
);
}
#[test]
fn foreign_rc_into_local_rc_self_resolves_and_frees() {
use crate::Foreign;
use crate::registry::FileId;
let tmp = TempStack::new();
let alloc = tmp.allocator();
{
let g = MacroLeaf::new(&alloc, 0).unwrap();
g.bstack_drop(&alloc).unwrap();
}
let base = alloc.len().unwrap();
let data_size = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let ctrl_size = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let data = alloc_block(&alloc, MacroStrongChild::eightcc(), data_size).unwrap();
let ctrl = alloc_control(&alloc, ctrl_tag(), data, ctrl_size).unwrap();
let data_off = data.start();
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
assert_eq!(
crate::io_core::refcount::load(alloc.stack(), nn(strong_off)).unwrap(),
1
);
let h = ForeignStrongHolder::new(&alloc, 1, unsafe {
Foreign::<MacroStrongChild>::new(FileId::SELF, data_off)
})
.unwrap();
let (_, rc): (u32, crate::ForeignRc<MacroStrongChild>) = bstack_move!(h, &alloc).unwrap();
assert!(rc.is_self());
let local = rc.into_local(&alloc).unwrap();
drop(local);
assert!(
alloc.len().unwrap() <= base,
"into_local + drop must reclaim the shared target"
);
}
#[test]
fn foreign_weak_into_local_weak_self_decrements() {
use crate::Foreign;
use crate::registry::FileId;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let data_size = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let ctrl_size = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let data = alloc_block(&alloc, MacroStrongChild::eightcc(), data_size).unwrap();
let ctrl = alloc_control(&alloc, ctrl_tag(), data, ctrl_size).unwrap();
let ctrl_off = ctrl.start();
let weak_off = ctrl_off + CTRL_WEAK_OFFSET;
crate::io_core::refcount::fetch_add(alloc.stack(), nn(weak_off), 1).unwrap();
let load = |o: u64| crate::io_core::refcount::load(alloc.stack(), nn(o)).unwrap();
assert_eq!(load(weak_off), 2);
let h = ForeignWeakHolder::new(&alloc, 1, unsafe {
Foreign::<MacroStrongChild>::new(FileId::SELF, ctrl_off)
})
.unwrap();
let (_, weak): (u32, crate::ForeignWeak<MacroStrongChild>) = bstack_move!(h, &alloc).unwrap();
assert!(weak.is_self());
let local = weak.into_local(&alloc).unwrap();
drop(local);
assert_eq!(
load(weak_off),
1,
"into_local + drop must decrement the weak count"
);
}
#[test]
fn foreign_into_local_rejects_wrong_file_target() {
use crate::Foreign;
use crate::registry::FileId;
let tmp = TempStack::new();
let alloc = tmp.allocator(); let elsewhere = FileId::from_u64(3).unwrap();
let rc =
unsafe { crate::ForeignRc::from_foreign(Foreign::<MacroStrongChild>::new(elsewhere, 64)) };
assert!(
rc.into_local(&alloc).is_err(),
"ForeignRc::into_local must reject a wrong-file target"
);
let weak = unsafe {
crate::ForeignWeak::from_foreign(Foreign::<MacroStrongChild>::new(elsewhere, 64))
};
assert!(
weak.into_local(&alloc).is_err(),
"ForeignWeak::into_local must reject a wrong-file target"
);
}
#[test]
fn clone_lock_nested_contended_returns_wouldblock_not_deadlock() {
use crate::io_core::wal::HeldLock;
use std::sync::mpsc;
let a = TempStack::new();
let b = TempStack::new();
let alloc_a = a.allocator();
let alloc_b = b.allocator();
let (held_tx, held_rx) = mpsc::channel::<()>(); let (release_tx, release_rx) = mpsc::channel::<()>();
std::thread::scope(|s| {
let alloc_b_ref = &alloc_b;
s.spawn(move || {
let _b_lock = HeldLock::acquire(alloc_b_ref).expect("first acquire of B succeeds");
held_tx.send(()).unwrap();
release_rx.recv().unwrap(); });
let _a_lock = HeldLock::acquire(&alloc_a).expect("first acquire of A succeeds");
held_rx.recv().unwrap(); let err = match HeldLock::acquire(&alloc_b) {
Ok(_) => panic!("a nested acquire of a contended file lock must error, not block"),
Err(e) => e,
};
assert_eq!(
err.kind(),
std::io::ErrorKind::WouldBlock,
"contention while holding another clone lock must be a retryable WouldBlock"
);
release_tx.send(()).unwrap(); });
}
#[test]
fn macro_foreign_strong_teardown_frees_at_zero_across_files() {
use crate::Foreign;
use crate::registry;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let foreign_alloc = foreign.allocator();
let data_size = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let ctrl_size = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let base = foreign_alloc.len().unwrap();
let data = alloc_block(&foreign_alloc, MacroStrongChild::eightcc(), data_size).unwrap();
let ctrl = alloc_control(&foreign_alloc, ctrl_tag(), data, ctrl_size).unwrap();
let data_off = data.start();
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
assert_eq!(
crate::io_core::refcount::load(foreign_alloc.stack(), nn(strong_off)).unwrap(),
1
);
let grown = foreign_alloc.len().unwrap();
assert!(grown > base);
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let fid = registry::attach(&foreign.path, foreign_alloc).unwrap();
let h = ForeignStrongHolder::new(&home_alloc, 1, unsafe {
Foreign::<MacroStrongChild>::new(fid, data_off)
})
.unwrap();
h.bstack_drop(&home_alloc).unwrap();
let after = registry::with_host(fid, |host| host.stack().len().unwrap()).unwrap();
assert!(
after <= base,
"foreign strong target not freed at zero: {after} > {base}"
);
registry::detach(fid);
}
#[test]
fn macro_foreign_concurrent_ab_ba_teardown() {
use crate::Foreign;
use crate::registry;
use std::sync::Arc;
use std::thread;
let fa = TempStack::new();
let fb = TempStack::new();
let arc_a = Arc::new(fa.allocator());
let arc_b = Arc::new(fb.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid_a = reg.attach(&fa.path, arc_a.clone()).unwrap();
let fid_b = reg.attach(&fb.path, arc_b.clone()).unwrap();
{
let bl = MacroLeaf::new(&*arc_b, 1).unwrap();
ForeignHolder::new(
&*arc_a,
0,
unsafe { Foreign::<MacroLeaf>::new(fid_b, bl.handle().range().start()) },
None,
)
.unwrap()
.bstack_drop(&*arc_a)
.unwrap();
let al = MacroLeaf::new(&*arc_a, 1).unwrap();
ForeignHolder::new(
&*arc_b,
0,
unsafe { Foreign::<MacroLeaf>::new(fid_a, al.handle().range().start()) },
None,
)
.unwrap()
.bstack_drop(&*arc_b)
.unwrap();
}
let base_a = arc_a.len().unwrap();
let base_b = arc_b.len().unwrap();
const N: usize = 48;
const ROUNDS: usize = 3;
const THREADS: usize = 4;
for _ in 0..ROUNDS {
let mut a_holders = Vec::with_capacity(N);
let mut b_holders = Vec::with_capacity(N);
for i in 0..N as u32 {
let bl = MacroLeaf::new(&*arc_b, i).unwrap();
a_holders.push(
ForeignHolder::new(
&*arc_a,
i,
unsafe { Foreign::<MacroLeaf>::new(fid_b, bl.handle().range().start()) },
None,
)
.unwrap()
.into_inner(),
);
let al = MacroLeaf::new(&*arc_a, i).unwrap();
b_holders.push(
ForeignHolder::new(
&*arc_b,
i,
unsafe { Foreign::<MacroLeaf>::new(fid_a, al.handle().range().start()) },
None,
)
.unwrap()
.into_inner(),
);
}
let chunk = N.div_ceil(THREADS);
thread::scope(|s| {
let arc_a = &arc_a;
let arc_b = &arc_b;
for part in a_holders.chunks(chunk) {
let part = part.to_vec();
s.spawn(move || {
for h in part {
unsafe { BStackOwned::from_raw(h) }
.bstack_drop(&**arc_a)
.unwrap();
}
});
}
for part in b_holders.chunks(chunk) {
let part = part.to_vec();
s.spawn(move || {
for h in part {
unsafe { BStackOwned::from_raw(h) }
.bstack_drop(&**arc_b)
.unwrap();
}
});
}
});
assert_eq!(
arc_a.len().unwrap(),
base_a,
"file A not fully reclaimed after concurrent AB-BA teardown"
);
assert_eq!(
arc_b.len().unwrap(),
base_b,
"file B not fully reclaimed after concurrent AB-BA teardown"
);
}
reg.detach(fid_a);
reg.detach(fid_b);
}
#[test]
fn macro_foreign_owned_clone_deep_copies_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
{
let l0 = MacroLeaf::new(&*arc_b, 0).unwrap();
let h0 = ForeignHolder::new(
&home_alloc,
0,
unsafe { Foreign::<MacroLeaf>::new(fid, l0.handle().range().start()) },
None,
)
.unwrap();
let c0 = h0.handle().try_clone_in(&home_alloc).unwrap();
h0.bstack_drop(&home_alloc).unwrap();
c0.bstack_drop(&home_alloc).unwrap();
}
let base_b = arc_b.len().unwrap();
let leaf = MacroLeaf::new(&*arc_b, 42).unwrap();
let off = leaf.handle().range().start();
let h = ForeignHolder::new(
&home_alloc,
7,
unsafe { Foreign::<MacroLeaf>::new(fid, off) },
None,
)
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let clone_link = c.handle().get_owned_link(hstack).unwrap();
assert_eq!(clone_link.file_id(), fid);
assert_ne!(
clone_link.offset().get(),
off,
"owned clone must be a fresh copy, not an alias"
);
assert_eq!(
clone_link
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
42
);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base_b,
"clone+teardown leaked or double-freed on the foreign file"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_owned_clone_on_bulk_home_copies_once() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.ghost_allocator(); let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
{
let l0 = MacroLeaf::new(&*arc_b, 0).unwrap();
let h0 = ForeignHolder::new(
&home_alloc,
0,
unsafe { Foreign::<MacroLeaf>::new(fid, l0.handle().range().start()) },
None,
)
.unwrap();
h0.handle()
.try_clone_in(&home_alloc)
.unwrap()
.bstack_drop(&home_alloc)
.unwrap();
h0.bstack_drop(&home_alloc).unwrap();
}
let base_b = arc_b.len().unwrap();
let leaf = MacroLeaf::new(&*arc_b, 42).unwrap();
let off = leaf.handle().range().start();
let h = ForeignHolder::new(
&home_alloc,
7,
unsafe { Foreign::<MacroLeaf>::new(fid, off) },
None,
)
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let clone_link = c.handle().get_owned_link(hstack).unwrap();
assert_eq!(clone_link.file_id(), fid);
assert_ne!(
clone_link.offset().get(),
off,
"must be a fresh copy, not an alias"
);
assert_eq!(
clone_link
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
42
);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base_b,
"measure pass double-cloned the foreign target (guard missing/broken)"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_strong_clone_bumps_count_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let data_size = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let ctrl_size = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let base = arc_b.len().unwrap();
let data = alloc_block(&*arc_b, MacroStrongChild::eightcc(), data_size).unwrap();
let ctrl = alloc_control(&*arc_b, ctrl_tag(), data, ctrl_size).unwrap();
let data_off = data.start();
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let load = |o: u64| crate::io_core::refcount::load(arc_b.stack(), nn(o)).unwrap();
assert_eq!(load(strong_off), 1);
let h = ForeignStrongHolder::new(&home_alloc, 1, unsafe {
Foreign::<MacroStrongChild>::new(fid, data_off)
})
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
assert_eq!(
load(strong_off),
2,
"strong clone should bump the far count"
);
h.bstack_drop(&home_alloc).unwrap();
assert_eq!(load(strong_off), 1);
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base,
"target should be reclaimed once both strong owners drop"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_weak_clone_bumps_count_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let data_size = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let ctrl_size = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let data = alloc_block(&*arc_b, MacroStrongChild::eightcc(), data_size).unwrap();
let ctrl = alloc_control(&*arc_b, ctrl_tag(), data, ctrl_size).unwrap();
let ctrl_off = ctrl.start();
let weak_off = ctrl_off + CTRL_WEAK_OFFSET;
crate::io_core::refcount::fetch_add(arc_b.stack(), nn(weak_off), 1).unwrap();
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let load = |o: u64| crate::io_core::refcount::load(arc_b.stack(), nn(o)).unwrap();
assert_eq!(load(weak_off), 2);
let h = ForeignWeakHolder::new(&home_alloc, 1, unsafe {
Foreign::<MacroStrongChild>::new(fid, ctrl_off)
})
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
assert_eq!(
load(weak_off),
3,
"weak clone should bump the far weak count"
);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
load(weak_off),
1,
"weak teardown should decrement the far count"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_concurrent_ab_ba_clone() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
use std::thread;
let fa = TempStack::new();
let fb = TempStack::new();
let arc_a = Arc::new(fa.allocator());
let arc_b = Arc::new(fb.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid_a = reg.attach(&fa.path, arc_a.clone()).unwrap();
let fid_b = reg.attach(&fb.path, arc_b.clone()).unwrap();
for (ha, hb, tgt) in [(&arc_a, &arc_b, fid_b), (&arc_b, &arc_a, fid_a)] {
let l = MacroLeaf::new(&**hb, 0).unwrap();
let h = ForeignHolder::new(
&**ha,
0,
unsafe { Foreign::<MacroLeaf>::new(tgt, l.handle().range().start()) },
None,
)
.unwrap();
h.handle()
.try_clone_in(&**ha)
.unwrap()
.bstack_drop(&**ha)
.unwrap();
h.bstack_drop(&**ha).unwrap();
}
let base_a = arc_a.len().unwrap();
let base_b = arc_b.len().unwrap();
const N: usize = 32;
const THREADS: usize = 4;
let mut a_orig = Vec::with_capacity(N);
let mut b_orig = Vec::with_capacity(N);
for i in 0..N as u32 {
let bl = MacroLeaf::new(&*arc_b, i).unwrap();
a_orig.push(
ForeignHolder::new(
&*arc_a,
i,
unsafe { Foreign::<MacroLeaf>::new(fid_b, bl.handle().range().start()) },
None,
)
.unwrap()
.into_inner(),
);
let al = MacroLeaf::new(&*arc_a, i).unwrap();
b_orig.push(
ForeignHolder::new(
&*arc_b,
i,
unsafe { Foreign::<MacroLeaf>::new(fid_a, al.handle().range().start()) },
None,
)
.unwrap()
.into_inner(),
);
}
let chunk = N.div_ceil(THREADS);
let (a_clones, b_clones) = thread::scope(|s| {
let arc_a = &arc_a;
let arc_b = &arc_b;
let mut ja = Vec::new();
let mut jb = Vec::new();
for part in a_orig.chunks(chunk) {
let part = part.to_vec();
ja.push(s.spawn(move || {
part.iter()
.map(|h| h.try_clone_in(&**arc_a).unwrap().into_inner())
.collect::<Vec<_>>()
}));
}
for part in b_orig.chunks(chunk) {
let part = part.to_vec();
jb.push(s.spawn(move || {
part.iter()
.map(|h| h.try_clone_in(&**arc_b).unwrap().into_inner())
.collect::<Vec<_>>()
}));
}
let a_clones: Vec<_> = ja.into_iter().flat_map(|j| j.join().unwrap()).collect();
let b_clones: Vec<_> = jb.into_iter().flat_map(|j| j.join().unwrap()).collect();
(a_clones, b_clones)
});
assert_eq!(a_clones.len(), N);
assert_eq!(b_clones.len(), N);
for h in a_orig.into_iter().chain(a_clones) {
unsafe { BStackOwned::from_raw(h) }
.bstack_drop(&*arc_a)
.unwrap();
}
for h in b_orig.into_iter().chain(b_clones) {
unsafe { BStackOwned::from_raw(h) }
.bstack_drop(&*arc_b)
.unwrap();
}
assert_eq!(
arc_a.len().unwrap(),
base_a,
"file A not fully reclaimed after concurrent AB-BA clone"
);
assert_eq!(
arc_b.len().unwrap(),
base_b,
"file B not fully reclaimed after concurrent AB-BA clone"
);
reg.detach(fid_a);
reg.detach(fid_b);
}
#[test]
fn macro_foreign_vec_owned_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
{
let l = MacroLeaf::new(&*arc_b, 0).unwrap();
let h = ForeignVecHolder::new(
&home_alloc,
0,
vec![unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }],
)
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
h.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
const N: u32 = 5;
let mut links = Vec::new();
for i in 0..N {
let l = MacroLeaf::new(&*arc_b, 100 + i).unwrap();
links.push(unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) });
}
let h = ForeignVecHolder::new(&home_alloc, 7, links).unwrap();
let got = h.handle().get_links(&home_alloc).unwrap();
assert_eq!(got.len(), N as usize);
for (i, f) in got.iter().enumerate() {
assert_eq!(
f.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
100 + i as u32
);
}
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let clinks = c.handle().get_links(&home_alloc).unwrap();
assert_eq!(clinks.len(), N as usize);
for (o, n) in got.iter().zip(clinks.iter()) {
assert_ne!(o.offset(), n.offset(), "each element must be a fresh copy");
assert_eq!(
n.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
o.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap()
);
}
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base,
"foreign-vec clone/teardown leaked or double-freed on B"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_vec_owned_move_yields_dual_vec() {
use crate::registry;
use crate::{Foreign, ForeignOwned};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
{
let l = MacroLeaf::new(&*arc_b, 0).unwrap();
let h = ForeignVecHolder::new(
&home_alloc,
0,
vec![unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }],
)
.unwrap();
let (_, duals): (u32, Vec<ForeignOwned<MacroLeaf>>) = bstack_move!(h, &home_alloc).unwrap();
for d in duals {
d.bstack_drop(&home_alloc).unwrap();
}
}
let base_b = arc_b.len().unwrap();
let base_home = home_alloc.len().unwrap();
const N: u32 = 4;
let mut links = Vec::new();
for i in 0..N {
let l = MacroLeaf::new(&*arc_b, 200 + i).unwrap();
links.push(unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) });
}
let h = ForeignVecHolder::new(&home_alloc, 9, links).unwrap();
let (tag, duals): (u32, Vec<ForeignOwned<MacroLeaf>>) = bstack_move!(h, &home_alloc).unwrap();
assert_eq!(tag, 9);
assert_eq!(duals.len(), N as usize);
for (i, d) in duals.into_iter().enumerate() {
assert!(!d.is_self());
assert_eq!(
d.as_foreign()
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
200 + i as u32
);
d.bstack_drop(&home_alloc).unwrap();
}
assert_eq!(arc_b.len().unwrap(), base_b, "targets leaked on B");
assert_eq!(
home_alloc.len().unwrap(),
base_home,
"parent shell or the WidePtr storage block leaked on home"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_array_owned_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mk = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }
};
{
let h = ForeignArrHolder::new(&home_alloc, 0, [mk(0), mk(0), mk(0)]).unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
h.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
let h = ForeignArrHolder::new(&home_alloc, 7, [mk(10), mk(20), mk(30)]).unwrap();
let got = h.handle().get_links(hstack).unwrap();
let vals: Vec<u32> = got
.iter()
.map(|f| {
f.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap()
})
.collect();
assert_eq!(vals, vec![10, 20, 30]);
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let clinks = c.handle().get_links(hstack).unwrap();
for (o, n) in got.iter().zip(clinks.iter()) {
assert_ne!(o.offset(), n.offset(), "each slot must be a fresh copy");
}
let cvals: Vec<u32> = clinks
.iter()
.map(|f| {
f.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap()
})
.collect();
assert_eq!(cvals, vec![10, 20, 30]);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base,
"foreign-array clone/teardown leaked or double-freed on B"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_strong_vec_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let ds = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let cs = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mut links = Vec::new();
let mut strong_offs = Vec::new();
for _ in 0..3 {
let d = alloc_block(&*arc_b, MacroStrongChild::eightcc(), ds).unwrap();
let c = alloc_control(&*arc_b, ctrl_tag(), d, cs).unwrap();
strong_offs.push(c.start() + CTRL_STRONG_OFFSET);
links.push(unsafe { Foreign::<MacroStrongChild>::new(fid, d.start()) });
}
let load = |o: u64| crate::io_core::refcount::load(arc_b.stack(), nn(o)).unwrap();
for &o in &strong_offs {
assert_eq!(load(o), 1);
}
let h = ForeignStrongVecHolder::new(&home_alloc, 1, links).unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
for &o in &strong_offs {
assert_eq!(load(o), 2, "each strong vec element should bump on clone");
}
h.bstack_drop(&home_alloc).unwrap();
for &o in &strong_offs {
assert_eq!(
load(o),
1,
"each element should drop to 1 after one owner tears down"
);
}
c.bstack_drop(&home_alloc).unwrap();
reg.detach(fid);
}
#[test]
fn macro_foreign_generic_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
{
let l = MacroLeaf::new(&*arc_b, 0).unwrap();
let h = GenForeign::<MacroLeaf>::new(&home_alloc, 0, unsafe {
Foreign::new(fid, l.handle().range().start())
})
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
h.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
let l = MacroLeaf::new(&*arc_b, 55).unwrap();
let off = l.handle().range().start();
let h =
GenForeign::<MacroLeaf>::new(&home_alloc, 7, unsafe { Foreign::new(fid, off) }).unwrap();
let link = h.handle().get_link(hstack).unwrap();
assert_eq!(
link.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
55
);
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let clink = c.handle().get_link(hstack).unwrap();
assert_ne!(clink.offset().get(), off);
assert_eq!(
clink
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
55
);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(arc_b.len().unwrap(), base);
let gv = GenForeignVec::<MacroLeaf>::new(&home_alloc, vec![]).unwrap();
assert!(gv.handle().get_links(&home_alloc).unwrap().is_empty());
gv.bstack_drop(&home_alloc).unwrap();
reg.detach(fid);
}
#[test]
fn macro_foreign_cursed_valid_combos_compile_and_run() {
use crate::Foreign;
use crate::TryCloneIn;
use crate::registry::FileId;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let a = CursedArr8::new(&alloc, 9, [None, None, None, None, None, None, None, None]).unwrap();
assert_eq!(a.handle().get_tag(stack).unwrap(), 9);
let slots = a.handle().get_slots(stack).unwrap();
assert_eq!(slots.len(), 8);
assert!(slots.iter().all(::core::option::Option::is_none));
a.handle()
.try_clone_in(&alloc)
.unwrap()
.bstack_drop(&alloc)
.unwrap();
a.bstack_drop(&alloc).unwrap();
let null = unsafe { Foreign::<MacroStrongChild>::new(FileId::SELF, 0) };
let n = CursedNestedArr::new(&alloc, [[null, null], [null, null], [null, null]]).unwrap();
let grid = n.handle().get_grid(stack).unwrap();
assert_eq!(grid.len(), 3);
assert_eq!(grid[0].len(), 2);
n.handle()
.try_clone_in(&alloc)
.unwrap()
.bstack_drop(&alloc)
.unwrap();
n.bstack_drop(&alloc).unwrap();
let m = CursedMix::new(
&alloc,
None,
vec![],
None,
unsafe { Foreign::<MacroLeaf>::new(FileId::SELF, 0) },
None,
)
.unwrap();
assert!(m.handle().get_maybe_owned(&alloc).unwrap().is_none());
assert!(m.handle().get_refs(&alloc).unwrap().is_empty());
assert!(m.handle().get_maybe_weak(stack).unwrap().is_none());
assert!(m.handle().get_deep(&alloc).unwrap().is_none());
m.handle()
.try_clone_in(&alloc)
.unwrap()
.bstack_drop(&alloc)
.unwrap();
m.bstack_drop(&alloc).unwrap();
}
#[test]
fn macro_foreign_vec_of_option_roundtrips() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let f = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
Some(unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) })
};
let h = OptForeignVecHolder::new(&home_alloc, vec![f(11), None, f(22)]).unwrap();
let got = h.handle().get_links(&home_alloc).unwrap();
assert_eq!(got.len(), 3);
assert!(got[1].is_none());
assert_eq!(
got[0]
.unwrap()
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
11
);
assert_eq!(
got[2]
.unwrap()
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
22
);
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let cgot = c.handle().get_links(&home_alloc).unwrap();
assert!(cgot[1].is_none());
assert_ne!(cgot[0].unwrap().offset(), got[0].unwrap().offset());
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
let _ = hstack;
reg.detach(fid);
}
#[test]
fn macro_foreign_in_enum_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mk = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }
};
let n = ForeignEnum::new(&home_alloc, ForeignEnumData::Local(42)).unwrap();
match n.handle().read(&home_alloc).unwrap() {
ForeignEnumView::Local(x) => assert_eq!(x, 42),
_ => panic!("wrong variant"),
}
n.bstack_drop(&home_alloc).unwrap();
{
let e = ForeignEnum::new(&home_alloc, ForeignEnumData::Far(mk(0))).unwrap();
let c = e.handle().try_clone_in(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
e.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
let e = ForeignEnum::new(&home_alloc, ForeignEnumData::Far(mk(77))).unwrap();
let off = match e.handle().read(&home_alloc).unwrap() {
ForeignEnumView::Far(f) => {
assert_eq!(
f.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
77
);
f.offset()
}
_ => panic!("wrong variant"),
};
let c = e.handle().try_clone_in(&home_alloc).unwrap();
match c.handle().read(&home_alloc).unwrap() {
ForeignEnumView::Far(f) => {
assert_ne!(f.offset(), off);
assert_eq!(
f.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
77
);
}
_ => panic!("wrong variant"),
}
e.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base,
"foreign enum variant leaked or double-freed on B"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_generic_tuple_and_enum() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mk = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }
};
let t = GenForeignTup::<MacroLeaf>::new(&home_alloc, 1, (9, mk(11))).unwrap();
let pair = t.handle().get_pair(hstack).unwrap();
assert_eq!(pair.0, 9);
assert_eq!(
pair.1
.with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
11
);
let tc = t.handle().try_clone_in(&home_alloc).unwrap();
assert_ne!(
tc.handle().get_pair(hstack).unwrap().1.offset(),
pair.1.offset()
);
t.bstack_drop(&home_alloc).unwrap();
tc.bstack_drop(&home_alloc).unwrap();
let e = GenForeignEnum::<MacroLeaf>::new(&home_alloc, GenForeignEnumData::Far(mk(22))).unwrap();
let off = match e.handle().read(&home_alloc).unwrap() {
GenForeignEnumView::Far(f) => {
assert_eq!(
f.with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
22
);
f.offset()
}
_ => panic!("wrong variant"),
};
let ec = e.handle().try_clone_in(&home_alloc).unwrap();
match ec.handle().read(&home_alloc).unwrap() {
GenForeignEnumView::Far(f) => assert_ne!(f.offset(), off),
_ => panic!("wrong variant"),
}
e.bstack_drop(&home_alloc).unwrap();
ec.bstack_drop(&home_alloc).unwrap();
reg.detach(fid);
}
#[test]
fn macro_foreign_strong_enum_variant() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let ds = size_of::<<MacroStrongChild as BStackBlock>::OnDisk>() as u64;
let cs = size_of::<<MacroStrongChild as BStackWeakable>::Control>() as u64;
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let d = alloc_block(&*arc_b, MacroStrongChild::eightcc(), ds).unwrap();
let ctrl = alloc_control(&*arc_b, ctrl_tag(), d, cs).unwrap();
let strong_off = ctrl.start() + CTRL_STRONG_OFFSET;
let load = |o: u64| crate::io_core::refcount::load(arc_b.stack(), nn(o)).unwrap();
assert_eq!(load(strong_off), 1);
let e = ForeignStrongEnum::new(
&home_alloc,
ForeignStrongEnumData::S(unsafe { Foreign::<MacroStrongChild>::new(fid, d.start()) }),
)
.unwrap();
let cl = e.handle().try_clone_in(&home_alloc).unwrap();
assert_eq!(
load(strong_off),
2,
"strong enum variant should bump on clone"
);
e.bstack_drop(&home_alloc).unwrap();
assert_eq!(load(strong_off), 1);
cl.bstack_drop(&home_alloc).unwrap();
reg.detach(fid);
}
#[test]
fn macro_foreign_tuple_in_enum_variant() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mk = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }
};
{
let e = ForeignTupEnum::new(
&home_alloc,
ForeignTupEnumData::Pair((0, mk(0), Some(mk(0)))),
)
.unwrap();
e.handle()
.try_clone_in(&home_alloc)
.unwrap()
.bstack_drop(&home_alloc)
.unwrap();
e.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
let e = ForeignTupEnum::new(
&home_alloc,
ForeignTupEnumData::Pair((100, mk(11), Some(mk(22)))),
)
.unwrap();
let (off1, off2) = match e.handle().read(&home_alloc).unwrap() {
ForeignTupEnumView::Pair((a, f1, f2)) => {
assert_eq!(a, 100);
assert_eq!(
f1.with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
11
);
let f2 = f2.expect("Some");
assert_eq!(
f2.with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
22
);
(f1.offset(), f2.offset())
}
_ => panic!("wrong variant"),
};
let c = e.handle().try_clone_in(&home_alloc).unwrap();
match c.handle().read(&home_alloc).unwrap() {
ForeignTupEnumView::Pair((_, f1, f2)) => {
assert_ne!(f1.offset(), off1);
assert_ne!(f2.expect("Some").offset(), off2);
}
_ => panic!("wrong variant"),
}
e.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base,
"foreign tuple-in-enum variant leaked"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_enum_container_variants() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mk = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }
};
{
let e = ForeignContainerEnum::new(&home_alloc, ForeignContainerEnumData::Many(vec![mk(0)]))
.unwrap();
e.handle()
.try_clone_in(&home_alloc)
.unwrap()
.bstack_drop(&home_alloc)
.unwrap();
e.bstack_drop(&home_alloc).unwrap();
let e =
ForeignContainerEnum::new(&home_alloc, ForeignContainerEnumData::Fixed([mk(0), mk(0)]))
.unwrap();
e.handle()
.try_clone_in(&home_alloc)
.unwrap()
.bstack_drop(&home_alloc)
.unwrap();
e.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
let e = ForeignContainerEnum::new(
&home_alloc,
ForeignContainerEnumData::Many(vec![mk(1), mk(2), mk(3)]),
)
.unwrap();
match e.handle().read(&home_alloc).unwrap() {
ForeignContainerEnumView::Many(v) => {
assert_eq!(v.len(), 3);
assert_eq!(
v[1].with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
2
);
}
_ => panic!("wrong variant"),
}
let c = e.handle().try_clone_in(&home_alloc).unwrap();
e.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
let e = ForeignContainerEnum::new(&home_alloc, ForeignContainerEnumData::Fixed([mk(7), mk(8)]))
.unwrap();
match e.handle().read(&home_alloc).unwrap() {
ForeignContainerEnumView::Fixed(a) => {
assert_eq!(
a[0].with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
7
);
assert_eq!(
a[1].with(&home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
8
);
}
_ => panic!("wrong variant"),
}
let c = e.handle().try_clone_in(&home_alloc).unwrap();
e.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base,
"enum foreign container variant leaked"
);
reg.detach(fid);
}
#[test]
fn macro_foreign_enum_container_self_normalizes() {
use crate::Foreign;
use crate::registry::{self, FileId};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = Arc::new(home.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let hid = reg.attach(&home.path, home_alloc.clone()).unwrap();
let self_to = |off: u64| unsafe { Foreign::<MacroLeaf>::new(FileId::SELF, off) };
let l1 = MacroLeaf::new(&*home_alloc, 5).unwrap().into_inner();
let e = ForeignContainerEnum::new(
&*home_alloc,
ForeignContainerEnumData::Many(vec![self_to(l1.range().start())]),
)
.unwrap();
match e.handle().read(&*home_alloc).unwrap() {
ForeignContainerEnumView::Many(v) => {
assert!(
!v[0].is_self(),
"vec variant: a stored SELF must resolve on read"
);
assert_eq!(v[0].file_id(), hid);
assert_eq!(
v[0].with(&*home_alloc, |x, fs| x.get_val(fs).unwrap())
.unwrap()
.unwrap(),
5
);
}
_ => panic!("wrong variant"),
}
e.bstack_drop(&*home_alloc).unwrap();
let l2 = MacroLeaf::new(&*home_alloc, 7).unwrap().into_inner();
let l3 = MacroLeaf::new(&*home_alloc, 8).unwrap().into_inner();
let e = ForeignContainerEnum::new(
&*home_alloc,
ForeignContainerEnumData::Fixed([self_to(l2.range().start()), self_to(l3.range().start())]),
)
.unwrap();
match e.handle().read(&*home_alloc).unwrap() {
ForeignContainerEnumView::Fixed(a) => {
assert!(
!a[0].is_self(),
"array variant: a stored SELF must resolve on read"
);
assert_eq!(a[0].file_id(), hid);
assert_eq!(a[1].file_id(), hid);
}
_ => panic!("wrong variant"),
}
e.bstack_drop(&*home_alloc).unwrap();
reg.detach(hid);
}
#[test]
fn macro_foreign_in_tuple_across_files() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let mk = |v: u32| {
let l = MacroLeaf::new(&*arc_b, v).unwrap();
unsafe { Foreign::<MacroLeaf>::new(fid, l.handle().range().start()) }
};
{
let h = ForeignTupHolder::new(&home_alloc, 0, (0, mk(0)), (0, Some(mk(0)), 0)).unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
h.bstack_drop(&home_alloc).unwrap();
}
let base = arc_b.len().unwrap();
let h = ForeignTupHolder::new(&home_alloc, 5, (100, mk(11)), (7, Some(mk(22)), 9)).unwrap();
let pair = h.handle().get_pair(hstack).unwrap();
assert_eq!(pair.0, 100);
assert_eq!(
pair.1
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
11
);
let maybe = h.handle().get_maybe(hstack).unwrap();
assert_eq!((maybe.0, maybe.2), (7, 9));
assert_eq!(
maybe
.1
.unwrap()
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
22
);
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let cpair = c.handle().get_pair(hstack).unwrap();
assert_ne!(cpair.1.offset(), pair.1.offset());
assert_eq!(
cpair
.1
.with(&home_alloc, |t, fs| t.get_val(fs).unwrap())
.unwrap()
.unwrap(),
11
);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(arc_b.len().unwrap(), base, "foreign-in-tuple leaked");
reg.detach(fid);
}
#[test]
fn macro_foreign_owned_clone_errors_when_target_file_detached() {
use crate::registry;
use crate::{Foreign, TryCloneIn};
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let leaf = MacroLeaf::new(&*arc_b, 5).unwrap();
let off = leaf.handle().range().start();
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let h = ForeignHolder::new(
&home_alloc,
1,
unsafe { Foreign::<MacroLeaf>::new(fid, off) },
None,
)
.unwrap();
reg.detach(fid);
assert!(
h.handle().try_clone_in(&home_alloc).is_err(),
"cloning an owned Foreign with a detached target file must error, not alias"
);
}
#[test]
fn foreign_reverse_map_and_bstack_cast() {
use crate::registry::{FileId, FileRegistry};
use crate::{BStackRef, Foreign};
use bstack::BStackSlice;
use std::sync::Arc;
let reg_file = TempStack::new();
let foreign_file = TempStack::new();
let local_file = TempStack::new();
let reg = FileRegistry::open(®_file.path).unwrap();
let foreign_alloc = foreign_file.allocator();
let leaf = MacroLeaf::new(&foreign_alloc, 3).unwrap();
let off = leaf.handle().range().start();
let id = reg
.attach(&foreign_file.path, Arc::new(foreign_alloc))
.unwrap();
assert_eq!(
reg.with_host(id, |host| reg.id_of_host(host.stack())),
Some(Some(id))
);
let selfp = unsafe { Foreign::<MacroLeaf>::new(FileId::SELF, off) };
let r: Option<BStackRef<MacroLeaf>> = bstack_cast!(selfp as BStackRef<MacroLeaf>);
assert!(r.is_some());
let dead = FileId::from_u64(60_000).unwrap();
assert!(
unsafe { Foreign::<MacroLeaf>::new(dead, off) }
.into_local()
.is_none()
);
let la = local_file.allocator();
let s = la.alloc(16).unwrap().as_range();
let slice = unsafe { BStackSlice::from_raw_range(la.stack(), s) };
let f: Option<Foreign<MacroLeaf>> = bstack_cast!(slice as Foreign<MacroLeaf>);
assert!(f.is_none());
reg.detach(id);
assert!(!reg.is_live(id));
assert_eq!(reg.id_of_host(la.stack()), None);
}
fn deque_values(dq: &BStackDeque<MacroLeaf>, stack: &BStack) -> Vec<u32> {
dq.to_vec(stack)
.unwrap()
.iter()
.map(|h| h.get_val(stack).unwrap())
.collect()
}
#[bstack_block]
struct ForeignCollectionHolder {
tag: u32,
#[bstack_owned]
dq: Foreign<BStackDeque<MacroLeaf>>,
}
#[test]
fn stdlib_foreign_collection_target_clone_and_teardown() {
use crate::Foreign;
use crate::registry;
use std::sync::Arc;
let home = TempStack::new();
let home_alloc = home.allocator();
let hstack = home_alloc.stack();
let foreign = TempStack::new();
let arc_b = Arc::new(foreign.allocator());
let reg_file = TempStack::new();
let _ = registry::init(®_file.path);
let reg = registry::get().unwrap();
let fid = reg.attach(&foreign.path, arc_b.clone()).unwrap();
let dq = BStackDeque::<MacroLeaf>::new(&*arc_b).unwrap();
dq.push_back(&*arc_b, MacroLeaf::new(&*arc_b, 1).unwrap())
.unwrap();
dq.push_back(&*arc_b, MacroLeaf::new(&*arc_b, 2).unwrap())
.unwrap();
let dq_off = dq.handle().range().start();
{
let warm_dq = BStackDeque::<MacroLeaf>::new(&*arc_b).unwrap();
warm_dq
.push_back(&*arc_b, MacroLeaf::new(&*arc_b, 99).unwrap())
.unwrap();
let h0 = ForeignCollectionHolder::new(&home_alloc, 0, unsafe {
Foreign::<BStackDeque<MacroLeaf>>::new(fid, warm_dq.handle().range().start())
})
.unwrap();
let c0 = h0.handle().try_clone_in(&home_alloc).unwrap();
h0.bstack_drop(&home_alloc).unwrap();
c0.bstack_drop(&home_alloc).unwrap();
}
let base_b = arc_b.len().unwrap();
let h = ForeignCollectionHolder::new(&home_alloc, 7, unsafe {
Foreign::<BStackDeque<MacroLeaf>>::new(fid, dq_off)
})
.unwrap();
let c = h.handle().try_clone_in(&home_alloc).unwrap();
let clone_link = c.handle().get_dq(hstack).unwrap();
assert_eq!(clone_link.file_id(), fid);
assert_ne!(
clone_link.offset().get(),
dq_off,
"owned clone must be a fresh copy"
);
let clone_vals = clone_link
.with(&home_alloc, |d, fs| {
Ok::<_, std::io::Error>(deque_values(&d, fs))
})
.unwrap()
.unwrap()
.unwrap();
assert_eq!(clone_vals, vec![1, 2]);
let orig_offsets = dq.to_vec(arc_b.stack()).unwrap();
let cloned_offsets = clone_link
.with(&home_alloc, |d, fs| {
Ok::<_, std::io::Error>(d.to_vec(fs).unwrap())
})
.unwrap()
.unwrap()
.unwrap();
assert!(
orig_offsets
.iter()
.zip(cloned_offsets.iter())
.all(|(a, b)| a.range().start() != b.range().start()),
"cross-file clone must deep-copy the deque's elements"
);
h.bstack_drop(&home_alloc).unwrap();
c.bstack_drop(&home_alloc).unwrap();
assert_eq!(
arc_b.len().unwrap(),
base_b,
"foreign collection clone+teardown leaked or double-freed"
);
reg.detach(fid);
}
#[bstack_block]
struct SinkLeaf {
v: u32,
}
struct SinkCombo<'b, B: BStackRaiiAllocator> {
a_leaf: BStackOwned<SinkLeaf>,
b_leaf: BStackOwned<SinkLeaf>,
alloc_b: &'b B,
}
impl<'b, B: BStackRaiiAllocator> BStackDrop for SinkCombo<'b, B> {
fn bstack_drop<A: BStackRaiiAllocator>(self, allocator: &A) -> io::Result<()> {
let SinkCombo {
a_leaf,
b_leaf,
alloc_b,
} = self;
b_leaf.bstack_drop(alloc_b)?; a_leaf.bstack_drop(allocator)?; Ok(())
}
}
#[test]
fn wal_teardown_scopes_sink_to_installing_file() {
let ta = TempStack::new();
let alloc_a = ta.allocator();
let tb = TempStack::new();
let alloc_b = tb.allocator();
assert!(
alloc_a.wal_anchor().is_some(),
"test needs an anchor-bearing allocator"
);
let b_leaf = SinkLeaf::new(&alloc_b, 0xBBBB).unwrap();
let b_off = b_leaf.handle().range().start();
let victim = SinkLeaf::new(&alloc_a, 0xAAAA).unwrap().into_inner();
let victim_off = victim.range().start();
assert_eq!(
victim_off, b_off,
"victim and b_leaf must collide for the test"
);
let a_leaf = SinkLeaf::new(&alloc_a, 0x00CC).unwrap();
crate::wal_teardown(
SinkCombo {
a_leaf,
b_leaf,
alloc_b: &alloc_b,
},
&alloc_a,
)
.unwrap();
let reuse = SinkLeaf::new(&alloc_b, 0x1234).unwrap();
assert_eq!(
reuse.handle().range().start(),
b_off,
"b_leaf must be freed in file B (its offset must be reusable), not misdirected"
);
reuse.bstack_drop(&alloc_b).unwrap();
let intruders: Vec<_> = (0..4)
.map(|i| SinkLeaf::new(&alloc_a, 0x9990 + i).unwrap())
.collect();
assert_eq!(
victim.get_v(alloc_a.stack()).unwrap(),
0xAAAA,
"victim was freed in A and aliased by a later allocation"
);
for it in intruders {
it.bstack_drop(&alloc_a).unwrap();
}
unsafe { BStackOwned::from_raw(victim) }
.bstack_drop(&alloc_a)
.unwrap();
}
#[test]
fn wal_teardown_restores_sink_after_caught_panic() {
use std::panic::{AssertUnwindSafe, catch_unwind};
struct PanicDrop;
impl BStackDrop for PanicDrop {
fn bstack_drop<A: BStackRaiiAllocator>(self, _allocator: &A) -> io::Result<()> {
panic!("boom in teardown");
}
}
let tmp = TempStack::new();
let alloc = tmp.allocator();
assert!(
alloc.wal_anchor().is_some(),
"test needs an anchor-bearing allocator to install the sink"
);
SinkLeaf::new(&alloc, 0)
.unwrap()
.bstack_drop(&alloc)
.unwrap();
let caught = catch_unwind(AssertUnwindSafe(|| {
let _ = crate::wal_teardown(PanicDrop, &alloc);
}));
assert!(caught.is_err(), "expected the injected teardown panic");
let leaf = SinkLeaf::new(&alloc, 1).unwrap();
let off = leaf.handle().range().start();
leaf.bstack_drop(&alloc).unwrap();
let reuse = SinkLeaf::new(&alloc, 2).unwrap();
let reuse_off = reuse.handle().range().start();
assert_eq!(
reuse_off, off,
"TEARDOWN_SINK stuck after the panic → the block was collected-not-freed (leaked)"
);
reuse.bstack_drop(&alloc).unwrap();
}
#[bstack_block(rc, weak)]
struct WArrLeaf {
v: u32,
}
#[bstack_block]
struct WArrHolder {
#[bstack_weak]
slots: [WArrLeaf; 3],
tail: u64,
}
#[test]
fn weak_array_setter_bounds_checked() {
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let holder = WArrHolder::new(&alloc, 0u64).unwrap();
let target = WArrLeaf::new(&alloc, 7).unwrap();
assert!(
holder
.handle()
.set_slots(&alloc, 3, target.downgrade().unwrap())
.is_err(),
"OOB weak-array set must return Err"
);
assert_eq!(
holder.handle().get_tail(stack).unwrap(),
0,
"OOB set corrupted the neighboring `tail` field"
);
holder
.handle()
.set_slots(&alloc, 0, target.downgrade().unwrap())
.unwrap();
let slots = holder.handle().get_slots(&alloc).unwrap();
assert!(slots[0].is_some());
assert!(slots[1].is_none());
drop(slots);
holder.bstack_drop(&alloc).unwrap();
drop(target);
}
#[test]
fn foreign_repr_round_trip_preserves_type_index() {
use crate::{Foreign, WidePtr};
let repr = WidePtr::from_raw(3, 1, 4096);
assert_eq!(repr.type_index(), 1);
let f = unsafe { Foreign::<MacroLeaf>::from_repr(repr) };
let back = f.repr();
assert_eq!(back.type_index(), 1, "type_index wiped on round-trip");
assert_eq!(back.offset().get(), 4096);
assert_eq!(back.file_id(), 3);
let self_repr = WidePtr::from_raw(0, 7, 512);
let fs = unsafe { Foreign::<MacroLeaf>::from_repr(self_repr) };
assert_eq!(fs.repr().type_index(), 7);
assert_eq!(fs.repr().offset().get(), 512);
assert_eq!(fs.repr().file_id(), 0);
let raw = unsafe { Foreign::<MacroLeaf>::new(crate::registry::FileId::SELF, 64) };
assert_eq!(raw.repr().type_index(), 0);
}
#[test]
fn try_clone_in_preserves_foreign_type_index() {
use crate::{Foreign, TryCloneIn, WidePtr};
let tmp = TempStack::new();
let alloc = tmp.allocator();
let stack = alloc.stack();
let target = MacroLeaf::new(&alloc, 42).unwrap();
let toff = target.handle().range().start();
let typed = unsafe { Foreign::<MacroLeaf>::from_repr(WidePtr::from_raw(0, 1, toff)) };
let h = GenForeign::<MacroLeaf>::new(&alloc, 9, typed).unwrap();
assert_eq!(h.handle().get_link(stack).unwrap().repr().type_index(), 1);
let c = h.handle().try_clone_in(&alloc).unwrap();
let cl = c.handle().get_link(stack).unwrap();
assert_eq!(
cl.repr().type_index(),
1,
"clone wiped the foreign type_index"
);
assert_ne!(
cl.repr().offset().get(),
toff,
"owned foreign should deep-copy the target"
);
c.bstack_drop(&alloc).unwrap();
h.bstack_drop(&alloc).unwrap();
let _ = target;
}
#[bstack_enum]
enum VecVarEnum {
Empty,
Bytes(Vec<u8>),
}
#[test]
fn enum_vec_variant_read_persists_growth() {
use crate::BStackVec;
let tmp = TempStack::new();
let alloc = tmp.allocator();
let e = VecVarEnum::new(
&alloc,
VecVarEnumData::Bytes(BStackVec::from_slice(&alloc, &[1u8, 2]).unwrap()),
)
.unwrap();
{
let VecVarEnumView::Bytes(mut v) = e.handle().read(&alloc).unwrap() else {
panic!("Bytes variant");
};
for i in 0..64u8 {
v.push(i).unwrap();
}
}
let VecVarEnumView::Bytes(v2) = e.handle().read(&alloc).unwrap() else {
panic!("Bytes variant");
};
assert_eq!(
v2.len().unwrap(),
66,
"enum descriptor did not track the realloc"
);
let all = v2.to_vec().unwrap();
assert_eq!(&all[..2], &[1u8, 2]);
assert_eq!(all[2], 0);
e.bstack_drop(&alloc).unwrap();
}
#[test]
fn registry_reattach_removes_stale_reverse_map_entry() {
use crate::registry::FileRegistry;
use std::sync::Arc;
let reg_tmp = TempStack::new();
let reg = FileRegistry::open(®_tmp.path).unwrap();
let a = TempStack::new();
let host_a = Arc::new(a.allocator());
let b = TempStack::new();
let host_b = Arc::new(b.allocator());
let path_p = std::path::Path::new("registry_reattach_test_path.bstack");
let id1 = reg.attach(path_p, host_a.clone()).unwrap();
let id2 = reg.attach(path_p, host_b.clone()).unwrap();
assert_eq!(id1, id2, "same path must resolve to the same id");
assert_eq!(reg.id_of_host(host_b.stack()), Some(id2));
assert_eq!(
reg.id_of_host(host_a.stack()),
None,
"replaced host's stale by_stack entry not removed (two stacks map to one id)"
);
reg.detach(id2);
assert_eq!(reg.id_of_host(host_b.stack()), None);
assert_eq!(reg.id_of_host(host_a.stack()), None);
}