extern crate zwave;
mod ack {
mod serialize {
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::Ack;
fn serialized() -> Vec<u8> {
let serializer = MessageSerializer::for_response();
let mut buffer = Vec::<u8>::with_capacity(16);
serializer.serialize(&Ack::new(), &mut buffer).unwrap();
buffer
}
#[test]
fn it_serializes_preamble() {
assert_eq!(0x06, serialized()[0]);
}
#[test]
fn it_serializes_correct_length() {
assert_eq!(1, serialized().len());
}
}
mod deserialize {
use std::io::Cursor;
use zwave::core::ErrorKind;
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::Ack;
use zwave::protocol::serialization::Reader;
#[test]
fn it_deserializes_preamble() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x06];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let response = serializer.deserialize(&mut reader).unwrap();
assert!(response.is::<Ack>());
}
#[test]
fn it_handles_short_packets() {
let serializer = MessageSerializer::for_response();
let buffer = &[];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::ShortRead, result.err().unwrap().kind());
}
}
}
mod nack {
mod serialize {
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::Nack;
fn serialized() -> Vec<u8> {
let serializer = MessageSerializer::for_response();
let mut buffer = Vec::<u8>::with_capacity(16);
serializer.serialize(&Nack::new(), &mut buffer).unwrap();
buffer
}
#[test]
fn it_serializes_preamble() {
assert_eq!(0x15, serialized()[0]);
}
#[test]
fn it_serializes_correct_length() {
assert_eq!(1, serialized().len());
}
}
mod deserialize {
use std::io::Cursor;
use zwave::core::ErrorKind;
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::Nack;
use zwave::protocol::serialization::Reader;
#[test]
fn it_deserializes_preamble() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x15];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let response = serializer.deserialize(&mut reader).unwrap();
assert!(response.is::<Nack>());
}
#[test]
fn it_handles_short_packets() {
let serializer = MessageSerializer::for_response();
let buffer = &[];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::ShortRead, result.err().unwrap().kind());
}
}
}
mod cancel {
mod serialize {
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::Cancel;
fn serialized() -> Vec<u8> {
let serializer = MessageSerializer::for_response();
let mut buffer = Vec::<u8>::with_capacity(16);
serializer.serialize(&Cancel::new(), &mut buffer).unwrap();
buffer
}
#[test]
fn it_serializes_preamble() {
assert_eq!(0x18, serialized()[0]);
}
#[test]
fn it_serializes_correct_length() {
assert_eq!(1, serialized().len());
}
}
mod deserialize {
use std::io::Cursor;
use zwave::core::ErrorKind;
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::Cancel;
use zwave::protocol::serialization::Reader;
#[test]
fn it_deserializes_preamble() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x18];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let response = serializer.deserialize(&mut reader).unwrap();
assert!(response.is::<Cancel>());
}
#[test]
fn it_handles_short_packets() {
let serializer = MessageSerializer::for_response();
let buffer = &[];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::ShortRead, result.err().unwrap().kind());
}
}
}
mod message_transmitted {
mod serialize {
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::MessageTransmitted;
fn serialized(flags: u8) -> Vec<u8> {
let serializer = MessageSerializer::for_response();
let mut buffer = Vec::<u8>::with_capacity(16);
serializer.serialize(&MessageTransmitted::new(flags), &mut buffer).unwrap();
buffer
}
#[test]
fn it_serializes_preamble() {
assert_eq!(0x01, serialized(0x01)[0]);
}
#[test]
fn it_serializes_length() {
assert_eq!(0x04, serialized(0x01)[1]);
}
#[test]
fn it_serializes_message_type() {
assert_eq!(0x01, serialized(0x01)[2]);
}
#[test]
fn it_serializes_function_id() {
assert_eq!(0x13, serialized(0x01)[3]);
}
#[test]
fn it_serializes_flags() {
assert_eq!(0x01, serialized(0x01)[4]);
assert_eq!(0x42, serialized(0x42)[4]);
}
#[test]
fn it_serializes_checksum() {
assert_eq!(0xE8, serialized(0x01)[5]);
assert_eq!(0xAB, serialized(0x42)[5]);
}
#[test]
fn it_serializes_correct_length() {
assert_eq!(6, serialized(0x01).len());
}
}
mod deserialize {
use std::io::Cursor;
use zwave::core::ErrorKind;
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::MessageTransmitted;
use zwave::protocol::serialization::Reader;
fn deserialized(buffer: &[u8]) -> Box<MessageTransmitted> {
let serializer = MessageSerializer::for_response();
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let response = serializer.deserialize(&mut reader).unwrap();
response.downcast::<MessageTransmitted>().unwrap()
}
#[test]
fn it_deserializes_flags() {
assert_eq!(0x01, deserialized(&[0x01, 0x04, 0x01, 0x13, 0x01, 0xE8]).flags());
assert_eq!(0x42, deserialized(&[0x01, 0x04, 0x01, 0x13, 0x42, 0xAB]).flags());
}
#[test]
fn it_verifies_parity() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x01, 0x04, 0x01, 0x13, 0x01, 0x2A];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::Corrupt, result.err().unwrap().kind());
}
#[test]
fn it_handles_short_packets() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x01, 0x04, 0x01, 0x13, 0x01];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::ShortRead, result.err().unwrap().kind());
}
}
}
mod message_received {
mod serialize {
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::MessageReceived;
struct TestParameters {
callback_id: u8,
flags: u8,
}
const DEFAULT: TestParameters = TestParameters {
callback_id: 0x11,
flags: 0x01,
};
fn serialized(parameters: TestParameters) -> Vec<u8> {
let serializer = MessageSerializer::for_response();
let mut buffer = Vec::<u8>::with_capacity(16);
serializer.serialize(&MessageReceived::new(parameters.callback_id, parameters.flags), &mut buffer).unwrap();
buffer
}
#[test]
fn it_serializes_preamble() {
assert_eq!(0x01, serialized(DEFAULT)[0]);
}
#[test]
fn it_serializes_length() {
assert_eq!(0x05, serialized(DEFAULT)[1]);
}
#[test]
fn it_serializes_message_type() {
assert_eq!(0x00, serialized(DEFAULT)[2]);
}
#[test]
fn it_serializes_function_id() {
assert_eq!(0x13, serialized(DEFAULT)[3]);
}
#[test]
fn it_serializes_callback_id() {
assert_eq!(DEFAULT.callback_id, serialized(DEFAULT)[4]);
assert_eq!(0x2A, serialized(TestParameters { callback_id: 0x2A, .. DEFAULT })[4]);
}
#[test]
fn it_serializes_flags() {
assert_eq!(DEFAULT.flags, serialized(DEFAULT)[5]);
assert_eq!(0x2A, serialized(TestParameters { flags: 0x2A, .. DEFAULT })[5]);
}
#[test]
fn it_serializes_checksum() {
assert_eq!(0xF9, serialized(DEFAULT)[6]);
assert_eq!(0xC2, serialized(TestParameters { callback_id: 0x2A, .. DEFAULT })[6]);
assert_eq!(0xD2, serialized(TestParameters { flags: 0x2A, .. DEFAULT })[6]);
}
#[test]
fn it_serializes_correct_length() {
assert_eq!(7, serialized(DEFAULT).len());
}
}
mod deserialize {
use std::io::Cursor;
use zwave::core::ErrorKind;
use zwave::protocol::message::MessageSerializer;
use zwave::protocol::message::MessageReceived;
use zwave::protocol::serialization::Reader;
fn deserialized(buffer: &[u8]) -> Box<MessageReceived> {
let serializer = MessageSerializer::for_response();
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let response = serializer.deserialize(&mut reader).unwrap();
response.downcast::<MessageReceived>().unwrap()
}
#[test]
fn it_deserializes_callback_id() {
assert_eq!(0x11, deserialized(&[0x01, 0x05, 0x00, 0x13, 0x11, 0x01, 0xF9]).callback_id());
assert_eq!(0x2A, deserialized(&[0x01, 0x05, 0x00, 0x13, 0x2A, 0x01, 0xC2]).callback_id());
}
#[test]
fn it_deserializes_flags() {
assert_eq!(0x01, deserialized(&[0x01, 0x05, 0x00, 0x13, 0x11, 0x01, 0xF9]).flags());
assert_eq!(0x2A, deserialized(&[0x01, 0x05, 0x00, 0x13, 0x11, 0x2A, 0xD2]).flags());
}
#[test]
fn it_verifies_parity() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x01, 0x05, 0x00, 0x13, 0x11, 0x01, 0x2A];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::Corrupt, result.err().unwrap().kind());
}
#[test]
fn it_handles_short_packets() {
let serializer = MessageSerializer::for_response();
let buffer = &[0x01, 0x05, 0x00, 0x13, 0x11, 0x01];
let mut cursor = Cursor::new(buffer);
let mut reader = Reader::new(&mut cursor);
let result = serializer.deserialize(&mut reader);
assert!(result.is_err());
assert_eq!(ErrorKind::ShortRead, result.err().unwrap().kind());
}
}
}