#![cfg(all(feature = "std", feature = "rustcrypto"))]
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::indexing_slicing,
clippy::panic,
clippy::arithmetic_side_effects
)]
use matter_kit::clusters::generated::{
binding, general_diagnostics, groups, level_control, on_off, scenes_management,
};
use matter_kit::tlv::{Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv};
fn encode<T: ToTlv>(value: &T, buf: &mut [u8]) -> Vec<u8> {
let mut w = TlvWriter::new(buf);
value.to_tlv(&mut w, Tag::Anonymous).expect("encode");
w.finish().expect("finish").to_vec()
}
fn decode<'a, T: FromTlv<'a>>(bytes: &'a [u8]) -> T {
let mut reader = TlvReader::new(bytes);
let element: Element<'a> = reader.next_element().expect("read").expect("an element");
T::from_tlv(&mut reader, &element).expect("decode")
}
#[test]
fn a_command_payload_encodes_to_the_field_numbers_the_specification_assigns() {
let fields = on_off::OnWithTimedOffFields {
on_off_control: on_off::OnOffControlBitmap::ACCEPT_ONLY_WHEN_ON,
on_time: 0x1234,
off_wait_time: 0x00FF,
};
let mut buf = [0u8; 64];
let bytes = encode(&fields, &mut buf);
assert_eq!(
bytes,
vec![
0x15, 0x24, 0x00, 0x01, 0x25, 0x01, 0x34, 0x12, 0x24, 0x02, 0xFF, 0x18, ]
);
assert_eq!(decode::<on_off::OnWithTimedOffFields>(&bytes), fields);
}
#[test]
fn an_enumeration_refuses_a_value_this_revision_does_not_define() {
let mut buf = [0u8; 32];
let mut w = TlvWriter::new(&mut buf);
w.unsigned(Tag::Anonymous, 0x7F).expect("write");
let bytes = w.finish().expect("finish").to_vec();
let mut reader = TlvReader::new(&bytes);
let element = reader.next_element().unwrap().unwrap();
assert!(on_off::StartUpOnOffEnum::from_tlv(&mut reader, &element).is_err());
let bytes = encode(&on_off::StartUpOnOffEnum::Toggle, &mut buf);
assert_eq!(
decode::<on_off::StartUpOnOffEnum>(&bytes),
on_off::StartUpOnOffEnum::Toggle
);
}
#[test]
fn a_bitmap_refuses_a_bit_this_revision_does_not_define() {
let mut buf = [0u8; 32];
let mut w = TlvWriter::new(&mut buf);
w.unsigned(Tag::Anonymous, 0xFE).expect("write");
let bytes = w.finish().expect("finish").to_vec();
let mut reader = TlvReader::new(&bytes);
let element = reader.next_element().unwrap().unwrap();
assert!(on_off::OnOffControlBitmap::from_tlv(&mut reader, &element).is_err());
}
#[test]
fn absent_null_and_present_are_three_different_things() {
let mut buf = [0u8; 64];
let with_time = level_control::MoveToLevelFields {
level: 128,
transition_time: Nullable::some(20),
options_mask: level_control::OptionsBitmap::empty(),
options_override: level_control::OptionsBitmap::empty(),
};
let bytes = encode(&with_time, &mut buf);
assert_eq!(
decode::<level_control::MoveToLevelFields>(&bytes).transition_time,
Nullable::some(20)
);
let with_null = level_control::MoveToLevelFields {
transition_time: Nullable::null(),
..with_time
};
let bytes = encode(&with_null, &mut buf);
let decoded = decode::<level_control::MoveToLevelFields>(&bytes);
assert!(decoded.transition_time.is_null(), "null survived the trip");
assert!(bytes.contains(&0x34), "a null element, not a zero value");
}
#[test]
fn a_borrowed_field_points_into_the_buffer_it_was_decoded_from() {
let mut buf = [0u8; 128];
let fields = groups::AddGroupFields {
group_id: matter_kit::msg::GroupId(7),
group_name: "kitchen",
};
let bytes = encode(&fields, &mut buf);
let decoded = decode::<groups::AddGroupFields<'_>>(&bytes);
assert_eq!(decoded.group_name, "kitchen");
let start = bytes.as_ptr() as usize;
let field = decoded.group_name.as_ptr() as usize;
assert!(
field >= start && field < start + bytes.len(),
"the string borrows from the encoded bytes rather than copying them"
);
}
#[test]
fn a_list_field_decodes_its_entries_lazily() {
let mut buf = [0u8; 256];
let mut w = TlvWriter::new(&mut buf);
w.start_array(Tag::Anonymous).expect("array");
for cluster in [0x0006u32, 0x0008] {
w.start_structure(Tag::Anonymous).expect("member");
w.unsigned(Tag::Context(0), u64::from(cluster))
.expect("cluster");
w.start_array(Tag::Context(1)).expect("values");
w.end_container().expect("end values");
w.end_container().expect("end member");
}
w.end_container().expect("end");
let bytes = w.finish().expect("finish").to_vec();
let list: TlvList<'_, scenes_management::ExtensionFieldSetStruct<'_>> = decode(&bytes);
assert_eq!(list.count().expect("count"), 2);
let clusters: Vec<u32> = list
.iter()
.map(|entry| entry.expect("decode").cluster_id)
.collect();
assert_eq!(clusters, vec![0x0006, 0x0008]);
let mut out = [0u8; 256];
assert_eq!(encode(&list, &mut out), bytes);
}
#[test]
fn an_unknown_field_is_ignored_rather_than_refusing_the_whole_structure() {
let mut buf = [0u8; 128];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("structure");
w.unsigned(Tag::Context(0), 42).expect("GroupID");
w.utf8(Tag::Context(1), "hall").expect("GroupName");
w.start_structure(Tag::Context(99)).expect("future");
w.unsigned(Tag::Context(0), 1).expect("inner");
w.end_container().expect("end future");
w.end_container().expect("end");
let bytes = w.finish().expect("finish").to_vec();
let decoded = decode::<groups::AddGroupFields<'_>>(&bytes);
assert_eq!(decoded.group_id, matter_kit::msg::GroupId(42));
assert_eq!(decoded.group_name, "hall");
}
#[test]
fn a_missing_mandatory_field_is_refused() {
let mut buf = [0u8; 64];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("structure");
w.unsigned(Tag::Context(0), 42).expect("GroupID");
w.end_container().expect("end");
let bytes = w.finish().expect("finish").to_vec();
let mut reader = TlvReader::new(&bytes);
let element = reader.next_element().unwrap().unwrap();
assert!(
groups::AddGroupFields::from_tlv(&mut reader, &element).is_err(),
"GroupName is mandatory"
);
}
#[test]
fn a_nested_structure_round_trips() {
let mut buf = [0u8; 256];
let load = general_diagnostics::DeviceLoadStruct {
current_subscriptions: 3,
current_subscriptions_for_fabric: 2,
total_subscriptions_established: 9,
total_interaction_model_messages_sent: 100,
total_interaction_model_messages_received: 101,
};
let bytes = encode(&load, &mut buf);
assert_eq!(
decode::<general_diagnostics::DeviceLoadStruct>(&bytes),
load
);
}
#[test]
fn a_fabric_scoped_struct_carries_its_index() {
let target = binding::TargetStruct {
node: Some(matter_kit::msg::NodeId(0xAABB)),
group: None,
endpoint: Some(1),
cluster: Some(0x0006),
fabric_index: matter_kit::msg::FabricIndex(2),
};
let mut buf = [0u8; 128];
let bytes = encode(&target, &mut buf);
assert_eq!(decode::<binding::TargetStruct>(&bytes), target);
assert!(bytes.contains(&254), "the FabricIndex field number");
}