use std::cell::RefCell;
use std::io::Cursor;
use std::io::Error;
use std::io::ErrorKind;
use std::io::Seek;
use std::io::SeekFrom;
use std::io::Write;
use std::rc::Rc;
use qubit_codec::BigEndian;
use qubit_codec::ByteOrder;
use qubit_codec::LittleEndian;
use qubit_codec::NativeEndian;
use qubit_io::BufferedOutputRecovery;
use qubit_io::Output;
use qubit_io_binary::BinaryWriteExt;
use qubit_io_binary::BufferedBinaryWriter;
use super::internal::string_write_test_support_tests::PrefixErrorOutput;
macro_rules! float_bit_vectors {
(f32) => {
[
0x0000_0000_u32,
0x8000_0000,
0x7f80_0000,
0xff80_0000,
0x7fc1_2345,
0xffc5_4321,
0x0000_0001,
0x8000_0001,
]
};
(f64) => {
[
0x0000_0000_0000_0000_u64,
0x8000_0000_0000_0000,
0x7ff0_0000_0000_0000,
0xfff0_0000_0000_0000,
0x7ff8_1234_5678_9abc,
0xfff8_abcd_ef01_2345,
0x0000_0000_0000_0001,
0x8000_0000_0000_0001,
]
};
}
macro_rules! check_writer_float_bits {
($factory:expr, $finish:expr, $method:ident, $float:ident, $endian:ident) => {{
for bits in float_bit_vectors!($float) {
for padding in [0, 18] {
let mut writer = ($factory)();
let mut expected = vec![0xa5; padding];
writer.write_fully(&expected).expect("padding should be writable");
writer
.$method($float::from_bits(bits))
.expect("float should be writable");
expected.extend_from_slice(&bits.$endian());
writer.flush().expect("output should flush");
assert_eq!(
expected,
($finish)(writer),
"{} padding {}",
stringify!($method),
padding
);
}
}
}};
}
#[test]
fn test_buffered_binary_writer_float_bits() {
check_writer_float_bits!(
|| BufferedBinaryWriter::<_, BigEndian>::with_capacity(Vec::new(), 19),
|writer: BufferedBinaryWriter<Vec<u8>, BigEndian>| {
let (bytes, recovery) = writer.into_parts();
assert!(matches!(
recovery,
BufferedOutputRecovery::Pending(buffer) if buffer.is_empty()
));
bytes
},
write_f32,
f32,
to_be_bytes
);
check_writer_float_bits!(
|| BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19),
|writer: BufferedBinaryWriter<Vec<u8>, LittleEndian>| {
let (bytes, recovery) = writer.into_parts();
assert!(matches!(
recovery,
BufferedOutputRecovery::Pending(buffer) if buffer.is_empty()
));
bytes
},
write_f32,
f32,
to_le_bytes
);
check_writer_float_bits!(
|| BufferedBinaryWriter::<_, NativeEndian>::with_capacity(Vec::new(), 19),
|writer: BufferedBinaryWriter<Vec<u8>, NativeEndian>| {
let (bytes, recovery) = writer.into_parts();
assert!(matches!(
recovery,
BufferedOutputRecovery::Pending(buffer) if buffer.is_empty()
));
bytes
},
write_f32,
f32,
to_ne_bytes
);
check_writer_float_bits!(
|| BufferedBinaryWriter::<_, BigEndian>::with_capacity(Vec::new(), 19),
|writer: BufferedBinaryWriter<Vec<u8>, BigEndian>| {
let (bytes, recovery) = writer.into_parts();
assert!(matches!(
recovery,
BufferedOutputRecovery::Pending(buffer) if buffer.is_empty()
));
bytes
},
write_f64,
f64,
to_be_bytes
);
check_writer_float_bits!(
|| BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19),
|writer: BufferedBinaryWriter<Vec<u8>, LittleEndian>| {
let (bytes, recovery) = writer.into_parts();
assert!(matches!(
recovery,
BufferedOutputRecovery::Pending(buffer) if buffer.is_empty()
));
bytes
},
write_f64,
f64,
to_le_bytes
);
check_writer_float_bits!(
|| BufferedBinaryWriter::<_, NativeEndian>::with_capacity(Vec::new(), 19),
|writer: BufferedBinaryWriter<Vec<u8>, NativeEndian>| {
let (bytes, recovery) = writer.into_parts();
assert!(matches!(
recovery,
BufferedOutputRecovery::Pending(buffer) if buffer.is_empty()
));
bytes
},
write_f64,
f64,
to_ne_bytes
);
}
#[test]
fn test_seek_current_zero_preserves_pending_bytes() {
let mut writer = BufferedBinaryWriter::<_, BigEndian>::new(Cursor::new(Vec::new()));
writer.write_u8(1).unwrap();
assert_eq!(1, writer.seek_to(SeekFrom::Current(0)).unwrap());
assert_eq!(0, writer.inner().position());
assert!(writer.inner().get_ref().is_empty());
let (_, recovery) = writer.into_parts();
match recovery {
BufferedOutputRecovery::Pending(bytes) => assert_eq!(&[1], bytes.readable()),
BufferedOutputRecovery::Indeterminate(_) => {
panic!("position query must preserve determinate pending bytes")
}
}
}
struct FailingWriter;
impl Write for FailingWriter {
fn write(&mut self, _buffer: &[u8]) -> std::io::Result<usize> {
Err(Error::other("write failed"))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
struct FailingSeekWriter;
struct SeekErrorWriter {
output: Vec<u8>,
}
struct FlushErrorWriter;
impl Write for FailingSeekWriter {
fn write(&mut self, _buffer: &[u8]) -> std::io::Result<usize> {
Err(Error::other("write failed"))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl SeekErrorWriter {
fn new() -> Self {
Self { output: Vec::new() }
}
}
impl Write for SeekErrorWriter {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
self.output.extend_from_slice(buffer);
Ok(buffer.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl Seek for SeekErrorWriter {
fn seek(&mut self, _position: SeekFrom) -> std::io::Result<u64> {
Err(Error::other("seek failed"))
}
}
impl Write for FlushErrorWriter {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
Ok(buffer.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Err(Error::other("flush failed"))
}
}
impl Seek for FailingSeekWriter {
fn seek(&mut self, _position: SeekFrom) -> std::io::Result<u64> {
Ok(0)
}
}
struct ZeroWriter;
impl Write for ZeroWriter {
fn write(&mut self, _buffer: &[u8]) -> std::io::Result<usize> {
Ok(0)
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
struct InterruptedOnceWriter {
output: Vec<u8>,
interrupted: bool,
}
struct InterruptedThenErrorWriter {
interrupted: bool,
}
impl InterruptedOnceWriter {
fn new() -> Self {
Self {
output: Vec::new(),
interrupted: false,
}
}
}
impl InterruptedThenErrorWriter {
const fn new() -> Self {
Self { interrupted: false }
}
}
impl Write for InterruptedOnceWriter {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
if !self.interrupted {
self.interrupted = true;
return Err(Error::new(ErrorKind::Interrupted, "interrupted once"));
}
self.output.extend_from_slice(buffer);
Ok(buffer.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl Write for InterruptedThenErrorWriter {
fn write(&mut self, _buffer: &[u8]) -> std::io::Result<usize> {
if !self.interrupted {
self.interrupted = true;
return Err(Error::new(ErrorKind::Interrupted, "interrupted once"));
}
Err(Error::other("write failed after interruption"))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
struct ChunkedWriter {
output: Rc<RefCell<Vec<u8>>>,
request_lengths: Rc<RefCell<Vec<usize>>>,
max_chunk_len: usize,
}
impl ChunkedWriter {
fn new(output: Rc<RefCell<Vec<u8>>>, request_lengths: Rc<RefCell<Vec<usize>>>, max_chunk_len: usize) -> Self {
Self {
output,
request_lengths,
max_chunk_len,
}
}
}
impl Write for ChunkedWriter {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
self.request_lengths.borrow_mut().push(buffer.len());
let count = buffer.len().min(self.max_chunk_len);
self.output.borrow_mut().extend_from_slice(&buffer[..count]);
Ok(count)
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
struct PartialErrorWriter {
output: Rc<RefCell<Vec<u8>>>,
write_count: usize,
}
impl PartialErrorWriter {
fn new(output: Rc<RefCell<Vec<u8>>>) -> Self {
Self { output, write_count: 0 }
}
}
impl Write for PartialErrorWriter {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
self.write_count += 1;
match self.write_count {
1 => {
let count = buffer.len().min(2);
self.output.borrow_mut().extend_from_slice(&buffer[..count]);
Ok(count)
}
2 => Err(Error::other("write failed after partial write")),
_ => {
self.output.borrow_mut().extend_from_slice(buffer);
Ok(buffer.len())
}
}
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
fn expected_values() -> Vec<u8> {
let mut bytes = Vec::new();
bytes.write_u8(0xaa).expect("u8 should be encoded");
bytes.write_i8(-2).expect("i8 should be encoded");
bytes.write_u16_le(0x1234).expect("u16 should be encoded");
bytes.write_u32_le(0x1234_5678).expect("u32 should be encoded");
bytes
.write_u64_le(0x0123_4567_89ab_cdef)
.expect("u64 should be encoded");
bytes
.write_u128_le(0x0123_4567_89ab_cdef_fedc_ba98_7654_3210)
.expect("u128 should be encoded");
bytes.write_i16_le(-0x1234).expect("i16 should be encoded");
bytes.write_i32_le(-0x0123_4567).expect("i32 should be encoded");
bytes
.write_i64_le(-0x0123_4567_89ab_cdef)
.expect("i64 should be encoded");
bytes
.write_i128_le(-0x0123_4567_89ab_cdef_fedc_ba98_7654_3210)
.expect("i128 should be encoded");
bytes.write_f32_le(12.5).expect("f32 should be encoded");
bytes.write_f64_le(-25.25).expect("f64 should be encoded");
bytes
}
#[derive(Default)]
struct PanicOutput {
bytes: Vec<u8>,
}
impl Output for PanicOutput {
type Item = u8;
unsafe fn write_unchecked(&mut self, input: &[u8], index: usize, count: usize) -> std::io::Result<usize> {
let committed = count.min(1);
self.bytes.extend_from_slice(&input[index..index + committed]);
panic!("scripted output panic after committing a prefix");
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
#[test]
fn test_buffered_binary_writer_writes_scalars_across_buffer_boundaries() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 9);
assert_eq!(ByteOrder::LittleEndian, writer.byte_order());
writer.write_u8(0xaa).expect("u8 should be written");
writer.write_i8(-2).expect("i8 should be written");
writer.write_u16(0x1234).expect("u16 should be written");
writer.write_u32(0x1234_5678).expect("u32 should be written");
writer.write_u64(0x0123_4567_89ab_cdef).expect("u64 should be written");
writer
.write_u128(0x0123_4567_89ab_cdef_fedc_ba98_7654_3210)
.expect("u128 should be written");
writer.write_i16(-0x1234).expect("i16 should be written");
writer.write_i32(-0x0123_4567).expect("i32 should be written");
writer.write_i64(-0x0123_4567_89ab_cdef).expect("i64 should be written");
writer
.write_i128(-0x0123_4567_89ab_cdef_fedc_ba98_7654_3210)
.expect("i128 should be written");
writer.write_f32(12.5).expect("f32 should be written");
writer.write_f64(-25.25).expect("f64 should be written");
writer.flush().expect("writer should flush");
assert_eq!(expected_values(), writer.inner().clone());
}
#[test]
fn test_buffered_binary_writer_accessors_write_all_and_seek() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::new(Cursor::new(Vec::new()));
assert_eq!(ByteOrder::LittleEndian, writer.byte_order());
assert_eq!(0, writer.inner().position());
writer.write_u8(1).expect("u8 should be buffered");
assert_eq!(2, writer.write(&[2, 3]).expect("raw bytes should be buffered"));
assert_eq!(
3,
writer
.seek_to(SeekFrom::End(0))
.expect("seek should drain pending bytes before repositioning")
);
writer.write_u8(4).expect("u8 should be buffered after seek");
writer.flush().expect("flush should write all bytes");
assert_eq!(vec![1, 2, 3, 4], writer.inner().clone().into_inner());
}
#[test]
fn test_buffered_binary_writer_into_parts_returns_pending_bytes_without_flushing() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::new(Cursor::new(Vec::new()));
writer.write_u16(0x1234).expect("u16 should be buffered");
assert_eq!(0, writer.inner().position());
let (inner, pending) = writer.into_parts();
let pending = match pending {
qubit_io::BufferedOutputRecovery::Pending(buffer) => buffer,
qubit_io::BufferedOutputRecovery::Indeterminate(_) => {
panic!("unexpected indeterminate recovery")
}
};
assert_eq!(b"\x34\x12", pending.readable());
assert!(inner.into_inner().is_empty());
}
#[test]
fn test_buffered_binary_writer_cursor_cold_paths_and_fixed_flush() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Cursor::new(Vec::new()), 19);
writer.write_fully(&[1; 14]).expect("initial bytes should be buffered");
writer
.write_fully(&[2; 5])
.expect("exact spare write_all should stay buffered");
writer.write_u16(0x0403).expect("fixed value should flush full buffer");
writer
.write_fully(&[5; 16])
.expect("bytes should fill most of the buffer");
assert_eq!(5, writer.write(&[6; 5]).expect("write should flush then buffer"));
writer.flush().expect("writer should flush");
let cursor = writer.inner().clone();
let mut expected = vec![1; 14];
expected.extend_from_slice(&[2; 5]);
expected.extend_from_slice(&[3, 4]);
expected.extend_from_slice(&[5; 16]);
expected.extend_from_slice(&[6; 5]);
assert_eq!(expected, cursor.into_inner());
}
#[test]
fn test_buffered_binary_writer_write_all_direct_and_buffered_slow_paths() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19);
let large: Vec<u8> = (0u8..32).collect();
writer.write_fully(&large).expect("large write_all should delegate");
writer.write_fully(&[1; 18]).expect("small write_all should buffer");
writer.write_fully(&[2; 5]).expect("write_all should flush then buffer");
let mut expected = large;
expected.extend_from_slice(&[1; 18]);
expected.extend_from_slice(&[2; 5]);
writer.flush().expect("writer should flush");
assert_eq!(expected, writer.inner().clone());
}
#[test]
fn test_buffered_binary_writer_write_all_exact_spare_uses_cold_no_flush_path() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19);
writer.write_fully(&[1; 14]).expect("initial bytes should be buffered");
assert!(writer.inner().is_empty());
writer
.write_fully(&[2; 5])
.expect("exact spare write_all should stay buffered");
assert!(writer.inner().is_empty());
let mut expected = vec![1; 14];
expected.extend_from_slice(&[2; 5]);
writer.flush().expect("writer should flush");
assert_eq!(expected, writer.inner().clone());
}
#[test]
fn test_buffered_binary_writer_write_flushes_then_buffers_small_input() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19);
writer.write_fully(&[1; 18]).expect("initial bytes should be buffered");
assert_eq!(5, writer.write(&[2; 5]).expect("small write should flush then buffer"));
assert_eq!(&[1; 18], writer.inner().as_slice());
let mut expected = vec![1; 18];
expected.extend_from_slice(&[2; 5]);
writer.flush().expect("writer should flush");
assert_eq!(expected, writer.inner().clone());
}
#[test]
fn test_buffered_binary_writer_write_exact_spare_uses_cold_no_flush_path() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19);
writer.write_fully(&[1; 14]).expect("initial bytes should be buffered");
assert!(writer.inner().is_empty());
assert_eq!(
5,
writer.write(&[2; 5]).expect("exact spare write should stay buffered")
);
assert!(writer.inner().is_empty());
let mut expected = vec![1; 14];
expected.extend_from_slice(&[2; 5]);
writer.flush().expect("writer should flush");
assert_eq!(expected, writer.inner().clone());
}
#[test]
fn test_buffered_binary_writer_flushes_before_fixed_value_when_full() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 19);
writer.write_fully(&[1; 18]).expect("initial bytes should be buffered");
writer.write_u16(0x0203).expect("fixed value should flush then buffer");
assert_eq!(&[1; 18], writer.inner().as_slice());
let mut expected = vec![1; 18];
expected.extend_from_slice(&[3, 2]);
writer.flush().expect("writer should flush");
assert_eq!(expected, writer.inner().clone());
}
#[test]
fn test_buffered_binary_writer_reports_automatic_flush_error_before_fixed_value() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 19);
writer.write_fully(&[1; 18]).expect("initial bytes should be buffered");
let error = writer.write_u16(0x0203).expect_err("automatic flush should fail");
assert_eq!(ErrorKind::Other, error.kind());
let (_, recovery) = writer.into_parts();
match recovery {
BufferedOutputRecovery::Pending(buffer) => assert_eq!(&[1; 18], buffer.readable()),
BufferedOutputRecovery::Indeterminate(_) => {
panic!("I/O error must retain determinate pending bytes")
}
}
}
#[test]
fn test_buffered_binary_writer_grows_for_value_larger_than_initial_capacity() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(Vec::new(), 1);
writer
.write_u16(0x1234)
.expect("a complete value should fit after growth");
assert!(writer.inner().is_empty());
writer.flush().expect("flush should succeed");
assert_eq!(&[0x34, 0x12], writer.inner().as_slice());
}
#[test]
fn test_buffered_binary_writer_write_all_reports_flush_error() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 19);
writer.write_fully(&[1; 18]).expect("initial bytes should be buffered");
let error = writer
.write_fully(&[2; 5])
.expect_err("write_all should report flush error");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_write_reports_flush_error() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 19);
writer.write_fully(&[1; 18]).expect("initial bytes should be buffered");
let error = writer.write(&[2; 5]).expect_err("write should report flush error");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_large_write_reports_inner_error_without_pending_buffer() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 19);
let write_error = writer
.write(&[1; 19])
.expect_err("large write should report writer error");
let write_all_error = writer
.write_fully(&[1; 19])
.expect_err("large write_all should report writer error");
assert_eq!(ErrorKind::Other, write_error.kind());
assert_eq!(ErrorKind::Other, write_all_error.kind());
}
#[test]
fn test_buffered_binary_writer_seek_reports_flush_error() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingSeekWriter, 19);
writer.write_fully(&[1; 18]).expect("initial bytes should be buffered");
let error = writer
.seek_to(SeekFrom::Start(0))
.expect_err("seek should report flush error");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_reports_inner_seek_error_after_flush() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(SeekErrorWriter::new(), 19);
writer.write_u8(1).expect("value should be buffered");
let error = writer
.seek_to(SeekFrom::Start(0))
.expect_err("inner seek error should be returned after flushing");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_reports_inner_flush_error_without_pending_buffer() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FlushErrorWriter, 19);
let error = writer.flush().expect_err("inner flush error should be returned");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_flush_error_leaves_writer_available_for_retry() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 8);
writer.write_u32(0x0102_0304).expect("value should be buffered");
let error = writer.flush().expect_err("flush should report write failure");
assert_eq!(ErrorKind::Other, error.kind());
let retry_error = writer
.flush()
.expect_err("writer should remain retryable after a flush failure");
assert_eq!(ErrorKind::Other, retry_error.kind());
}
#[test]
fn test_buffered_binary_writer_reports_write_zero_while_flushing() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(ZeroWriter, 8);
writer.write_u32(0x0102_0304).expect("value should be buffered");
let error = writer.flush().expect_err("zero write should fail");
assert_eq!(ErrorKind::WriteZero, error.kind());
}
#[test]
fn test_buffered_binary_writer_retries_interrupted_flush() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(InterruptedOnceWriter::new(), 8);
writer.write_u32(0x0102_0304).expect("value should be buffered");
writer.flush().expect("flush should retry interruption");
let inner = writer.inner();
assert_eq!(vec![4, 3, 2, 1], inner.output);
}
#[test]
fn test_buffered_binary_writer_returns_error_after_interrupted_flush() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(InterruptedThenErrorWriter::new(), 8);
writer.write_u32(0x0102_0304).expect("value should be buffered");
let error = writer
.flush()
.expect_err("non-interrupted write error should be returned");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_returns_writer_error() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 8);
writer.write_u64(0x1234).expect("value should be buffered");
let error = writer.flush().expect_err("flush should fail");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_delegates_large_raw_write_once() {
let output = Rc::new(RefCell::new(Vec::new()));
let request_lengths = Rc::new(RefCell::new(Vec::new()));
let inner = ChunkedWriter::new(Rc::clone(&output), Rc::clone(&request_lengths), 8);
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(inner, 19);
let bytes: Vec<u8> = (0u8..32).collect();
let count = writer.write(&bytes).expect("raw bytes should be written");
assert_eq!(8, count);
assert_eq!((0u8..8).collect::<Vec<_>>(), *output.borrow());
assert_eq!(vec![32], *request_lengths.borrow());
}
#[test]
fn test_buffered_binary_writer_buffers_small_write_with_chunked_writer() {
let output = Rc::new(RefCell::new(Vec::new()));
let request_lengths = Rc::new(RefCell::new(Vec::new()));
let inner = ChunkedWriter::new(Rc::clone(&output), Rc::clone(&request_lengths), 8);
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(inner, 19);
writer.write_fully(&[1, 2, 3]).expect("small write should be buffered");
assert!(output.borrow().is_empty());
assert!(request_lengths.borrow().is_empty());
writer.flush().expect("flush should write buffered bytes");
assert_eq!(vec![1, 2, 3], *output.borrow());
assert_eq!(vec![3], *request_lengths.borrow());
}
#[test]
fn test_buffered_binary_writer_drops_flushed_prefix_after_error() {
let output = Rc::new(RefCell::new(Vec::new()));
let inner = PartialErrorWriter::new(Rc::clone(&output));
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(inner, 19);
writer.write_u32(0x0102_0304).expect("value should buffer");
let error = writer.flush().expect_err("partial flush should fail");
assert_eq!(ErrorKind::Other, error.kind());
writer.flush().expect("remaining buffered bytes should flush");
assert_eq!([4, 3, 2, 1], output.borrow().as_slice());
}
#[test]
fn test_buffered_binary_writer_writes_strings_with_fixed_length_prefixes() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::new(Vec::new());
writer
.write_string_with_u16_len("foo")
.expect("u16-prefixed string should be written");
writer
.write_string_with_u32_len("bar")
.expect("u32-prefixed string should be written");
writer.flush().expect("buffered writer should flush");
assert_eq!(
vec![3, 0, b'f', b'o', b'o', 3, 0, 0, 0, b'b', b'a', b'r'],
writer.inner().as_slice(),
);
}
#[test]
fn test_buffered_binary_writer_reports_string_length_and_prefix_errors() {
let oversized = "x".repeat(usize::from(u16::MAX) + 1);
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::new(Vec::new());
let error = writer
.write_string_with_u16_len(&oversized)
.expect_err("oversized u16 string should fail");
assert_eq!(ErrorKind::InvalidInput, error.kind());
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 19);
writer
.write_fully(&[1; 18])
.expect("the buffer should accept the initial bytes");
let error = writer
.write_string_with_u16_len("x")
.expect_err("u16 prefix flush error should be returned");
assert_eq!(ErrorKind::Other, error.kind());
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(FailingWriter, 19);
writer
.write_fully(&[1; 18])
.expect("the buffer should accept the initial bytes");
let error = writer
.write_string_with_u32_len("x")
.expect_err("u32 prefix flush error should be returned");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_writer_rejects_impossible_capacity() {
let result = BufferedBinaryWriter::<_, LittleEndian>::try_with_capacity(Vec::<u8>::new(), usize::MAX);
assert!(result.is_err());
}
#[test]
fn test_into_parts_preserves_indeterminate_after_inner_write_panics() {
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::new(PanicOutput::default());
writer.write_u16(0x1234).expect("the encoded value should be buffered");
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| qubit_io::Output::flush(&mut writer)));
assert!(result.is_err());
let (inner, recovery) = writer.into_parts();
assert_eq!([0x34], inner.bytes.as_slice());
assert!(matches!(recovery, qubit_io::BufferedOutputRecovery::Indeterminate(_)));
}
#[test]
fn test_buffered_binary_string_payload_failure_is_not_completed_by_flush() {
for use_u32 in [false, true] {
let mut expected = if use_u32 { vec![40, 0, 0, 0] } else { vec![40, 0] };
let output = PrefixErrorOutput::new(expected.len() + 2);
let mut writer = BufferedBinaryWriter::<_, LittleEndian>::with_capacity(output, 19);
let payload = "x".repeat(40);
let result = if use_u32 {
writer.write_string_with_u32_len(&payload)
} else {
writer.write_string_with_u16_len(&payload)
};
assert_eq!(ErrorKind::Other, result.expect_err("payload should fail").kind());
expected.extend_from_slice(b"xx");
assert_eq!(expected.as_slice(), writer.inner().bytes());
writer
.flush()
.expect("an empty buffer can flush without completing the field");
let (output, recovery) = writer.into_parts();
assert_eq!(expected.as_slice(), output.bytes());
match recovery {
BufferedOutputRecovery::Pending(buffer) => assert!(buffer.readable().is_empty()),
BufferedOutputRecovery::Indeterminate(_) => {
panic!("ordinary errors must not imply a panic")
}
}
}
}