#[cfg(test)]
mod base {
extern crate cbitmap;
use cbitmap::bitmap::*;
#[test]
fn advanced_op() {
let mut map = newmap!(;16);
assert_eq!(map.find_first_one(), None);
map.set(10);
assert_eq!(map.find_first_one(), Some(10));
map.set(7);
assert_eq!(map.find_first_one(), Some(7));
map.set(0);
assert_eq!(map.find_first_one(), Some(0));
map.set_all();
assert_eq!(map.find_first_zero(), None);
map.reset(10);
assert_eq!(map.find_first_zero(), Some(10));
map.reset(7);
assert_eq!(map.find_first_zero(), Some(7));
map.reset(0);
assert_eq!(map.find_first_zero(), Some(0));
let mut map = newmap!(;64);
assert_eq!(map.count(), 0);
let some = [0b11, 0b110, 0b101, 0b1010, 0b1111, 0b1, 0b10000, 0b01];
map.fill_prefix(some);
assert_eq!(map.count(), 15);
map.flip_all();
assert_eq!(map.count(), 49);
map.set_all();
assert_eq!(map.count(), 64);
}
#[test]
fn base_op() {
let mut bitmap: Bitmap<2> = Default::default();
assert_eq!(bitmap.get_bool(0), false);
assert_eq!(bitmap.get_01(4), 0);
bitmap.set(7);
bitmap.set(8);
assert_eq!(bitmap.get_bool(7), true);
assert_eq!(bitmap.get_01(8), 1);
bitmap.reset(7);
assert_eq!(bitmap.get_bool(7), false);
bitmap.flip(8);
assert_eq!(bitmap.get_bool(8), false);
bitmap.flip(9);
assert_eq!(bitmap.get_bool(9), true);
bitmap.set_all();
assert_eq!(&bitmap.range_to_string(0, 16).unwrap(), "11111111 11111111");
bitmap.reset_all();
assert_eq!(&bitmap.range_to_string(0, 16).unwrap(), "00000000 00000000");
bitmap.set(1).set(5).set(12);
assert_eq!(bitmap.range_to_string(0, 0), None);
assert_eq!(&bitmap.range_to_string(5, 6).unwrap(), "1");
assert_eq!(&bitmap.range_to_string(7, 8).unwrap(), "0");
assert_eq!(&bitmap.range_to_string(7, 9).unwrap(), "0 0");
bitmap.flip_all();
assert_eq!(&bitmap.range_to_string(0, 16).unwrap(), "11101111 11011101");
}
#[test]
fn from_into() {
let map0 = Bitmap::<0>::from([]);
assert_eq!(Into::<[u8; 0]>::into(map0), []);
let map1 = Bitmap::<1>::from(0b00001010);
assert_eq!(Into::<[u8; 1]>::into(map1), [0b00001010u8; 1]);
let map2 = Bitmap::<2>::from(0b00001111_00001010);
assert_eq!(Into::<[u8; 2]>::into(map2), [0b00001010u8, 0b00001111]);
let u = 0u8;
let mut map3: Bitmap<4> = [u, u, u, u].into();
map3.flip_all();
assert_eq!(Into::<[u8; 4]>::into(map3), [255; 4]);
}
#[test]
fn ref_refmut() {
let mut bitmap = Bitmap::<2>::new();
{
let mut bitmut = bitmap.at_mut(7);
assert_eq!(*bitmut, false);
bitmut.set();
assert_eq!(*bitmut, true);
assert_eq!(Into::<bool>::into(bitmut), true);
}
assert_eq!(bitmap.get_bool(7), true);
{
let bit = bitmap.at(7);
assert_eq!(*bit, true);
assert_eq!(Into::<bool>::into(bit), true);
}
{
let mut bitmut = bitmap.at_mut(7);
assert_eq!(*bitmut, true);
bitmut.reset();
assert_eq!(*bitmut, false);
assert_eq!(Into::<bool>::into(bitmut), false);
}
{
let bit = bitmap.at(7);
assert_eq!(*bit, false);
assert_eq!(Into::<bool>::into(bit), false);
}
{
let mut bitmut = bitmap.at_mut(7);
bitmut.flip();
assert_eq!(*bitmut, true);
}
assert_eq!(bitmap.get_bool(7), true);
{
let mut bitmut = bitmap.at_mut(4);
bitmut.reset().flip();
}
assert_eq!(bitmap.get_bool(4), true);
}
#[test]
fn and_or() {
let mut bitmap = Bitmap::<16>::new();
bitmap |= 0b_10100010_u8;
assert_eq!(bitmap.get_01(0), 0);
assert_eq!(bitmap.get_01(1), 1);
assert_eq!(bitmap.get_01(2), 0);
assert_eq!(bitmap.get_01(3), 0);
assert_eq!(bitmap.get_01(4), 0);
assert_eq!(bitmap.get_01(5), 1);
assert_eq!(bitmap.get_01(6), 0);
assert_eq!(bitmap.get_01(7), 1);
bitmap |= (0b_11000000 << 8) as u16;
assert_eq!(bitmap.get_01(14), 1);
assert_eq!(bitmap.get_01(15), 1);
bitmap |= (0b_00110000_00000011 << 16) as u32;
assert_eq!(bitmap.get_01(16), 1);
assert_eq!(bitmap.get_01(17), 1);
assert_eq!(bitmap.get_01(28), 1);
assert_eq!(bitmap.get_01(29), 1);
bitmap |= 1u64 << 32;
assert_eq!(bitmap.get_01(32), 1);
bitmap |= 1u128 << 100;
assert_eq!(bitmap.get_01(100), 1);
assert_eq!(&bitmap & (1u128 << 100), 1u128 << 100);
assert_eq!(&bitmap & (1u128 << 99), 0);
assert_eq!(
&bitmap & (0b_10001000_11000010_u16),
0b_10000000_10000010_u16
);
bitmap |= [0b_10101010_u8; 15];
assert_eq!(&bitmap & [0b_10001000_u8; 10], [0b_10001000_u8; 10]);
bitmap.set(127);
bitmap &= [0b_10000000_u8; 15];
assert_eq!(&bitmap & [0b_11111111_u8; 15], [0b_10000000_u8; 15]);
assert_eq!(bitmap.get_bool(127), false);
bitmap.set_all();
bitmap &= u128::MAX;
assert_eq!(bitmap.get_bool(127), true);
bitmap &= u64::MAX;
assert_eq!(bitmap.get_bool(127), false);
assert_eq!(bitmap.get_bool(63), true);
bitmap &= u32::MAX;
assert_eq!(bitmap.get_bool(63), false);
assert_eq!(bitmap.get_bool(31), true);
bitmap &= u16::MAX;
assert_eq!(bitmap.get_bool(31), false);
assert_eq!(bitmap.get_bool(15), true);
bitmap &= u8::MAX;
assert_eq!(bitmap.get_bool(15), false);
assert_eq!(bitmap.get_bool(7), true);
}
#[test]
fn test_macro() {
let map = newmap!();
assert_eq!(map.bit_len(), 0);
let map = newmap!(;35);
assert_eq!(map.bit_len(), 40);
let map = newmap!(1u8 | 0b100000u128; 48);
assert_eq!(map.bit_len(), 48);
assert_eq!(map.get_bool(0), true);
assert_eq!(map.get_bool(5), true);
let a = 1u64 << 34;
let b = 1u128 << 47;
let map = newmap!(a | b; 48);
assert_eq!(map.get_bool(34), true);
assert_eq!(map.get_bool(47), true);
let map = he_lang!(1 | 2; 8);
assert_eq!(map.get_bool(1), true);
assert_eq!(map.get_bool(2), true);
}
#[test]
fn test_mem() {
use core::mem::*;
let map = newmap!();
assert_eq!(size_of_val(&map), 0);
let map = newmap!(;48);
assert_eq!(size_of_val(&map), 6);
let page = Box::new(newmap!(;4096 * 8));
assert_eq!(size_of_val(&page), 8);
assert_eq!(size_of_val(&*page), 4096);
}
}