addr_ty!(
Eui64Addr[8]
);
#[cfg(test)]
mod tests {
use super::*;
use crate::{ParseError, TestCase};
use std::{string::ToString, vec, vec::Vec};
const EUI64_ADDRESS_SIZE: usize = 8;
fn test_cases() -> Vec<TestCase<EUI64_ADDRESS_SIZE>> {
vec![
TestCase {
input: "02:00:5e:10:00:00:00:01",
output: Some(vec![0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01]),
err: None,
},
TestCase {
input: "02-00-5e-10-00-00-00-01",
output: Some(vec![0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01]),
err: None,
},
TestCase {
input: "0200.5e10.0000.0001",
output: Some(vec![0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01]),
err: None,
},
TestCase {
input: "ab:cd:ef:AB:CD:EF:ab:cd",
output: Some(vec![0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef, 0xab, 0xcd]),
err: None,
},
TestCase {
input: "0200-5e10.0000.0001",
output: None,
err: Some(ParseError::UnexpectedSeparator {
expected: b'.',
actual: b'-',
}),
},
TestCase {
input: "xx00.5e10.0000.0001",
output: None,
err: Some(ParseError::InvalidHexDigit([b'x', b'x'])),
},
TestCase {
input: "00xx.5e10.0000.0001",
output: None,
err: Some(ParseError::InvalidHexDigit([b'x', b'x'])),
},
]
}
#[test]
fn parse() {
let cases = test_cases();
for (i, test) in cases.iter().enumerate() {
let result = Eui64Addr::try_from(test.input);
match (result, &test.output) {
(Ok(out), Some(expected)) => {
assert_eq!(
out,
expected.as_slice(),
"Test case {}: Eui64Addr::parse({}) output mismatch",
i,
test.input
);
if test.err.is_none() {
let formatted = out.to_string();
let round_trip = Eui64Addr::try_from(formatted.as_str());
assert!(
round_trip.is_ok(),
"Test case {}: Round-trip parse failed for {}",
i,
formatted
);
assert_eq!(
round_trip.unwrap(),
out,
"Test case {}: Round-trip value mismatch",
i
);
}
}
(Err(err), None) => {
assert_eq!(
Some(&err),
test.err.as_ref(),
"Test case {}: Expected error containing '{:?}', got '{:?}'",
i,
test.err,
err
);
}
(Ok(out), None) => {
panic!(
"Test case {}: Expected error '{:?}', got success: {:?}",
i, test.err, out
);
}
(Err(err), Some(expected)) => {
panic!(
"Test case {}: Expected {:?}, got error: {:?}",
i, expected, err
);
}
}
}
}
#[test]
fn test_default() {
let addr = Eui64Addr::default();
assert_eq!(addr.octets(), [0; EUI64_ADDRESS_SIZE]);
}
#[test]
fn formatted() {
let addr = Eui64Addr::try_from("02:00:5e:10:00:00:00:01").unwrap();
assert_eq!(addr.to_string(), "02:00:5e:10:00:00:00:01");
assert_eq!(addr.to_colon_separated(), "02:00:5e:10:00:00:00:01");
let dot = addr.to_dot_separated_array();
let dot_str = core::str::from_utf8(&dot).unwrap();
assert_eq!(dot_str, "0200.5e10.0000.0001");
assert_eq!(addr.to_dot_separated(), "0200.5e10.0000.0001");
let dashed = addr.to_hyphen_separated_array();
let dashed_str = core::str::from_utf8(&dashed).unwrap();
assert_eq!(dashed_str, "02-00-5e-10-00-00-00-01");
assert_eq!(addr.to_hyphen_separated(), "02-00-5e-10-00-00-00-01");
}
#[cfg(feature = "serde")]
#[test]
fn serde_human_readable() {
let addr = Eui64Addr::try_from("02:00:5e:10:00:00:00:01").unwrap();
let json = serde_json::to_string(&addr).unwrap();
assert_eq!(json, "\"02:00:5e:10:00:00:00:01\"");
let addr2: Eui64Addr = serde_json::from_str(&json).unwrap();
assert_eq!(addr, addr2);
}
#[cfg(feature = "serde")]
#[test]
fn serde_human_unreadable() {
let addr = Eui64Addr::try_from("02:00:5e:10:00:00:00:01").unwrap();
let encoded = bincode::serde::encode_to_vec(addr, bincode::config::standard()).unwrap();
assert_eq!(encoded, [2, 0, 94, 16, 0, 0, 0, 1]);
assert_eq!(addr.octets(), [2, 0, 94, 16, 0, 0, 0, 1]);
let addr2: Eui64Addr = bincode::serde::decode_from_slice(&encoded, bincode::config::standard())
.unwrap()
.0;
assert_eq!(addr, addr2);
let addr3 = Eui64Addr::from([2, 0, 94, 16, 0, 0, 0, 1]);
assert_eq!(addr, addr3);
let octets: [u8; EUI64_ADDRESS_SIZE] = addr3.into();
assert_eq!(octets, addr3.octets());
println!("{:?}", addr);
}
#[cfg(feature = "arbitrary")]
#[test]
fn arbitrary_is_deterministic() {
use arbitrary::{Arbitrary, Unstructured};
let data = [0xAA; 32];
let a = Eui64Addr::arbitrary(&mut Unstructured::new(&data)).expect("arbitrary should succeed");
let b = Eui64Addr::arbitrary(&mut Unstructured::new(&data)).expect("arbitrary should succeed");
assert_eq!(a, b, "arbitrary should be deterministic for a fixed input");
}
#[cfg(feature = "arbitrary")]
#[test]
fn arbitrary_size_hint_matches_byte_array() {
use arbitrary::Arbitrary;
let hint = Eui64Addr::size_hint(0);
let expected = <[u8; EUI64_ADDRESS_SIZE] as Arbitrary>::size_hint(0);
assert_eq!(hint, expected);
}
#[cfg(feature = "arbitrary")]
#[test]
fn arbitrary_consumes_expected_bytes() {
use arbitrary::{Arbitrary, Unstructured};
let data = [1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let mut u = Unstructured::new(&data);
let _first = Eui64Addr::arbitrary(&mut u).unwrap();
let _second = Eui64Addr::arbitrary(&mut u).unwrap();
}
#[cfg(feature = "quickcheck")]
#[test]
fn quickcheck_arbitrary_roundtrips_through_string() {
use quickcheck::{Arbitrary, Gen};
let mut g = Gen::new(32);
for _ in 0..128 {
let addr = Eui64Addr::arbitrary(&mut g);
let parsed =
Eui64Addr::try_from(addr.to_string().as_str()).expect("to_string() output must parse back");
assert_eq!(addr, parsed);
}
}
#[cfg(feature = "quickcheck")]
#[test]
fn quickcheck_shrink_terminates_and_preserves_length() {
use quickcheck::Arbitrary;
let addr = Eui64Addr::from_raw([0xFF; EUI64_ADDRESS_SIZE]);
let shrinks: Vec<_> = addr.shrink().take(4096).collect();
assert!(!shrinks.is_empty(), "non-zero address should yield shrinks");
for s in &shrinks {
assert_eq!(s.octets().len(), EUI64_ADDRESS_SIZE);
}
}
#[cfg(feature = "quickcheck")]
#[test]
fn quickcheck_shrink_zero_is_empty() {
use quickcheck::Arbitrary;
let zero = Eui64Addr::from_raw([0; EUI64_ADDRESS_SIZE]);
let shrinks: Vec<_> = zero.shrink().collect();
assert!(
shrinks.is_empty(),
"zero address should yield no shrinks, got {:?}",
shrinks
);
}
#[cfg(feature = "quickcheck")]
#[test]
fn quickcheck_roundtrip_property() {
fn prop(addr: Eui64Addr) -> bool {
Eui64Addr::try_from(addr.to_string().as_str())
.map(|p| p == addr)
.unwrap_or(false)
}
quickcheck::quickcheck(prop as fn(Eui64Addr) -> bool);
}
}