use crate::{ProtocolError, Result};
const MAX_VARINT_VALUE: u64 = (1 << 62) - 1;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DecodeLimits {
pub max_string_len: usize,
pub max_collection_len: usize,
}
impl Default for DecodeLimits {
fn default() -> Self {
Self {
max_string_len: 256 * 1024,
max_collection_len: 256 * 1024,
}
}
}
#[derive(Debug, Clone)]
pub struct BinaryWriter {
buffer: Vec<u8>,
limit: usize,
}
impl Default for BinaryWriter {
fn default() -> Self {
Self::new()
}
}
impl BinaryWriter {
pub fn new() -> Self {
Self {
buffer: Vec::new(),
limit: usize::MAX,
}
}
pub fn with_limit(limit: usize) -> Self {
Self {
buffer: Vec::new(),
limit,
}
}
pub fn len(&self) -> usize {
self.buffer.len()
}
pub fn is_empty(&self) -> bool {
self.buffer.is_empty()
}
pub fn as_slice(&self) -> &[u8] {
&self.buffer
}
pub fn into_inner(self) -> Vec<u8> {
self.buffer
}
pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<()> {
let attempted = self.buffer.len().saturating_add(bytes.len());
if attempted > self.limit {
return Err(ProtocolError::WriteLimitExceeded {
attempted,
limit: self.limit,
});
}
self.buffer.extend_from_slice(bytes);
Ok(())
}
pub fn write_var_u64(&mut self, value: u64) -> Result<()> {
let (encoded, length) = encode_varint(value)?;
self.write_bytes(&encoded[..length])
}
}
#[derive(Debug, Clone)]
pub struct BinaryReader<'a> {
input: &'a [u8],
position: usize,
limits: DecodeLimits,
}
impl<'a> BinaryReader<'a> {
pub fn new(input: &'a [u8]) -> Self {
Self::with_limits(input, DecodeLimits::default())
}
pub fn with_limits(input: &'a [u8], limits: DecodeLimits) -> Self {
Self {
input,
position: 0,
limits,
}
}
pub fn position(&self) -> usize {
self.position
}
pub fn remaining(&self) -> usize {
self.input.len() - self.position
}
pub fn is_empty(&self) -> bool {
self.remaining() == 0
}
pub fn limits(&self) -> DecodeLimits {
self.limits
}
pub fn read_bytes(&mut self, length: usize) -> Result<&'a [u8]> {
if length > self.remaining() {
return Err(ProtocolError::UnexpectedEnd {
needed: length,
remaining: self.remaining(),
});
}
let start = self.position;
self.position += length;
Ok(&self.input[start..self.position])
}
pub fn read_var_u64(&mut self) -> Result<u64> {
let first = *self
.input
.get(self.position)
.ok_or(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})?;
let length = varint_length_from_first(first);
let bytes = self.read_bytes(length)?;
decode_varint_bytes(bytes, true)
}
fn read_length(&mut self, kind: &'static str, maximum: usize) -> Result<usize> {
let length = self.read_var_u64()?;
if length > maximum as u64 {
return Err(ProtocolError::LengthLimitExceeded {
kind,
length,
maximum,
});
}
Ok(length as usize)
}
}
pub trait BinaryEncode {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()>;
}
pub trait BinaryDecode: Sized {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self>;
}
impl<T: BinaryEncode + ?Sized> BinaryEncode for &T {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
(*self).encode(writer)
}
}
macro_rules! fixed_width_integer {
($type:ty, $size:expr) => {
impl BinaryEncode for $type {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
writer.write_bytes(&self.to_be_bytes())
}
}
impl BinaryDecode for $type {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
let bytes: [u8; $size] = reader.read_bytes($size)?.try_into().expect("fixed size");
Ok(Self::from_be_bytes(bytes))
}
}
};
}
fixed_width_integer!(u16, 2);
fixed_width_integer!(u32, 4);
fixed_width_integer!(u64, 8);
fixed_width_integer!(u128, 16);
fixed_width_integer!(i16, 2);
fixed_width_integer!(i32, 4);
fixed_width_integer!(i64, 8);
fixed_width_integer!(i128, 16);
impl BinaryEncode for u8 {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
writer.write_bytes(&[*self])
}
}
impl BinaryDecode for u8 {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
Ok(reader.read_bytes(1)?[0])
}
}
impl BinaryEncode for i8 {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
(*self as u8).encode(writer)
}
}
impl BinaryDecode for i8 {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
Ok(u8::decode(reader)? as Self)
}
}
impl BinaryEncode for f32 {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
self.to_bits().encode(writer)
}
}
impl BinaryDecode for f32 {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
Ok(Self::from_bits(u32::decode(reader)?))
}
}
impl BinaryEncode for f64 {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
self.to_bits().encode(writer)
}
}
impl BinaryDecode for f64 {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
Ok(Self::from_bits(u64::decode(reader)?))
}
}
impl BinaryEncode for bool {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
u8::from(*self).encode(writer)
}
}
impl BinaryDecode for bool {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
match u8::decode(reader)? {
0 => Ok(false),
1 => Ok(true),
value => Err(ProtocolError::InvalidBool(value)),
}
}
}
impl BinaryEncode for str {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
writer
.write_var_u64(self.len() as u64)
.and_then(|()| writer.write_bytes(self.as_bytes()))
}
}
impl BinaryEncode for String {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
self.as_str().encode(writer)
}
}
impl BinaryDecode for String {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
let length = reader.read_length("string", reader.limits.max_string_len)?;
let bytes = reader.read_bytes(length)?;
let value = std::str::from_utf8(bytes).map_err(|_| ProtocolError::InvalidUtf8)?;
Ok(value.to_owned())
}
}
impl<T: BinaryEncode> BinaryEncode for [T] {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
writer
.write_var_u64(self.len() as u64)
.and_then(|()| self.iter().try_for_each(|value| value.encode(writer)))
}
}
impl<T: BinaryEncode> BinaryEncode for Vec<T> {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
self.as_slice().encode(writer)
}
}
impl<T: BinaryDecode> BinaryDecode for Vec<T> {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
reader
.read_length("collection", reader.limits.max_collection_len)
.and_then(|length| {
(0..length).map(|_| T::decode(reader)).collect()
})
}
}
impl<T: BinaryEncode, const N: usize> BinaryEncode for [T; N] {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
self.iter().try_for_each(|value| value.encode(writer))
}
}
impl<T: BinaryDecode, const N: usize> BinaryDecode for [T; N] {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
(0..N)
.map(|_| T::decode(reader))
.collect::<Result<Vec<_>>>()
.map(|values| {
let mut values = values.into_iter();
std::array::from_fn(|_| values.next().expect("exactly N elements were decoded"))
})
}
}
impl<T: BinaryEncode> BinaryEncode for Option<T> {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
match self {
Some(value) => true.encode(writer).and_then(|()| value.encode(writer)),
None => false.encode(writer),
}
}
}
impl<T: BinaryDecode> BinaryDecode for Option<T> {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
bool::decode(reader).and_then(|present| {
if present {
T::decode(reader).map(Some)
} else {
Ok(None)
}
})
}
}
impl<T: BinaryEncode + ?Sized> BinaryEncode for Box<T> {
fn encode(&self, writer: &mut BinaryWriter) -> Result<()> {
self.as_ref().encode(writer)
}
}
impl<T: BinaryDecode> BinaryDecode for Box<T> {
fn decode(reader: &mut BinaryReader<'_>) -> Result<Self> {
T::decode(reader).map(Box::new)
}
}
impl BinaryEncode for () {
fn encode(&self, _writer: &mut BinaryWriter) -> Result<()> {
Ok(())
}
}
impl BinaryDecode for () {
fn decode(_reader: &mut BinaryReader<'_>) -> Result<Self> {
Ok(())
}
}
pub(crate) fn varint_length(value: u64) -> Result<usize> {
if value > MAX_VARINT_VALUE {
Err(ProtocolError::VarIntOutOfRange { value })
} else {
Ok(varint_length_in_range(value))
}
}
pub(crate) fn varint_length_in_range(value: u64) -> usize {
match value {
0..=63 => 1,
64..=16_383 => 2,
16_384..=1_073_741_823 => 4,
_ => 8,
}
}
pub(crate) fn varint_length_from_first(first: u8) -> usize {
1 << (first >> 6)
}
pub(crate) fn encode_varint(value: u64) -> Result<([u8; 8], usize)> {
varint_length(value).map(|_| encode_varint_in_range(value))
}
pub(crate) fn encode_varint_in_range(value: u64) -> ([u8; 8], usize) {
let length = varint_length_in_range(value);
let mut bytes = value.to_be_bytes();
let prefix = length.trailing_zeros() as u8;
let start = bytes.len() - length;
bytes[start] |= prefix << 6;
bytes.copy_within(start.., 0);
(bytes, length)
}
pub(crate) fn decode_varint_bytes(bytes: &[u8], canonical: bool) -> Result<u64> {
let Some(&first) = bytes.first() else {
return Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
});
};
let length = bytes.len();
if !matches!(length, 1 | 2 | 4 | 8) || varint_length_from_first(first) != length {
return Err(ProtocolError::UnexpectedEnd {
needed: varint_length_from_first(first),
remaining: length,
});
}
let mut value = u64::from(first & 0x3f);
for byte in &bytes[1..] {
value = (value << 8) | u64::from(*byte);
}
if canonical && varint_length_in_range(value) != length {
return Err(ProtocolError::NonCanonicalVarInt {
value,
encoded_length: length,
});
}
Ok(value)
}
#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod tests {
use super::*;
fn encode<T: BinaryEncode + ?Sized>(value: &T) -> Vec<u8> {
let mut writer = BinaryWriter::new();
value.encode(&mut writer).unwrap();
writer.into_inner()
}
fn round_trip<T>(value: T) -> T
where
T: BinaryEncode + BinaryDecode,
{
let bytes = encode(&value);
let mut reader = BinaryReader::new(&bytes);
let decoded = T::decode(&mut reader).unwrap();
assert!(reader.is_empty());
decoded
}
#[test]
fn quic_varints_round_trip_at_boundaries() {
for value in [
0,
63,
64,
16_383,
16_384,
1_073_741_823,
1_073_741_824,
MAX_VARINT_VALUE,
] {
let (encoded, length) = encode_varint(value).unwrap();
assert_eq!(decode_varint_bytes(&encoded[..length], true), Ok(value));
}
}
#[test]
fn rejects_varints_above_62_bits_without_writing() {
for value in [MAX_VARINT_VALUE + 1, u64::MAX] {
let error = ProtocolError::VarIntOutOfRange { value };
assert_eq!(varint_length(value), Err(error.clone()));
assert_eq!(encode_varint(value), Err(error.clone()));
let mut writer = BinaryWriter::new();
writer.write_bytes(&[0xaa]).unwrap();
assert_eq!(writer.write_var_u64(value), Err(error));
assert_eq!(writer.as_slice(), &[0xaa]);
}
}
#[test]
fn fixed_width_u64_retains_its_full_range() {
let mut writer = BinaryWriter::new();
u64::MAX.encode(&mut writer).unwrap();
let mut reader = BinaryReader::new(writer.as_slice());
assert_eq!(u64::decode(&mut reader), Ok(u64::MAX));
assert!(reader.is_empty());
}
#[test]
fn common_values_round_trip() {
let value = (
"packetwire".to_owned(),
vec![1_u16, 2, 65_535],
Some(42_u64),
);
let mut writer = BinaryWriter::new();
value.0.encode(&mut writer).unwrap();
value.1.encode(&mut writer).unwrap();
value.2.encode(&mut writer).unwrap();
let mut reader = BinaryReader::new(writer.as_slice());
assert_eq!(String::decode(&mut reader).unwrap(), value.0);
assert_eq!(Vec::<u16>::decode(&mut reader).unwrap(), value.1);
assert_eq!(Option::<u64>::decode(&mut reader).unwrap(), value.2);
assert!(reader.is_empty());
}
#[test]
fn rejects_non_canonical_varint() {
let mut reader = BinaryReader::new(&[0x40, 0x01]);
assert_eq!(
reader.read_var_u64(),
Err(ProtocolError::NonCanonicalVarInt {
value: 1,
encoded_length: 2,
})
);
}
#[test]
fn writer_accessors_and_limits_are_atomic() {
let mut writer = BinaryWriter::default();
assert!(writer.is_empty());
assert_eq!(writer.len(), 0);
writer.write_bytes(&[1, 2]).unwrap();
assert_eq!(writer.len(), 2);
assert_eq!(writer.as_slice(), &[1, 2]);
assert_eq!(writer.clone().into_inner(), vec![1, 2]);
let mut limited = BinaryWriter::with_limit(3);
limited.write_bytes(&[1, 2]).unwrap();
assert_eq!(
limited.write_bytes(&[3, 4]),
Err(ProtocolError::WriteLimitExceeded {
attempted: 4,
limit: 3,
})
);
assert_eq!(limited.as_slice(), &[1, 2]);
}
#[test]
fn reader_accessors_and_short_reads_preserve_position() {
let limits = DecodeLimits {
max_string_len: 7,
max_collection_len: 9,
};
let mut reader = BinaryReader::with_limits(&[1, 2, 3], limits);
assert_eq!(reader.position(), 0);
assert_eq!(reader.remaining(), 3);
assert_eq!(reader.limits(), limits);
assert_eq!(reader.read_bytes(0), Ok(&[][..]));
assert_eq!(reader.read_bytes(2), Ok(&[1, 2][..]));
assert_eq!(reader.position(), 2);
assert_eq!(reader.remaining(), 1);
assert_eq!(
reader.read_bytes(2),
Err(ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 1,
})
);
assert_eq!(reader.position(), 2);
assert_eq!(reader.read_bytes(1), Ok(&[3][..]));
assert!(reader.is_empty());
assert_eq!(
DecodeLimits::default(),
DecodeLimits {
max_string_len: 256 * 1024,
max_collection_len: 256 * 1024,
}
);
}
#[test]
fn every_fixed_width_integer_is_big_endian_and_round_trips() {
macro_rules! check {
($type:ty, $value:expr) => {{
let value: $type = $value;
assert_eq!(encode(&value), value.to_be_bytes());
assert_eq!(round_trip(value), value);
}};
}
check!(u16, u16::MAX);
check!(u32, u32::MAX);
check!(u64, u64::MAX);
check!(u128, u128::MAX);
check!(i16, i16::MIN);
check!(i32, i32::MIN);
check!(i64, i64::MIN);
check!(i128, i128::MIN);
check!(u8, u8::MAX);
check!(i8, i8::MIN);
let mut reader = BinaryReader::new(&[]);
assert_eq!(
u128::decode(&mut reader),
Err(ProtocolError::UnexpectedEnd {
needed: 16,
remaining: 0,
})
);
}
#[test]
fn floats_preserve_their_exact_bits() {
for bits in [
0_u32,
(-0.0_f32).to_bits(),
f32::INFINITY.to_bits(),
0x7fc0_1234,
] {
let value = f32::from_bits(bits);
assert_eq!(round_trip(value).to_bits(), bits);
}
for bits in [
0_u64,
(-0.0_f64).to_bits(),
f64::NEG_INFINITY.to_bits(),
0x7ff8_0000_0000_1234,
] {
let value = f64::from_bits(bits);
assert_eq!(round_trip(value).to_bits(), bits);
}
}
#[test]
fn booleans_use_only_zero_and_one() {
assert_eq!(encode(&false), vec![0]);
assert_eq!(encode(&true), vec![1]);
assert!(!round_trip(false));
assert!(round_trip(true));
let mut reader = BinaryReader::new(&[2]);
assert_eq!(
bool::decode(&mut reader),
Err(ProtocolError::InvalidBool(2))
);
}
#[test]
fn strings_validate_lengths_utf8_and_writer_limits() {
assert_eq!(round_trip(String::new()), "");
assert_eq!(round_trip("héllo".to_owned()), "héllo");
let mut invalid = BinaryReader::new(&[1, 0xff]);
assert_eq!(
String::decode(&mut invalid),
Err(ProtocolError::InvalidUtf8)
);
let limits = DecodeLimits {
max_string_len: 1,
..DecodeLimits::default()
};
let mut too_large = BinaryReader::with_limits(&[2, b'a', b'b'], limits);
assert_eq!(
String::decode(&mut too_large),
Err(ProtocolError::LengthLimitExceeded {
kind: "string",
length: 2,
maximum: 1,
})
);
let mut truncated = BinaryReader::new(&[2, b'a']);
assert_eq!(
String::decode(&mut truncated),
Err(ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 1,
})
);
let mut writer = BinaryWriter::with_limit(1);
assert_eq!(
"ab".encode(&mut writer),
Err(ProtocolError::WriteLimitExceeded {
attempted: 3,
limit: 1,
})
);
assert_eq!(writer.as_slice(), &[2]);
}
#[test]
fn collections_arrays_options_boxes_references_and_unit_round_trip() {
assert_eq!(round_trip(Vec::<u16>::new()), Vec::<u16>::new());
assert_eq!(round_trip(vec![1_u16, 2, 3]), vec![1, 2, 3]);
assert_eq!(round_trip::<[u8; 0]>([]), []);
assert_eq!(round_trip([1_u16, 2, 3]), [1, 2, 3]);
assert_eq!(round_trip::<Option<u32>>(None), None);
assert_eq!(round_trip(Some(17_u32)), Some(17));
assert_eq!(round_trip(Box::new(21_u64)), Box::new(21));
assert_eq!(round_trip(()), ());
let value = 0x1234_u16;
let mut writer = BinaryWriter::new();
<&u16 as BinaryEncode>::encode(&&value, &mut writer).unwrap();
assert_eq!(writer.as_slice(), &[0x12, 0x34]);
let values = [4_u8, 5, 6];
let mut writer = BinaryWriter::new();
<[u8] as BinaryEncode>::encode(&values, &mut writer).unwrap();
assert_eq!(writer.as_slice(), &[3, 4, 5, 6]);
}
#[test]
fn collection_and_composite_errors_propagate() {
let mut empty_string = BinaryReader::new(&[]);
assert_eq!(
String::decode(&mut empty_string),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
let mut empty_vec = BinaryReader::new(&[]);
assert_eq!(
Vec::<u8>::decode(&mut empty_vec),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
let limits = DecodeLimits {
max_collection_len: 1,
..DecodeLimits::default()
};
let mut too_large = BinaryReader::with_limits(&[2], limits);
assert_eq!(
Vec::<u8>::decode(&mut too_large),
Err(ProtocolError::LengthLimitExceeded {
kind: "collection",
length: 2,
maximum: 1,
})
);
let mut truncated_vec = BinaryReader::new(&[2, 7]);
assert_eq!(
Vec::<u8>::decode(&mut truncated_vec),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
let mut truncated_array = BinaryReader::new(&[0, 1]);
assert_eq!(
<[u16; 2]>::decode(&mut truncated_array),
Err(ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 0,
})
);
let mut invalid_option = BinaryReader::new(&[3]);
assert_eq!(
Option::<u8>::decode(&mut invalid_option),
Err(ProtocolError::InvalidBool(3))
);
let mut truncated_option = BinaryReader::new(&[1]);
assert_eq!(
Option::<u16>::decode(&mut truncated_option),
Err(ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 0,
})
);
let mut reader = BinaryReader::new(&[0]);
assert_eq!(Option::<u8>::decode(&mut reader), Ok(None));
let mut reader = BinaryReader::new(&[1, 7]);
assert_eq!(Option::<u8>::decode(&mut reader), Ok(Some(7)));
let mut reader = BinaryReader::new(&[0]);
assert_eq!(Option::<u16>::decode(&mut reader), Ok(None));
let mut reader = BinaryReader::new(&[1, 0, 7]);
assert_eq!(Option::<u16>::decode(&mut reader), Ok(Some(7)));
let mut reader = BinaryReader::new(&[0]);
assert_eq!(Option::<u64>::decode(&mut reader), Ok(None));
assert_eq!(encode(&Option::<u8>::None), [0]);
assert_eq!(encode(&Option::<u16>::None), [0]);
assert_eq!(encode(&Option::<u64>::None), [0]);
let mut writer = BinaryWriter::with_limit(2);
assert_eq!(
vec![1_u16].encode(&mut writer),
Err(ProtocolError::WriteLimitExceeded {
attempted: 3,
limit: 2,
})
);
assert_eq!(writer.as_slice(), &[1]);
let mut writer = BinaryWriter::with_limit(2);
assert_eq!(
[1_u16, 2].encode(&mut writer),
Err(ProtocolError::WriteLimitExceeded {
attempted: 4,
limit: 2,
})
);
assert_eq!(writer.as_slice(), &[0, 1]);
let mut writer = BinaryWriter::with_limit(1);
assert_eq!(
Some(1_u16).encode(&mut writer),
Err(ProtocolError::WriteLimitExceeded {
attempted: 3,
limit: 1,
})
);
assert_eq!(writer.as_slice(), &[1]);
let mut writer = BinaryWriter::with_limit(0);
assert_eq!(
Some(1_u8).encode(&mut writer),
Err(ProtocolError::WriteLimitExceeded {
attempted: 1,
limit: 0,
})
);
assert!(writer.is_empty());
}
#[test]
fn primitive_and_box_decode_errors_propagate() {
let mut reader = BinaryReader::new(&[]);
assert_eq!(
i8::decode(&mut reader),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
let mut reader = BinaryReader::new(&[0, 0, 0]);
assert_eq!(
f32::decode(&mut reader),
Err(ProtocolError::UnexpectedEnd {
needed: 4,
remaining: 3,
})
);
let mut reader = BinaryReader::new(&[0; 7]);
assert_eq!(
f64::decode(&mut reader),
Err(ProtocolError::UnexpectedEnd {
needed: 8,
remaining: 7,
})
);
let mut reader = BinaryReader::new(&[]);
assert_eq!(
bool::decode(&mut reader),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
let mut reader = BinaryReader::new(&[]);
assert_eq!(
Box::<u16>::decode(&mut reader),
Err(ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 0,
})
);
}
#[test]
fn varint_helpers_reject_empty_truncated_and_mismatched_inputs() {
assert_eq!(varint_length_from_first(0x00), 1);
assert_eq!(varint_length_from_first(0x40), 2);
assert_eq!(varint_length_from_first(0x80), 4);
assert_eq!(varint_length_from_first(0xc0), 8);
assert_eq!(
decode_varint_bytes(&[], true),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
assert_eq!(
decode_varint_bytes(&[0, 0, 0], true),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 3,
})
);
assert_eq!(
decode_varint_bytes(&[0x40], true),
Err(ProtocolError::UnexpectedEnd {
needed: 2,
remaining: 1,
})
);
assert_eq!(decode_varint_bytes(&[0x40, 1], false), Ok(1));
let mut empty = BinaryReader::new(&[]);
assert_eq!(
empty.read_var_u64(),
Err(ProtocolError::UnexpectedEnd {
needed: 1,
remaining: 0,
})
);
let mut truncated = BinaryReader::new(&[0x80, 0]);
assert_eq!(
truncated.read_var_u64(),
Err(ProtocolError::UnexpectedEnd {
needed: 4,
remaining: 2,
})
);
}
}