#[cfg(test)]
mod tests {
use bitmask_enum::bitmask;
#[bitmask]
enum Bitmask {
Flag1,
Flag2,
Flag3,
Flag4,
Flag5,
Flag6,
Flag7,
Flag8,
}
#[test]
fn test() {
let mut bm = Bitmask::none();
assert_eq!(bm, 0);
bm |= Bitmask::Flag5;
assert_eq!(bm, Bitmask::Flag5);
bm |= Bitmask::Flag1 | Bitmask::Flag8;
assert_eq!(bm, 0b10010001);
bm &= !Bitmask::Flag1 & !Bitmask::Flag5;
assert_eq!(bm, 0b10000000);
bm |= !Bitmask::Flag8;
assert_eq!(bm.is_all_bits(), true);
}
#[test]
fn test_bits() {
let all = Bitmask::all_bits();
assert_eq!(all.bits(), std::usize::MAX);
}
#[test]
fn test_all_bits() {
let all = Bitmask::all_bits();
assert_eq!(all.is_all_bits(), true);
assert_eq!(all, std::usize::MAX);
}
#[test]
fn test_none() {
let none = Bitmask::none();
assert_eq!(none.is_none(), true);
assert_eq!(none, std::usize::MIN);
}
#[test]
fn test_all_flags() {
let all_flags = Bitmask::all_flags();
assert_eq!(all_flags.is_all_flags(), true);
assert_eq!(
all_flags,
Bitmask::Flag1
| Bitmask::Flag2
| Bitmask::Flag3
| Bitmask::Flag4
| Bitmask::Flag5
| Bitmask::Flag6
| Bitmask::Flag7
| Bitmask::Flag8
);
}
#[test]
fn test_truncate() {
let all = Bitmask::all_bits();
assert_eq!(all.is_all_bits(), true);
assert_eq!(all.is_all_flags(), false);
assert_eq!(all.truncate().is_all_flags(), true);
}
#[test]
fn test_intersects() {
let bm = Bitmask::Flag4;
assert_eq!(bm.intersects(Bitmask::Flag4), true);
assert_eq!(bm.intersects(Bitmask::Flag4 | Bitmask::Flag1), true);
assert_eq!(bm.intersects(Bitmask::Flag1), false);
}
#[test]
fn test_contains() {
let bm = Bitmask::Flag4 | Bitmask::Flag6;
assert_eq!(bm.contains(Bitmask::Flag4), true);
assert_eq!(bm.contains(Bitmask::Flag4 | Bitmask::Flag6), true);
assert_eq!(bm.contains(Bitmask::Flag1), false);
assert_eq!(bm.contains(Bitmask::Flag4 | Bitmask::Flag1), false);
}
#[test]
fn test_from() {
let mask: usize = 0b100010;
let bm = Bitmask::from(mask);
assert_eq!(bm, Bitmask::Flag2 | Bitmask::Flag6);
let value: usize = bm.into();
assert_eq!(value, mask);
}
#[test]
fn test_types() {
#[bitmask(usize)]
enum BitmaskUsize {
Flag1,
Flag2,
}
assert_eq!(BitmaskUsize::Flag1, 0b01);
assert_eq!(BitmaskUsize::Flag2, 0b10);
#[bitmask(u8)]
enum BitmaskU8 {
Flag1,
Flag2,
}
assert_eq!(BitmaskU8::Flag1, 0b01);
assert_eq!(BitmaskU8::Flag2, 0b10);
#[bitmask(u16)]
enum BitmaskU16 {
Flag1,
Flag2,
}
assert_eq!(BitmaskU16::Flag1, 0b01);
assert_eq!(BitmaskU16::Flag2, 0b10);
#[bitmask(u32)]
enum BitmaskU32 {
Flag1,
Flag2,
}
assert_eq!(BitmaskU32::Flag1, 0b01);
assert_eq!(BitmaskU32::Flag2, 0b10);
#[bitmask(u64)]
enum BitmaskU64 {
Flag1,
Flag2,
}
assert_eq!(BitmaskU64::Flag1, 0b01);
assert_eq!(BitmaskU64::Flag2, 0b10);
#[bitmask(u128)]
enum BitmaskU128 {
Flag1,
Flag2,
}
assert_eq!(BitmaskU128::Flag1, 0b01);
assert_eq!(BitmaskU128::Flag2, 0b10);
#[bitmask(isize)]
enum BitmaskIsize {
Flag1,
Flag2,
}
assert_eq!(BitmaskIsize::Flag1, 0b01);
assert_eq!(BitmaskIsize::Flag2, 0b10);
#[bitmask(i8)]
enum BitmaskI8 {
Flag1,
Flag2,
}
assert_eq!(BitmaskI8::Flag1, 0b01);
assert_eq!(BitmaskI8::Flag2, 0b10);
#[bitmask(i16)]
enum BitmaskI16 {
Flag1,
Flag2,
}
assert_eq!(BitmaskI16::Flag1, 0b01);
assert_eq!(BitmaskI16::Flag2, 0b10);
#[bitmask(i32)]
enum BitmaskI32 {
Flag1,
Flag2,
}
assert_eq!(BitmaskI32::Flag1, 0b01);
assert_eq!(BitmaskI32::Flag2, 0b10);
#[bitmask(i64)]
enum BitmaskI64 {
Flag1,
Flag2,
}
assert_eq!(BitmaskI64::Flag1, 0b01);
assert_eq!(BitmaskI64::Flag2, 0b10);
#[bitmask(i128)]
enum BitmaskI128 {
Flag1,
Flag2,
}
assert_eq!(BitmaskI128::Flag1, 0b01);
assert_eq!(BitmaskI128::Flag2, 0b10);
}
#[test]
fn test_custom() {
#[bitmask]
enum BitmaskCustom {
Flag1,
Flag2,
Flag12 = Self::Flag1.or(Self::Flag2).bits,
Flag3,
Flag123 = Self::Flag12.or(Self::Flag3).bits,
Flag4,
}
assert_eq!(BitmaskCustom::Flag1, 0b1);
assert_eq!(BitmaskCustom::Flag2, 0b10);
assert_eq!(BitmaskCustom::Flag12, 0b11);
assert_eq!(BitmaskCustom::Flag3, 0b100);
assert_eq!(BitmaskCustom::Flag123, 0b111);
assert_eq!(BitmaskCustom::Flag4, 0b1000);
#[bitmask(u8)]
enum BitmaskCustomTyped {
Flag1,
Flag2,
Flag12 = Self::Flag1.or(Self::Flag2).bits,
Flag3,
Flag123 = Self::Flag12.or(Self::Flag3).bits,
Flag4,
}
assert_eq!(BitmaskCustomTyped::Flag1, 0b1);
assert_eq!(BitmaskCustomTyped::Flag2, 0b10);
assert_eq!(BitmaskCustomTyped::Flag12, 0b11);
assert_eq!(BitmaskCustomTyped::Flag3, 0b100);
assert_eq!(BitmaskCustomTyped::Flag123, 0b111);
assert_eq!(BitmaskCustomTyped::Flag4, 0b1000);
}
#[test]
fn test_inverted() {
#[bitmask]
#[bitmask_config(inverted_flags)]
enum BitmaskInverted {
Flag1,
Flag2,
Flag3,
Flag4,
}
assert_eq!(
BitmaskInverted::InvertedFlag1,
BitmaskInverted::all_bits().xor(BitmaskInverted::Flag1)
);
assert_eq!(
BitmaskInverted::InvertedFlag2,
BitmaskInverted::all_bits().xor(BitmaskInverted::Flag2)
);
assert_eq!(
BitmaskInverted::InvertedFlag3,
BitmaskInverted::all_bits().xor(BitmaskInverted::Flag3)
);
assert_eq!(
BitmaskInverted::InvertedFlag4,
BitmaskInverted::all_bits().xor(BitmaskInverted::Flag4)
);
}
#[test]
fn test_type_with_inverted() {
#[bitmask(usize)]
#[bitmask_config(inverted_flags)]
enum BitmaskUsize {
Flag1,
Flag2,
}
assert_eq!(BitmaskUsize::InvertedFlag1, 0b01 ^ !0);
assert_eq!(BitmaskUsize::InvertedFlag2, 0b10 ^ !0);
#[bitmask(u8)]
#[bitmask_config(inverted_flags)]
enum BitmaskU8 {
Flag1,
Flag2,
}
assert_eq!(BitmaskU8::InvertedFlag1, 0b11111110);
assert_eq!(BitmaskU8::InvertedFlag2, 0b11111101);
#[bitmask(i16)]
#[bitmask_config(inverted_flags)]
enum BitmaskI16 {
Flag1,
Flag2,
}
assert_eq!(BitmaskI16::InvertedFlag1, 0b1111111111111110u16 as i16);
assert_eq!(BitmaskI16::InvertedFlag2, 0b1111111111111101u16 as i16);
}
#[test]
fn test_custom_inverted() {
#[bitmask]
#[bitmask_config(inverted_flags)]
enum BitmaskCustom {
Flag1,
Flag2,
Flag12 = Self::Flag1.or(Self::Flag2).bits,
Flag3,
Flag123 = Self::Flag12.or(Self::Flag3).bits,
Flag4,
}
assert_eq!(BitmaskCustom::Flag1, 0b1);
assert_eq!(BitmaskCustom::Flag2, 0b10);
assert_eq!(BitmaskCustom::Flag12, 0b11);
assert_eq!(BitmaskCustom::Flag3, 0b100);
assert_eq!(BitmaskCustom::Flag123, 0b111);
assert_eq!(BitmaskCustom::Flag4, 0b1000);
assert_eq!(BitmaskCustom::InvertedFlag1, !0b1);
assert_eq!(BitmaskCustom::InvertedFlag2, !0b10);
assert_eq!(BitmaskCustom::InvertedFlag12, !0b11);
assert_eq!(BitmaskCustom::InvertedFlag3, !0b100);
assert_eq!(BitmaskCustom::InvertedFlag123, !0b111);
assert_eq!(BitmaskCustom::InvertedFlag4, !0b1000);
#[bitmask(u8)]
#[bitmask_config(inverted_flags)]
enum BitmaskCustomTyped {
Flag1,
Flag2,
Flag12 = Self::Flag1.or(Self::Flag2).bits,
Flag3,
Flag123 = Self::Flag12.or(Self::Flag3).bits,
Flag4,
}
assert_eq!(BitmaskCustomTyped::Flag1, 0b1);
assert_eq!(BitmaskCustomTyped::Flag2, 0b10);
assert_eq!(BitmaskCustomTyped::Flag12, 0b11);
assert_eq!(BitmaskCustomTyped::Flag3, 0b100);
assert_eq!(BitmaskCustomTyped::Flag123, 0b111);
assert_eq!(BitmaskCustomTyped::Flag4, 0b1000);
assert_eq!(BitmaskCustomTyped::InvertedFlag1, !0b1);
assert_eq!(BitmaskCustomTyped::InvertedFlag2, !0b10);
assert_eq!(BitmaskCustomTyped::InvertedFlag12, !0b11);
assert_eq!(BitmaskCustomTyped::InvertedFlag3, !0b100);
assert_eq!(BitmaskCustomTyped::InvertedFlag123, !0b111);
assert_eq!(BitmaskCustomTyped::InvertedFlag4, !0b1000);
}
#[test]
fn test_vec_debug() {
#[bitmask]
#[bitmask_config(vec_debug)]
pub enum BitmaskVecDebug {
Flag1,
Flag2,
Flag12 = Self::Flag1.or(Self::Flag2).bits,
Flag3,
}
assert_eq!(
format!("{:?}", BitmaskVecDebug::none()),
"BitmaskVecDebug[]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag1),
"BitmaskVecDebug[Flag1]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag2),
"BitmaskVecDebug[Flag2]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag12),
"BitmaskVecDebug[Flag1, Flag2, Flag12]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag3),
"BitmaskVecDebug[Flag3]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag2.or(BitmaskVecDebug::Flag3)),
"BitmaskVecDebug[Flag2, Flag3]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::all_flags()),
"BitmaskVecDebug[Flag1, Flag2, Flag12, Flag3]"
);
assert_eq!(format!("{:?}", Bitmask::none()), "Bitmask { bits: 0 }");
assert_eq!(format!("{:?}", Bitmask::Flag1), "Bitmask { bits: 1 }");
assert_eq!(format!("{:?}", Bitmask::Flag2), "Bitmask { bits: 2 }");
assert_eq!(
format!("{:?}", Bitmask::Flag1.or(Bitmask::Flag2)),
"Bitmask { bits: 3 }"
);
assert_eq!(format!("{:?}", Bitmask::Flag3), "Bitmask { bits: 4 }");
}
#[test]
fn test_vec_debug_inverted() {
#[bitmask(u8)]
#[bitmask_config(vec_debug, inverted_flags)]
pub enum BitmaskVecDebug {
Flag1,
Flag2,
}
assert_eq!(
format!("{:?}", BitmaskVecDebug::none()),
"BitmaskVecDebug[]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag1),
"BitmaskVecDebug[Flag1]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::Flag2),
"BitmaskVecDebug[Flag2]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::InvertedFlag1),
"BitmaskVecDebug[InvertedFlag1, Flag2]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::InvertedFlag2),
"BitmaskVecDebug[Flag1, InvertedFlag2]"
);
assert_eq!(
format!("{:?}", BitmaskVecDebug::all_flags()),
"BitmaskVecDebug[Flag1, InvertedFlag1, Flag2, InvertedFlag2]"
);
}
#[test]
fn test_import_debug() {
#[allow(unused)]
use std::fmt::Debug;
#[bitmask]
pub enum BitmaskImportDebug {
Flag1,
Flag2,
}
}
#[test]
fn test_fields_iter() {
#[bitmask(u8)]
#[bitmask_config(flags_iter)]
pub enum BitmaskFlagsIter {
Flag1,
Flag2,
Flag3,
FlagCustom = 123,
}
assert_eq!(
BitmaskFlagsIter::flags().copied().collect::<Vec<_>>(),
vec![
("Flag1", BitmaskFlagsIter::Flag1),
("Flag2", BitmaskFlagsIter::Flag2),
("Flag3", BitmaskFlagsIter::Flag3),
("FlagCustom", BitmaskFlagsIter::FlagCustom),
],
);
}
#[test]
fn test_fields_iter_inverted() {
#[bitmask(u8)]
#[bitmask_config(flags_iter, inverted_flags)]
pub enum BitmaskFlagsIter {
Flag1,
FlagCustom = 123,
}
assert_eq!(
BitmaskFlagsIter::flags().copied().collect::<Vec<_>>(),
vec![
("Flag1", BitmaskFlagsIter::Flag1),
("InvertedFlag1", BitmaskFlagsIter::InvertedFlag1),
("FlagCustom", BitmaskFlagsIter::FlagCustom),
("InvertedFlagCustom", BitmaskFlagsIter::InvertedFlagCustom),
],
);
}
}