完成bitmap的static bitmap功能，能够静态声明bitmap (#490)

* 完成bitmap的static bitmap功能，能够静态声明bitmap

kernel/Cargo.toml

@@ -26,8 +26,9 @@ backtrace = []
 acpi = { git = "https://git.mirrors.dragonos.org/DragonOS-Community/acpi-rs.git", rev = "fb69243dcf" }
 atomic_enum = "0.2.0"
 bit_field = "0.10"
-bitflags = "1.3.2"
 bitfield-struct = "0.5.3"
+bitflags = "1.3.2"
+bitmap = { path = "crates/bitmap" }
 # 一个no_std的hashmap、hashset
 elf = { version = "0.7.2", default-features = false }
 hashbrown = "0.13.2"

kernel/crates/bitmap/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "bitmap"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

kernel/crates/bitmap/src/bitmap_core.rs

@@ -0,0 +1,266 @@
+use core::{intrinsics::unlikely, marker::PhantomData};
+
+use crate::traits::BitOps;
+
+pub(crate) struct BitMapCore<T: BitOps, const N: usize> {
+    phantom: PhantomData<T>,
+}
+
+impl<T: BitOps, const N: usize> BitMapCore<T, N> {
+    pub const fn new() -> Self {
+        Self {
+            phantom: PhantomData,
+        }
+    }
+
+    /// 获取位图中的某一位
+    pub(crate) fn get(&self, data: &[T], index: usize) -> Option<bool> {
+        if unlikely(index >= N) {
+            return None;
+        }
+
+        let element_index = index / T::bit_size();
+        let bit_index = index % T::bit_size();
+
+        let element = data.get(element_index)?;
+        let bit = <T as BitOps>::get(element, bit_index);
+
+        Some(bit)
+    }
+
+    /// 设置位图中的某一位
+    pub(crate) fn set(&self, data: &mut [T], index: usize, value: bool) -> Option<bool> {
+        if unlikely(index >= N) {
+            return None;
+        }
+        let element_index = index / T::bit_size();
+        let bit_index = index % T::bit_size();
+
+        let element = data.get_mut(element_index)?;
+        let bit = <T as BitOps>::set(element, bit_index, value);
+
+        Some(bit)
+    }
+
+    pub(crate) fn set_all(&self, data: &mut [T], value: bool) {
+        let val = if value { T::max() } else { T::zero() };
+        for element in data.iter_mut() {
+            *element = val;
+        }
+
+        // 特殊处理最后一个元素
+        let last_element = data.last_mut().unwrap();
+        let mask = T::make_mask(N % T::bit_size());
+        if mask != T::zero() {
+            *last_element &= mask;
+        }
+    }
+
+    /// 获取位图中第一个为1的位
+    pub(crate) fn first_index(&self, data: &[T]) -> Option<usize> {
+        for (i, element) in data.iter().enumerate() {
+            let bit = <T as BitOps>::first_index(element);
+            if bit.is_some() {
+                return Some(i * T::bit_size() + bit.unwrap());
+            }
+        }
+
+        None
+    }
+
+    /// 获取位图中第一个为0的位
+    pub(crate) fn first_false_index(&self, 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);
+            }
+        }
+
+        None
+    }
+
+    /// 获取位图中最后一个为1的位
+    pub(crate) fn last_index(&self, 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);
+            }
+        }
+
+        None
+    }
+
+    /// 获取位图中最后一个为0的位
+    ///
+    /// ## 参数
+    ///
+    /// - `data`：位图数据
+    /// - `n`：位图有效位数
+    pub(crate) fn last_false_index(&self, 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());
+        if mask != T::zero() {
+            <T as BitOps>::invert(&mut mask);
+
+            last_element |= mask;
+        }
+
+        if let Some(bit) = <T as BitOps>::last_false_index(&last_element) {
+            return self.make_index((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);
+            }
+        }
+
+        None
+    }
+
+    /// 获取位图中下一个为1的位
+    pub(crate) fn next_index(&self, data: &[T], index: usize) -> Option<usize> {
+        if unlikely(index >= N) {
+            return None;
+        }
+
+        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>::next_index(element, bit_index) {
+            return self.make_index(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);
+            }
+        }
+
+        None
+    }
+
+    /// 获取位图中下一个为0的位
+    pub(crate) fn next_false_index(&self, data: &[T], index: usize) -> Option<usize> {
+        if unlikely(index >= N) {
+            return None;
+        }
+
+        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>::next_false_index(element, bit_index) {
+            return self.make_index(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);
+            }
+        }
+
+        None
+    }
+
+    /// 获取位图中上一个为1的位
+    pub(crate) fn prev_index(&self, data: &[T], index: usize) -> Option<usize> {
+        if unlikely(index >= N) {
+            return None;
+        }
+        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_index(element, bit_index) {
+            return self.make_index(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);
+            }
+        }
+
+        None
+    }
+
+    pub(crate) fn prev_false_index(&self, 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);
+        }
+
+        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);
+            }
+        }
+
+        None
+    }
+
+    pub(crate) fn invert(&self, data: &mut [T]) {
+        for element in data.iter_mut() {
+            <T as BitOps>::invert(element);
+        }
+
+        // 特殊处理最后一个元素
+
+        let last_element = data.last_mut().unwrap();
+        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 {
+        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());
+                if mask == T::zero() {
+                    mask = T::max();
+                }
+
+                T::bit_and(&mut element, &mask);
+                if element == mask {
+                    return true;
+                }
+            } else {
+                if element != &T::make_mask(T::bit_size()) {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    pub(crate) fn is_empty(&self, data: &[T]) -> bool {
+        for element in data.iter() {
+            if element != &T::zero() {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    fn make_index(&self, index: usize) -> Option<usize> {
+        if unlikely(index >= N) {
+            return None;
+        }
+
+        Some(index)
+    }
+}

kernel/crates/bitmap/src/lib.rs

@@ -0,0 +1,9 @@
+#![no_std]
+#![feature(core_intrinsics)]
+#![allow(incomplete_features)] // for const generics
+#![feature(generic_const_exprs)]
+
+mod bitmap_core;
+mod static_bitmap;
+pub mod traits;
+pub use static_bitmap::StaticBitmap;

kernel/crates/bitmap/src/static_bitmap.rs

@@ -0,0 +1,119 @@
+use core::mem::size_of;
+
+use crate::{bitmap_core::BitMapCore, traits::BitMapOps};
+
+/// 静态位图
+///
+/// 该位图的大小在编译时确定，不可变
+pub struct StaticBitmap<const N: usize>
+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>,
+}
+
+impl<const N: usize> StaticBitmap<N>
+where
+    [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
+{
+    /// 创建一个新的静态位图
+    pub const fn new() -> Self {
+        Self {
+            data: [0; (N + usize::BITS as usize - 1) / (usize::BITS as usize)],
+            core: BitMapCore::new(),
+        }
+    }
+}
+
+impl<const N: usize> BitMapOps<usize> for StaticBitmap<N>
+where
+    [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
+{
+    #[inline]
+    fn get(&self, index: usize) -> Option<bool> {
+        return self.core.get(&self.data, index);
+    }
+
+    #[inline]
+    fn set(&mut self, index: usize, value: bool) -> Option<bool> {
+        return self.core.set(&mut self.data, index, value);
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        N
+    }
+
+    #[inline]
+    fn size(&self) -> usize {
+        self.data.len() * 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.data)
+    }
+
+    #[inline]
+    fn last_index(&self) -> Option<usize> {
+        self.core.last_index(&self.data)
+    }
+
+    #[inline]
+    fn last_false_index(&self) -> Option<usize> {
+        self.core.last_false_index(&self.data)
+    }
+
+    #[inline]
+    fn next_index(&self, index: usize) -> Option<usize> {
+        self.core.next_index(&self.data, index)
+    }
+
+    #[inline]
+    fn next_false_index(&self, index: usize) -> Option<usize> {
+        self.core.next_false_index(&self.data, index)
+    }
+
+    #[inline]
+    fn prev_index(&self, index: usize) -> Option<usize> {
+        self.core.prev_index(&self.data, index)
+    }
+
+    #[inline]
+    fn prev_false_index(&self, index: usize) -> Option<usize> {
+        self.core.prev_false_index(&self.data, index)
+    }
+
+    #[inline]
+    fn invert(&mut self) {
+        self.core.invert(&mut self.data);
+    }
+
+    #[inline]
+    fn is_full(&self) -> bool {
+        self.core.is_full(&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(&mut self.data, value);
+    }
+}

kernel/crates/bitmap/src/traits.rs

@@ -0,0 +1,314 @@
+use core::ops::{BitAnd, BitAndAssign, BitOrAssign, Not};
+
+/// A trait that defines generalised operations on a `Bits::Store` type.
+pub trait BitOps:
+    BitAndAssign + Sized + Copy + PartialEq + Not + BitOrAssign + BitOrAssign + BitAnd
+{
+    fn get(bits: &Self, index: usize) -> bool;
+    fn set(bits: &mut Self, index: usize, value: bool) -> bool;
+    fn set_value(bits: &mut Self, value: Self);
+    fn len(bits: &Self) -> usize;
+    fn first_index(bits: &Self) -> Option<usize>;
+    fn first_false_index(bits: &Self) -> Option<usize>;
+    fn last_index(bits: &Self) -> Option<usize>;
+    fn last_false_index(bits: &Self) -> Option<usize>;
+    fn next_index(bits: &Self, index: usize) -> Option<usize>;
+    fn next_false_index(bits: &Self, index: usize) -> Option<usize>;
+    fn prev_index(bits: &Self, index: usize) -> Option<usize>;
+    fn prev_false_index(bits: &Self, index: usize) -> Option<usize>;
+    fn bit_and(bits: &mut Self, other_bits: &Self);
+    fn bit_or(bits: &mut Self, other_bits: &Self);
+    fn bit_xor(bits: &mut Self, other_bits: &Self);
+    fn invert(bits: &mut Self);
+    fn make_mask(shift: usize) -> Self;
+    fn bit_size() -> usize;
+    fn zero() -> Self;
+    fn max() -> Self;
+}
+
+macro_rules! bitops_for {
+    ($target:ty) => {
+        impl BitOps for $target {
+            #[inline]
+            fn get(bits: &Self, index: usize) -> bool {
+                bits & (1 << index) != 0
+            }
+
+            #[inline]
+            fn set(bits: &mut Self, index: usize, value: bool) -> bool {
+                let mask = 1 << index;
+                let prev = *bits & mask;
+                if value {
+                    *bits |= mask;
+                } else {
+                    *bits &= !mask;
+                }
+                prev != 0
+            }
+
+            #[inline]
+            fn set_value(bits: &mut Self, value: Self) {
+                *bits = value;
+            }
+
+            #[inline]
+            fn len(bits: &Self) -> usize {
+                bits.count_ones() as usize
+            }
+
+            #[inline]
+            fn first_index(bits: &Self) -> Option<usize> {
+                if *bits == 0 {
+                    None
+                } else {
+                    Some(bits.trailing_zeros() as usize)
+                }
+            }
+
+            #[inline]
+            fn first_false_index(bits: &Self) -> Option<usize> {
+                if *bits == <$target>::MAX {
+                    None
+                } else {
+                    Some(bits.trailing_ones() as usize)
+                }
+            }
+
+            #[inline]
+            fn last_index(bits: &Self) -> Option<usize> {
+                if *bits == 0 {
+                    None
+                } else {
+                    Some(<$target>::BITS as usize - 1 - (bits.leading_zeros() as usize))
+                }
+            }
+
+            #[inline]
+            fn last_false_index(bits: &Self) -> Option<usize> {
+                if *bits == <$target>::MAX {
+                    None
+                } else {
+                    Some(<$target>::BITS as usize - 1 - bits.leading_ones() as usize)
+                }
+            }
+
+            #[inline]
+            fn next_index(bits: &Self, index: usize) -> Option<usize> {
+                if *bits == 0 || index >= <$target>::BITS as usize - 1 {
+                    None
+                } else {
+                    let intermediate =
+                        (*bits & (<$target>::MAX.overflowing_shl(1 + index as u32).0));
+
+                    if intermediate == 0 {
+                        None
+                    } else {
+                        Some(intermediate.trailing_zeros() as usize)
+                    }
+                }
+            }
+
+            #[inline]
+            fn next_false_index(bits: &Self, index: usize) -> Option<usize> {
+                if *bits == <$target>::MAX || index >= <$target>::BITS as usize - 1 {
+                    None
+                } else {
+                    let intermediate = (*bits | ((1 << (index + 1)) - 1));
+
+                    if intermediate == <$target>::MAX {
+                        None
+                    } else {
+                        Some(intermediate.trailing_ones() as usize)
+                    }
+                }
+            }
+
+            #[inline]
+            fn prev_index(bits: &Self, index: usize) -> Option<usize> {
+                if *bits == 0 || index == 0 {
+                    None
+                } else {
+                    let intermediate = bits & ((1 << index) - 1);
+
+                    if intermediate == 0 {
+                        None
+                    } else {
+                        Some(<$target>::BITS as usize - 1 - (intermediate.leading_zeros() as usize))
+                    }
+                }
+            }
+
+            #[inline]
+            fn prev_false_index(bits: &Self, index: usize) -> Option<usize> {
+                if *bits == <$target>::MAX || index == 0 {
+                    None
+                } else {
+                    let intermediate = bits | (<$target>::MAX.overflowing_shl(index as u32).0);
+
+                    if intermediate == <$target>::MAX {
+                        None
+                    } else {
+                        Some(<$target>::BITS as usize - 1 - (intermediate.leading_ones() as usize))
+                    }
+                }
+            }
+
+            #[inline]
+            fn bit_and(bits: &mut Self, other_bits: &Self) {
+                *bits &= *other_bits;
+            }
+
+            #[inline]
+            fn bit_or(bits: &mut Self, other_bits: &Self) {
+                *bits |= *other_bits;
+            }
+
+            #[inline]
+            fn bit_xor(bits: &mut Self, other_bits: &Self) {
+                *bits ^= *other_bits;
+            }
+
+            #[inline]
+            fn invert(bits: &mut Self) {
+                *bits = !*bits;
+            }
+
+            #[inline]
+            fn make_mask(shift: usize) -> Self {
+                if shift == <$target>::BITS as usize {
+                    <$target>::MAX
+                } else {
+                    (1 << shift) - 1
+                }
+            }
+
+            #[cfg(feature = "std")]
+            fn to_hex(bits: &Self) -> String {
+                format!("{:x}", bits)
+            }
+
+            #[inline]
+            fn bit_size() -> usize {
+                <$target>::BITS as usize
+            }
+
+            #[inline]
+            fn zero() -> Self {
+                0
+            }
+
+            #[inline]
+            fn max() -> Self {
+                <$target>::MAX
+            }
+        }
+    };
+}
+
+// 为 `u8` 、 `u16` 、 `u32` 和 `u64` 实现 `BitOps` trait
+bitops_for!(u8);
+bitops_for!(u16);
+bitops_for!(u32);
+bitops_for!(u64);
+bitops_for!(usize);
+
+/// Bitmap应当实现的trait
+pub trait BitMapOps<T: BitOps> {
+    /// 获取指定index的位
+    ///
+    /// ## 返回
+    ///
+    /// - `Some(true)` - 该位为1
+    /// - `Some(false)` - 该位为0
+    /// - `None` - index超出范围
+    fn get(&self, index: usize) -> Option<bool>;
+
+    /// 设置指定index的位，并返回该位之前的值
+    ///
+    /// ## 参数
+    ///
+    /// - `index` - 位的index
+    /// - `value` - 位的新值
+    ///
+    /// ## 返回
+    ///
+    /// - `Some(true)` - 该位之前为1
+    /// - `Some(false)` - 该位之前为0
+    /// - `None` - index超出范围
+    fn set(&mut self, index: usize, value: bool) -> Option<bool>;
+
+    /// 将所有位设置为指定值
+    fn set_all(&mut self, value: bool);
+
+    /// 获取bitmap的长度（以位为单位）
+    ///
+    /// ## Example
+    ///
+    /// ```
+    /// use bitmap::StaticBitmap;
+    /// use bitmap::traits::BitMapOps;
+    ///
+    /// let mut bitmap = StaticBitmap::<34>::new();
+    /// assert_eq!(bitmap.len(), 34);
+    /// ```
+    ///
+    fn len(&self) -> usize;
+    /// 获取bitmap的大小（以字节为单位）
+    fn size(&self) -> usize;
+
+    /// 获取第一个为1的位的index
+    ///
+    /// ## 返回
+    ///
+    /// - `Some(index)` - 第一个为1的位的index
+    /// - `None` - 不存在为1的位
+    fn first_index(&self) -> Option<usize>;
+
+    /// 获取第一个为0的位的index
+    ///
+    /// ## 返回
+    ///
+    /// - `Some(index)` - 第一个为0的位的index
+    /// - `None` - 不存在为0的位
+    fn first_false_index(&self) -> Option<usize>;
+
+    /// 获取最后一个为1的位的index
+    ///
+    /// ## 返回
+    ///
+    /// - `Some(index)` - 最后一个为1的位的index
+    /// - `None` - 不存在为1的位
+    fn last_index(&self) -> Option<usize>;
+
+    /// 获取最后一个为0的位的index
+    ///
+    /// ## 返回
+    ///
+    /// - `Some(index)` - 最后一个为0的位的index
+    /// - `None` - 不存在为0的位
+    fn last_false_index(&self) -> Option<usize>;
+
+    /// 获取指定index之后第一个为1的位的index
+    fn next_index(&self, index: usize) -> Option<usize>;
+
+    /// 获取指定index之后第一个为0的位的index
+    fn next_false_index(&self, index: usize) -> Option<usize>;
+
+    /// 获取指定index之前第一个为1的位的index
+    fn prev_index(&self, index: usize) -> Option<usize>;
+
+    /// 获取指定index之前第一个为0的位的index
+    fn prev_false_index(&self, index: usize) -> Option<usize>;
+
+    /// 反转bitmap
+    fn invert(&mut self);
+
+    /// 判断bitmap是否满了
+    fn is_full(&self) -> bool;
+
+    /// 判断bitmap是否为空
+    fn is_empty(&self) -> bool;
+
+    /// 将bitmap转换为字节数组
+    unsafe fn as_bytes(&self) -> &[u8];
+}

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

@@ -0,0 +1,645 @@
+//! 静态位图的集成测试
+
+use bitmap::{traits::BitMapOps, StaticBitmap};
+
+/// 测试空的位图
+///
+/// 这是一个测试空的位图的例子
+///
+
+/// 测试空的位图
+#[test]
+fn test_empty_bitmap_32() {
+    let mut bitmap = StaticBitmap::<32>::new();
+    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 = StaticBitmap::<64>::new();
+    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_bitmap_32_first_1() {
+    let mut bitmap = StaticBitmap::<32>::new();
+    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_bitmap_32_middle_1() {
+    let mut bitmap = StaticBitmap::<32>::new();
+    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_bitmap_32_last_1() {
+    let mut bitmap = StaticBitmap::<32>::new();
+    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_bitmap_64_first_1() {
+    let mut bitmap = StaticBitmap::<64>::new();
+    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_bitmap_64_middle_1() {
+    let mut bitmap = StaticBitmap::<64>::new();
+    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_bitmap_64_last_1() {
+    let mut bitmap = StaticBitmap::<64>::new();
+    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_bitmap_64_two_1_first() {
+    let mut bitmap = StaticBitmap::<64>::new();
+    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_bitmap_64_two_1_middle() {
+    let mut bitmap = StaticBitmap::<64>::new();
+    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_bitmap_128_two_1_seperate_first() {
+    let mut bitmap = StaticBitmap::<128>::new();
+
+    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_bitmap_128_two_1_nearby_middle() {
+    let mut bitmap = StaticBitmap::<128>::new();
+
+    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_bitmap_full_32() {
+    let mut bitmap = StaticBitmap::<32>::new();
+    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_bitmap_full_64() {
+    let mut bitmap = StaticBitmap::<64>::new();
+    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_bitmap_full_100() {
+    let mut bitmap = StaticBitmap::<100>::new();
+    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_bitmap_full_128() {
+    let mut bitmap = StaticBitmap::<128>::new();
+    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);
+}