添加动态申请的bitmap (#532)

kernel/crates/bitmap/src/alloc_bitmap.rs

@@ -0,0 +1,109 @@
+use alloc::vec::Vec;
+
+use crate::{bitmap_core::BitMapCore, traits::BitMapOps};
+
+pub struct AllocBitmap {
+    elements: usize,
+    data: Vec<usize>,
+    core: BitMapCore<usize>,
+}
+
+impl AllocBitmap {
+    pub fn new(elements: usize) -> Self {
+        let data = vec![0usize; (elements + usize::BITS as usize - 1) / (usize::BITS as usize)];
+        Self {
+            elements,
+            data,
+            core: BitMapCore::new(),
+        }
+    }
+}
+
+impl BitMapOps<usize> for AllocBitmap {
+    #[inline]
+    fn get(&self, index: usize) -> Option<bool> {
+        return self.core.get(self.elements, &self.data, index);
+    }
+
+    #[inline]
+    fn set(&mut self, index: usize, value: bool) -> Option<bool> {
+        return self.core.set(self.elements, &mut self.data, index, value);
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.elements
+    }
+
+    #[inline]
+    fn size(&self) -> usize {
+        self.data.len() * core::mem::size_of::<usize>()
+    }
+
+    #[inline]
+    fn first_index(&self) -> Option<usize> {
+        self.core.first_index(&self.data)
+    }
+
+    #[inline]
+    fn first_false_index(&self) -> Option<usize> {
+        self.core.first_false_index(self.elements, &self.data)
+    }
+
+    #[inline]
+    fn last_index(&self) -> Option<usize> {
+        self.core.last_index(self.elements, &self.data)
+    }
+
+    #[inline]
+    fn last_false_index(&self) -> Option<usize> {
+        self.core.last_false_index(self.elements, &self.data)
+    }
+
+    #[inline]
+    fn next_index(&self, index: usize) -> Option<usize> {
+        self.core.next_index(self.elements, &self.data, index)
+    }
+
+    #[inline]
+    fn next_false_index(&self, index: usize) -> Option<usize> {
+        self.core.next_false_index(self.elements, &self.data, index)
+    }
+
+    #[inline]
+    fn prev_index(&self, index: usize) -> Option<usize> {
+        self.core.prev_index(self.elements, &self.data, index)
+    }
+
+    #[inline]
+    fn prev_false_index(&self, index: usize) -> Option<usize> {
+        self.core.prev_false_index(self.elements, &self.data, index)
+    }
+
+    #[inline]
+    fn invert(&mut self) {
+        self.core.invert(self.elements, &mut self.data);
+    }
+
+    #[inline]
+    fn is_full(&self) -> bool {
+        self.core.is_full(self.elements, &self.data)
+    }
+
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.core.is_empty(&self.data)
+    }
+
+    #[inline]
+    unsafe fn as_bytes(&self) -> &[u8] {
+        core::slice::from_raw_parts(
+            self.data.as_ptr() as *const u8,
+            core::mem::size_of::<Self>(),
+        )
+    }
+
+    fn set_all(&mut self, value: bool) {
+        self.core.set_all(self.elements, &mut self.data, value);
+    }
+}

kernel/crates/bitmap/src/bitmap_core.rs

@@ -2,11 +2,11 @@ use core::{intrinsics::unlikely, marker::PhantomData};
 
 use crate::traits::BitOps;
 
-pub(crate) struct BitMapCore<T: BitOps, const N: usize> {
+pub(crate) struct BitMapCore<T: BitOps> {
     phantom: PhantomData<T>,
 }
 
-impl<T: BitOps, const N: usize> BitMapCore<T, N> {
+impl<T: BitOps> BitMapCore<T> {
     pub const fn new() -> Self {
         Self {
             phantom: PhantomData,
@@ -14,8 +14,8 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 获取位图中的某一位
-    pub(crate) fn get(&self, data: &[T], index: usize) -> Option<bool> {
-        if unlikely(index >= N) {
+    pub(crate) fn get(&self, n: usize, data: &[T], index: usize) -> Option<bool> {
+        if unlikely(index >= n) {
             return None;
         }
 
@@ -29,8 +29,8 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 设置位图中的某一位
-    pub(crate) fn set(&self, data: &mut [T], index: usize, value: bool) -> Option<bool> {
-        if unlikely(index >= N) {
+    pub(crate) fn set(&self, n: usize, data: &mut [T], index: usize, value: bool) -> Option<bool> {
+        if unlikely(index >= n) {
             return None;
         }
         let element_index = index / T::bit_size();
@@ -42,7 +42,7 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
         Some(bit)
     }
 
-    pub(crate) fn set_all(&self, data: &mut [T], value: bool) {
+    pub(crate) fn set_all(&self, n: usize, data: &mut [T], value: bool) {
         let val = if value { T::max() } else { T::zero() };
         for element in data.iter_mut() {
             *element = val;
@@ -50,7 +50,7 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
 
         // 特殊处理最后一个元素
         let last_element = data.last_mut().unwrap();
-        let mask = T::make_mask(N % T::bit_size());
+        let mask = T::make_mask(n % T::bit_size());
         if mask != T::zero() {
             *last_element &= mask;
         }
@@ -69,10 +69,10 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 获取位图中第一个为0的位
-    pub(crate) fn first_false_index(&self, data: &[T]) -> Option<usize> {
+    pub(crate) fn first_false_index(&self, n: usize, data: &[T]) -> Option<usize> {
         for (i, element) in data.iter().enumerate() {
             if let Some(bit) = <T as BitOps>::first_false_index(element) {
-                return self.make_index(i * T::bit_size() + bit);
+                return self.make_index(n, i * T::bit_size() + bit);
             }
         }
 
@@ -80,10 +80,10 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 获取位图中最后一个为1的位
-    pub(crate) fn last_index(&self, data: &[T]) -> Option<usize> {
+    pub(crate) fn last_index(&self, n: usize, data: &[T]) -> Option<usize> {
         for (i, element) in data.iter().enumerate().rev() {
             if let Some(bit) = <T as BitOps>::last_index(element) {
-                return self.make_index(i * T::bit_size() + bit);
+                return self.make_index(n, i * T::bit_size() + bit);
             }
         }
 
@@ -96,12 +96,12 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     ///
     /// - `data`：位图数据
     /// - `n`：位图有效位数
-    pub(crate) fn last_false_index(&self, data: &[T]) -> Option<usize> {
+    pub(crate) fn last_false_index(&self, n: usize, data: &[T]) -> Option<usize> {
         let mut iter = data.iter().rev();
         let mut last_element = *iter.next()?;
 
         // 对最后一个元素进行特殊处理，因为最后一个元素可能不是满的
-        let mut mask = T::make_mask(N % T::bit_size());
+        let mut mask = T::make_mask(n % T::bit_size());
         if mask != T::zero() {
             <T as BitOps>::invert(&mut mask);
 
@@ -109,12 +109,12 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
         }
 
         if let Some(bit) = <T as BitOps>::last_false_index(&last_element) {
-            return self.make_index((data.len() - 1) * T::bit_size() + bit);
+            return self.make_index(n, (data.len() - 1) * T::bit_size() + bit);
         }
 
         for element in iter {
             if let Some(bit) = <T as BitOps>::last_false_index(element) {
-                return self.make_index((data.len() - 1) * T::bit_size() + bit);
+                return self.make_index(n, (data.len() - 1) * T::bit_size() + bit);
             }
         }
 
@@ -122,8 +122,8 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 获取位图中下一个为1的位
-    pub(crate) fn next_index(&self, data: &[T], index: usize) -> Option<usize> {
-        if unlikely(index >= N) {
+    pub(crate) fn next_index(&self, n: usize, data: &[T], index: usize) -> Option<usize> {
+        if unlikely(index >= n) {
             return None;
         }
 
@@ -132,12 +132,12 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
 
         let element = data.get(element_index)?;
         if let Some(bit) = <T as BitOps>::next_index(element, bit_index) {
-            return self.make_index(element_index * T::bit_size() + bit);
+            return self.make_index(n, element_index * T::bit_size() + bit);
         }
 
         for (i, element) in data.iter().enumerate().skip(element_index + 1) {
             if let Some(bit) = <T as BitOps>::first_index(element) {
-                return self.make_index(i * T::bit_size() + bit);
+                return self.make_index(n, i * T::bit_size() + bit);
             }
         }
 
@@ -145,8 +145,8 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 获取位图中下一个为0的位
-    pub(crate) fn next_false_index(&self, data: &[T], index: usize) -> Option<usize> {
-        if unlikely(index >= N) {
+    pub(crate) fn next_false_index(&self, n: usize, data: &[T], index: usize) -> Option<usize> {
+        if unlikely(index >= n) {
             return None;
         }
 
@@ -155,12 +155,12 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
 
         let element = data.get(element_index)?;
         if let Some(bit) = <T as BitOps>::next_false_index(element, bit_index) {
-            return self.make_index(element_index * T::bit_size() + bit);
+            return self.make_index(n, element_index * T::bit_size() + bit);
         }
 
         for (i, element) in data.iter().enumerate().skip(element_index + 1) {
             if let Some(bit) = <T as BitOps>::first_false_index(element) {
-                return self.make_index(i * T::bit_size() + bit);
+                return self.make_index(n, i * T::bit_size() + bit);
             }
         }
 
@@ -168,8 +168,8 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
     }
 
     /// 获取位图中上一个为1的位
-    pub(crate) fn prev_index(&self, data: &[T], index: usize) -> Option<usize> {
-        if unlikely(index >= N) {
+    pub(crate) fn prev_index(&self, n: usize, data: &[T], index: usize) -> Option<usize> {
+        if unlikely(index >= n) {
             return None;
         }
         let element_index = index / T::bit_size();
@@ -177,37 +177,37 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
 
         let element = data.get(element_index)?;
         if let Some(bit) = <T as BitOps>::prev_index(element, bit_index) {
-            return self.make_index(element_index * T::bit_size() + bit);
+            return self.make_index(n, element_index * T::bit_size() + bit);
         }
 
         for (i, element) in data.iter().enumerate().take(element_index).rev() {
             if let Some(bit) = <T as BitOps>::last_index(element) {
-                return self.make_index(i * T::bit_size() + bit);
+                return self.make_index(n, i * T::bit_size() + bit);
             }
         }
 
         None
     }
 
-    pub(crate) fn prev_false_index(&self, data: &[T], index: usize) -> Option<usize> {
+    pub(crate) fn prev_false_index(&self, n: usize, data: &[T], index: usize) -> Option<usize> {
         let element_index = index / T::bit_size();
         let bit_index = index % T::bit_size();
 
         let element = data.get(element_index)?;
         if let Some(bit) = <T as BitOps>::prev_false_index(element, bit_index) {
-            return self.make_index(element_index * T::bit_size() + bit);
+            return self.make_index(n, element_index * T::bit_size() + bit);
         }
 
         for (i, element) in data.iter().enumerate().take(element_index).rev() {
             if let Some(bit) = <T as BitOps>::last_false_index(element) {
-                return self.make_index(i * T::bit_size() + bit);
+                return self.make_index(n, i * T::bit_size() + bit);
             }
         }
 
         None
     }
 
-    pub(crate) fn invert(&self, data: &mut [T]) {
+    pub(crate) fn invert(&self, n: usize, data: &mut [T]) {
         for element in data.iter_mut() {
             <T as BitOps>::invert(element);
         }
@@ -215,19 +215,19 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
         // 特殊处理最后一个元素
 
         let last_element = data.last_mut().unwrap();
-        let mask = T::make_mask(N % T::bit_size());
+        let mask = T::make_mask(n % T::bit_size());
         if mask != T::zero() {
             *last_element &= mask;
         }
     }
 
-    pub(crate) fn is_full(&self, data: &[T]) -> bool {
+    pub(crate) fn is_full(&self, n: usize, data: &[T]) -> bool {
         let mut iter = data.iter().peekable();
         while let Some(element) = iter.next() {
             if iter.peek().is_none() {
                 // 这是最后一个元素，进行特殊处理
                 let mut element = *element;
-                let mut mask = T::make_mask(N % T::bit_size());
+                let mut mask = T::make_mask(n % T::bit_size());
                 if mask == T::zero() {
                     mask = T::max();
                 }
@@ -256,8 +256,8 @@ impl<T: BitOps, const N: usize> BitMapCore<T, N> {
         return true;
     }
 
-    fn make_index(&self, index: usize) -> Option<usize> {
-        if unlikely(index >= N) {
+    fn make_index(&self, n: usize, index: usize) -> Option<usize> {
+        if unlikely(index >= n) {
             return None;
         }
 

kernel/crates/bitmap/src/lib.rs

@@ -3,7 +3,12 @@
 #![allow(incomplete_features)] // for const generics
 #![feature(generic_const_exprs)]
 
+#[macro_use]
+extern crate alloc;
+
+mod alloc_bitmap;
 mod bitmap_core;
 mod static_bitmap;
 pub mod traits;
+pub use alloc_bitmap::AllocBitmap;
 pub use static_bitmap::StaticBitmap;

kernel/crates/bitmap/src/static_bitmap.rs

@@ -10,7 +10,7 @@ where
     [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
 {
     pub data: [usize; (N + usize::BITS as usize - 1) / (usize::BITS as usize)],
-    core: BitMapCore<usize, N>,
+    core: BitMapCore<usize>,
 }
 
 impl<const N: usize> StaticBitmap<N>
@@ -32,12 +32,12 @@ where
 {
     #[inline]
     fn get(&self, index: usize) -> Option<bool> {
-        return self.core.get(&self.data, index);
+        return self.core.get(N, &self.data, index);
     }
 
     #[inline]
     fn set(&mut self, index: usize, value: bool) -> Option<bool> {
-        return self.core.set(&mut self.data, index, value);
+        return self.core.set(N, &mut self.data, index, value);
     }
 
     #[inline]
@@ -57,47 +57,47 @@ where
 
     #[inline]
     fn first_false_index(&self) -> Option<usize> {
-        self.core.first_false_index(&self.data)
+        self.core.first_false_index(N, &self.data)
     }
 
     #[inline]
     fn last_index(&self) -> Option<usize> {
-        self.core.last_index(&self.data)
+        self.core.last_index(N, &self.data)
     }
 
     #[inline]
     fn last_false_index(&self) -> Option<usize> {
-        self.core.last_false_index(&self.data)
+        self.core.last_false_index(N, &self.data)
     }
 
     #[inline]
     fn next_index(&self, index: usize) -> Option<usize> {
-        self.core.next_index(&self.data, index)
+        self.core.next_index(N, &self.data, index)
     }
 
     #[inline]
     fn next_false_index(&self, index: usize) -> Option<usize> {
-        self.core.next_false_index(&self.data, index)
+        self.core.next_false_index(N, &self.data, index)
     }
 
     #[inline]
     fn prev_index(&self, index: usize) -> Option<usize> {
-        self.core.prev_index(&self.data, index)
+        self.core.prev_index(N, &self.data, index)
     }
 
     #[inline]
     fn prev_false_index(&self, index: usize) -> Option<usize> {
-        self.core.prev_false_index(&self.data, index)
+        self.core.prev_false_index(N, &self.data, index)
     }
 
     #[inline]
     fn invert(&mut self) {
-        self.core.invert(&mut self.data);
+        self.core.invert(N, &mut self.data);
     }
 
     #[inline]
     fn is_full(&self) -> bool {
-        self.core.is_full(&self.data)
+        self.core.is_full(N, &self.data)
     }
 
     #[inline]
@@ -114,6 +114,6 @@ where
     }
 
     fn set_all(&mut self, value: bool) {
-        self.core.set_all(&mut self.data, value);
+        self.core.set_all(N, &mut self.data, value);
     }
 }

kernel/crates/bitmap/tests/alloc-bitmap.rs

@@ -0,0 +1,645 @@
+//! 动态位图的集成测试
+
+use bitmap::{traits::BitMapOps, AllocBitmap};
+
+/// 测试空的位图
+///
+/// 这是一个测试空的位图的例子
+///
+
+/// 测试空的位图
+#[test]
+fn test_empty_bitmap_32() {
+    let mut bitmap = AllocBitmap::new(32);
+    assert_eq!(bitmap.len(), 32);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), None);
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), None);
+    assert_eq!(bitmap.last_false_index(), Some(31));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), true);
+    bitmap.invert();
+    assert_eq!(bitmap.len(), 32);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), None);
+    assert_eq!(bitmap.last_index(), Some(31));
+    assert_eq!(bitmap.last_false_index(), None);
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), true);
+    assert_eq!(bitmap.is_empty(), false);
+}
+
+#[test]
+fn test_empty_bitmap_64() {
+    let mut bitmap = AllocBitmap::new(64);
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), None);
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), None);
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), true);
+    bitmap.invert();
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), None);
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), None);
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), true);
+    assert_eq!(bitmap.is_empty(), false);
+}
+
+/// 测试长度为32的bmp，其中第一个元素为1
+#[test]
+fn test_alloc_bitmap_32_first_1() {
+    let mut bitmap = AllocBitmap::new(32);
+    bitmap.set(0, true);
+    assert_eq!(bitmap.len(), 32);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(1));
+    assert_eq!(bitmap.last_index(), Some(0));
+    assert_eq!(bitmap.last_false_index(), Some(31));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(0));
+    assert_eq!(bitmap.prev_false_index(2), Some(1));
+    assert_eq!(bitmap.next_index(2), None);
+    assert_eq!(bitmap.next_false_index(2), Some(3));
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(1));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(31));
+    assert_eq!(bitmap.last_false_index(), Some(0));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(1));
+    assert_eq!(bitmap.prev_false_index(2), Some(0));
+    assert_eq!(bitmap.next_index(2), Some(3));
+}
+
+/// 测试长度为32的bmp，其中中间某个元素为1
+#[test]
+fn test_alloc_bitmap_32_middle_1() {
+    let mut bitmap = AllocBitmap::new(32);
+    bitmap.set(15, true);
+    assert_eq!(bitmap.len(), 32);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(15));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(15));
+    assert_eq!(bitmap.last_false_index(), Some(31));
+    assert_eq!(bitmap.next_index(0), Some(15));
+    assert_eq!(bitmap.next_index(15), None);
+    assert_eq!(bitmap.next_false_index(15), Some(16));
+    assert_eq!(bitmap.prev_index(15), None);
+    assert_eq!(bitmap.prev_false_index(15), Some(14));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(20), Some(15));
+    assert_eq!(bitmap.prev_false_index(20), Some(19));
+    assert_eq!(bitmap.next_index(2), Some(15));
+    assert_eq!(bitmap.next_false_index(2), Some(3));
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(15));
+    assert_eq!(bitmap.last_index(), Some(31));
+    assert_eq!(bitmap.last_false_index(), Some(15));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(1), Some(15));
+    assert_eq!(bitmap.prev_index(15), Some(14));
+    assert_eq!(bitmap.prev_false_index(15), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(30), Some(29));
+    assert_eq!(bitmap.prev_false_index(30), Some(15));
+    assert_eq!(bitmap.next_index(2), Some(3));
+}
+
+/// 测试长度为32的bmp，其中最后一个元素为1
+#[test]
+fn test_alloc_bitmap_32_last_1() {
+    let mut bitmap = AllocBitmap::new(32);
+    bitmap.set(31, true);
+    assert_eq!(bitmap.len(), 32);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(31));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(31));
+    assert_eq!(bitmap.last_false_index(), Some(30));
+    assert_eq!(bitmap.next_index(0), Some(31));
+    assert_eq!(bitmap.next_index(31), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(31), None);
+    assert_eq!(bitmap.prev_false_index(31), Some(30));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), None);
+    assert_eq!(bitmap.prev_false_index(2), Some(1));
+    assert_eq!(bitmap.next_index(2), Some(31));
+    assert_eq!(bitmap.next_false_index(2), Some(3));
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(31));
+    assert_eq!(bitmap.last_index(), Some(30));
+    assert_eq!(bitmap.last_false_index(), Some(31));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), Some(31));
+    assert_eq!(bitmap.prev_index(31), Some(30));
+    assert_eq!(bitmap.prev_false_index(31), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(1));
+    assert_eq!(bitmap.prev_false_index(2), None);
+    assert_eq!(bitmap.next_index(2), Some(3));
+}
+
+/// 测试长度为64的bmp，其中第一个元素为1
+#[test]
+fn test_alloc_bitmap_64_first_1() {
+    let mut bitmap = AllocBitmap::new(64);
+    bitmap.set(0, true);
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(1));
+    assert_eq!(bitmap.last_index(), Some(0));
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(0));
+    assert_eq!(bitmap.prev_false_index(2), Some(1));
+    assert_eq!(bitmap.next_index(2), None);
+    assert_eq!(bitmap.next_false_index(2), Some(3));
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(1));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), Some(0));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(0), None);
+    assert_eq!(bitmap.prev_false_index(0), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(1));
+    assert_eq!(bitmap.prev_false_index(2), Some(0));
+    assert_eq!(bitmap.next_index(2), Some(3));
+}
+
+/// 测试长度为64的bmp，其中中间某个元素为1
+#[test]
+fn test_alloc_bitmap_64_middle_1() {
+    let mut bitmap = AllocBitmap::new(64);
+    bitmap.set(15, true);
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(15));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(15));
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), Some(15));
+    assert_eq!(bitmap.next_index(15), None);
+    assert_eq!(bitmap.next_false_index(15), Some(16));
+    assert_eq!(bitmap.prev_index(15), None);
+    assert_eq!(bitmap.prev_false_index(15), Some(14));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(20), Some(15));
+    assert_eq!(bitmap.prev_false_index(20), Some(19));
+    assert_eq!(bitmap.next_index(2), Some(15));
+    assert_eq!(bitmap.next_false_index(2), Some(3));
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(15));
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), Some(15));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(1), Some(15));
+    assert_eq!(bitmap.prev_index(15), Some(14));
+    assert_eq!(bitmap.prev_false_index(15), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(63), Some(62));
+    assert_eq!(bitmap.prev_false_index(62), Some(15));
+    assert_eq!(bitmap.next_index(2), Some(3));
+}
+
+/// 测试长度为64的bmp，其中最后一个元素为1
+#[test]
+fn test_alloc_bitmap_64_last_1() {
+    let mut bitmap = AllocBitmap::new(64);
+    bitmap.set(63, true);
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(63));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), Some(62));
+    assert_eq!(bitmap.next_index(0), Some(63));
+    assert_eq!(bitmap.next_index(63), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(63), None);
+    assert_eq!(bitmap.prev_false_index(63), Some(62));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), None);
+    assert_eq!(bitmap.prev_false_index(2), Some(1));
+    assert_eq!(bitmap.next_index(2), Some(63));
+    assert_eq!(bitmap.next_false_index(2), Some(3));
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(63));
+    assert_eq!(bitmap.last_index(), Some(62));
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), Some(63));
+    assert_eq!(bitmap.prev_index(63), Some(62));
+    assert_eq!(bitmap.prev_false_index(63), None);
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(1));
+    assert_eq!(bitmap.prev_false_index(2), None);
+    assert_eq!(bitmap.next_index(2), Some(3));
+}
+
+/// 测试长度为64的bmp，其中第一个和最后一个元素为1
+#[test]
+fn test_alloc_bitmap_64_two_1_first() {
+    let mut bitmap = AllocBitmap::new(64);
+    bitmap.set(0, true);
+    bitmap.set(63, true);
+
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(1));
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), Some(62));
+    assert_eq!(bitmap.next_index(0), Some(63));
+    assert_eq!(bitmap.next_index(63), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(63), Some(0));
+    assert_eq!(bitmap.prev_false_index(63), Some(62));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(1));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(62));
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), Some(63));
+    assert_eq!(bitmap.prev_index(63), Some(62));
+    assert_eq!(bitmap.prev_false_index(63), Some(0));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(1));
+    assert_eq!(bitmap.prev_false_index(2), Some(0));
+    assert_eq!(bitmap.next_index(2), Some(3));
+    assert_eq!(bitmap.next_false_index(2), Some(63));
+}
+
+/// 测试长度为64的bmp，中间两个不相邻的元素为1
+#[test]
+fn test_alloc_bitmap_64_two_1_middle() {
+    let mut bitmap = AllocBitmap::new(64);
+    bitmap.set(15, true);
+    bitmap.set(63, true);
+
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(15));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), Some(62));
+    assert_eq!(bitmap.next_index(0), Some(15));
+    assert_eq!(bitmap.next_index(15), Some(63));
+    assert_eq!(bitmap.next_index(63), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(63), Some(15));
+    assert_eq!(bitmap.prev_false_index(63), Some(62));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(15));
+    assert_eq!(bitmap.last_index(), Some(62));
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), Some(15));
+    assert_eq!(bitmap.next_false_index(15), Some(63));
+    assert_eq!(bitmap.prev_index(63), Some(62));
+    assert_eq!(bitmap.prev_false_index(63), Some(15));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.prev_index(2), Some(1));
+    assert_eq!(bitmap.prev_false_index(2), None);
+    assert_eq!(bitmap.next_index(2), Some(3));
+    assert_eq!(bitmap.next_false_index(2), Some(15));
+}
+
+#[test]
+fn test_alloc_bitmap_128_two_1_seperate_first() {
+    let mut bitmap = AllocBitmap::new(128);
+
+    bitmap.set(0, true);
+    bitmap.set(127, true);
+
+    assert_eq!(bitmap.len(), 128);
+    assert_eq!(bitmap.size(), 16);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(1));
+    assert_eq!(bitmap.last_index(), Some(127));
+    assert_eq!(bitmap.last_false_index(), Some(126));
+    assert_eq!(bitmap.next_index(0), Some(127));
+    assert_eq!(bitmap.next_index(127), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(127), Some(0));
+    assert_eq!(bitmap.prev_false_index(127), Some(126));
+    assert_eq!(bitmap.prev_index(64), Some(0));
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(1));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(126));
+    assert_eq!(bitmap.last_false_index(), Some(127));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), Some(127));
+    assert_eq!(bitmap.prev_index(127), Some(126));
+    assert_eq!(bitmap.prev_false_index(127), Some(0));
+    assert_eq!(bitmap.prev_false_index(64), Some(0));
+    assert_eq!(bitmap.is_empty(), false);
+    assert_eq!(bitmap.is_full(), false);
+}
+
+/// 长度128, 第63、64bit为1
+#[test]
+fn test_alloc_bitmap_128_two_1_nearby_middle() {
+    let mut bitmap = AllocBitmap::new(128);
+
+    bitmap.set(63, true);
+    bitmap.set(64, true);
+
+    assert_eq!(bitmap.len(), 128);
+    assert_eq!(bitmap.size(), 16);
+
+    assert_eq!(bitmap.first_index(), Some(63));
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), Some(64));
+    assert_eq!(bitmap.last_false_index(), Some(127));
+    assert_eq!(bitmap.next_index(0), Some(63));
+    assert_eq!(bitmap.next_index(63), Some(64));
+    assert_eq!(bitmap.next_index(64), None);
+
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(63), Some(65));
+    assert_eq!(bitmap.prev_index(64), Some(63));
+    assert_eq!(bitmap.prev_false_index(64), Some(62));
+    assert_eq!(bitmap.prev_index(63), None);
+    assert_eq!(bitmap.prev_false_index(63), Some(62));
+    assert_eq!(bitmap.prev_index(65), Some(64));
+
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), Some(63));
+    assert_eq!(bitmap.last_index(), Some(127));
+    assert_eq!(bitmap.last_false_index(), Some(64));
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_false_index(0), Some(63));
+    assert_eq!(bitmap.next_false_index(63), Some(64));
+    assert_eq!(bitmap.next_index(63), Some(65));
+    assert_eq!(bitmap.prev_false_index(127), Some(64));
+    assert_eq!(bitmap.prev_index(127), Some(126));
+    assert_eq!(bitmap.prev_false_index(64), Some(63));
+    assert_eq!(bitmap.prev_index(64), Some(62));
+    assert_eq!(bitmap.prev_index(63), Some(62));
+
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), false);
+}
+
+#[test]
+fn test_alloc_bitmap_full_32() {
+    let mut bitmap = AllocBitmap::new(32);
+    bitmap.set_all(true);
+
+    assert_eq!(bitmap.len(), 32);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), None);
+    assert_eq!(bitmap.last_index(), Some(31));
+    assert_eq!(bitmap.last_false_index(), None);
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_index(31), None);
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(31), Some(30));
+    assert_eq!(bitmap.prev_false_index(31), None);
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), true);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), None);
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), None);
+    assert_eq!(bitmap.last_false_index(), Some(31));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(31), None);
+    assert_eq!(bitmap.prev_false_index(31), Some(30));
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), true);
+}
+
+#[test]
+fn test_alloc_bitmap_full_64() {
+    let mut bitmap = AllocBitmap::new(64);
+    bitmap.set_all(true);
+
+    assert_eq!(bitmap.len(), 64);
+    assert_eq!(bitmap.size(), 8);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), None);
+    assert_eq!(bitmap.last_index(), Some(63));
+    assert_eq!(bitmap.last_false_index(), None);
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_index(63), None);
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(63), Some(62));
+    assert_eq!(bitmap.prev_false_index(63), None);
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), true);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), None);
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), None);
+    assert_eq!(bitmap.last_false_index(), Some(63));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(63), None);
+    assert_eq!(bitmap.prev_false_index(63), Some(62));
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), true);
+}
+
+#[test]
+fn test_alloc_bitmap_full_100() {
+    let mut bitmap = AllocBitmap::new(100);
+    bitmap.set_all(true);
+
+    assert_eq!(bitmap.len(), 100);
+    assert_eq!(bitmap.size(), 16);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), None);
+    assert_eq!(bitmap.last_index(), Some(99));
+    assert_eq!(bitmap.last_false_index(), None);
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_index(99), None);
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(99), Some(98));
+    assert_eq!(bitmap.prev_false_index(99), None);
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), true);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), None);
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), None);
+    assert_eq!(bitmap.last_false_index(), Some(99));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(99), None);
+    assert_eq!(bitmap.prev_false_index(99), Some(98));
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), true);
+}
+
+#[test]
+fn test_alloc_bitmap_full_128() {
+    let mut bitmap = AllocBitmap::new(128);
+    bitmap.set_all(true);
+
+    assert_eq!(bitmap.len(), 128);
+    assert_eq!(bitmap.size(), 16);
+    assert_eq!(bitmap.first_index(), Some(0));
+    assert_eq!(bitmap.first_false_index(), None);
+    assert_eq!(bitmap.last_index(), Some(127));
+    assert_eq!(bitmap.last_false_index(), None);
+    assert_eq!(bitmap.next_index(0), Some(1));
+    assert_eq!(bitmap.next_index(127), None);
+    assert_eq!(bitmap.next_false_index(0), None);
+    assert_eq!(bitmap.prev_index(127), Some(126));
+    assert_eq!(bitmap.prev_false_index(127), None);
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), true);
+    assert_eq!(bitmap.is_empty(), false);
+
+    // 反转
+    bitmap.invert();
+
+    assert_eq!(bitmap.first_index(), None);
+    assert_eq!(bitmap.first_false_index(), Some(0));
+    assert_eq!(bitmap.last_index(), None);
+    assert_eq!(bitmap.last_false_index(), Some(127));
+    assert_eq!(bitmap.next_index(0), None);
+    assert_eq!(bitmap.next_false_index(0), Some(1));
+    assert_eq!(bitmap.prev_index(127), None);
+    assert_eq!(bitmap.prev_false_index(127), Some(126));
+    assert_eq!(bitmap.prev_index(0), None);
+
+    assert_eq!(bitmap.is_full(), false);
+    assert_eq!(bitmap.is_empty(), true);
+}

kernel/crates/bitmap/tests/static-bitmap.rs

@@ -70,7 +70,7 @@ fn test_empty_bitmap_64() {
 
 /// 测试长度为32的bmp，其中第一个元素为1
 #[test]
-fn test_bitmap_32_first_1() {
+fn test_static_bitmap_32_first_1() {
     let mut bitmap = StaticBitmap::<32>::new();
     bitmap.set(0, true);
     assert_eq!(bitmap.len(), 32);
@@ -111,7 +111,7 @@ fn test_bitmap_32_first_1() {
 
 /// 测试长度为32的bmp，其中中间某个元素为1
 #[test]
-fn test_bitmap_32_middle_1() {
+fn test_static_bitmap_32_middle_1() {
     let mut bitmap = StaticBitmap::<32>::new();
     bitmap.set(15, true);
     assert_eq!(bitmap.len(), 32);
@@ -153,7 +153,7 @@ fn test_bitmap_32_middle_1() {
 
 /// 测试长度为32的bmp，其中最后一个元素为1
 #[test]
-fn test_bitmap_32_last_1() {
+fn test_static_bitmap_32_last_1() {
     let mut bitmap = StaticBitmap::<32>::new();
     bitmap.set(31, true);
     assert_eq!(bitmap.len(), 32);
@@ -195,7 +195,7 @@ fn test_bitmap_32_last_1() {
 
 /// 测试长度为64的bmp，其中第一个元素为1
 #[test]
-fn test_bitmap_64_first_1() {
+fn test_static_bitmap_64_first_1() {
     let mut bitmap = StaticBitmap::<64>::new();
     bitmap.set(0, true);
     assert_eq!(bitmap.len(), 64);
@@ -236,7 +236,7 @@ fn test_bitmap_64_first_1() {
 
 /// 测试长度为64的bmp，其中中间某个元素为1
 #[test]
-fn test_bitmap_64_middle_1() {
+fn test_static_bitmap_64_middle_1() {
     let mut bitmap = StaticBitmap::<64>::new();
     bitmap.set(15, true);
     assert_eq!(bitmap.len(), 64);
@@ -278,7 +278,7 @@ fn test_bitmap_64_middle_1() {
 
 /// 测试长度为64的bmp，其中最后一个元素为1
 #[test]
-fn test_bitmap_64_last_1() {
+fn test_static_bitmap_64_last_1() {
     let mut bitmap = StaticBitmap::<64>::new();
     bitmap.set(63, true);
     assert_eq!(bitmap.len(), 64);
@@ -320,7 +320,7 @@ fn test_bitmap_64_last_1() {
 
 /// 测试长度为64的bmp，其中第一个和最后一个元素为1
 #[test]
-fn test_bitmap_64_two_1_first() {
+fn test_static_bitmap_64_two_1_first() {
     let mut bitmap = StaticBitmap::<64>::new();
     bitmap.set(0, true);
     bitmap.set(63, true);
@@ -361,7 +361,7 @@ fn test_bitmap_64_two_1_first() {
 
 /// 测试长度为64的bmp，中间两个不相邻的元素为1
 #[test]
-fn test_bitmap_64_two_1_middle() {
+fn test_static_bitmap_64_two_1_middle() {
     let mut bitmap = StaticBitmap::<64>::new();
     bitmap.set(15, true);
     bitmap.set(63, true);
@@ -403,7 +403,7 @@ fn test_bitmap_64_two_1_middle() {
 }
 
 #[test]
-fn test_bitmap_128_two_1_seperate_first() {
+fn test_static_bitmap_128_two_1_seperate_first() {
     let mut bitmap = StaticBitmap::<128>::new();
 
     bitmap.set(0, true);
@@ -443,7 +443,7 @@ fn test_bitmap_128_two_1_seperate_first() {
 
 /// 长度128, 第63、64bit为1
 #[test]
-fn test_bitmap_128_two_1_nearby_middle() {
+fn test_static_bitmap_128_two_1_nearby_middle() {
     let mut bitmap = StaticBitmap::<128>::new();
 
     bitmap.set(63, true);
@@ -493,7 +493,7 @@ fn test_bitmap_128_two_1_nearby_middle() {
 }
 
 #[test]
-fn test_bitmap_full_32() {
+fn test_static_bitmap_full_32() {
     let mut bitmap = StaticBitmap::<32>::new();
     bitmap.set_all(true);
 
@@ -531,7 +531,7 @@ fn test_bitmap_full_32() {
 }
 
 #[test]
-fn test_bitmap_full_64() {
+fn test_static_bitmap_full_64() {
     let mut bitmap = StaticBitmap::<64>::new();
     bitmap.set_all(true);
 
@@ -569,7 +569,7 @@ fn test_bitmap_full_64() {
 }
 
 #[test]
-fn test_bitmap_full_100() {
+fn test_static_bitmap_full_100() {
     let mut bitmap = StaticBitmap::<100>::new();
     bitmap.set_all(true);
 
@@ -607,7 +607,7 @@ fn test_bitmap_full_100() {
 }
 
 #[test]
-fn test_bitmap_full_128() {
+fn test_static_bitmap_full_128() {
     let mut bitmap = StaticBitmap::<128>::new();
     bitmap.set_all(true);