94 lines
2.9 KiB
Rust
94 lines
2.9 KiB
Rust
//! Acceptance tests for ADR-120 §2.2 sink marker enforcement (invariant I1).
|
|
|
|
use wifi_densepose_bfld::sink::{LocalKind, MatterKind, NetworkKind};
|
|
use wifi_densepose_bfld::{check_class, BfldError, PrivacyClass};
|
|
|
|
// --- PrivacyClass::try_from ----------------------------------------------
|
|
|
|
#[test]
|
|
fn privacy_class_try_from_accepts_all_four_valid_bytes() {
|
|
assert_eq!(PrivacyClass::try_from(0).unwrap(), PrivacyClass::Raw);
|
|
assert_eq!(PrivacyClass::try_from(1).unwrap(), PrivacyClass::Derived);
|
|
assert_eq!(PrivacyClass::try_from(2).unwrap(), PrivacyClass::Anonymous);
|
|
assert_eq!(PrivacyClass::try_from(3).unwrap(), PrivacyClass::Restricted);
|
|
}
|
|
|
|
#[test]
|
|
fn privacy_class_try_from_rejects_out_of_range_bytes() {
|
|
for b in [4u8, 5, 7, 17, 42, 100, 200, 255] {
|
|
match PrivacyClass::try_from(b) {
|
|
Err(BfldError::InvalidPrivacyClass(got)) => assert_eq!(got, b),
|
|
other => panic!("expected InvalidPrivacyClass({b}), got {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn privacy_class_byte_roundtrip_is_stable() {
|
|
for c in [
|
|
PrivacyClass::Raw,
|
|
PrivacyClass::Derived,
|
|
PrivacyClass::Anonymous,
|
|
PrivacyClass::Restricted,
|
|
] {
|
|
assert_eq!(PrivacyClass::try_from(c.as_u8()).unwrap(), c);
|
|
}
|
|
}
|
|
|
|
// --- LocalSink accepts everything ---------------------------------------
|
|
|
|
#[test]
|
|
fn local_sink_accepts_all_classes() {
|
|
for c in [
|
|
PrivacyClass::Raw,
|
|
PrivacyClass::Derived,
|
|
PrivacyClass::Anonymous,
|
|
PrivacyClass::Restricted,
|
|
] {
|
|
check_class::<LocalKind>(c).expect("LocalSink must accept every class");
|
|
}
|
|
}
|
|
|
|
// --- NetworkSink rejects Raw, accepts the rest --------------------------
|
|
|
|
#[test]
|
|
fn network_sink_rejects_raw_frames() {
|
|
let err = check_class::<NetworkKind>(PrivacyClass::Raw).unwrap_err();
|
|
match err {
|
|
BfldError::PrivacyViolation { reason } => assert_eq!(reason, "NetworkKind"),
|
|
other => panic!("expected PrivacyViolation, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn network_sink_accepts_derived_anonymous_restricted() {
|
|
for c in [
|
|
PrivacyClass::Derived,
|
|
PrivacyClass::Anonymous,
|
|
PrivacyClass::Restricted,
|
|
] {
|
|
check_class::<NetworkKind>(c)
|
|
.expect("NetworkSink must accept Derived/Anonymous/Restricted");
|
|
}
|
|
}
|
|
|
|
// --- MatterSink rejects Raw and Derived ---------------------------------
|
|
|
|
#[test]
|
|
fn matter_sink_rejects_raw_and_derived() {
|
|
for c in [PrivacyClass::Raw, PrivacyClass::Derived] {
|
|
let err = check_class::<MatterKind>(c).unwrap_err();
|
|
match err {
|
|
BfldError::PrivacyViolation { reason } => assert_eq!(reason, "MatterKind"),
|
|
other => panic!("expected PrivacyViolation for {c:?}, got {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn matter_sink_accepts_anonymous_and_restricted() {
|
|
for c in [PrivacyClass::Anonymous, PrivacyClass::Restricted] {
|
|
check_class::<MatterKind>(c).expect("MatterSink must accept anonymous + restricted");
|
|
}
|
|
}
|