From 6994f6b113f6fea7b997ec07130a7bdaecfd67b7 Mon Sep 17 00:00:00 2001 From: LoGin Date: Mon, 15 Jan 2024 18:13:22 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E6=88=90bitmap=E7=9A=84static=20bitma?= =?UTF-8?q?p=E5=8A=9F=E8=83=BD=EF=BC=8C=E8=83=BD=E5=A4=9F=E9=9D=99?= =?UTF-8?q?=E6=80=81=E5=A3=B0=E6=98=8Ebitmap=20(#490)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 完成bitmap的static bitmap功能,能够静态声明bitmap --- kernel/Cargo.toml | 3 +- kernel/crates/bitmap/Cargo.toml | 8 + kernel/crates/bitmap/src/bitmap_core.rs | 266 ++++++++ kernel/crates/bitmap/src/lib.rs | 9 + kernel/crates/bitmap/src/static_bitmap.rs | 119 ++++ kernel/crates/bitmap/src/traits.rs | 314 ++++++++++ kernel/crates/bitmap/tests/static-bitmap.rs | 645 ++++++++++++++++++++ 7 files changed, 1363 insertions(+), 1 deletion(-) create mode 100644 kernel/crates/bitmap/Cargo.toml create mode 100644 kernel/crates/bitmap/src/bitmap_core.rs create mode 100644 kernel/crates/bitmap/src/lib.rs create mode 100644 kernel/crates/bitmap/src/static_bitmap.rs create mode 100644 kernel/crates/bitmap/src/traits.rs create mode 100644 kernel/crates/bitmap/tests/static-bitmap.rs diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 23f5b7bf..efe68154 100644 --- a/kernel/Cargo.toml +++ b/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" diff --git a/kernel/crates/bitmap/Cargo.toml b/kernel/crates/bitmap/Cargo.toml new file mode 100644 index 00000000..d58d65f2 --- /dev/null +++ b/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] diff --git a/kernel/crates/bitmap/src/bitmap_core.rs b/kernel/crates/bitmap/src/bitmap_core.rs new file mode 100644 index 00000000..409ba0f0 --- /dev/null +++ b/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 { + phantom: PhantomData, +} + +impl BitMapCore { + pub const fn new() -> Self { + Self { + phantom: PhantomData, + } + } + + /// 获取位图中的某一位 + pub(crate) fn get(&self, data: &[T], index: usize) -> Option { + 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 = ::get(element, bit_index); + + Some(bit) + } + + /// 设置位图中的某一位 + pub(crate) fn set(&self, data: &mut [T], index: usize, value: bool) -> Option { + 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 = ::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 { + for (i, element) in data.iter().enumerate() { + let bit = ::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 { + for (i, element) in data.iter().enumerate() { + if let Some(bit) = ::first_false_index(element) { + return self.make_index(i * T::bit_size() + bit); + } + } + + None + } + + /// 获取位图中最后一个为1的位 + pub(crate) fn last_index(&self, data: &[T]) -> Option { + for (i, element) in data.iter().enumerate().rev() { + if let Some(bit) = ::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 { + 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() { + ::invert(&mut mask); + + last_element |= mask; + } + + if let Some(bit) = ::last_false_index(&last_element) { + return self.make_index((data.len() - 1) * T::bit_size() + bit); + } + + for element in iter { + if let Some(bit) = ::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 { + 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) = ::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) = ::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 { + 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) = ::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) = ::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 { + 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) = ::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) = ::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 { + let element_index = index / T::bit_size(); + let bit_index = index % T::bit_size(); + + let element = data.get(element_index)?; + if let Some(bit) = ::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) = ::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() { + ::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 { + if unlikely(index >= N) { + return None; + } + + Some(index) + } +} diff --git a/kernel/crates/bitmap/src/lib.rs b/kernel/crates/bitmap/src/lib.rs new file mode 100644 index 00000000..7aeb76db --- /dev/null +++ b/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; diff --git a/kernel/crates/bitmap/src/static_bitmap.rs b/kernel/crates/bitmap/src/static_bitmap.rs new file mode 100644 index 00000000..547b5f55 --- /dev/null +++ b/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 +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, +} + +impl StaticBitmap +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 BitMapOps for StaticBitmap +where + [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:, +{ + #[inline] + fn get(&self, index: usize) -> Option { + return self.core.get(&self.data, index); + } + + #[inline] + fn set(&mut self, index: usize, value: bool) -> Option { + 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::() + } + + #[inline] + fn first_index(&self) -> Option { + self.core.first_index(&self.data) + } + + #[inline] + fn first_false_index(&self) -> Option { + self.core.first_false_index(&self.data) + } + + #[inline] + fn last_index(&self) -> Option { + self.core.last_index(&self.data) + } + + #[inline] + fn last_false_index(&self) -> Option { + self.core.last_false_index(&self.data) + } + + #[inline] + fn next_index(&self, index: usize) -> Option { + self.core.next_index(&self.data, index) + } + + #[inline] + fn next_false_index(&self, index: usize) -> Option { + self.core.next_false_index(&self.data, index) + } + + #[inline] + fn prev_index(&self, index: usize) -> Option { + self.core.prev_index(&self.data, index) + } + + #[inline] + fn prev_false_index(&self, index: usize) -> Option { + 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::(), + ) + } + + fn set_all(&mut self, value: bool) { + self.core.set_all(&mut self.data, value); + } +} diff --git a/kernel/crates/bitmap/src/traits.rs b/kernel/crates/bitmap/src/traits.rs new file mode 100644 index 00000000..3db91543 --- /dev/null +++ b/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; + fn first_false_index(bits: &Self) -> Option; + fn last_index(bits: &Self) -> Option; + fn last_false_index(bits: &Self) -> Option; + fn next_index(bits: &Self, index: usize) -> Option; + fn next_false_index(bits: &Self, index: usize) -> Option; + fn prev_index(bits: &Self, index: usize) -> Option; + fn prev_false_index(bits: &Self, index: usize) -> Option; + 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 { + if *bits == 0 { + None + } else { + Some(bits.trailing_zeros() as usize) + } + } + + #[inline] + fn first_false_index(bits: &Self) -> Option { + if *bits == <$target>::MAX { + None + } else { + Some(bits.trailing_ones() as usize) + } + } + + #[inline] + fn last_index(bits: &Self) -> Option { + if *bits == 0 { + None + } else { + Some(<$target>::BITS as usize - 1 - (bits.leading_zeros() as usize)) + } + } + + #[inline] + fn last_false_index(bits: &Self) -> Option { + 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 { + 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 { + 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 { + 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 { + 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 { + /// 获取指定index的位 + /// + /// ## 返回 + /// + /// - `Some(true)` - 该位为1 + /// - `Some(false)` - 该位为0 + /// - `None` - index超出范围 + fn get(&self, index: usize) -> Option; + + /// 设置指定index的位,并返回该位之前的值 + /// + /// ## 参数 + /// + /// - `index` - 位的index + /// - `value` - 位的新值 + /// + /// ## 返回 + /// + /// - `Some(true)` - 该位之前为1 + /// - `Some(false)` - 该位之前为0 + /// - `None` - index超出范围 + fn set(&mut self, index: usize, value: bool) -> Option; + + /// 将所有位设置为指定值 + 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; + + /// 获取第一个为0的位的index + /// + /// ## 返回 + /// + /// - `Some(index)` - 第一个为0的位的index + /// - `None` - 不存在为0的位 + fn first_false_index(&self) -> Option; + + /// 获取最后一个为1的位的index + /// + /// ## 返回 + /// + /// - `Some(index)` - 最后一个为1的位的index + /// - `None` - 不存在为1的位 + fn last_index(&self) -> Option; + + /// 获取最后一个为0的位的index + /// + /// ## 返回 + /// + /// - `Some(index)` - 最后一个为0的位的index + /// - `None` - 不存在为0的位 + fn last_false_index(&self) -> Option; + + /// 获取指定index之后第一个为1的位的index + fn next_index(&self, index: usize) -> Option; + + /// 获取指定index之后第一个为0的位的index + fn next_false_index(&self, index: usize) -> Option; + + /// 获取指定index之前第一个为1的位的index + fn prev_index(&self, index: usize) -> Option; + + /// 获取指定index之前第一个为0的位的index + fn prev_false_index(&self, index: usize) -> Option; + + /// 反转bitmap + fn invert(&mut self); + + /// 判断bitmap是否满了 + fn is_full(&self) -> bool; + + /// 判断bitmap是否为空 + fn is_empty(&self) -> bool; + + /// 将bitmap转换为字节数组 + unsafe fn as_bytes(&self) -> &[u8]; +} diff --git a/kernel/crates/bitmap/tests/static-bitmap.rs b/kernel/crates/bitmap/tests/static-bitmap.rs new file mode 100644 index 00000000..4fb34a11 --- /dev/null +++ b/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); +}