Debian Codegraph @

.cargo/vendor/weezl/tests/roundtrip.rs

raw
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 }