use core::mem::MaybeUninit;
use bytes::{Buf, BufMut, Bytes, BytesMut};
use crate::alloc::vec::Vec;
pub trait EncodeSink {
const IS_SEGMENTED: bool = false;
fn put_u8(&mut self, value: u8);
fn put_slice(&mut self, src: &[u8]);
fn put_u32_le(&mut self, value: u32);
fn put_u64_le(&mut self, value: u64);
#[inline]
fn put_i32_le(&mut self, value: i32) {
#[allow(clippy::cast_sign_loss)]
self.put_u32_le(value as u32);
}
#[inline]
fn put_i64_le(&mut self, value: i64) {
#[allow(clippy::cast_sign_loss)]
self.put_u64_le(value as u64);
}
#[inline]
fn put_f32_le(&mut self, value: f32) {
self.put_u32_le(value.to_bits());
}
#[inline]
fn put_f64_le(&mut self, value: f64) {
self.put_u64_le(value.to_bits());
}
#[inline]
fn put_shared(&mut self, bytes: Bytes) {
self.put_slice(&bytes);
}
#[doc(hidden)]
const __PRE_SIZED: bool = false;
#[doc(hidden)]
#[inline]
fn __with_pre_sized(&mut self, f: &mut dyn FnMut(&mut PreSized<'_>)) -> bool {
let _ = f;
false
}
#[doc(hidden)]
#[inline]
fn __write_pre_sized<F: FnOnce(&mut PreSized<'_>)>(
&mut self,
len: usize,
fill: F,
) -> Result<(), F> {
let _ = len;
Err(fill)
}
}
impl<T: BufMut + ?Sized> EncodeSink for T {
const __PRE_SIZED: bool = true;
#[inline]
fn __write_pre_sized<F: FnOnce(&mut PreSized<'_>)>(
&mut self,
len: usize,
fill: F,
) -> Result<(), F> {
let spare: &mut [MaybeUninit<u8>] = if len == 0 {
&mut []
} else {
let chunk = BufMut::chunk_mut(self);
if chunk.len() < len {
return Err(fill);
}
unsafe {
core::slice::from_raw_parts_mut(chunk.as_mut_ptr().cast::<MaybeUninit<u8>>(), len)
}
};
let mut cursor = PreSized::new(spare);
fill(&mut cursor);
let written = cursor.written();
unsafe { BufMut::advance_mut(self, written) };
Ok(())
}
#[inline]
fn put_u8(&mut self, value: u8) {
BufMut::put_u8(self, value);
}
#[inline]
fn put_slice(&mut self, src: &[u8]) {
BufMut::put_slice(self, src);
}
#[inline]
fn put_u32_le(&mut self, value: u32) {
BufMut::put_u32_le(self, value);
}
#[inline]
fn put_u64_le(&mut self, value: u64) {
BufMut::put_u64_le(self, value);
}
}
#[doc(hidden)]
pub struct PreSized<'a> {
dst: &'a mut [MaybeUninit<u8>],
pos: usize,
}
#[cold]
#[inline(never)]
fn pre_sized_overflow() -> ! {
panic!("write_to produced more bytes than compute_size declared (two-pass traversal mismatch)")
}
impl<'a> PreSized<'a> {
#[inline]
pub(crate) fn new(dst: &'a mut [MaybeUninit<u8>]) -> Self {
Self { dst, pos: 0 }
}
#[inline]
pub(crate) const fn written(&self) -> usize {
self.pos
}
}
impl EncodeSink for PreSized<'_> {
#[inline]
fn __with_pre_sized(&mut self, f: &mut dyn FnMut(&mut PreSized<'_>)) -> bool {
f(self);
true
}
#[inline]
fn put_u8(&mut self, value: u8) {
let Some(slot) = self.dst.get_mut(self.pos) else {
pre_sized_overflow()
};
slot.write(value);
self.pos += 1;
}
#[inline]
fn put_slice(&mut self, src: &[u8]) {
let Some(dst) = self
.dst
.get_mut(self.pos..)
.and_then(|rest| rest.get_mut(..src.len()))
else {
pre_sized_overflow()
};
unsafe {
core::ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr().cast::<u8>(), src.len());
}
self.pos += src.len();
}
#[inline]
fn put_u32_le(&mut self, value: u32) {
self.put_slice(&value.to_le_bytes());
}
#[inline]
fn put_u64_le(&mut self, value: u64) {
self.put_slice(&value.to_le_bytes());
}
}
#[inline]
pub(crate) fn write_contiguous<S: EncodeSink>(
size: usize,
cache: &mut crate::SizeCache,
buf: &mut S,
pre_sized: impl FnOnce(&mut crate::SizeCache, &mut PreSized<'_>),
per_write: impl FnOnce(&mut crate::SizeCache, &mut S),
) {
if S::IS_SEGMENTED || !S::__PRE_SIZED {
per_write(cache, buf);
return;
}
let fill = move |cursor: &mut PreSized<'_>| {
pre_sized(cache, cursor);
crate::message::debug_assert_two_pass(cursor.written(), size);
};
if let Err(fill) = buf.__write_pre_sized(size, fill) {
let scratch = write_to_new_vec(size, fill);
buf.put_slice(&scratch);
}
}
#[inline]
pub(crate) fn write_to_new_vec(size: usize, fill: impl FnOnce(&mut PreSized<'_>)) -> Vec<u8> {
debug_assert!(size <= crate::MAX_MESSAGE_BYTES as usize);
let mut vec = Vec::with_capacity(size);
let written = {
let mut cursor = PreSized::new(&mut vec.spare_capacity_mut()[..size]);
fill(&mut cursor);
cursor.written()
};
unsafe { vec.set_len(written) };
vec
}
pub const DEFAULT_MIN_SEGMENT: usize = 4 * 1024;
#[derive(Debug)]
pub struct Rope {
segments: Vec<Bytes>,
tail: BytesMut,
backing: Option<Bytes>,
min_segment: usize,
}
impl Default for Rope {
fn default() -> Self {
Self::new()
}
}
impl Rope {
#[must_use]
pub fn new() -> Self {
Self::with_min_segment(DEFAULT_MIN_SEGMENT)
}
#[must_use]
pub fn with_min_segment(min_segment: usize) -> Self {
Self {
segments: Vec::new(),
tail: BytesMut::new(),
backing: None,
min_segment: min_segment.max(1),
}
}
#[must_use]
pub fn with_backing(mut self, backing: Bytes) -> Self {
self.backing = Some(backing);
self
}
#[must_use]
pub fn len(&self) -> usize {
self.segments.iter().map(Bytes::len).sum::<usize>() + self.tail.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.tail.is_empty() && self.segments.is_empty()
}
#[must_use]
pub fn segment_count(&self) -> usize {
self.segments.len() + usize::from(!self.tail.is_empty())
}
#[must_use]
pub fn into_segments(mut self) -> Vec<Bytes> {
self.flush_tail();
self.segments
}
#[must_use]
pub fn to_contiguous_bytes(&self) -> Bytes {
let mut out = Vec::with_capacity(self.len());
for segment in &self.segments {
out.extend_from_slice(segment);
}
out.extend_from_slice(&self.tail);
Bytes::from(out)
}
fn flush_tail(&mut self) {
if !self.tail.is_empty() {
self.segments.push(self.tail.split().freeze());
}
}
}
impl EncodeSink for Rope {
const IS_SEGMENTED: bool = true;
#[inline]
fn put_u8(&mut self, value: u8) {
self.tail.extend_from_slice(&[value]);
}
#[inline]
fn put_slice(&mut self, src: &[u8]) {
if src.len() >= self.min_segment {
if let Some(segment) = self
.backing
.as_ref()
.and_then(|b| crate::view::try_slice_ref(b, src))
{
self.flush_tail();
self.segments.push(segment);
return;
}
}
self.tail.extend_from_slice(src);
}
#[inline]
fn put_u32_le(&mut self, value: u32) {
self.tail.extend_from_slice(&value.to_le_bytes());
}
#[inline]
fn put_u64_le(&mut self, value: u64) {
self.tail.extend_from_slice(&value.to_le_bytes());
}
#[inline]
fn put_shared(&mut self, bytes: Bytes) {
if bytes.len() >= self.min_segment {
self.flush_tail();
self.segments.push(bytes);
} else {
self.tail.extend_from_slice(&bytes);
}
}
}
impl EncodeSink for &mut Rope {
const IS_SEGMENTED: bool = true;
#[inline]
fn put_u8(&mut self, value: u8) {
Rope::put_u8(self, value);
}
#[inline]
fn put_slice(&mut self, src: &[u8]) {
Rope::put_slice(self, src);
}
#[inline]
fn put_u32_le(&mut self, value: u32) {
Rope::put_u32_le(self, value);
}
#[inline]
fn put_u64_le(&mut self, value: u64) {
Rope::put_u64_le(self, value);
}
#[inline]
fn put_shared(&mut self, bytes: Bytes) {
Rope::put_shared(self, bytes);
}
}
#[derive(Debug)]
pub struct RopeBuf {
segments: Vec<Bytes>,
pos: usize,
remaining: usize,
}
impl From<Rope> for RopeBuf {
fn from(rope: Rope) -> Self {
let segments = rope.into_segments();
let remaining = segments.iter().map(Bytes::len).sum();
Self {
segments,
pos: 0,
remaining,
}
}
}
impl Buf for RopeBuf {
fn remaining(&self) -> usize {
self.remaining
}
fn chunk(&self) -> &[u8] {
self.segments.get(self.pos).map_or(&[], |b| &b[..])
}
fn advance(&mut self, mut cnt: usize) {
assert!(cnt <= self.remaining, "advance past end of RopeBuf");
self.remaining -= cnt;
while cnt > 0 {
let front = &mut self.segments[self.pos];
if cnt < front.len() {
front.advance(cnt);
return;
}
cnt -= front.len();
*front = Bytes::new();
self.pos += 1;
}
}
#[inline]
fn copy_to_bytes(&mut self, len: usize) -> Bytes {
assert!(len <= self.remaining, "copy_to_bytes past end of RopeBuf");
if len == 0 {
return Bytes::new();
}
if len <= self.chunk().len() {
let front = &mut self.segments[self.pos];
let bytes = front.split_to(len);
self.remaining -= len;
if front.is_empty() {
self.pos += 1;
}
return bytes;
}
let mut bytes = BytesMut::with_capacity(len);
bytes.put(self.take(len));
bytes.freeze()
}
#[cfg(feature = "std")]
fn chunks_vectored<'a>(&'a self, dst: &mut [std::io::IoSlice<'a>]) -> usize {
let mut n = 0;
for segment in &self.segments[self.pos..] {
if n == dst.len() {
break;
}
debug_assert!(!segment.is_empty());
dst[n] = std::io::IoSlice::new(segment);
n += 1;
}
n
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_doubles::Probe;
#[test]
fn default_matches_new() {
let mut rope = Rope::default();
rope.put_shared(Bytes::from_static(b"tiny"));
rope.put_shared(Bytes::new());
assert_eq!(rope.segment_count(), 1);
let segments = rope.into_segments();
assert_eq!(segments.len(), 1);
assert!(!segments[0].is_empty());
}
#[test]
fn mut_ref_forwarding_impl() {
fn write_through(mut sink: impl EncodeSink) {
sink.put_slice(b"via reborrow");
sink.put_shared(Bytes::from(crate::alloc::vec![9u8; 64]));
}
let mut rope = Rope::with_min_segment(64);
write_through(&mut rope);
assert_eq!(rope.segment_count(), 2);
assert_eq!(rope.len(), 12 + 64);
}
#[test]
fn advance_releases_consumed_segments() {
let payload = Bytes::from(crate::alloc::vec![3u8; 128]);
let mut rope = Rope::with_min_segment(64);
rope.put_shared(payload.clone());
rope.put_slice(b"after");
let mut buf = RopeBuf::from(rope);
assert!(payload.clone().try_into_mut().is_err(), "not unique yet");
buf.advance(128);
assert!(
payload.try_into_mut().is_ok(),
"consumed segment must be released before RopeBuf drop"
);
assert_eq!(buf.copy_to_bytes(buf.remaining()), &b"after"[..]);
}
#[test]
fn small_writes_coalesce() {
let mut rope = Rope::with_min_segment(16);
rope.put_u8(1);
rope.put_slice(b"abc");
rope.put_u32_le(7);
rope.put_u64_le(9);
assert_eq!(rope.segment_count(), 1);
let segments = rope.into_segments();
assert_eq!(segments.len(), 1);
assert_eq!(segments[0].len(), 1 + 3 + 4 + 8);
}
#[test]
fn large_shared_segment_is_not_copied() {
let payload = Bytes::from(crate::alloc::vec![0xAB; 64]);
let ptr = payload.as_ptr();
let mut rope = Rope::with_min_segment(64);
rope.put_slice(b"head");
rope.put_shared(payload);
rope.put_slice(b"tail");
let segments = rope.into_segments();
assert_eq!(segments.len(), 3);
assert_eq!(&segments[0][..], b"head");
assert!(core::ptr::eq(segments[1].as_ptr(), ptr), "must not copy");
assert_eq!(&segments[2][..], b"tail");
}
#[test]
fn small_shared_write_coalesces() {
let mut rope = Rope::with_min_segment(64);
rope.put_slice(b"a");
rope.put_shared(Bytes::from_static(b"bc"));
rope.put_slice(b"d");
let segments = rope.into_segments();
assert_eq!(segments.len(), 1);
assert_eq!(&segments[0][..], b"abcd");
}
#[test]
fn backed_slice_is_captured_zero_copy() {
let backing = Bytes::from(crate::alloc::vec![0x5A; 256]);
let inside: &[u8] = &backing[32..224];
let outside = crate::alloc::vec![0x5A; 192];
let mut rope = Rope::with_min_segment(64).with_backing(backing.clone());
rope.put_slice(inside);
rope.put_slice(&outside);
let segments = rope.into_segments();
assert_eq!(segments.len(), 2);
assert!(
core::ptr::eq(segments[0].as_ptr(), inside.as_ptr()),
"backed slice must be zero-copy"
);
assert!(
!core::ptr::eq(segments[1].as_ptr(), outside.as_ptr()),
"unbacked slice must be copied"
);
assert_eq!(&segments[1][..], &outside[..]);
}
#[test]
fn segments_concatenate_to_contiguous_output() {
let payload = Bytes::from(crate::alloc::vec![0x11; 128]);
let mut contiguous: Vec<u8> = Vec::new();
EncodeSink::put_u8(&mut contiguous, 0x0A);
EncodeSink::put_slice(&mut contiguous, &payload);
EncodeSink::put_u32_le(&mut contiguous, 42);
EncodeSink::put_u64_le(&mut contiguous, 0x0102_0304_0506_0708);
let mut rope = Rope::with_min_segment(64);
rope.put_u8(0x0A);
rope.put_shared(payload);
rope.put_u32_le(42);
rope.put_u64_le(0x0102_0304_0506_0708);
assert_eq!(&rope.to_contiguous_bytes()[..], &contiguous[..]);
}
#[test]
fn rope_buf_traverses_segments() {
let mut rope = Rope::with_min_segment(4);
rope.put_slice(b"ab");
rope.put_shared(Bytes::from_static(b"cdefgh"));
rope.put_slice(b"ij");
let mut buf = RopeBuf::from(rope);
assert_eq!(buf.remaining(), 10);
assert_eq!(buf.chunk(), b"ab");
buf.advance(3); assert_eq!(buf.chunk(), b"defgh");
let rest = buf.copy_to_bytes(buf.remaining());
assert_eq!(&rest[..], b"defghij");
}
fn rope_buf(segments: &[Bytes]) -> RopeBuf {
let mut rope = Rope::with_min_segment(1);
for segment in segments {
rope.put_shared(segment.clone());
}
RopeBuf::from(rope)
}
#[test]
fn rope_buf_copy_to_bytes_shares_whole_segment() {
let payload = Bytes::from(crate::alloc::vec![0xAB; 64]);
let ptr = payload.as_ptr();
let mut rope = Rope::with_min_segment(1);
rope.put_shared(payload);
let mut buf = RopeBuf::from(rope);
let copied = buf.copy_to_bytes(64);
assert_eq!(copied.as_ptr(), ptr);
assert_eq!(copied.as_ref(), &[0xAB; 64]);
assert_eq!(buf.remaining(), 0);
assert!(buf.chunk().is_empty());
assert!(copied.try_into_mut().is_ok());
}
#[test]
fn rope_buf_copy_to_bytes_shares_partial_segment() {
let payload = Bytes::copy_from_slice(b"abcdefgh");
let mut buf = rope_buf(core::slice::from_ref(&payload));
let copied = buf.copy_to_bytes(3);
assert_eq!(copied, &b"abc"[..]);
assert_eq!(copied.as_ptr(), payload.as_ptr());
assert_eq!(buf.remaining(), 5);
assert_eq!(buf.chunk(), b"defgh");
let rest = buf.copy_to_bytes(5);
assert_eq!(rest.as_ptr(), payload.as_ptr().wrapping_add(3));
assert_eq!(rest, &b"defgh"[..]);
assert_eq!(buf.remaining(), 0);
}
#[test]
fn rope_buf_copy_to_bytes_partial_result_outlives_buffer() {
let (copied, ptr) = {
let payload = Bytes::copy_from_slice(b"abcdefgh");
let ptr = payload.as_ptr();
let mut buf = rope_buf(&[payload]);
(buf.copy_to_bytes(3), ptr)
};
assert_eq!(copied.as_ptr(), ptr);
assert_eq!(copied, &b"abc"[..]);
assert!(copied.try_into_mut().is_ok());
}
#[test]
fn rope_buf_copy_to_bytes_shares_segment_after_advance() {
let payload = Bytes::from(crate::alloc::vec![0x5A; 64]);
let mut buf = rope_buf(&[Bytes::from_static(b"head"), payload.clone()]);
buf.advance(7);
let copied = buf.copy_to_bytes(10);
assert_eq!(copied.as_ptr(), payload.as_ptr().wrapping_add(3));
assert_eq!(copied.as_ref(), &[0x5A; 10]);
assert_eq!(buf.remaining(), 51);
assert_eq!(buf.chunk().as_ptr(), payload.as_ptr().wrapping_add(13));
}
#[test]
fn rope_buf_copy_to_bytes_zero_does_not_advance() {
let mut empty = RopeBuf::from(Rope::new());
assert!(empty.copy_to_bytes(0).is_empty());
assert_eq!(empty.remaining(), 0);
let mut buf = rope_buf(&[Bytes::from_static(b"abc")]);
assert!(buf.copy_to_bytes(0).is_empty());
assert_eq!(buf.remaining(), 3);
assert_eq!(buf.chunk(), b"abc");
assert_eq!(buf.copy_to_bytes(3), &b"abc"[..]);
assert!(buf.copy_to_bytes(0).is_empty());
assert!(buf.chunk().is_empty());
}
#[test]
fn rope_buf_copy_to_bytes_matches_contiguous_buffer_at_every_boundary() {
let segments = [
Bytes::from_static(b"a"),
Bytes::from_static(b"bcde"),
Bytes::from_static(b"fgh"),
Bytes::from_static(b"ijklmn"),
];
let expected = b"abcdefghijklmn";
for offset in 0..=expected.len() {
for len in 0..=expected.len() - offset {
let mut buf = rope_buf(&segments);
buf.advance(offset);
assert_eq!(buf.copy_to_bytes(len), &expected[offset..offset + len]);
assert_eq!(buf.remaining(), expected.len() - offset - len);
let remaining = buf.remaining();
assert_eq!(buf.copy_to_bytes(remaining), &expected[offset + len..]);
assert!(buf.chunk().is_empty());
}
}
}
#[test]
fn rope_buf_copy_to_bytes_take_preserves_limit_and_sharing() {
let payload = Bytes::from_static(b"abcdefgh");
let mut buf = rope_buf(core::slice::from_ref(&payload));
let mut limited = (&mut buf).take(3);
let copied = limited.copy_to_bytes(2);
assert_eq!(copied.as_ptr(), payload.as_ptr());
assert_eq!(copied, &b"ab"[..]);
assert_eq!(limited.remaining(), 1);
assert_eq!(limited.copy_to_bytes(1), &b"c"[..]);
assert_eq!(limited.remaining(), 0);
assert_eq!(buf.remaining(), 5);
assert_eq!(buf.chunk(), b"defgh");
}
#[cfg(feature = "std")]
#[test]
fn rope_buf_copy_to_bytes_updates_vectored_chunks() {
let segments = [Bytes::from_static(b"abc"), Bytes::from_static(b"def")];
let mut buf = rope_buf(&segments);
assert_eq!(buf.copy_to_bytes(3), &b"abc"[..]);
{
let mut slices = [std::io::IoSlice::new(&[]); 2];
assert_eq!(buf.chunks_vectored(&mut slices), 1);
assert_eq!(slices[0].as_ref(), b"def");
}
assert_eq!(buf.copy_to_bytes(3), &b"def"[..]);
let mut slices = [std::io::IoSlice::new(&[]); 2];
assert_eq!(buf.chunks_vectored(&mut slices), 0);
}
#[test]
#[should_panic(expected = "copy_to_bytes past end of RopeBuf")]
fn rope_buf_copy_to_bytes_rejects_overread() {
let mut buf = rope_buf(&[Bytes::from_static(b"a"), Bytes::from_static(b"bc")]);
buf.copy_to_bytes(4);
}
#[test]
#[should_panic(expected = "copy_to_bytes past end of RopeBuf")]
fn rope_buf_copy_to_bytes_rejects_read_from_empty_buffer() {
let mut buf = RopeBuf::from(Rope::new());
buf.copy_to_bytes(1);
}
#[test]
fn max_threshold_never_segments() {
let mut rope = Rope::with_min_segment(usize::MAX);
rope.put_shared(Bytes::from(crate::alloc::vec![1u8; 1024]));
rope.put_slice(&crate::alloc::vec![2u8; 1024]);
assert_eq!(rope.segment_count(), 1);
}
const PAYLOAD_LEN: usize = 16;
fn write_payload<S: EncodeSink>(sink: &mut S) {
sink.put_u8(0xAA);
sink.put_slice(b"abc");
sink.put_u32_le(0x0403_0201);
sink.put_u64_le(0x0807_0605_0403_0201);
}
fn payload() -> Vec<u8> {
let mut expected = Vec::new();
write_payload(&mut expected);
assert_eq!(expected.len(), PAYLOAD_LEN);
expected
}
#[derive(Debug, PartialEq)]
enum Ran {
Cursor,
Sink,
Neither,
}
fn run<S: EncodeSink>(size: usize, buf: &mut S) -> Ran {
let ran = core::cell::Cell::new(Ran::Neither);
write_contiguous(
size,
&mut crate::SizeCache::new(),
buf,
|_, cursor| {
ran.set(Ran::Cursor);
write_payload(cursor);
},
|_, sink| {
ran.set(Ran::Sink);
write_payload(sink);
},
);
ran.into_inner()
}
#[test]
fn pre_sized_matches_vec_for_every_write() {
let mut storage = [MaybeUninit::<u8>::uninit(); PAYLOAD_LEN];
let mut cursor = PreSized::new(&mut storage);
write_payload(&mut cursor);
assert_eq!(cursor.written(), PAYLOAD_LEN);
let got: Vec<u8> = storage.iter().map(|b| unsafe { b.assume_init() }).collect();
assert_eq!(got, payload());
}
#[test]
#[should_panic(expected = "more bytes than compute_size declared")]
fn pre_sized_put_u8_past_end_panics() {
let mut storage = [MaybeUninit::<u8>::uninit(); 1];
let mut cursor = PreSized::new(&mut storage);
cursor.put_u8(1);
cursor.put_u8(2);
}
#[test]
#[should_panic(expected = "more bytes than compute_size declared")]
fn pre_sized_put_slice_past_end_panics() {
let mut storage = [MaybeUninit::<u8>::uninit(); 2];
PreSized::new(&mut storage).put_slice(b"abc");
}
#[test]
#[should_panic(expected = "more bytes than compute_size declared")]
fn pre_sized_fixed_width_past_end_panics() {
let mut storage = [MaybeUninit::<u8>::uninit(); 7];
PreSized::new(&mut storage).put_u64_le(1);
}
#[test]
fn spare_capacity_is_filled_in_place() {
let mut sink = Probe {
inner: Vec::with_capacity(64),
..Probe::default()
};
sink.inner.extend_from_slice(b"prefix");
assert_eq!(run(PAYLOAD_LEN, &mut sink), Ran::Cursor);
assert_eq!(sink.put_slice_calls, 0, "no scratch buffer");
assert_eq!(sink.advance_mut_calls, 1);
assert_eq!(&sink.inner[..6], b"prefix");
assert_eq!(&sink.inner[6..], &payload()[..]);
assert_eq!(sink.inner.capacity(), 64, "the sink did not grow");
}
#[test]
fn short_chunk_is_filled_through_a_scratch_buffer() {
let mut sink = Probe {
chunk_limit: Some(PAYLOAD_LEN - 1),
..Probe::default()
};
assert_eq!(run(PAYLOAD_LEN, &mut sink), Ran::Cursor);
assert_eq!(sink.advance_mut_calls, 0);
assert_eq!(sink.put_slice_calls, 1);
assert_eq!(sink.inner, payload());
}
#[test]
fn chained_buffers_receive_the_bytes_across_the_boundary() {
let mut head = [0u8; 4];
let mut tail = Vec::new();
let mut sink = (&mut head[..]).chain_mut(&mut tail);
assert_eq!(run(PAYLOAD_LEN, &mut sink), Ran::Cursor);
let expected = payload();
assert_eq!(head, expected[..4]);
assert_eq!(tail, expected[4..]);
}
#[test]
fn bytes_mut_and_slice_sinks_receive_the_same_bytes() {
let expected = payload();
let mut bytes_mut = BytesMut::with_capacity(PAYLOAD_LEN);
assert_eq!(run(PAYLOAD_LEN, &mut bytes_mut), Ran::Cursor);
assert_eq!(&bytes_mut[..], &expected[..]);
let mut storage = [0u8; PAYLOAD_LEN];
let mut slice: &mut [u8] = &mut storage;
assert_eq!(run(PAYLOAD_LEN, &mut slice), Ran::Cursor);
assert_eq!(
slice.len(),
0,
"the slice sink was advanced past the message"
);
assert_eq!(&storage[..], &expected[..]);
}
#[test]
#[should_panic]
fn slice_sink_too_small_still_panics() {
let mut storage = [0u8; PAYLOAD_LEN - 1];
let mut slice: &mut [u8] = &mut storage;
run(PAYLOAD_LEN, &mut slice);
}
#[test]
fn empty_message_appends_nothing() {
let mut sink = Probe::default();
write_contiguous(
0,
&mut crate::SizeCache::new(),
&mut sink,
|_, _| {},
|_, _| unreachable!("a `BufMut` is written through the cursor"),
);
assert!(sink.inner.is_empty());
assert_eq!(sink.chunk_mut_calls, 0);
assert_eq!(sink.put_slice_calls, 0);
}
#[test]
fn direct_encode_sink_receives_every_write() {
#[derive(Default)]
struct Recording {
puts: Vec<&'static str>,
bytes: Vec<u8>,
}
impl EncodeSink for Recording {
fn put_u8(&mut self, v: u8) {
self.puts.push("u8");
self.bytes.push(v);
}
fn put_slice(&mut self, src: &[u8]) {
self.puts.push("slice");
self.bytes.extend_from_slice(src);
}
fn put_u32_le(&mut self, v: u32) {
self.puts.push("u32");
self.bytes.extend_from_slice(&v.to_le_bytes());
}
fn put_u64_le(&mut self, v: u64) {
self.puts.push("u64");
self.bytes.extend_from_slice(&v.to_le_bytes());
}
}
let mut sink = Recording::default();
assert_eq!(run(PAYLOAD_LEN, &mut sink), Ran::Sink);
assert_eq!(sink.puts, ["u8", "slice", "u32", "u64"]);
assert_eq!(sink.bytes, payload());
}
#[test]
fn rope_takes_the_sink_path() {
let mut rope = Rope::new();
assert_eq!(run(PAYLOAD_LEN, &mut rope), Ran::Sink);
assert_eq!(&rope.to_contiguous_bytes()[..], &payload()[..]);
}
#[cfg(debug_assertions)]
#[test]
#[should_panic(expected = "two-pass traversal mismatch")]
fn under_writing_is_caught_in_debug_builds() {
write_contiguous(
10,
&mut crate::SizeCache::new(),
&mut Vec::with_capacity(32),
|_, cursor| cursor.put_slice(b"abc"),
|_, _| unreachable!("a Vec is written through the cursor"),
);
}
#[test]
fn write_to_new_vec_is_exactly_sized() {
let vec = write_to_new_vec(PAYLOAD_LEN, |cursor| write_payload(cursor));
assert_eq!(vec, payload());
assert_eq!(vec.capacity(), PAYLOAD_LEN);
}
#[test]
fn under_writing_publishes_only_the_written_bytes() {
let mut vec = Vec::with_capacity(32);
assert!(vec
.__write_pre_sized(10, |cursor| cursor.put_slice(b"abc"))
.is_ok());
assert_eq!(vec, b"abc");
let scratch = write_to_new_vec(10, |cursor| cursor.put_slice(b"abc"));
assert_eq!(scratch, b"abc");
assert_eq!(scratch.capacity(), 10);
}
#[cfg(feature = "std")]
#[test]
fn a_panic_mid_write_leaves_the_sink_unchanged() {
let mut vec = Vec::with_capacity(32);
vec.extend_from_slice(b"kept");
let result = std::panic::catch_unwind(core::panic::AssertUnwindSafe(|| {
let _ = vec.__write_pre_sized(8, |cursor| {
cursor.put_slice(b"abc");
panic!("write_to failed");
});
}));
assert!(result.is_err());
assert_eq!(vec, b"kept");
}
#[test]
fn limit_sink_is_filled_within_its_limit() {
let mut sink = Vec::new().limit(PAYLOAD_LEN);
assert_eq!(run(PAYLOAD_LEN, &mut sink), Ran::Cursor);
assert_eq!(sink.remaining_mut(), 0);
assert_eq!(sink.into_inner(), payload());
}
#[test]
#[should_panic(expected = "more bytes than compute_size declared")]
fn empty_message_that_writes_anyway_panics() {
run(0, &mut Vec::<u8>::new());
}
}