From e80dbe67890b0a3ce71027e468e47f766e5f8630 Mon Sep 17 00:00:00 2001 From: tison Date: Wed, 18 Nov 2026 18:38:31 +0800 Subject: [PATCH] test(io): consolidate adapter regression coverage --- bases/src/io.rs | 181 ------------------------ tests-integration/tests/contracts/io.rs | 31 ++++ tests-integration/tests/io.rs | 62 +------- 3 files changed, 37 insertions(+), 237 deletions(-) diff --git a/bases/src/io.rs b/bases/src/io.rs index 4caa500..9332b89 100644 --- a/bases/src/io.rs +++ b/bases/src/io.rs @@ -441,184 +441,3 @@ fn decode_error_to_io(error: DecodeSliceError) -> io::Error { other => io::Error::new(io::ErrorKind::InvalidData, other), } } - -#[cfg(test)] -mod tests { - use std::io; - use std::io::Read; - use std::io::Write; - use std::vec::Vec; - - use crate::Base16Lower; - use crate::Base32; - use crate::Base32Unpadded; - use crate::Base64; - use crate::Base64Unpadded; - use crate::Codec; - use crate::DecodeError; - use crate::io::EncoderWriter; - - struct FlakyWriter { - inner: Vec, - max_write: usize, - interrupt_every: usize, - calls: usize, - } - - impl FlakyWriter { - fn new(max_write: usize, interrupt_every: usize) -> Self { - Self { - inner: Vec::new(), - max_write, - interrupt_every, - calls: 0, - } - } - } - - impl Write for FlakyWriter { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.calls += 1; - if self.interrupt_every > 0 && self.calls.is_multiple_of(self.interrupt_every) { - return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted")); - } - let take = buf.len().min(self.max_write); - self.inner.extend_from_slice(&buf[..take]); - Ok(take) - } - - fn flush(&mut self) -> io::Result<()> { - Ok(()) - } - } - - struct FlakyReader<'a> { - data: &'a [u8], - pos: usize, - max_read: usize, - interrupt_every: usize, - calls: usize, - } - - impl<'a> FlakyReader<'a> { - fn new(data: &'a [u8], max_read: usize, interrupt_every: usize) -> Self { - Self { - data, - pos: 0, - max_read, - interrupt_every, - calls: 0, - } - } - } - - impl Read for FlakyReader<'_> { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.calls += 1; - if self.interrupt_every > 0 && self.calls.is_multiple_of(self.interrupt_every) { - return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted")); - } - let remaining = self.data.len() - self.pos; - let take = remaining.min(buf.len()).min(self.max_read); - buf[..take].copy_from_slice(&self.data[self.pos..self.pos + take]); - self.pos += take; - Ok(take) - } - } - - #[test] - fn encoder_writer_handles_short_writes_interrupts_and_finish() { - let input: Vec = (0..1500_u16).map(|i| (i % 251) as u8).collect(); - let writer = FlakyWriter::new(3, 2); - let mut encoder = Base64::encoder_writer(writer); - encoder.write_all(&input).unwrap(); - encoder.flush().unwrap(); - assert!(!encoder.get_ref().inner.is_empty()); - let _ = encoder.get_mut(); - let writer = encoder.finish().unwrap(); - assert_eq!(writer.inner, Base64::encode(&input).as_bytes()); - } - - #[test] - fn encoder_writer_finishes_on_drop() { - let mut out = Vec::new(); - { - let mut encoder = EncoderWriter::::new(&mut out); - encoder.write_all(b"f").unwrap(); - } - assert_eq!(out, b"Zg=="); - - let raw = Vec::new(); - let mut encoder = Base64::encoder_writer(raw); - encoder.write_all(b"f").unwrap(); - let raw = encoder.into_inner(); - assert!(raw.is_empty()); - } - - fn decode_all_by_byte(encoded: &[u8]) -> Vec { - let mut out = Vec::new(); - let mut reader = C::decoder_reader(FlakyReader::new(encoded, 1, 2)); - let _ = reader.get_ref(); - let _ = reader.get_mut(); - let mut byte = [0_u8; 1]; - loop { - match reader.read(&mut byte) { - Ok(0) => break, - Ok(1) => out.push(byte[0]), - Ok(n) => panic!("unexpected read size {n}"), - Err(err) => panic!("unexpected error: {err}"), - } - } - let _ = reader.into_inner(); - out - } - - #[test] - fn decoder_reader_handles_single_byte_reads_and_interrupts() { - assert_eq!( - decode_all_by_byte::(Base64::encode(b"foobar").as_bytes()), - b"foobar" - ); - assert_eq!(decode_all_by_byte::(b"Zm8"), b"fo"); - assert_eq!( - decode_all_by_byte::(Base32::encode(b"foobar").as_bytes()), - b"foobar" - ); - assert_eq!( - decode_all_by_byte::( - Base32Unpadded::encode(b"hello world!").as_bytes() - ), - b"hello world!" - ); - assert_eq!( - decode_all_by_byte::(b"deadbeef"), - b"\xde\xad\xbe\xef" - ); - } - - #[test] - fn decoder_reader_maps_decode_errors_to_invalid_data() { - let mut decoder = Base64::decoder_reader(&b"Zg"[..]); - let mut buf = [0_u8; 8]; - let err = decoder.read(&mut buf).unwrap_err(); - assert_eq!(err.kind(), io::ErrorKind::InvalidData); - assert_eq!( - err.get_ref().and_then(|e| e.downcast_ref::()), - Some(&DecodeError::InvalidLength { length: 2 }) - ); - // Re-reading at EOF after a finalization error still reports InvalidData. - let err2 = decoder.read(&mut buf).unwrap_err(); - assert_eq!(err2.kind(), io::ErrorKind::InvalidData); - - let mut bad_byte = Base64::decoder_reader(&b"Zm!v"[..]); - let err3 = bad_byte.read(&mut buf).unwrap_err(); - assert_eq!(err3.kind(), io::ErrorKind::InvalidData); - assert_eq!( - err3.get_ref().and_then(|e| e.downcast_ref::()), - Some(&DecodeError::InvalidByte { - index: 2, - byte: b'!' - }) - ); - } -} diff --git a/tests-integration/tests/contracts/io.rs b/tests-integration/tests/contracts/io.rs index aaf672a..2c5850f 100644 --- a/tests-integration/tests/contracts/io.rs +++ b/tests-integration/tests/contracts/io.rs @@ -16,7 +16,9 @@ use std::io; use std::io::Read; use std::io::Write; +use bases::Base64; use bases::Codec; +use bases::DecodeError; use bases::io::DecoderReader; use bases::io::EncoderWriter; use data_encoding::Encoding; @@ -132,3 +134,32 @@ pub fn check(reference: &Encoding) { } } } + +#[test] +fn decoder_reader_exposes_invalid_data_and_inner_accessors() { + let cases: [(&[u8], DecodeError); 3] = [ + ( + b"Zm9vYm!y", + DecodeError::InvalidByte { + index: 6, + byte: b'!', + }, + ), + (b"Zg==AAAA", DecodeError::InvalidPadding { index: 2 }), + (b"Zh==", DecodeError::NonCanonical { index: 1 }), + ]; + + for (wire, expected) in cases { + let mut reader = Base64::decoder_reader(ChunkedReader::new(wire, 1, 0)); + assert_eq!(reader.get_ref().data, wire); + let _ = reader.get_mut(); + let mut out = Vec::new(); + let err = reader.read_to_end(&mut out).unwrap_err(); + assert_eq!(err.kind(), io::ErrorKind::InvalidData); + assert_eq!( + err.get_ref().and_then(|e| e.downcast_ref::()), + Some(&expected) + ); + assert_eq!(reader.into_inner().data, wire); + } +} diff --git a/tests-integration/tests/io.rs b/tests-integration/tests/io.rs index 5d06572..981c362 100644 --- a/tests-integration/tests/io.rs +++ b/tests-integration/tests/io.rs @@ -21,40 +21,6 @@ use bases::Base64; use bases::DecodeError; use bases::io::EncoderWriter; -struct ChunkedReader<'a> { - data: &'a [u8], - pos: usize, - max_read: usize, - interrupt_every: usize, - calls: usize, -} - -impl<'a> ChunkedReader<'a> { - fn new(data: &'a [u8], max_read: usize, interrupt_every: usize) -> Self { - Self { - data, - pos: 0, - max_read, - interrupt_every, - calls: 0, - } - } -} - -impl Read for ChunkedReader<'_> { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.calls += 1; - if self.interrupt_every > 0 && self.calls.is_multiple_of(self.interrupt_every) { - return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted")); - } - let remaining = self.data.len() - self.pos; - let take = remaining.min(buf.len()).min(self.max_read); - buf[..take].copy_from_slice(&self.data[self.pos..self.pos + take]); - self.pos += take; - Ok(take) - } -} - #[test] fn encoder_writer_handles_drop_and_into_inner() { // Inherent constructors work without Codec in scope. @@ -80,32 +46,16 @@ fn encoder_writer_handles_drop_and_into_inner() { } #[test] -fn decoder_reader_exposes_invalid_data_and_inner_accessors() { - let cases: [(&[u8], DecodeError); 4] = [ - (b"Zg", DecodeError::InvalidLength { length: 2 }), - ( - b"Zm9vYm!y", - DecodeError::InvalidByte { - index: 6, - byte: b'!', - }, - ), - (b"Zg==AAAA", DecodeError::InvalidPadding { index: 2 }), - (b"Zh==", DecodeError::NonCanonical { index: 1 }), - ]; - - for (wire, expected) in cases { - let mut reader = Base64::decoder_reader(ChunkedReader::new(wire, 1, 0)); - assert_eq!(reader.get_ref().data, wire); - let _ = reader.get_mut(); - let mut out = Vec::new(); - let err = reader.read_to_end(&mut out).unwrap_err(); +fn decoder_reader_repeats_the_finalization_error_at_eof() { + let mut reader = Base64::decoder_reader(&b"Zg"[..]); + let mut buf = [0; 3]; + for _ in 0..2 { + let err = reader.read(&mut buf).unwrap_err(); assert_eq!(err.kind(), io::ErrorKind::InvalidData); assert_eq!( err.get_ref().and_then(|e| e.downcast_ref::()), - Some(&expected) + Some(&DecodeError::InvalidLength { length: 2 }) ); - assert_eq!(reader.into_inner().data, wire); } }