use std::cell::RefCell;
use std::io::Cursor;
use std::io::Error;
use std::io::ErrorKind;
use std::io::Read;
use std::io::SeekFrom;
use std::rc::Rc;
use qubit_codec::BigEndian;
use qubit_codec::ByteOrder;
use qubit_codec::LittleEndian;
use qubit_codec::NativeEndian;
use qubit_io_binary::BinaryWriteExt;
use qubit_io_binary::BufferedBinaryReader;
use crate::stream::internal::seek_test_support_tests::RejectingCurrentSeekReader;
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_reader_float_bits {
($factory:expr, $method:ident, $float:ident, $endian:ident) => {{
for bits in float_bit_vectors!($float) {
for padding in [0, 18] {
let mut encoded = vec![0xa5; padding];
encoded.extend_from_slice(&bits.$endian());
let mut reader = ($factory)(encoded);
let mut prefix = vec![0; padding];
reader.read_exactly(&mut prefix).expect("padding should be readable");
assert_eq!(vec![0xa5; padding], prefix);
assert_eq!(
bits,
reader.$method().expect("float should be readable").to_bits(),
"{} padding {}",
stringify!($method),
padding
);
}
}
}};
}
#[test]
fn test_buffered_binary_reader_float_bits() {
check_reader_float_bits!(
|bytes| BufferedBinaryReader::<_, BigEndian>::with_capacity(Cursor::new(bytes), 19),
read_f32,
f32,
to_be_bytes
);
check_reader_float_bits!(
|bytes| BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(bytes), 19),
read_f32,
f32,
to_le_bytes
);
check_reader_float_bits!(
|bytes| BufferedBinaryReader::<_, NativeEndian>::with_capacity(Cursor::new(bytes), 19),
read_f32,
f32,
to_ne_bytes
);
check_reader_float_bits!(
|bytes| BufferedBinaryReader::<_, BigEndian>::with_capacity(Cursor::new(bytes), 19),
read_f64,
f64,
to_be_bytes
);
check_reader_float_bits!(
|bytes| BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(bytes), 19),
read_f64,
f64,
to_le_bytes
);
check_reader_float_bits!(
|bytes| BufferedBinaryReader::<_, NativeEndian>::with_capacity(Cursor::new(bytes), 19),
read_f64,
f64,
to_ne_bytes
);
}
#[test]
fn test_seek_within_buffer_preserves_logical_position() {
let mut reader = BufferedBinaryReader::<_, BigEndian>::with_capacity(Cursor::new(vec![1, 2, 3, 4, 5]), 19);
reader.read_exactly(&mut [0_u8; 1]).unwrap();
assert_eq!(5, reader.inner().position());
assert_eq!(1, reader.seek_to(SeekFrom::Current(0)).unwrap());
assert_eq!(2, reader.seek_to(SeekFrom::Current(1)).unwrap());
assert_eq!(1, reader.seek_to(SeekFrom::Current(-1)).unwrap());
assert_eq!(5, reader.inner().position());
let (_, unread) = reader.into_parts();
assert_eq!(&[2, 3, 4, 5], unread.readable());
}
fn encoded_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
}
struct ChunkedReader {
bytes: Vec<u8>,
position: usize,
max_chunk_len: usize,
request_lengths: Rc<RefCell<Vec<usize>>>,
}
impl ChunkedReader {
fn new(bytes: Vec<u8>, max_chunk_len: usize, request_lengths: Rc<RefCell<Vec<usize>>>) -> Self {
Self {
bytes,
position: 0,
max_chunk_len,
request_lengths,
}
}
}
impl Read for ChunkedReader {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
self.request_lengths.borrow_mut().push(buffer.len());
let remaining = self.bytes.len() - self.position;
let count = remaining.min(buffer.len()).min(self.max_chunk_len);
buffer[..count].copy_from_slice(&self.bytes[self.position..self.position + count]);
self.position += count;
Ok(count)
}
}
struct InterruptedOnceReader {
bytes: Vec<u8>,
position: usize,
interrupted: bool,
}
struct InterruptedThenErrorReader {
interrupted: bool,
}
impl InterruptedOnceReader {
fn new(bytes: Vec<u8>) -> Self {
Self {
bytes,
position: 0,
interrupted: false,
}
}
}
impl InterruptedThenErrorReader {
const fn new() -> Self {
Self { interrupted: false }
}
}
struct ByteThenErrorReader {
byte: u8,
returned: bool,
}
struct ErrorReader;
impl ByteThenErrorReader {
const fn new(byte: u8) -> Self {
Self { byte, returned: false }
}
}
impl Read for InterruptedOnceReader {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
if !self.interrupted {
self.interrupted = true;
return Err(Error::new(ErrorKind::Interrupted, "interrupted once"));
}
let remaining = self.bytes.len() - self.position;
let count = remaining.min(buffer.len());
buffer[..count].copy_from_slice(&self.bytes[self.position..self.position + count]);
self.position += count;
Ok(count)
}
}
impl Read for InterruptedThenErrorReader {
fn read(&mut self, _buffer: &mut [u8]) -> std::io::Result<usize> {
if !self.interrupted {
self.interrupted = true;
return Err(Error::new(ErrorKind::Interrupted, "interrupted once"));
}
Err(Error::other("read failed after interruption"))
}
}
impl Read for ByteThenErrorReader {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
if self.returned {
return Err(Error::other("read failed"));
}
self.returned = true;
buffer[0] = self.byte;
Ok(1)
}
}
impl Read for ErrorReader {
fn read(&mut self, _buffer: &mut [u8]) -> std::io::Result<usize> {
Err(Error::other("read failed"))
}
}
#[test]
fn test_buffered_binary_reader_reads_scalars_across_buffer_boundaries() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(encoded_values()), 9);
assert_eq!(ByteOrder::LittleEndian, reader.byte_order());
assert_eq!(0xaa, reader.read_u8().expect("u8 should be read"));
assert_eq!(-2, reader.read_i8().expect("i8 should be read"));
assert_eq!(0x1234, reader.read_u16().expect("u16 should be read"));
assert_eq!(0x1234_5678, reader.read_u32().expect("u32 should be read"));
assert_eq!(0x0123_4567_89ab_cdef, reader.read_u64().expect("u64 should be read"));
assert_eq!(
0x0123_4567_89ab_cdef_fedc_ba98_7654_3210,
reader.read_u128().expect("u128 should be read")
);
assert_eq!(-0x1234, reader.read_i16().expect("i16 should be read"));
assert_eq!(-0x0123_4567, reader.read_i32().expect("i32 should be read"));
assert_eq!(-0x0123_4567_89ab_cdef, reader.read_i64().expect("i64 should be read"));
assert_eq!(
-0x0123_4567_89ab_cdef_fedc_ba98_7654_3210,
reader.read_i128().expect("i128 should be read")
);
assert_eq!(12.5, reader.read_f32().expect("f32 should be read"));
assert_eq!(-25.25, reader.read_f64().expect("f64 should be read"));
}
#[test]
fn test_buffered_binary_reader_reports_unexpected_eof() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![0x34]), 8);
let error = reader.read_u16().expect_err("truncated u16 should fail");
assert_eq!(ErrorKind::UnexpectedEof, error.kind());
}
#[test]
fn test_buffered_binary_reader_reports_refill_error_after_partial_scalar() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(ByteThenErrorReader::new(0x34), 4);
let error = reader
.read_u16()
.expect_err("reader error after a partial scalar should be returned");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_reader_implements_read() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![1, 2, 3, 4]), 2);
let mut bytes = [0u8; 3];
reader.read_fully(&mut bytes).expect("raw bytes should be read");
assert_eq!([1, 2, 3], bytes);
assert_eq!(4, reader.read_u8().expect("remaining byte should be read"));
}
#[test]
fn test_buffered_binary_reader_bypasses_buffer_for_large_raw_read() {
let request_lengths = Rc::new(RefCell::new(Vec::new()));
let inner = ChunkedReader::new((0u8..32).collect(), usize::MAX, Rc::clone(&request_lengths));
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(inner, 19);
let mut bytes = [0u8; 32];
let count = reader.read(&mut bytes).expect("raw bytes should be read");
assert_eq!(32, count);
assert_eq!((0u8..32).collect::<Vec<_>>(), bytes);
assert_eq!(vec![32], *request_lengths.borrow());
}
#[test]
fn test_buffered_binary_reader_reports_eof_for_empty_small_raw_read() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(Vec::<u8>::new()), 19);
let mut byte = [0_u8; 1];
assert_eq!(0, reader.read(&mut byte).expect("empty reader should report EOF"));
}
#[test]
fn test_buffered_binary_reader_returns_refill_error_for_small_raw_read() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(ErrorReader, 19);
let mut byte = [0_u8; 1];
let error = reader
.read(&mut byte)
.expect_err("small raw read should return refill error");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_reader_retries_interrupted_small_raw_read() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(InterruptedOnceReader::new(vec![7]), 19);
let mut byte = [0_u8; 1];
assert_eq!(1, reader.read(&mut byte).expect("small raw read should retry"));
assert_eq!([7], byte);
}
#[test]
fn test_buffered_binary_reader_appends_before_backshifting() {
let request_lengths = Rc::new(RefCell::new(Vec::new()));
let inner = ChunkedReader::new((0u8..40).collect(), 20, Rc::clone(&request_lengths));
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(inner, 32);
let _ = reader.read_u128().expect("u128 should be read");
let _ = reader.read_u64().expect("u64 should be read");
assert_eq!(vec![32, 12], *request_lengths.borrow());
}
#[test]
fn test_buffered_binary_reader_refills_fixed_value_when_tail_has_room() {
let request_lengths = Rc::new(RefCell::new(Vec::new()));
let inner = ChunkedReader::new(vec![0x34, 0x12], 1, Rc::clone(&request_lengths));
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(inner, 19);
assert_eq!(0x1234, reader.read_u16().expect("split u16 should be read"));
assert_eq!(vec![19, 18], *request_lengths.borrow());
}
#[test]
fn test_buffered_binary_reader_accessors_raw_read_and_seek() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::new(Cursor::new(vec![1, 2, 3, 4, 5]));
assert_eq!(ByteOrder::LittleEndian, reader.byte_order());
assert_eq!(0, reader.inner().position());
assert_eq!(0, reader.read(&mut []).expect("empty read should succeed"));
assert_eq!(0x0201, reader.read_u16().expect("u16 should be read"));
assert_eq!(
2,
reader
.seek_to(SeekFrom::Current(0))
.expect("logical current seek should succeed")
);
assert_eq!(3, reader.read_u8().expect("byte after current seek should be read"));
assert_eq!(
1,
reader
.seek_to(SeekFrom::Start(1))
.expect("absolute seek should succeed")
);
assert!(reader.inner().position() >= 1);
}
#[test]
fn test_buffered_binary_reader_recovers_inner_and_unread_buffer() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![1, 2, 3, 4]), 19);
assert_eq!(0x0201, reader.read_u16().expect("u16 should be read"));
assert_eq!(4, reader.inner().position());
let (inner, unread) = reader.into_parts();
assert_eq!(4, inner.position());
assert_eq!(&[3, 4], unread.readable());
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![5, 6]), 19);
assert_eq!(5, reader.read_u8().expect("u8 should be read"));
let (inner, unread) = reader.into_parts();
assert_eq!(2, inner.position());
assert_eq!(&[6], unread.readable());
}
#[test]
fn test_buffered_binary_reader_retries_interrupted_refill() {
let inner = InterruptedOnceReader::new(vec![9]);
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(inner, 4);
assert_eq!(9, reader.read_u8().expect("read should retry interruption"));
}
#[test]
fn test_buffered_binary_reader_returns_error_after_interrupted_refill() {
let inner = InterruptedThenErrorReader::new();
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(inner, 4);
let error = reader
.read_u8()
.expect_err("non-interrupted refill error should be returned");
assert_eq!(ErrorKind::Other, error.kind());
}
#[test]
fn test_buffered_binary_reader_current_seek_without_unread_buffer() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![1, 2, 3]), 4);
assert_eq!(
2,
reader
.seek_to(SeekFrom::Current(2))
.expect("current seek without unread bytes should succeed")
);
assert_eq!(3, reader.read_u8().expect("seek target byte should be read"));
}
#[test]
fn test_buffered_binary_reader_current_seek_reports_underflow() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![1, 2, 3, 4]), 4);
assert_eq!(1, reader.read_u8().expect("first byte should be read"));
let error = reader
.seek_to(SeekFrom::Current(i64::MIN))
.expect_err("seek underflow should be reported");
assert_eq!(ErrorKind::InvalidInput, error.kind());
assert_eq!(
2,
reader.read_u8().expect("unread buffered byte should remain readable")
);
}
#[test]
fn test_buffered_binary_reader_preserves_buffer_when_seek_fails() {
let inner = RejectingCurrentSeekReader::new(vec![1, 2, 3, 4, 5]);
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(inner, 4);
assert_eq!(1, reader.read_u8().expect("first byte should be read"));
let error = reader
.seek_to(SeekFrom::Current(0))
.expect_err("inner seek should fail");
assert_eq!(ErrorKind::Other, error.kind());
assert_eq!(2, reader.read_u8().expect("unread buffered byte should be preserved"));
}
#[test]
fn test_seek_window_failure_preserves_unread() {
for (consume_count, offset, expected_unread) in [(1, 1, &[2, 3, 4, 5][..]), (2, -1, &[3, 4, 5][..])] {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(
RejectingCurrentSeekReader::new(vec![1, 2, 3, 4, 5]),
5,
);
let mut consumed = vec![0; consume_count];
reader.read_exactly(&mut consumed).expect("bytes should be consumed");
let error = reader
.seek_to(SeekFrom::Current(offset))
.expect_err("current query must fail");
assert_eq!(ErrorKind::Other, error.kind());
let (_, unread): (_, qubit_io::Buffer<u8>) = reader.into_parts();
assert_eq!(expected_unread, unread.readable());
}
for (consume_count, offset, expected_next) in [(1, 1, 2), (2, -1, 3)] {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(
RejectingCurrentSeekReader::new(vec![1, 2, 3, 4, 5]),
5,
);
let mut consumed = vec![0; consume_count];
reader.read_exactly(&mut consumed).expect("bytes should be consumed");
reader
.seek_to(SeekFrom::Current(offset))
.expect_err("current query must fail");
let mut next = [0];
reader
.read_exactly(&mut next)
.expect("unread byte should remain readable");
assert_eq!([expected_next], next);
}
}
#[test]
fn test_buffered_binary_reader_seek_end_discards_buffer_after_success() {
let mut reader = BufferedBinaryReader::<_, LittleEndian>::with_capacity(Cursor::new(vec![1, 2, 3, 4]), 4);
assert_eq!(1, reader.read_u8().expect("first byte should be read"));
assert_eq!(4, reader.seek_to(SeekFrom::End(0)).expect("seek to end should succeed"));
let mut byte = [0_u8; 1];
assert_eq!(0, reader.read(&mut byte).expect("reader should be at EOF"));
}
#[test]
fn test_buffered_binary_reader_reads_strings_with_fixed_length_prefixes() {
let bytes = vec![3, 0, b'f', b'o', b'o', 3, 0, 0, 0, b'b', b'a', b'r'];
let mut reader = BufferedBinaryReader::<_, LittleEndian>::new(Cursor::new(bytes));
assert_eq!(
"foo",
reader
.read_string_with_u16_len(3)
.expect("u16-prefixed string should be read")
);
assert_eq!(
"bar",
reader
.read_string_with_u32_len(3)
.expect("u32-prefixed string should be read")
);
}
macro_rules! check_buffered_string_error_position {
($factory:expr, $prefix:expr, $method:ident) => {{
for capacity in [19, 23] {
for padding in [0, 18] {
for (length, payload, max_len, kind, consumed, remainder) in [
(3, &b"abcQB"[..], 2, ErrorKind::InvalidData, 0, &b"abcQB"[..]),
(3, &b"\xffabQB"[..], 3, ErrorKind::InvalidData, 3, &b"QB"[..]),
(4, &b"ab"[..], 4, ErrorKind::UnexpectedEof, 2, &b""[..]),
] {
let mut bytes = vec![0xa5; padding];
let prefix = ($prefix)(length);
bytes.extend_from_slice(&prefix);
bytes.extend_from_slice(payload);
let expected_position = padding + prefix.len() + consumed;
let mut reader = ($factory)(Cursor::new(bytes.clone()), capacity);
reader
.read_exactly(&mut vec![0; padding])
.expect("padding should be readable");
let error = reader.$method(max_len).expect_err("invalid string input should fail");
assert_eq!(kind, error.kind());
let (inner, unread) = reader.into_parts();
assert_eq!(
expected_position as u64,
inner.position() - unread.readable().len() as u64,
"logical position after string failure"
);
let mut actual_remainder = unread.readable().to_vec();
actual_remainder.extend_from_slice(&inner.get_ref()[inner.position() as usize..]);
assert_eq!(
remainder,
actual_remainder.as_slice(),
"unread bytes after string failure"
);
let mut reader = ($factory)(Cursor::new(bytes), capacity);
reader
.read_exactly(&mut vec![0; padding])
.expect("padding should be readable");
assert_eq!(
kind,
reader
.$method(max_len)
.expect_err("invalid string input should fail")
.kind()
);
let mut raw = vec![0; remainder.len()];
reader
.read_exactly(&mut raw)
.expect("remaining raw bytes should be readable");
assert_eq!(remainder, raw.as_slice(), "remaining bytes through raw API");
}
}
}
}};
}
#[test]
fn test_buffered_string_error_position_fixed_prefixes() {
check_buffered_string_error_position!(
BufferedBinaryReader::<_, LittleEndian>::with_capacity,
|length: u16| length.to_le_bytes(),
read_string_with_u16_len
);
check_buffered_string_error_position!(
BufferedBinaryReader::<_, LittleEndian>::with_capacity,
|length: u32| length.to_le_bytes(),
read_string_with_u32_len
);
check_buffered_string_error_position!(
BufferedBinaryReader::<_, BigEndian>::with_capacity,
|length: u16| length.to_be_bytes(),
read_string_with_u16_len
);
check_buffered_string_error_position!(
BufferedBinaryReader::<_, BigEndian>::with_capacity,
|length: u32| length.to_be_bytes(),
read_string_with_u32_len
);
}