360 lines
12 KiB
Rust
360 lines
12 KiB
Rust
use enumset::*;
|
|
|
|
macro_rules! read_slice {
|
|
($set:expr, $size:expr) => {{
|
|
let mut arr = [0; $size];
|
|
$set.copy_into_slice(&mut arr);
|
|
arr
|
|
}};
|
|
}
|
|
|
|
macro_rules! try_read_slice {
|
|
($set:expr, $size:expr) => {{
|
|
let mut arr = [0; $size];
|
|
match $set.try_copy_into_slice(&mut arr) {
|
|
Some(()) => Some(arr),
|
|
None => None,
|
|
}
|
|
}};
|
|
}
|
|
|
|
macro_rules! read_slice_truncated {
|
|
($set:expr, $size:expr) => {{
|
|
let mut arr = [0; $size];
|
|
$set.copy_into_slice_truncated(&mut arr);
|
|
arr
|
|
}};
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum8 {
|
|
A, B, C, D, E, F, G,
|
|
// H omitted for non-existent bit test
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum16 {
|
|
A, B, C, D, E=8, F, G, H,
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum32 {
|
|
A, B, C, D, E=16, F, G, H,
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum64 {
|
|
A, B, C, D, E=32, F, G, H,
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum128 {
|
|
A, B, C, D, E=64, F, G, H,
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum192 {
|
|
A, B, C, D, E=128, F, G, H,
|
|
}
|
|
|
|
#[derive(EnumSetType, Debug)]
|
|
pub enum Enum256 {
|
|
A, B, C, D, E=192, F, G, H,
|
|
}
|
|
|
|
macro_rules! check_simple_conversion {
|
|
($mod:ident, $e:ident) => {
|
|
mod $mod {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn to_integer() {
|
|
assert_eq!(7,
|
|
($e::A | $e::B | $e::C).as_u8());
|
|
assert_eq!(7,
|
|
($e::A | $e::B | $e::C).as_u16());
|
|
assert_eq!(7,
|
|
($e::A | $e::B | $e::C).as_u32());
|
|
assert_eq!(7,
|
|
($e::A | $e::B | $e::C).as_u64());
|
|
assert_eq!(7,
|
|
($e::A | $e::B | $e::C).as_u128());
|
|
assert_eq!(7,
|
|
($e::A | $e::B | $e::C).as_usize());
|
|
}
|
|
|
|
#[test]
|
|
fn try_from_integer() {
|
|
assert_eq!(Some($e::A | $e::B | $e::C),
|
|
EnumSet::try_from_u8(7));
|
|
assert_eq!(None,
|
|
EnumSet::<$e>::try_from_u8(7 | (1 << 7)));
|
|
assert_eq!(None,
|
|
EnumSet::<$e>::try_from_u16(7 | (1 << 15)));
|
|
assert_eq!(None,
|
|
EnumSet::<$e>::try_from_u32(7 | (1 << 31)));
|
|
assert_eq!(None,
|
|
EnumSet::<$e>::try_from_usize(7 | (1 << 31)));
|
|
assert_eq!(None,
|
|
EnumSet::<$e>::try_from_u64(7 | (1 << 63)));
|
|
assert_eq!(None,
|
|
EnumSet::<$e>::try_from_u128(7 | (1 << 127)));
|
|
}
|
|
|
|
#[test]
|
|
fn from_integer_truncated() {
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_u8_truncated(7));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_u8_truncated(7 | (1 << 7)));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_u16_truncated(7 | (1 << 15)));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_u32_truncated(7 | (1 << 31)));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_usize_truncated(7 | (1 << 31)));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_u64_truncated(7 | (1 << 63)));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::from_u128_truncated(7 | (1 << 127)));
|
|
}
|
|
|
|
#[test]
|
|
fn basic_to_array() {
|
|
// array tests
|
|
assert_eq!(($e::A | $e::B | $e::C).as_array_truncated(),
|
|
[]);
|
|
assert_eq!(EnumSet::<$e>::EMPTY.as_array_truncated(),
|
|
[]);
|
|
assert_eq!(($e::A | $e::B | $e::C).as_array(),
|
|
[7]);
|
|
assert_eq!(($e::A | $e::B | $e::C).as_array(),
|
|
[7, 0]);
|
|
assert_eq!(($e::A | $e::B | $e::C).as_array(),
|
|
[7, 0, 0]);
|
|
assert_eq!(($e::A | $e::B | $e::C).as_array(),
|
|
[7, 0, 0, 0]);
|
|
assert_eq!(($e::A | $e::B | $e::C).as_array(),
|
|
[7, 0, 0, 0, 0]);
|
|
|
|
// slice tests
|
|
assert_eq!(read_slice!($e::A | $e::B | $e::C, 1),
|
|
[7]);
|
|
assert_eq!(read_slice!($e::A | $e::B | $e::C, 2),
|
|
[7, 0]);
|
|
assert_eq!(read_slice!($e::A | $e::B | $e::C, 3),
|
|
[7, 0, 0]);
|
|
assert_eq!(read_slice!($e::A | $e::B | $e::C, 4),
|
|
[7, 0, 0, 0]);
|
|
assert_eq!(read_slice!($e::A | $e::B | $e::C, 5),
|
|
[7, 0, 0, 0, 0]);
|
|
|
|
// slice tests truncated
|
|
assert_eq!(read_slice_truncated!($e::A | $e::B | $e::C, 1),
|
|
[7]);
|
|
assert_eq!(read_slice_truncated!($e::A | $e::B | $e::C, 2),
|
|
[7, 0]);
|
|
assert_eq!(read_slice_truncated!($e::A | $e::B | $e::C, 3),
|
|
[7, 0, 0]);
|
|
assert_eq!(read_slice_truncated!($e::A | $e::B | $e::C, 4),
|
|
[7, 0, 0, 0]);
|
|
assert_eq!(read_slice_truncated!($e::A | $e::B | $e::C, 5),
|
|
[7, 0, 0, 0, 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_from_array() {
|
|
// array tests
|
|
assert_eq!(EnumSet::<$e>::EMPTY,
|
|
EnumSet::<$e>::from_array([]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array([7]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array([7, 0, 0]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array([7, 0, 0, 0]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array([7, 0, 0, 0, 0]));
|
|
|
|
// array tests
|
|
assert_eq!(EnumSet::<$e>::EMPTY,
|
|
EnumSet::<$e>::from_slice(&[]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice(&[7]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice(&[7, 0, 0]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice(&[7, 0, 0, 0]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice(&[7, 0, 0, 0, 0]));
|
|
}
|
|
|
|
#[test]
|
|
fn basic_from_array_truncated() {
|
|
// array tests
|
|
assert_eq!(EnumSet::<$e>::EMPTY,
|
|
EnumSet::<$e>::from_array_truncated([]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array_truncated([7 | (1 << 31)]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array_truncated([7, 0, 16]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array_truncated([7, 0, 0, 16]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_array_truncated([7, 0, 0, 0, 16]));
|
|
|
|
// array tests
|
|
assert_eq!(EnumSet::<$e>::EMPTY,
|
|
EnumSet::<$e>::from_slice_truncated(&[]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice_truncated(&[7 | (1 << 31)]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice_truncated(&[7, 0, 16]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice_truncated(&[7, 0, 0, 16]));
|
|
assert_eq!($e::A | $e::B | $e::C,
|
|
EnumSet::<$e>::from_slice_truncated(&[7, 0, 0, 0, 16]));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_u8() {
|
|
EnumSet::<$e>::from_u8(7 | (1 << 7));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_u16() {
|
|
EnumSet::<$e>::from_u16(7 | (1 << 15));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_u32() {
|
|
EnumSet::<$e>::from_u32(7 | (1 << 31));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_usize() {
|
|
EnumSet::<$e>::from_usize(7 | (1 << 31));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_u64() {
|
|
EnumSet::<$e>::from_u64(7 | (1 << 63));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_u128() {
|
|
EnumSet::<$e>::from_u128(7 | (1 << 127));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_to_array() {
|
|
($e::A | $e::B | $e::C).as_array::<0>();
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_to_slice() {
|
|
read_slice!($e::A | $e::B | $e::C, 0);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_array_1() {
|
|
EnumSet::<$e>::from_array([7 | (1 << 63), 0, 0, 0]);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_slice_1() {
|
|
EnumSet::<$e>::from_slice(&[7 | (1 << 63), 0, 0, 0]);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_array_2() {
|
|
EnumSet::<$e>::from_array([7, 0, 0, 0, 1]);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_from_slice_2() {
|
|
EnumSet::<$e>::from_slice(&[7, 0, 0, 0, 1]);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
check_simple_conversion!(enum_8_simple, Enum8);
|
|
check_simple_conversion!(enum_16_simple, Enum16);
|
|
check_simple_conversion!(enum_32_simple, Enum32);
|
|
check_simple_conversion!(enum_64_simple, Enum64);
|
|
check_simple_conversion!(enum_128_simple, Enum128);
|
|
check_simple_conversion!(enum_192_simple, Enum192);
|
|
check_simple_conversion!(enum_256_simple, Enum256);
|
|
|
|
macro_rules! check_oversized_64 {
|
|
($mod:ident, $e:ident) => {
|
|
mod $mod {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn downcast_to_u64() {
|
|
assert_eq!(Some(7), ($e::A | $e::B | $e::C).try_as_u64());
|
|
assert_eq!(Some([7]), ($e::A | $e::B | $e::C).try_as_array());
|
|
assert_eq!(Some([7]), try_read_slice!($e::A | $e::B | $e::C, 1));
|
|
|
|
assert_eq!(None, ($e::E | $e::F | $e::G).try_as_u64());
|
|
assert_eq!(None, ($e::E | $e::F | $e::G).try_as_array::<1>());
|
|
assert_eq!(None, try_read_slice!($e::E | $e::F | $e::G, 1));
|
|
}
|
|
|
|
#[test]
|
|
fn downcast_to_u64_truncated() {
|
|
assert_eq!(0, ($e::E | $e::F | $e::G).as_u64_truncated());
|
|
assert_eq!([0], ($e::E | $e::F | $e::G).as_array_truncated());
|
|
assert_eq!([0], read_slice_truncated!($e::E | $e::F | $e::G, 1));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_to_u64() {
|
|
($e::E | $e::F | $e::G).as_u64();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
check_oversized_64!(enum_128_oversized_64, Enum128);
|
|
check_oversized_64!(enum_192_oversized_64, Enum192);
|
|
check_oversized_64!(enum_256_oversized_64, Enum256);
|
|
|
|
macro_rules! check_oversized_128 {
|
|
($mod:ident, $e:ident) => {
|
|
mod $mod {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn downcast_to_u128() {
|
|
assert_eq!(Some(7), ($e::A | $e::B | $e::C).try_as_u128());
|
|
assert_eq!(None, ($e::E | $e::F | $e::G).try_as_u128());
|
|
assert_eq!(0, ($e::E | $e::F | $e::G).as_u128_truncated());
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn fail_to_u128() {
|
|
($e::E | $e::F | $e::G).as_u128();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
check_oversized_128!(enum_192_oversized_128, Enum192);
|
|
check_oversized_128!(enum_256_oversized_128, Enum256);
|