use std::{fmt, marker::PhantomData};
use crate::binary::{
decode_varint_bytes, encode_varint, encode_varint_in_range, varint_length_from_first,
varint_length_in_range,
};
use crate::{BinaryDecode, BinaryEncode, BinaryReader, BinaryWriter, DecodeLimits};
use crate::{ProtocolError, Result};
const DEFAULT_MAX_FRAME_LEN: usize = 1024 * 1024;
const COMPACT_AFTER_BYTES: usize = 8 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct PacketId(u16);
impl PacketId {
pub const fn new(value: u16) -> Self {
Self(value)
}
pub const fn get(self) -> u16 {
self.0
}
}
impl From<u16> for PacketId {
fn from(value: u16) -> Self {
Self::new(value)
}
}
impl From<PacketId> for u16 {
fn from(value: PacketId) -> Self {
value.get()
}
}
impl fmt::Display for PacketId {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "0x{:04x}", self.0)
}
}
pub trait Packet: BinaryEncode + BinaryDecode {
const ID: PacketId;
}
pub trait PacketEncode {
fn packet_id(&self) -> PacketId;
fn encode_payload(&self, writer: &mut BinaryWriter) -> Result<()>;
}
impl<T: Packet> PacketEncode for T {
fn packet_id(&self) -> PacketId {
T::ID
}
fn encode_payload(&self, writer: &mut BinaryWriter) -> Result<()> {
self.encode(writer)
}
}
pub trait PacketSet: Sized {
fn decode_packet(id: PacketId, reader: &mut BinaryReader<'_>) -> Result<Self>;
}
impl<T: Packet> PacketSet for T {
fn decode_packet(id: PacketId, reader: &mut BinaryReader<'_>) -> Result<Self> {
if id != T::ID {
return Err(ProtocolError::PacketIdMismatch {
expected: T::ID,
actual: id,
});
}
T::decode(reader)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CodecConfig {
pub max_frame_len: usize,
pub max_buffered_len: usize,
pub decode_limits: DecodeLimits,
}
impl Default for CodecConfig {
fn default() -> Self {
Self {
max_frame_len: DEFAULT_MAX_FRAME_LEN,
max_buffered_len: DEFAULT_MAX_FRAME_LEN * 2,
decode_limits: DecodeLimits::default(),
}
}
}
#[derive(Debug, Clone)]
pub struct PacketEncoder {
config: CodecConfig,
}
impl Default for PacketEncoder {
fn default() -> Self {
Self::new(CodecConfig::default())
}
}
impl PacketEncoder {
pub fn new(config: CodecConfig) -> Self {
Self { config }
}
pub fn config(&self) -> CodecConfig {
self.config
}
pub fn encode<P: PacketEncode + ?Sized>(&self, packet: &P) -> Result<Vec<u8>> {
let packet_id = packet.packet_id();
let id_length = varint_length_in_range(u64::from(packet_id.get()));
let payload_limit = self.config.max_frame_len.saturating_sub(id_length);
let mut payload = BinaryWriter::with_limit(payload_limit);
let payload_result = packet.encode_payload(&mut payload);
finish_encoding(self.config, packet_id, id_length, payload, payload_result)
}
pub fn encode_into<P: PacketEncode + ?Sized>(
&self,
packet: &P,
destination: &mut Vec<u8>,
) -> Result<()> {
self.encode(packet)
.map(|frame| destination.extend_from_slice(&frame))
}
}
fn finish_encoding(
config: CodecConfig,
packet_id: PacketId,
id_length: usize,
payload: BinaryWriter,
payload_result: Result<()>,
) -> Result<Vec<u8>> {
payload_result.and_then(|()| encode_frame_body(config, packet_id, id_length, payload))
}
fn encode_frame_body(
config: CodecConfig,
packet_id: PacketId,
id_length: usize,
payload: BinaryWriter,
) -> Result<Vec<u8>> {
let body_length = id_length as u64 + payload.len() as u64;
if body_length > config.max_frame_len as u64 {
return Err(ProtocolError::FrameTooLarge {
length: body_length,
maximum: config.max_frame_len,
});
}
let body_length = body_length as usize;
encode_varint(body_length as u64).map(|(encoded_length, length_width)| {
let (encoded_id, encoded_id_length) = encode_varint_in_range(u64::from(packet_id.get()));
let mut frame = Vec::with_capacity(length_width + body_length);
frame.extend_from_slice(&encoded_length[..length_width]);
frame.extend_from_slice(&encoded_id[..encoded_id_length]);
frame.extend_from_slice(payload.as_slice());
frame
})
}
#[derive(Debug, Clone)]
pub struct PacketDecoder<S> {
config: CodecConfig,
buffer: Vec<u8>,
start: usize,
packet_set: PhantomData<fn() -> S>,
}
impl<S> Default for PacketDecoder<S> {
fn default() -> Self {
Self::new(CodecConfig::default())
}
}
impl<S> PacketDecoder<S> {
pub fn new(config: CodecConfig) -> Self {
Self {
config,
buffer: Vec::new(),
start: 0,
packet_set: PhantomData,
}
}
pub fn config(&self) -> CodecConfig {
self.config
}
pub fn buffered_len(&self) -> usize {
self.buffer.len() - self.start
}
pub fn is_empty(&self) -> bool {
self.buffered_len() == 0
}
pub fn clear(&mut self) {
self.buffer.clear();
self.start = 0;
}
pub fn finish(&self) -> Result<()> {
if self.is_empty() {
Ok(())
} else {
Err(ProtocolError::IncompleteFrame {
buffered: self.buffered_len(),
})
}
}
pub fn push(&mut self, bytes: &[u8]) -> Result<()> {
let attempted = self.buffered_len().saturating_add(bytes.len());
if attempted > self.config.max_buffered_len {
return Err(ProtocolError::BufferedDataLimitExceeded {
attempted,
limit: self.config.max_buffered_len,
});
}
if self.start != 0 {
self.buffer.drain(..self.start);
self.start = 0;
}
self.buffer.extend_from_slice(bytes);
Ok(())
}
fn consume(&mut self, length: usize) {
self.start += length;
if self.start == self.buffer.len() {
self.clear();
} else if self.start >= COMPACT_AFTER_BYTES && self.start >= self.buffer.len() / 2 {
self.buffer.drain(..self.start);
self.start = 0;
}
}
}
impl<S: PacketSet> PacketDecoder<S> {
pub fn try_decode(&mut self) -> Result<Option<S>> {
let Some(frame) = inspect_frame(&self.buffer[self.start..], self.config)? else {
return Ok(None);
};
let result = decode_payload::<S>(frame.packet_id, frame.payload, self.config.decode_limits);
self.consume(frame.consumed);
result.map(Some)
}
pub fn decode_datagram(&self, datagram: &[u8]) -> Result<S> {
let frame =
inspect_frame(datagram, self.config)?.ok_or(ProtocolError::IncompleteFrame {
buffered: datagram.len(),
})?;
if frame.consumed != datagram.len() {
return Err(ProtocolError::TrailingFrameData(
datagram.len() - frame.consumed,
));
}
decode_payload::<S>(frame.packet_id, frame.payload, self.config.decode_limits)
}
}
#[derive(Debug)]
struct InspectedFrame<'a> {
packet_id: PacketId,
payload: &'a [u8],
consumed: usize,
}
fn inspect_frame(bytes: &[u8], config: CodecConfig) -> Result<Option<InspectedFrame<'_>>> {
let Some(first) = bytes.first().copied() else {
return Ok(None);
};
let length_width = varint_length_from_first(first);
if bytes.len() < length_width {
return Ok(None);
}
let body_length = decode_varint_bytes(&bytes[..length_width], true)?;
if body_length == 0 {
return Err(ProtocolError::InvalidFrameLength(body_length));
}
if body_length > config.max_frame_len as u64 {
return Err(ProtocolError::FrameTooLarge {
length: body_length,
maximum: config.max_frame_len,
});
}
let body_length = body_length as usize;
if body_length > bytes.len().saturating_sub(length_width) {
return Ok(None);
}
let consumed = length_width + body_length;
let body = &bytes[length_width..consumed];
let id_width = varint_length_from_first(body[0]);
if body.len() < id_width {
return Err(ProtocolError::UnexpectedEnd {
needed: id_width,
remaining: body.len(),
});
}
let raw_id = decode_varint_bytes(&body[..id_width], true)?;
let raw_id = u16::try_from(raw_id).map_err(|_| ProtocolError::PacketIdOutOfRange(raw_id))?;
Ok(Some(InspectedFrame {
packet_id: PacketId::new(raw_id),
payload: &body[id_width..],
consumed,
}))
}
fn decode_payload<S: PacketSet>(
packet_id: PacketId,
payload: &[u8],
limits: DecodeLimits,
) -> Result<S> {
let mut reader = BinaryReader::with_limits(payload, limits);
S::decode_packet(packet_id, &mut reader)
.and_then(|packet| ensure_payload_consumed(packet_id, &reader).map(|()| packet))
}
fn ensure_payload_consumed(packet_id: PacketId, reader: &BinaryReader<'_>) -> Result<()> {
if !reader.is_empty() {
return Err(ProtocolError::TrailingPayload {
packet_id,
remaining: reader.remaining(),
});
}
Ok(())
}
#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod tests {
use super::*;
use crate::sample::{DebugLevel, DebugMessage, Ping, Pong, SamplePacket};
#[crate::packet(id = 63)]
#[derive(Debug, Clone, PartialEq, Eq)]
struct OneByteId;
#[crate::packet(id = 64)]
#[derive(Debug, Clone, PartialEq, Eq)]
struct TwoByteId;
#[crate::packet(id = 16_384)]
#[derive(Debug, Clone, PartialEq, Eq)]
struct FourByteId;
struct FailingPacket;
impl PacketEncode for FailingPacket {
fn packet_id(&self) -> PacketId {
PacketId::new(1)
}
fn encode_payload(&self, writer: &mut BinaryWriter) -> Result<()> {
writer.write_bytes(&[0xaa])?;
Err(ProtocolError::InvalidBool(9))
}
}
#[test]
fn ping_has_stable_wire_representation() {
let bytes = PacketEncoder::default()
.encode(&Ping {
sequence: 42,
sent_at_micros: 1,
})
.unwrap();
assert_eq!(
bytes,
[
13, 3, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 1, ]
);
}
#[test]
fn stream_decoder_handles_every_fragment_boundary() {
let packet = Ping {
sequence: 7,
sent_at_micros: 99,
};
let encoded = PacketEncoder::default().encode(&packet).unwrap();
let mut decoder = PacketDecoder::<SamplePacket>::default();
for byte in encoded {
decoder.push(&[byte]).unwrap();
}
assert_eq!(decoder.try_decode().unwrap(), Some(packet.into()));
assert_eq!(decoder.try_decode().unwrap(), None);
assert!(decoder.is_empty());
}
#[test]
fn typed_decoder_checks_packet_id() {
let encoded = PacketEncoder::default()
.encode(&Ping {
sequence: 1,
sent_at_micros: 2,
})
.unwrap();
let decoder = PacketDecoder::<crate::sample::Pong>::default();
assert_eq!(
decoder.decode_datagram(&encoded),
Err(ProtocolError::PacketIdMismatch {
expected: crate::sample::Pong::ID,
actual: Ping::ID,
})
);
}
#[test]
fn invalid_complete_frame_is_consumed() {
let mut bytes = vec![1, 63];
PacketEncoder::default()
.encode_into(
&Ping {
sequence: 8,
sent_at_micros: 9,
},
&mut bytes,
)
.unwrap();
let mut decoder = PacketDecoder::<SamplePacket>::default();
decoder.push(&bytes).unwrap();
assert_eq!(
decoder.try_decode(),
Err(ProtocolError::UnknownPacketId(PacketId::new(63)))
);
assert!(matches!(
decoder.try_decode().unwrap(),
Some(SamplePacket::Ping(_))
));
}
#[test]
fn large_frame_survives_fragmented_multibyte_length() {
let packet = crate::sample::DebugMessage {
level: crate::sample::DebugLevel::Info,
target: "net".to_owned(),
message: "x".repeat(200),
};
let encoded = PacketEncoder::default().encode(&packet).unwrap();
assert_eq!(varint_length_from_first(encoded[0]), 2);
let mut decoder = PacketDecoder::<SamplePacket>::default();
decoder.push(&encoded[..1]).unwrap();
assert_eq!(decoder.try_decode().unwrap(), None);
decoder.push(&encoded[1..]).unwrap();
assert_eq!(decoder.try_decode().unwrap(), Some(packet.into()));
decoder.finish().unwrap();
}
#[test]
fn truncated_datagram_and_stream_eof_are_explicit() {
let encoded = PacketEncoder::default()
.encode(&Ping {
sequence: 1,
sent_at_micros: 2,
})
.unwrap();
let truncated = &encoded[..encoded.len() - 1];
let datagram_decoder = PacketDecoder::<SamplePacket>::default();
assert_eq!(
datagram_decoder.decode_datagram(truncated),
Err(ProtocolError::IncompleteFrame {
buffered: truncated.len(),
})
);
let mut stream_decoder = PacketDecoder::<SamplePacket>::default();
stream_decoder.push(truncated).unwrap();
assert_eq!(stream_decoder.try_decode().unwrap(), None);
assert_eq!(
stream_decoder.finish(),
Err(ProtocolError::IncompleteFrame {
buffered: truncated.len(),
})
);
}
#[test]
fn oversized_declared_frame_is_rejected_before_buffering_its_body() {
let config = CodecConfig {
max_frame_len: 8,
..CodecConfig::default()
};
let mut decoder = PacketDecoder::<SamplePacket>::new(config);
decoder.push(&[9]).unwrap();
assert_eq!(
decoder.try_decode(),
Err(ProtocolError::FrameTooLarge {
length: 9,
maximum: 8,
})
);
}
#[test]
fn packet_ids_and_default_config_are_stable() {
let id = PacketId::from(0xabcd);
assert_eq!(id.get(), 0xabcd);
assert_eq!(u16::from(id), 0xabcd);
assert_eq!(id.to_string(), "0xabcd");
let config = CodecConfig::default();
assert_eq!(config.max_frame_len, 1024 * 1024);
assert_eq!(config.max_buffered_len, 2 * 1024 * 1024);
assert_eq!(config.decode_limits, DecodeLimits::default());
assert_eq!(PacketEncoder::default().config(), config);
let decoder = PacketDecoder::<SamplePacket>::default();
assert_eq!(decoder.config(), config);
assert_eq!(decoder.buffered_len(), 0);
assert!(decoder.is_empty());
assert_eq!(decoder.finish(), Ok(()));
}
#[test]
fn packet_ids_use_each_available_varint_width() {
assert_eq!(
PacketEncoder::default().encode(&OneByteId).unwrap(),
[1, 63]
);
assert_eq!(
PacketEncoder::default().encode(&TwoByteId).unwrap(),
[2, 0x40, 0x40]
);
assert_eq!(
PacketEncoder::default().encode(&FourByteId).unwrap(),
[4, 0x80, 0x00, 0x40, 0x00]
);
}
#[test]
fn encoder_limits_and_encode_into_are_atomic() {
let unit_encoder = PacketEncoder::new(CodecConfig {
max_frame_len: 0,
..CodecConfig::default()
});
assert_eq!(
unit_encoder.encode(&OneByteId),
Err(ProtocolError::FrameTooLarge {
length: 1,
maximum: 0,
})
);
let payload_encoder = PacketEncoder::new(CodecConfig {
max_frame_len: 1,
..CodecConfig::default()
});
let ping = Ping {
sequence: 1,
sent_at_micros: 2,
};
assert_eq!(
payload_encoder.encode(&ping),
Err(ProtocolError::WriteLimitExceeded {
attempted: 4,
limit: 0,
})
);
let mut destination = vec![0x55];
assert_eq!(
payload_encoder.encode_into(&ping, &mut destination),
Err(ProtocolError::WriteLimitExceeded {
attempted: 4,
limit: 0,
})
);
assert_eq!(destination, [0x55]);
assert_eq!(
PacketEncoder::default().encode_into(&FailingPacket, &mut destination),
Err(ProtocolError::InvalidBool(9))
);
assert_eq!(destination, [0x55]);
}
#[test]
fn packet_set_variants_round_trip_when_encoded_as_the_enum() {
let packets = [
SamplePacket::from(Ping {
sequence: 10,
sent_at_micros: 11,
}),
SamplePacket::from(Pong),
SamplePacket::from(DebugMessage {
level: DebugLevel::Warn,
target: "codec".to_owned(),
message: "message".to_owned(),
}),
];
let encoder = PacketEncoder::default();
let decoder = PacketDecoder::<SamplePacket>::default();
for packet in packets {
let frame = encoder.encode(&packet).unwrap();
assert_eq!(decoder.decode_datagram(&frame).unwrap(), packet);
}
}
#[test]
fn every_debug_level_round_trips_and_invalid_tags_fail() {
for level in [
DebugLevel::Trace,
DebugLevel::Debug,
DebugLevel::Info,
DebugLevel::Warn,
DebugLevel::Error,
] {
let packet = DebugMessage {
level,
target: String::new(),
message: String::new(),
};
let frame = PacketEncoder::default().encode(&packet).unwrap();
assert_eq!(
PacketDecoder::<SamplePacket>::default()
.decode_datagram(&frame)
.unwrap(),
SamplePacket::from(packet)
);
}
assert_eq!(
PacketDecoder::<SamplePacket>::default().decode_datagram(&[4, 5, 9, 0, 0]),
Err(ProtocolError::InvalidEnumTag {
type_name: "DebugLevel",
tag: 9,
})
);
}
#[test]
fn typed_decoder_accepts_its_own_packet_id() {
let ping = Ping {
sequence: 5,
sent_at_micros: 6,
};
let frame = PacketEncoder::default().encode(&ping).unwrap();
assert_eq!(
PacketDecoder::<Ping>::default().decode_datagram(&frame),
Ok(ping)
);
let pong_frame = PacketEncoder::default().encode(&Pong).unwrap();
assert_eq!(
PacketDecoder::<Pong>::default().decode_datagram(&pong_frame),
Ok(Pong)
);
}
#[test]
fn datagrams_reject_empty_unknown_trailing_and_payload_data() {
let decoder = PacketDecoder::<SamplePacket>::default();
assert_eq!(
decoder.decode_datagram(&[]),
Err(ProtocolError::IncompleteFrame { buffered: 0 })
);
assert_eq!(
decoder.decode_datagram(&[1, 63]),
Err(ProtocolError::UnknownPacketId(PacketId::new(63)))
);
assert_eq!(
decoder.decode_datagram(&[2, 4, 0xff]),
Err(ProtocolError::TrailingPayload {
packet_id: Pong::ID,
remaining: 1,
})
);
let ping = PacketEncoder::default()
.encode(&Ping {
sequence: 1,
sent_at_micros: 2,
})
.unwrap();
let mut two_frames = ping.clone();
two_frames.extend_from_slice(&[1, 4]);
assert_eq!(
decoder.decode_datagram(&two_frames),
Err(ProtocolError::TrailingFrameData(2))
);
}
#[test]
fn field_decode_limits_are_forwarded_from_codec_config() {
let packet = DebugMessage {
level: DebugLevel::Info,
target: "net".to_owned(),
message: String::new(),
};
let frame = PacketEncoder::default().encode(&packet).unwrap();
let decoder = PacketDecoder::<SamplePacket>::new(CodecConfig {
decode_limits: DecodeLimits {
max_string_len: 2,
max_collection_len: 10,
},
..CodecConfig::default()
});
assert_eq!(
decoder.decode_datagram(&frame),
Err(ProtocolError::LengthLimitExceeded {
kind: "string",
length: 3,
maximum: 2,
})
);
}
#[test]
fn push_limit_failure_is_atomic_and_clear_resets_state() {
let mut decoder = PacketDecoder::<SamplePacket>::new(CodecConfig {
max_buffered_len: 3,
..CodecConfig::default()
});
decoder.push(&[1, 2]).unwrap();
assert_eq!(
decoder.push(&[3, 4]),
Err(ProtocolError::BufferedDataLimitExceeded {
attempted: 4,
limit: 3,
})
);
assert_eq!(decoder.buffered_len(), 2);
assert_eq!(
decoder.finish(),
Err(ProtocolError::IncompleteFrame { buffered: 2 })
);
decoder.clear();
assert!(decoder.is_empty());
assert_eq!(decoder.finish(), Ok(()));
}
#[test]
fn push_discards_consumed_prefix_before_appending() {
let encoder = PacketEncoder::default();
let first = encoder.encode(&Pong).unwrap();
let second = encoder
.encode(&Ping {
sequence: 1,
sent_at_micros: 2,
})
.unwrap();
let third = encoder.encode(&Pong).unwrap();
let mut initial = first.clone();
initial.extend_from_slice(&second);
let mut decoder = PacketDecoder::<SamplePacket>::default();
decoder.push(&initial).unwrap();
assert_eq!(
decoder.try_decode().unwrap(),
Some(SamplePacket::Pong(Pong))
);
assert_eq!(decoder.start, first.len());
decoder.push(&third).unwrap();
assert_eq!(decoder.start, 0);
assert_eq!(decoder.buffered_len(), second.len() + third.len());
assert!(matches!(
decoder.try_decode().unwrap(),
Some(SamplePacket::Ping(_))
));
assert_eq!(
decoder.try_decode().unwrap(),
Some(SamplePacket::Pong(Pong))
);
assert!(decoder.is_empty());
}
#[test]
fn decoder_compacts_after_consuming_a_large_prefix() {
let encoder = PacketEncoder::default();
let large = encoder
.encode(&DebugMessage {
level: DebugLevel::Info,
target: String::new(),
message: "x".repeat(COMPACT_AFTER_BYTES + 100),
})
.unwrap();
let remaining = encoder.encode(&Pong).unwrap();
let mut bytes = large.clone();
bytes.extend_from_slice(&remaining);
let mut decoder = PacketDecoder::<SamplePacket>::default();
decoder.push(&bytes).unwrap();
assert!(matches!(
decoder.try_decode().unwrap(),
Some(SamplePacket::DebugMessage(_))
));
assert_eq!(decoder.start, 0);
assert_eq!(decoder.buffer, remaining);
assert_eq!(
decoder.try_decode().unwrap(),
Some(SamplePacket::Pong(Pong))
);
}
#[test]
fn decoder_retains_a_large_prefix_when_it_is_less_than_half_the_buffer() {
let encoder = PacketEncoder::default();
let first = encoder
.encode(&DebugMessage {
level: DebugLevel::Info,
target: String::new(),
message: "a".repeat(COMPACT_AFTER_BYTES + 100),
})
.unwrap();
let second = encoder
.encode(&DebugMessage {
level: DebugLevel::Info,
target: String::new(),
message: "b".repeat((COMPACT_AFTER_BYTES + 100) * 2),
})
.unwrap();
let mut bytes = first.clone();
bytes.extend_from_slice(&second);
let mut decoder = PacketDecoder::<SamplePacket>::default();
decoder.push(&bytes).unwrap();
assert!(matches!(
decoder.try_decode().unwrap(),
Some(SamplePacket::DebugMessage(_))
));
assert_eq!(decoder.start, first.len());
assert_eq!(decoder.buffer.len(), bytes.len());
}
#[test]
fn malformed_headers_are_not_consumed() {
let mut decoder = PacketDecoder::<SamplePacket>::default();
decoder.push(&[0x40, 0x01]).unwrap();
let expected = Err(ProtocolError::NonCanonicalVarInt {
value: 1,
encoded_length: 2,
});
assert_eq!(decoder.try_decode(), expected);
assert_eq!(decoder.buffered_len(), 2);
assert_eq!(decoder.try_decode(), expected);
}
#[test]
fn frame_inspection_covers_partial_and_invalid_headers() {
let config = CodecConfig::default();
assert!(inspect_frame(&[], config).unwrap().is_none());
for bytes in [
&[0x40][..],
&[0x80, 0, 0][..],
&[0xc0, 0, 0, 0, 0, 0, 0][..],
] {
assert!(inspect_frame(bytes, config).unwrap().is_none());
}
assert_eq!(
inspect_frame(&[0], config).unwrap_err(),
ProtocolError::InvalidFrameLength(0)
);
assert_eq!(
inspect_frame(&[0x40, 0x01], config).unwrap_err(),
ProtocolError::NonCanonicalVarInt {
value: 1,
encoded_length: 2,
}
);
assert!(inspect_frame(&[2, 1], config).unwrap().is_none());
assert_eq!(
inspect_frame(&[1, 0x40], config).unwrap_err(),
ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 1,
}
);
assert_eq!(
inspect_frame(&[2, 0x40, 1], config).unwrap_err(),
ProtocolError::NonCanonicalVarInt {
value: 1,
encoded_length: 2,
}
);
assert_eq!(
inspect_frame(&[4, 0x80, 0x01, 0x00, 0x00], config).unwrap_err(),
ProtocolError::PacketIdOutOfRange(65_536)
);
}
#[test]
fn four_byte_frame_length_round_trips() {
let packet = DebugMessage {
level: DebugLevel::Debug,
target: "large".to_owned(),
message: "z".repeat(20_000),
};
let frame = PacketEncoder::default().encode(&packet).unwrap();
assert_eq!(varint_length_from_first(frame[0]), 4);
assert_eq!(
PacketDecoder::<SamplePacket>::default()
.decode_datagram(&frame)
.unwrap(),
SamplePacket::from(packet)
);
}
}