use crate::descriptor::cursor::{ByteCursor, ByteWriter};
use crate::{Error, Result};
pub(crate) const COMPOSITE_MEMBER_BYTE_LEN: usize = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum MemberRole {
Correction,
Base,
}
impl MemberRole {
#[inline]
pub fn wire_byte(self) -> u8 {
match self {
Self::Correction => 0x00,
Self::Base => 0x01,
}
}
#[inline]
pub fn from_wire(byte: u8) -> Result<Self> {
match byte {
0x00 => Ok(Self::Correction),
0x01 => Ok(Self::Base),
_ => Err(Error::InvalidMemberRole(byte)),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CompositeMemberDescriptor {
pub member_role: MemberRole,
}
impl CompositeMemberDescriptor {
pub fn new(member_role: MemberRole) -> Self {
Self { member_role }
}
pub(crate) fn encode_into(&self, w: &mut ByteWriter) {
let start = w.len();
w.write_u8(self.member_role.wire_byte());
w.write_zeros(15); debug_assert_eq!(
w.len() - start,
COMPOSITE_MEMBER_BYTE_LEN,
"composite member encoded size invariant violated"
);
}
pub(crate) fn decode_from(cursor: &mut ByteCursor<'_>) -> Result<Self> {
let role_byte = cursor.read_u8()?;
let member_role = MemberRole::from_wire(role_byte)?;
let reserved = cursor.read_bytes(15)?;
if reserved.iter().any(|&b| b != 0) {
return Err(Error::ReservedBytesNonZero {
field: "composite_member._reserved",
});
}
Ok(Self { member_role })
}
}
#[cfg(test)]
mod tests {
use super::*;
fn round_trip(desc: &CompositeMemberDescriptor) -> CompositeMemberDescriptor {
let mut w = ByteWriter::new();
desc.encode_into(&mut w);
let bytes = w.into_vec();
assert_eq!(bytes.len(), COMPOSITE_MEMBER_BYTE_LEN);
let mut c = ByteCursor::new(&bytes, bytes.len());
CompositeMemberDescriptor::decode_from(&mut c).unwrap()
}
#[test]
fn member_role_wire_round_trip() {
assert_eq!(MemberRole::Correction.wire_byte(), 0x00);
assert_eq!(MemberRole::Base.wire_byte(), 0x01);
assert_eq!(MemberRole::from_wire(0x00).unwrap(), MemberRole::Correction);
assert_eq!(MemberRole::from_wire(0x01).unwrap(), MemberRole::Base);
}
#[test]
fn member_role_rejects_reserved_bytes() {
for byte in [0x02_u8, 0x50, 0xFE, 0xFF] {
assert!(
matches!(MemberRole::from_wire(byte), Err(Error::InvalidMemberRole(b)) if b == byte),
"0x{byte:02X} should be rejected as InvalidMemberRole"
);
}
}
#[test]
fn composite_member_round_trip_correction() {
let desc = CompositeMemberDescriptor::new(MemberRole::Correction);
assert_eq!(round_trip(&desc), desc);
}
#[test]
fn composite_member_round_trip_base() {
let desc = CompositeMemberDescriptor::new(MemberRole::Base);
assert_eq!(round_trip(&desc), desc);
}
#[test]
fn composite_member_encode_reserved_bytes_are_zero() {
let desc = CompositeMemberDescriptor::new(MemberRole::Base);
let mut w = ByteWriter::new();
desc.encode_into(&mut w);
let bytes = w.into_vec();
assert_eq!(bytes[0], 0x01); assert!(
bytes[1..16].iter().all(|&b| b == 0),
"_reserved must be all-zero"
);
}
#[test]
fn composite_member_decode_rejects_nonzero_reserved_bytes() {
let mut w = ByteWriter::new();
w.write_u8(MemberRole::Base.wire_byte());
w.write_zeros(14);
w.write_u8(0xFF); let bytes = w.into_vec();
let mut c = ByteCursor::new(&bytes, bytes.len());
let err = CompositeMemberDescriptor::decode_from(&mut c).unwrap_err();
assert!(matches!(err, Error::ReservedBytesNonZero { .. }));
}
#[test]
fn composite_member_decode_rejects_invalid_role() {
let mut w = ByteWriter::new();
w.write_u8(0xFF); w.write_zeros(15);
let bytes = w.into_vec();
let mut c = ByteCursor::new(&bytes, bytes.len());
let err = CompositeMemberDescriptor::decode_from(&mut c).unwrap_err();
assert!(matches!(err, Error::InvalidMemberRole(0xFF)));
}
#[test]
fn composite_member_decode_truncated() {
let bytes = [0x00u8, 0x00, 0x00, 0x00, 0x00];
let mut c = ByteCursor::new(&bytes, bytes.len());
let err = CompositeMemberDescriptor::decode_from(&mut c).unwrap_err();
assert!(matches!(err, Error::DescriptorTruncated { .. }));
}
}