feat(domain): add memory module with page pool, per-process tracking, and region table

crates/domain/src/memory/tests.rs

@@ -0,0 +1,207 @@
+use super::page_pool::PagePool;
+use super::process_memory::ProcessMemory;
+use super::*;
+use types::address::PhysicalAddress;
+use types::bounded::PageCount;
+use types::generation::Generation;
+use types::id::{ProcessId, RegionId};
+
+fn base() -> PhysicalAddress {
+    PhysicalAddress::from_raw(0x8000_0000)
+}
+
+fn process(id: u16) -> ProcessId {
+    ProcessId::from_raw(id)
+}
+
+fn pages(n: u16) -> PageCount {
+    PageCount::new(n).unwrap()
+}
+
+// --- PagePool tests ---
+
+#[test]
+fn new_pool_has_all_pages_free() {
+    let pool = PagePool::new(base(), 100);
+    assert_eq!(pool.free_count(), 100);
+}
+
+#[test]
+fn allocate_reduces_free_count() {
+    let mut pool = PagePool::new(base(), 100);
+    pool.allocate(10).unwrap();
+    assert_eq!(pool.free_count(), 90);
+}
+
+#[test]
+fn allocate_returns_base_aligned_address() {
+    let mut pool = PagePool::new(base(), 100);
+    let addr = pool.allocate(1).unwrap();
+    assert_eq!(addr, base());
+}
+
+#[test]
+fn allocate_sequential_returns_contiguous() {
+    let mut pool = PagePool::new(base(), 100);
+    let a = pool.allocate(4).unwrap();
+    let b = pool.allocate(4).unwrap();
+    assert_eq!(a, base());
+    assert_eq!(b, base().offset(4));
+}
+
+#[test]
+fn allocate_too_many_returns_none() {
+    let mut pool = PagePool::new(base(), 10);
+    assert!(pool.allocate(11).is_none());
+}
+
+#[test]
+fn free_then_reallocate() {
+    let mut pool = PagePool::new(base(), 10);
+    let addr = pool.allocate(5).unwrap();
+    assert_eq!(pool.free_count(), 5);
+    assert!(pool.free(addr, 5));
+    assert_eq!(pool.free_count(), 10);
+    let addr2 = pool.allocate(5).unwrap();
+    assert_eq!(addr2, base());
+}
+
+#[test]
+fn free_out_of_range_returns_false() {
+    let mut pool = PagePool::new(base(), 10);
+    assert!(!pool.free(PhysicalAddress::from_raw(0), 1));
+}
+
+#[test]
+fn allocate_fragmented_finds_gap() {
+    let mut pool = PagePool::new(base(), 10);
+    let a = pool.allocate(3).unwrap();
+    let _b = pool.allocate(3).unwrap();
+    let _c = pool.allocate(3).unwrap();
+    pool.free(a, 3);
+    // now pages 0-2 are free, 3-8 allocated, 9 free
+    // asking for 3 contiguous should find 0-2
+    let d = pool.allocate(3).unwrap();
+    assert_eq!(d, base());
+}
+
+#[test]
+fn allocate_exact_remaining() {
+    let mut pool = PagePool::new(base(), 5);
+    let addr = pool.allocate(5).unwrap();
+    assert_eq!(addr, base());
+    assert_eq!(pool.free_count(), 0);
+    assert!(pool.allocate(1).is_none());
+}
+
+// --- ProcessMemory tests ---
+
+#[test]
+fn new_process_memory_has_zero_pages() {
+    let pm = ProcessMemory::new(process(0), 100);
+    assert_eq!(pm.page_count(), 0);
+    assert_eq!(pm.limit(), 100);
+}
+
+#[test]
+fn grant_pages_within_limit() {
+    let mut pm = ProcessMemory::new(process(0), 100);
+    assert!(pm.grant(10).is_ok());
+    assert_eq!(pm.page_count(), 10);
+}
+
+#[test]
+fn grant_pages_exceeding_limit_fails() {
+    let mut pm = ProcessMemory::new(process(0), 10);
+    assert!(pm.grant(11).is_err());
+    assert_eq!(pm.page_count(), 0);
+}
+
+#[test]
+fn release_pages_reduces_count() {
+    let mut pm = ProcessMemory::new(process(0), 100);
+    pm.grant(20).unwrap();
+    assert!(pm.release(5).is_ok());
+    assert_eq!(pm.page_count(), 15);
+}
+
+#[test]
+fn release_more_than_owned_fails() {
+    let mut pm = ProcessMemory::new(process(0), 100);
+    pm.grant(5).unwrap();
+    assert!(pm.release(10).is_err());
+    assert_eq!(pm.page_count(), 5);
+}
+
+#[test]
+fn grant_up_to_exact_limit() {
+    let mut pm = ProcessMemory::new(process(0), 10);
+    pm.grant(10).unwrap();
+    assert!(pm.grant(1).is_err());
+}
+
+// --- MemoryRegion tests ---
+
+#[test]
+fn memory_region_construction_and_accessors() {
+    let region = MemoryRegion::new(
+        RegionId::from_raw(1),
+        process(0),
+        base(),
+        pages(4),
+        Generation::initial(),
+    );
+    assert_eq!(region.id(), RegionId::from_raw(1));
+    assert_eq!(region.owner(), process(0));
+    assert_eq!(region.base(), base());
+    assert_eq!(region.size(), pages(4));
+    assert_eq!(region.generation(), &Generation::initial());
+}
+
+// --- RegionTable tests ---
+
+#[test]
+fn region_table_insert_and_get() {
+    let mut table = RegionTable::new();
+    let id = table.insert(MemoryRegion::new(
+        RegionId::from_raw(0),
+        process(0),
+        base(),
+        pages(4),
+        Generation::initial(),
+    ));
+    assert!(id.is_some());
+    let rid = id.unwrap();
+    assert!(table.get(rid).is_some());
+}
+
+#[test]
+fn region_table_remove() {
+    let mut table = RegionTable::new();
+    let id = table.insert(MemoryRegion::new(
+        RegionId::from_raw(0),
+        process(0),
+        base(),
+        pages(4),
+        Generation::initial(),
+    )).unwrap();
+    let removed = table.remove(id);
+    assert!(removed.is_some());
+    assert!(table.get(id).is_none());
+}
+
+#[test]
+fn region_table_regions_for_process() {
+    let mut table = RegionTable::new();
+    table.insert(MemoryRegion::new(
+        RegionId::from_raw(0), process(0), base(), pages(4), Generation::initial(),
+    ));
+    table.insert(MemoryRegion::new(
+        RegionId::from_raw(1), process(1), base(), pages(4), Generation::initial(),
+    ));
+    table.insert(MemoryRegion::new(
+        RegionId::from_raw(2), process(0), base(), pages(2), Generation::initial(),
+    ));
+    assert_eq!(table.regions_for_process(process(0)).count(), 2);
+    assert_eq!(table.regions_for_process(process(1)).count(), 1);
+}