添加初始化测试

Author: bullhh

allocator/Cargo.toml

@@ -15,4 +15,6 @@ tracking = []
 log = { version = "0.4", optional = true }
 cfg-if = "1.0"
 
+[dev-dependencies]
+
 

allocator/src/buddy/buddy_allocator.rs

@@ -544,3 +544,87 @@ impl<const PAGE_SIZE: usize> PageAllocator for BuddyPageAllocator<PAGE_SIZE> {
         return 0;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloc::alloc::{alloc, dealloc};
+    use core::alloc::Layout;
+
+    const TEST_HEAP_SIZE: usize = 16 * 1024 * 1024;
+    const TEST_PAGE_SIZE: usize = 0x1000;
+
+    fn alloc_test_heap(size: usize) -> (*mut u8, Layout) {
+        let layout = Layout::from_size_align(size, TEST_PAGE_SIZE).unwrap();
+        let ptr = unsafe { alloc(layout) };
+        assert!(!ptr.is_null());
+        (ptr, layout)
+    }
+
+    fn dealloc_test_heap(ptr: *mut u8, layout: Layout) {
+        unsafe { dealloc(ptr, layout) };
+    }
+
+    #[test]
+    fn test_buddy_allocator_init() {
+        let (heap_ptr, heap_layout) = alloc_test_heap(TEST_HEAP_SIZE);
+        let heap_addr = heap_ptr as usize;
+
+        let mut allocator = BuddyPageAllocator::<TEST_PAGE_SIZE>::new();
+        allocator.init(heap_addr, TEST_HEAP_SIZE);
+
+        let addr = allocator.alloc_pages(1, TEST_PAGE_SIZE);
+        assert!(addr.is_ok());
+        if let Ok(a) = addr {
+            allocator.dealloc_pages(a, 1);
+        }
+
+        dealloc_test_heap(heap_ptr, heap_layout);
+    }
+
+    #[test]
+    fn test_buddy_allocator_multi_pages() {
+        let (heap_ptr, heap_layout) = alloc_test_heap(TEST_HEAP_SIZE);
+        let heap_addr = heap_ptr as usize;
+
+        let mut allocator = BuddyPageAllocator::<TEST_PAGE_SIZE>::new();
+        allocator.init(heap_addr, TEST_HEAP_SIZE);
+
+        let addr1 = allocator.alloc_pages(4, TEST_PAGE_SIZE).unwrap();
+        let addr2 = allocator.alloc_pages(8, TEST_PAGE_SIZE).unwrap();
+        assert_ne!(addr1, addr2);
+
+        allocator.dealloc_pages(addr1, 4);
+        allocator.dealloc_pages(addr2, 8);
+
+        dealloc_test_heap(heap_ptr, heap_layout);
+    }
+
+    #[test]
+    fn test_buddy_allocator_alignment() {
+        let (heap_ptr, heap_layout) = alloc_test_heap(TEST_HEAP_SIZE);
+        let heap_addr = heap_ptr as usize;
+
+        let mut allocator = BuddyPageAllocator::<TEST_PAGE_SIZE>::new();
+        allocator.init(heap_addr, TEST_HEAP_SIZE);
+
+        let addr = allocator.alloc_pages(1, TEST_PAGE_SIZE * 4).unwrap();
+        assert_eq!(addr & (TEST_PAGE_SIZE * 4 - 1), 0);
+
+        allocator.dealloc_pages(addr, 1);
+        dealloc_test_heap(heap_ptr, heap_layout);
+    }
+
+    #[test]
+    fn test_buddy_allocator_zone_count() {
+        let (heap_ptr, heap_layout) = alloc_test_heap(TEST_HEAP_SIZE);
+        let heap_addr = heap_ptr as usize;
+
+        let mut allocator = BuddyPageAllocator::<TEST_PAGE_SIZE>::new();
+        allocator.init(heap_addr, TEST_HEAP_SIZE);
+
+        assert_eq!(allocator.get_zone_count(), 1);
+
+        dealloc_test_heap(heap_ptr, heap_layout);
+    }
+}

allocator/src/global_allocator.rs

@@ -187,6 +187,16 @@ impl<const PAGE_SIZE: usize> GlobalAllocator<PAGE_SIZE> {
     }
 
     /// Initialize allocator with given memory region
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use buddy_slab_allocator::GlobalAllocator;
+    ///
+    /// const PAGE_SIZE: usize = 0x1000;
+    /// let allocator = GlobalAllocator::<PAGE_SIZE>::new();
+    /// allocator.init(0x8000_0000, 16 * 1024 * 1024).unwrap();
+    /// ```
     pub fn init(&self, start_vaddr: usize, size: usize) -> AllocResult<()> {
         if size <= MIN_HEAP_SIZE {
             return Err(AllocError::InvalidParam);
@@ -243,6 +253,24 @@ impl<const PAGE_SIZE: usize> GlobalAllocator<PAGE_SIZE> {
     }
 
     /// Smart allocation based on size
+    ///
+    /// Small allocations (≤2048 bytes) use slab allocator,
+    /// larger allocations use page allocator.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use buddy_slab_allocator::GlobalAllocator;
+    /// use core::alloc::Layout;
+    ///
+    /// const PAGE_SIZE: usize = 0x1000;
+    /// let allocator = GlobalAllocator::<PAGE_SIZE>::new();
+    /// allocator.init(0x8000_0000, 16 * 1024 * 1024).unwrap();
+    ///
+    /// let layout = Layout::from_size_align(64, 8).unwrap();
+    /// let ptr = allocator.alloc(layout).unwrap();
+    /// allocator.dealloc(ptr, layout);
+    /// ```
     pub fn alloc(&self, layout: Layout) -> AllocResult<NonNull<u8>> {
         if !self.initialized.load(Ordering::SeqCst) {
             error!("global allocator: Allocator not initialized");
@@ -300,6 +328,19 @@ impl<const PAGE_SIZE: usize> GlobalAllocator<PAGE_SIZE> {
     }
 
     /// Allocate pages
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use buddy_slab_allocator::{GlobalAllocator, PageAllocator};
+    ///
+    /// const PAGE_SIZE: usize = 0x1000;
+    /// let allocator = GlobalAllocator::<PAGE_SIZE>::new();
+    /// allocator.init(0x8000_0000, 16 * 1024 * 1024).unwrap();
+    ///
+    /// let addr = allocator.alloc_pages(4, PAGE_SIZE).unwrap();
+    /// allocator.dealloc_pages(addr, 4);
+    /// ```
     pub fn alloc_pages(&self, num_pages: usize, alignment: usize) -> AllocResult<usize> {
         if !self.initialized.load(Ordering::SeqCst) {
             return Err(AllocError::NoMemory);

allocator/src/lib.rs

@@ -188,3 +188,61 @@ pub mod global_allocator;
 pub use global_allocator::GlobalAllocator;
 #[cfg(feature = "tracking")]
 pub use global_allocator::UsageStats;
+
+#[cfg(doc)]
+/// Documentation tests and examples
+///
+/// # Basic Usage
+///
+/// ```no_run
+/// use buddy_slab_allocator::{GlobalAllocator, PageAllocator};
+/// 
+/// const PAGE_SIZE: usize = 0x1000;
+/// let allocator = GlobalAllocator::<PAGE_SIZE>::new();
+/// 
+/// // Initialize with memory region
+/// let heap_start = 0x8000_0000;
+/// let heap_size = 16 * 1024 * 1024; // 16MB
+/// allocator.init(heap_start, heap_size).unwrap();
+/// 
+/// // Allocate pages
+/// let addr = allocator.alloc_pages(4, PAGE_SIZE).unwrap();
+/// // Use the allocated memory...
+/// allocator.dealloc_pages(addr, 4);
+/// ```
+///
+/// # Small Object Allocation
+///
+/// ```no_run
+/// use buddy_slab_allocator::GlobalAllocator;
+/// use core::alloc::Layout;
+/// 
+/// const PAGE_SIZE: usize = 0x1000;
+/// let allocator = GlobalAllocator::<PAGE_SIZE>::new();
+/// allocator.init(0x8000_0000, 16 * 1024 * 1024).unwrap();
+/// 
+/// // Small allocations go through slab allocator
+/// let layout = Layout::from_size_align(64, 8).unwrap();
+/// let ptr = allocator.alloc(layout).unwrap();
+/// // Use the allocated memory...
+/// allocator.dealloc(ptr, layout);
+/// ```
+///
+/// # Statistics Tracking
+///
+/// ```no_run
+/// # #[cfg(feature = "tracking")]
+/// # {
+/// use buddy_slab_allocator::GlobalAllocator;
+/// 
+/// const PAGE_SIZE: usize = 0x1000;
+/// let allocator = GlobalAllocator::<PAGE_SIZE>::new();
+/// allocator.init(0x8000_0000, 16 * 1024 * 1024).unwrap();
+/// 
+/// let stats = allocator.get_stats();
+/// println!("Total pages: {}", stats.total_pages);
+/// println!("Used pages: {}", stats.used_pages);
+/// println!("Free pages: {}", stats.free_pages);
+/// # }
+/// ```
+pub mod _examples {}

allocator/src/page_allocator.rs

@@ -512,3 +512,59 @@ mod tests {
         assert_eq!(info2.unwrap().part_count, 3);
     }
 }
+
+#[cfg(test)]
+mod unit_tests {
+    use super::*;
+    use alloc::alloc::{alloc, dealloc};
+    use core::alloc::Layout;
+
+    const TEST_HEAP_SIZE: usize = 16 * 1024 * 1024;
+    const TEST_PAGE_SIZE: usize = 0x1000;
+
+    fn alloc_test_heap(size: usize) -> (*mut u8, Layout) {
+        let layout = Layout::from_size_align(size, TEST_PAGE_SIZE).unwrap();
+        let ptr = unsafe { alloc(layout) };
+        assert!(!ptr.is_null());
+        (ptr, layout)
+    }
+
+    fn dealloc_test_heap(ptr: *mut u8, layout: Layout) {
+        unsafe { dealloc(ptr, layout) };
+    }
+
+    #[test]
+    fn test_composite_allocator_basic() {
+        let (heap_ptr, heap_layout) = alloc_test_heap(TEST_HEAP_SIZE);
+        let heap_addr = heap_ptr as usize;
+
+        let mut allocator = CompositePageAllocator::<TEST_PAGE_SIZE>::new();
+        allocator.init(heap_addr, TEST_HEAP_SIZE);
+
+        let addr1 = allocator.alloc_pages(1, TEST_PAGE_SIZE).unwrap();
+        let addr2 = allocator.alloc_pages(4, TEST_PAGE_SIZE).unwrap();
+
+        assert!(addr1 >= heap_addr && addr1 < heap_addr + TEST_HEAP_SIZE);
+        assert!(addr2 >= heap_addr && addr2 < heap_addr + TEST_HEAP_SIZE);
+
+        allocator.dealloc_pages(addr1, 1);
+        allocator.dealloc_pages(addr2, 4);
+
+        dealloc_test_heap(heap_ptr, heap_layout);
+    }
+
+    #[test]
+    fn test_composite_allocator_alignment() {
+        let (heap_ptr, heap_layout) = alloc_test_heap(TEST_HEAP_SIZE);
+        let heap_addr = heap_ptr as usize;
+
+        let mut allocator = CompositePageAllocator::<TEST_PAGE_SIZE>::new();
+        allocator.init(heap_addr, TEST_HEAP_SIZE);
+
+        let addr = allocator.alloc_pages(1, TEST_PAGE_SIZE * 4).unwrap();
+        assert_eq!(addr & (TEST_PAGE_SIZE * 4 - 1), 0);
+
+        allocator.dealloc_pages(addr, 1);
+        dealloc_test_heap(heap_ptr, heap_layout);
+    }
+}

allocator/src/slab/slab_byte_allocator.rs

@@ -228,4 +228,27 @@ mod tests {
             None
         );
     }
+
+    #[test]
+    fn test_size_class_boundaries() {
+        // Test all size class boundaries
+        assert_eq!(SizeClass::Bytes8.size(), 8);
+        assert_eq!(SizeClass::Bytes16.size(), 16);
+        assert_eq!(SizeClass::Bytes32.size(), 32);
+        assert_eq!(SizeClass::Bytes64.size(), 64);
+        assert_eq!(SizeClass::Bytes128.size(), 128);
+        assert_eq!(SizeClass::Bytes256.size(), 256);
+        assert_eq!(SizeClass::Bytes512.size(), 512);
+        assert_eq!(SizeClass::Bytes1024.size(), 1024);
+        assert_eq!(SizeClass::Bytes2048.size(), 2048);
+    }
+
+    #[test]
+    fn test_size_class_alignment_limits() {
+        // Alignment too large should return None
+        assert_eq!(
+            SizeClass::from_layout(Layout::from_size_align(64, 4096).unwrap()),
+            None
+        );
+    }
 }