OxideJS-New/crates/oxide_vm/tests/mem_tests.rs

use oxide_types::mem::{Epoch, P};

#[test]
fn epoch_alloc_and_read() {
    let epoch = Epoch::new();
    let ptr = epoch.alloc(42i32);
    assert_eq!(unsafe { *ptr }, 42);
}

#[test]
fn epoch_alloc_and_write() {
    let epoch = Epoch::new();
    let ptr = epoch.alloc(0i32);
    unsafe {
        *ptr = 99;
        assert_eq!(*ptr, 99);
    }
}

#[test]
fn epoch_reset_increments_id() {
    let mut epoch = Epoch::new();
    assert_eq!(epoch.current_id(), 0);
    epoch.reset();
    assert_eq!(epoch.current_id(), 1);
    epoch.reset();
    assert_eq!(epoch.current_id(), 2);
}

/// 换新 Bump 后旧地址空间不复用：reset 边界双 arena 保留锚恰 0
/// （空 chunk 哨兵计 0），容量不跨 reset 保留。
#[test]
fn epoch_reset_frees_arena() {
    let mut epoch = Epoch::new();
    let _ptr = epoch.alloc(vec![0u8; 1 << 20]);
    assert!(epoch.bump().allocated_bytes() > 0);
    epoch.reset();
    assert_eq!(epoch.bump().allocated_bytes(), 0);
}

#[test]
fn persistent_new_and_deref() {
    let p = P::new(42i32);
    assert_eq!(*p, 42);
}

#[test]
fn persistent_survives_epoch_reset() {
    let mut epoch = Epoch::new();
    let p = P::new(100i32);

    epoch.reset();

    assert_eq!(*p, 100);
}

#[test]
fn persistent_clone_shares_data() {
    let a = P::new(42i32);
    let b = a.clone();

    assert_eq!(*a, 42);
    assert_eq!(*b, 42);

    let a_ptr = &*a as *const i32;
    let b_ptr = &*b as *const i32;
    assert_eq!(a_ptr, b_ptr, "cloned P<T> should point to same data");
}

#[test]
fn persistent_custom_type() {
    #[derive(Debug, PartialEq)]
    struct Data {
        name: String,
        value: i32,
    }

    let p = P::new(Data {
        name: "test".to_string(),
        value: 42,
    });

    assert_eq!(p.name, "test");
    assert_eq!(p.value, 42);
}

#[test]
fn persistent_debug_format() {
    let p = P::new(42i32);
    assert_eq!(format!("{:?}", p), "P(42)");
}

#[test]
fn persistent_display_format() {
    let p = P::new(42i32);
    assert_eq!(format!("{}", p), "42");
}

#[test]
fn epoch_default_creates_valid() {
    let epoch = Epoch::default();
    assert_eq!(epoch.current_id(), 0);
    let ptr = epoch.alloc(7i32);
    assert_eq!(unsafe { *ptr }, 7);
}

#[test]
fn epoch_alloc_with_closure() {
    let epoch = Epoch::new();
    let ptr = epoch.alloc_with(|| 99i32);
    assert_eq!(unsafe { *ptr }, 99);
}