| 1 |
use std::io; |
| 2 |
use std::{env, fs}; |
| 3 |
use weezl::{decode, encode, BitOrder}; |
| 4 |
|
| 5 |
#[derive(Clone, Copy, Debug)] |
| 6 |
enum Flavor { |
| 7 |
Gif, |
| 8 |
Tiff, |
| 9 |
} |
| 10 |
|
| 11 |
#[test] |
| 12 |
fn roundtrip_all_lsb_tiny() { |
| 13 |
roundtrip_all(BitOrder::Lsb, 1); |
| 14 |
} |
| 15 |
|
| 16 |
#[test] |
| 17 |
fn roundtrip_all_msb_tiny() { |
| 18 |
roundtrip_all(BitOrder::Msb, 1); |
| 19 |
} |
| 20 |
|
| 21 |
#[test] |
| 22 |
fn roundtrip_all_lsb() { |
| 23 |
roundtrip_all(BitOrder::Lsb, 1 << 20); |
| 24 |
} |
| 25 |
|
| 26 |
#[test] |
| 27 |
fn roundtrip_all_msb() { |
| 28 |
roundtrip_all(BitOrder::Msb, 1 << 20); |
| 29 |
} |
| 30 |
|
| 31 |
fn roundtrip_all(bit_order: BitOrder, max_io_len: usize) { |
| 32 |
let file = env::args().next().unwrap(); |
| 33 |
let data = fs::read(file).unwrap(); |
| 34 |
|
| 35 |
for &flavor in &[Flavor::Gif, Flavor::Tiff] { |
| 36 |
for bit_width in 2..8 { |
| 37 |
let data: Vec<_> = data |
| 38 |
.iter() |
| 39 |
.copied() |
| 40 |
.map(|b| b & ((1 << bit_width) - 1)) |
| 41 |
.collect(); |
| 42 |
|
| 43 |
let enc = match flavor { |
| 44 |
Flavor::Gif => encode::Configuration::new, |
| 45 |
Flavor::Tiff => encode::Configuration::with_tiff_size_switch, |
| 46 |
}(bit_order, bit_width); |
| 47 |
|
| 48 |
let dec = match flavor { |
| 49 |
Flavor::Gif => decode::Configuration::new, |
| 50 |
Flavor::Tiff => decode::Configuration::with_tiff_size_switch, |
| 51 |
}(bit_order, bit_width); |
| 52 |
|
| 53 |
let yielding = dec.clone().with_yield_on_full_buffer(true); |
| 54 |
|
| 55 |
println!("Roundtrip test {:?} {:?} {}", flavor, bit_order, bit_width); |
| 56 |
assert_roundtrips(&*data, enc.clone(), dec, max_io_len); |
| 57 |
|
| 58 |
// Our encoder always passes an enclosed stream. So this must be the same. |
| 59 |
assert_roundtrips(&*data, enc, yielding, max_io_len); |
| 60 |
} |
| 61 |
} |
| 62 |
} |
| 63 |
|
| 64 |
fn assert_roundtrips( |
| 65 |
data: &[u8], |
| 66 |
enc: encode::Configuration, |
| 67 |
dec: decode::Configuration, |
| 68 |
max_io_len: usize, |
| 69 |
) { |
| 70 |
let mut encoder = enc.clone().build(); |
| 71 |
let mut writer = TinyWrite { |
| 72 |
data: Vec::with_capacity(2 * data.len() + 40), |
| 73 |
max_write_len: max_io_len, |
| 74 |
}; |
| 75 |
let _ = encoder.into_stream(&mut writer).encode_all(data); |
| 76 |
|
| 77 |
let mut decoder = dec.clone().build(); |
| 78 |
let mut compare = vec![]; |
| 79 |
|
| 80 |
let buf_reader = TinyRead { |
| 81 |
data: &writer.data, |
| 82 |
max_read_len: max_io_len, |
| 83 |
}; |
| 84 |
let result = decoder.into_stream(&mut compare).decode_all(buf_reader); |
| 85 |
assert!(result.status.is_ok(), "{:?}, {:?}", dec, result.status); |
| 86 |
assert!(data == &*compare, "{:?}\n{:?}\n{:?}", dec, data, compare); |
| 87 |
} |
| 88 |
|
| 89 |
struct TinyRead<'a> { |
| 90 |
data: &'a [u8], |
| 91 |
max_read_len: usize, |
| 92 |
} |
| 93 |
|
| 94 |
impl io::BufRead for TinyRead<'_> { |
| 95 |
fn fill_buf(&mut self) -> io::Result<&[u8]> { |
| 96 |
Ok(&self.data[..self.data.len().min(self.max_read_len)]) |
| 97 |
} |
| 98 |
fn consume(&mut self, n: usize) { |
| 99 |
debug_assert!(n <= self.max_read_len); |
| 100 |
self.data = &self.data[n..]; |
| 101 |
} |
| 102 |
} |
| 103 |
|
| 104 |
impl io::Read for TinyRead<'_> { |
| 105 |
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
| 106 |
let n = self.data.len().min(buf.len()).min(self.max_read_len); |
| 107 |
buf[..n].copy_from_slice(&self.data[..n]); |
| 108 |
self.data = &self.data[n..]; |
| 109 |
Ok(n) |
| 110 |
} |
| 111 |
} |
| 112 |
|
| 113 |
struct TinyWrite { |
| 114 |
data: Vec<u8>, |
| 115 |
max_write_len: usize, |
| 116 |
} |
| 117 |
|
| 118 |
impl io::Write for TinyWrite { |
| 119 |
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
| 120 |
let n = buf.len().min(self.max_write_len); |
| 121 |
self.data.extend_from_slice(&buf[..n]); |
| 122 |
Ok(n) |
| 123 |
} |
| 124 |
|
| 125 |
fn flush(&mut self) -> io::Result<()> { |
| 126 |
Ok(()) |
| 127 |
} |
| 128 |
} |