use bytes::{Bytes, BytesMut};
use crate::{DecodeError, EncodeError, PacketType};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PingReq;
impl PingReq {
const FLAGS: u8 = 0b0000;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
0
}
pub(super) fn encode_body(&self, _buf: &mut BytesMut) -> Result<(), EncodeError> {
Ok(())
}
pub(super) fn decode_body(header_flags: u8, buf: Bytes) -> Result<Self, DecodeError> {
if header_flags != Self::FLAGS {
return Err(DecodeError::InvalidFlags {
packet_type: PacketType::PingReq,
flags: header_flags,
});
}
if !buf.is_empty() {
return Err(DecodeError::TrailingBytes { count: buf.len() });
}
Ok(Self)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PingResp;
impl PingResp {
const FLAGS: u8 = 0b0000;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
0
}
pub(super) fn encode_body(&self, _buf: &mut BytesMut) -> Result<(), EncodeError> {
Ok(())
}
pub(super) fn decode_body(header_flags: u8, buf: Bytes) -> Result<Self, DecodeError> {
if header_flags != Self::FLAGS {
return Err(DecodeError::InvalidFlags {
packet_type: PacketType::PingResp,
flags: header_flags,
});
}
if !buf.is_empty() {
return Err(DecodeError::TrailingBytes { count: buf.len() });
}
Ok(Self)
}
}
#[cfg(test)]
mod tests {
use bytes::{Bytes, BytesMut};
use super::*;
use crate::v5::Packet;
use crate::{DecodeError, PacketType};
#[test]
fn pingreq_encode() {
let mut buf = BytesMut::new();
Packet::PingReq(PingReq).encode(&mut buf).unwrap();
assert_eq!(&buf[..], &[0xC0, 0x00]);
}
#[test]
fn pingreq_roundtrip() {
let mut buf = BytesMut::new();
Packet::PingReq(PingReq).encode(&mut buf).unwrap();
let pkt = Packet::decode(&mut buf).unwrap().unwrap();
assert_eq!(pkt, Packet::PingReq(PingReq));
}
#[test]
fn pingreq_invalid_flags() {
assert_eq!(
PingReq::decode_body(0x01, Bytes::new()),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::PingReq,
flags: 0x01,
})
);
}
#[test]
fn pingreq_trailing_bytes() {
assert_eq!(
PingReq::decode_body(0x00, Bytes::from_static(&[0xFF])),
Err(DecodeError::TrailingBytes { count: 1 })
);
}
#[test]
fn pingresp_encode() {
let mut buf = BytesMut::new();
Packet::PingResp(PingResp).encode(&mut buf).unwrap();
assert_eq!(&buf[..], &[0xD0, 0x00]);
}
#[test]
fn pingresp_roundtrip() {
let mut buf = BytesMut::new();
Packet::PingResp(PingResp).encode(&mut buf).unwrap();
let pkt = Packet::decode(&mut buf).unwrap().unwrap();
assert_eq!(pkt, Packet::PingResp(PingResp));
}
#[test]
fn pingresp_invalid_flags() {
assert_eq!(
PingResp::decode_body(0x01, Bytes::new()),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::PingResp,
flags: 0x01,
})
);
}
#[test]
fn pingresp_trailing_bytes() {
assert_eq!(
PingResp::decode_body(0x00, Bytes::from_static(&[0xFF])),
Err(DecodeError::TrailingBytes { count: 1 })
);
}
}