Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
181 changes: 0 additions & 181 deletions bases/src/io.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<u8>,
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<usize> {
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<usize> {
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<u8> = (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::<Base64, _>::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<C: Codec>(encoded: &[u8]) -> Vec<u8> {
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>(Base64::encode(b"foobar").as_bytes()),
b"foobar"
);
assert_eq!(decode_all_by_byte::<Base64Unpadded>(b"Zm8"), b"fo");
assert_eq!(
decode_all_by_byte::<Base32>(Base32::encode(b"foobar").as_bytes()),
b"foobar"
);
assert_eq!(
decode_all_by_byte::<Base32Unpadded>(
Base32Unpadded::encode(b"hello world!").as_bytes()
),
b"hello world!"
);
assert_eq!(
decode_all_by_byte::<Base16Lower>(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::<DecodeError>()),
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::<DecodeError>()),
Some(&DecodeError::InvalidByte {
index: 2,
byte: b'!'
})
);
}
}
31 changes: 31 additions & 0 deletions tests-integration/tests/contracts/io.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -132,3 +134,32 @@ pub fn check<C: Codec>(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::<DecodeError>()),
Some(&expected)
);
assert_eq!(reader.into_inner().data, wire);
}
}
62 changes: 6 additions & 56 deletions tests-integration/tests/io.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<usize> {
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.
Expand All @@ -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::<DecodeError>()),
Some(&expected)
Some(&DecodeError::InvalidLength { length: 2 })
);
assert_eq!(reader.into_inner().data, wire);
}
}

Expand Down
Loading