use bondrewd::*;
#[derive(Eq, PartialEq, Clone, Debug, BitfieldEnum)]
#[bondrewd_enum(u8)]
enum TestCustomEnum {
CustomZero = 0x30,
CustomOne = 0x10,
CustomTwo = 0x20,
CustomThree = 0x40,
Invalid,
}
#[derive(Bitfields, Clone, PartialEq, Eq, Debug)]
#[bondrewd(default_endianness = "be")]
struct SimpleCustomEnumUsage {
one: u8,
#[bondrewd(enum_primitive = "u8", bit_length = 8)]
two: TestCustomEnum,
three: u8,
}
#[test]
fn to_bytes_simple_with_custom_enum_spanning() -> anyhow::Result<()> {
let simple = SimpleCustomEnumUsage {
one: 0x08,
two: TestCustomEnum::CustomThree,
three: 0,
};
assert_eq!(SimpleCustomEnumUsage::BYTE_SIZE, 3);
let bytes = simple.clone().into_bytes();
assert_eq!(bytes.len(), 3);
assert_eq!(bytes[0], 0b00001000);
assert_eq!(bytes[1], 0b01000000);
#[cfg(feature = "slice_fns")]
{
assert_eq!(simple.one, SimpleCustomEnumUsage::read_slice_one(&bytes)?);
assert_eq!(simple.two, SimpleCustomEnumUsage::read_slice_two(&bytes)?);
assert_eq!(
simple.three,
SimpleCustomEnumUsage::read_slice_three(&bytes)?
);
}
let new_simple = SimpleCustomEnumUsage::from_bytes(bytes);
assert_eq!(simple, new_simple);
Ok(())
}
#[derive(Eq, PartialEq, Clone, Debug, BitfieldEnum)]
#[bondrewd_enum(u8)]
enum TestCustomContinuationEnum {
CustomZero = 0x7F,
CustomZeroContinued,
CustomOne = 0x3F,
CustomOneContinued,
Invalid,
}
#[derive(Bitfields, Clone, PartialEq, Eq, Debug)]
#[bondrewd(default_endianness = "be")]
struct SimpleCustomContinuationEnumUsage {
one: u8,
#[bondrewd(enum_primitive = "u8", bit_length = 8)]
two: TestCustomContinuationEnum,
three: u8,
}
#[test]
fn enum_contiunation_tests() -> anyhow::Result<()> {
let simple = SimpleCustomContinuationEnumUsage {
one: 0x80,
two: TestCustomContinuationEnum::CustomOneContinued,
three: 0x08,
};
assert_eq!(SimpleCustomContinuationEnumUsage::BYTE_SIZE, 3);
let mut bytes = simple.clone().into_bytes();
assert_eq!(bytes.len(), 3);
assert_eq!(bytes[0], 0b10000000);
assert_eq!(bytes[1], 0b00000001);
assert_eq!(bytes[2], 0b00001000);
#[cfg(feature = "slice_fns")]
{
assert_eq!(
simple.one,
SimpleCustomContinuationEnumUsage::read_slice_one(&bytes)?
);
assert_eq!(
simple.two,
SimpleCustomContinuationEnumUsage::read_slice_two(&bytes)?
);
assert_eq!(
simple.three,
SimpleCustomContinuationEnumUsage::read_slice_three(&bytes)?
);
}
let new_simple = SimpleCustomContinuationEnumUsage::from_bytes(bytes);
assert_eq!(simple, new_simple);
SimpleCustomContinuationEnumUsage::write_slice_two(
&mut bytes,
TestCustomContinuationEnum::CustomZeroContinued,
)?;
let expected = SimpleCustomContinuationEnumUsage {
one: 0x80,
two: TestCustomContinuationEnum::CustomZeroContinued,
three: 0x08,
};
assert_eq!(
SimpleCustomContinuationEnumUsage::from_bytes(bytes),
expected
);
Ok(())
}