1 // Copyright 2015 Ilkka Rauta
2 //
3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6 // option. This file may not be copied, modified, or distributed
7 // except according to those terms.
8
9 use super::*;
10
11 #[test]
read_buffer()12 fn read_buffer() {
13 let bytes = &[
14 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
15 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111,
16 ];
17
18 let mut reader = BitReader::new(bytes);
19
20 assert_eq!(reader.read_u8(1).unwrap(), 0b1);
21 assert_eq!(reader.peek_u8(3).unwrap(), 0b011);
22 assert_eq!(reader.read_u8(1).unwrap(), 0b0);
23 assert_eq!(reader.read_u8(2).unwrap(), 0b11);
24
25 assert!(!reader.is_aligned(1));
26 assert!(!reader.is_aligned(2));
27 assert!(!reader.is_aligned(4));
28
29 assert_eq!(reader.position(), 4);
30 assert_eq!(reader.remaining(), 60);
31
32 assert_eq!(reader.read_u8(4).unwrap(), 0b0101);
33
34 assert!(reader.is_aligned(1));
35 assert!(!reader.is_aligned(2));
36 assert!(!reader.is_aligned(4));
37
38 assert_eq!(reader.align(1), Ok(())); // shouldn't do anything if already aligned
39
40 assert_eq!(reader.peek_u64(16).unwrap(), 0b110_1010_1010_1100);
41 assert_eq!(reader.read_u8(3).unwrap(), 0b11);
42 assert_eq!(reader.peek_u16(13).unwrap(), 0b1010_1010_1100);
43 assert_eq!(reader.peek_u32(13).unwrap(), 0b1010_1010_1100);
44 assert_eq!(reader.peek_u64(13).unwrap(), 0b1010_1010_1100);
45 assert_eq!(reader.peek_u16(10).unwrap(), 0b01_0101_0101);
46 assert_eq!(reader.peek_u8(8).unwrap(), 0b0101_0101);
47 assert_eq!(reader.read_u16(10).unwrap(), 0b01_0101_0101);
48 assert_eq!(reader.read_u8(3).unwrap(), 0b100);
49
50 assert_eq!(reader.position(), 24);
51 assert_eq!(reader.remaining(), 40);
52
53 assert!(reader.is_aligned(1));
54
55 assert_eq!(reader.read_u32(32).unwrap(), 0b1001_1001_1001_1001_1001_1001_1001_1001);
56
57 assert_eq!(reader.peek_bool().unwrap(), true);
58 assert_eq!(reader.read_u8(4).unwrap(), 0b1110);
59 assert_eq!(reader.peek_bool().unwrap(), false);
60 assert_eq!(reader.read_u8(3).unwrap(), 0b011);
61 assert_eq!(reader.peek_bool().unwrap(), true);
62 assert_eq!(reader.read_bool().unwrap(), true);
63
64 // Could also be 8 at this point!
65 assert!(reader.is_aligned(4));
66
67 // shouldn't do anything if already aligned
68 assert_eq!(reader.align(1), Ok(()));
69 assert_eq!(reader.align(2), Ok(()));
70 assert_eq!(reader.align(4), Ok(()));
71 assert_eq!(reader.align(8), Ok(()));
72
73 // Start over to test align()
74 let mut reader = BitReader::new(bytes);
75
76 // shouldn't do anything if already aligned
77 assert_eq!(reader.align(1), Ok(()));
78 assert_eq!(reader.align(2), Ok(()));
79 assert_eq!(reader.align(4), Ok(()));
80 assert_eq!(reader.align(8), Ok(()));
81 assert_eq!(reader.position(), 0);
82
83 assert_eq!(reader.read_u8(1).unwrap(), 0b1);
84
85 assert_eq!(reader.align(1), Ok(()));
86 assert_eq!(reader.position(), 8);
87
88 assert!(reader.is_aligned(1));
89 assert!(!reader.is_aligned(2));
90 assert!(!reader.is_aligned(4));
91
92 assert_eq!(reader.align(2), Ok(()));
93 assert_eq!(reader.position(), 16);
94 assert!(reader.is_aligned(1));
95 assert!(reader.is_aligned(2));
96 assert!(!reader.is_aligned(4));
97
98 assert_eq!(reader.read_u8(7).unwrap(), 0b0101_0110);
99 assert_eq!(reader.align(4), Ok(()));
100 assert_eq!(reader.position(), 32);
101 assert!(reader.is_aligned(1));
102 assert!(reader.is_aligned(2));
103 assert!(reader.is_aligned(4));
104
105 let mut reader = BitReader::new(bytes);
106 assert_eq!(reader.position(), 0);
107 assert_eq!(reader.skip(1), Ok(()));
108 assert_eq!(reader.align(4), Ok(()));
109 assert_eq!(reader.position(), 32);
110 assert_eq!(reader.skip(7), Ok(()));
111 assert_eq!(reader.align(1), Ok(()));
112 assert_eq!(reader.position(), 40);
113 assert_eq!(reader.align(2), Ok(()));
114 assert_eq!(reader.position(), 48);
115 assert_eq!(reader.skip(5), Ok(()));
116 assert_eq!(reader.align(2), Ok(()));
117 assert_eq!(reader.position(), 64);
118
119 let mut reader = BitReader::new(bytes);
120 assert_eq!(reader.skip(1), Ok(()));
121 assert_eq!(reader.align(3), Ok(()));
122 assert_eq!(reader.position(), 24);
123
124 assert!(!reader.align(128).is_ok());
125 }
126
127 #[test]
try_all_sizes()128 fn try_all_sizes() {
129 let bytes = &[
130 0x4a, 0x1e, 0x39, 0xbb, 0xd0, 0x07, 0xca, 0x9a,
131 0xa6, 0xba, 0x25, 0x52, 0x6f, 0x0a, 0x6a, 0xba,
132 ];
133
134 let mut reader = BitReader::new(bytes);
135 assert_eq!(reader.read_u64(64).unwrap(), 0x4a1e39bbd007ca9a);
136 assert_eq!(reader.read_u64(64).unwrap(), 0xa6ba25526f0a6aba);
137
138 let mut reader = BitReader::new(bytes);
139 assert_eq!(reader.read_u32(32).unwrap(), 0x4a1e39bb);
140 assert_eq!(reader.read_u32(32).unwrap(), 0xd007ca9a);
141 assert_eq!(reader.read_u32(32).unwrap(), 0xa6ba2552);
142 assert_eq!(reader.read_u32(32).unwrap(), 0x6f0a6aba);
143
144 let mut reader = BitReader::new(bytes);
145 assert_eq!(reader.read_u16(16).unwrap(), 0x4a1e);
146 assert_eq!(reader.read_u16(16).unwrap(), 0x39bb);
147 assert_eq!(reader.read_u16(16).unwrap(), 0xd007);
148 assert_eq!(reader.read_u16(16).unwrap(), 0xca9a);
149 assert_eq!(reader.read_u16(16).unwrap(), 0xa6ba);
150 assert_eq!(reader.read_u16(16).unwrap(), 0x2552);
151 assert_eq!(reader.read_u16(16).unwrap(), 0x6f0a);
152 assert_eq!(reader.read_u16(16).unwrap(), 0x6aba);
153
154 let mut reader = BitReader::new(&bytes[..]);
155 for byte in bytes {
156 assert_eq!(reader.read_u8(8).unwrap(), *byte);
157 }
158 }
159
160 #[test]
skipping_and_zero_reads()161 fn skipping_and_zero_reads() {
162 let bytes = &[
163 0b1011_0101, 0b1110_1010, 0b1010_1100, 0b0011_0101,
164 ];
165
166 let mut reader = BitReader::new(bytes);
167
168 assert_eq!(reader.read_u8(4).unwrap(), 0b1011);
169 // Reading zero bits should be a no-op
170 assert_eq!(reader.read_u8(0).unwrap(), 0b0);
171 assert_eq!(reader.read_i8(0).unwrap(), 0b0);
172 assert_eq!(reader.read_u8(4).unwrap(), 0b0101);
173 reader.skip(3).unwrap(); // 0b111
174 assert_eq!(reader.read_u16(10).unwrap(), 0b0101010101);
175 assert_eq!(reader.read_u8(3).unwrap(), 0b100);
176 reader.skip(4).unwrap(); // 0b0011
177 assert_eq!(reader.read_u32(2).unwrap(), 0b01);
178 assert_eq!(reader.read_bool().unwrap(), false);
179 assert_eq!(reader.read_bool().unwrap(), true);
180 }
181
182 #[test]
errors()183 fn errors() {
184 let bytes = &[
185 0b1011_0101, 0b1110_1010, 0b1010_1100,
186 ];
187
188 let mut reader = BitReader::new(bytes);
189 assert_eq!(reader.read_u8(4).unwrap(), 0b1011);
190 assert_eq!(reader.read_u8(9).unwrap_err(), BitReaderError::TooManyBitsForType {
191 position: 4,
192 requested: 9,
193 allowed: 8
194 });
195 // If an error happens, it should be possible to resume as if nothing had happened
196 assert_eq!(reader.read_u8(4).unwrap(), 0b0101);
197
198 let mut reader = BitReader::new(bytes);
199 assert_eq!(reader.read_u8(4).unwrap(), 0b1011);
200 // Same with this error
201 assert_eq!(reader.read_u32(21).unwrap_err(), BitReaderError::NotEnoughData {
202 position: 4,
203 length: (bytes.len() * 8) as u64,
204 requested: 21
205 });
206 assert_eq!(reader.read_u8(4).unwrap(), 0b0101);
207 }
208
209 #[test]
signed_values()210 fn signed_values() {
211 let from = -2048;
212 let to = 2048;
213 for x in from..to {
214 let bytes = &[
215 (x >> 8) as u8,
216 x as u8,
217 ];
218 let mut reader = BitReader::new(bytes);
219 assert_eq!(reader.read_u8(4).unwrap(), if x < 0 { 0b1111 } else { 0 });
220 assert_eq!(reader.read_i16(12).unwrap(), x);
221 }
222 }
223
224 #[cfg(feature = "std")]
225 #[test]
boolean_values()226 fn boolean_values() {
227 let bytes: Vec<u8> = (0..16).collect();
228 let mut reader = BitReader::new(&bytes);
229 for v in &bytes {
230 assert_eq!(reader.read_bool().unwrap(), false);
231 reader.skip(3).unwrap();
232 assert_eq!(reader.read_bool().unwrap(), v & 0x08 == 8);
233 assert_eq!(reader.read_bool().unwrap(), v & 0x04 == 4);
234 assert_eq!(reader.read_bool().unwrap(), v & 0x02 == 2);
235 assert_eq!(reader.read_bool().unwrap(), v & 0x01 == 1);
236 }
237 }
238
239 #[test]
read_slice()240 fn read_slice() {
241 let bytes = &[
242 0b1111_0000, 0b0000_1111, 0b1111_0000,
243 0b0000_1000, 0b0000_0100, 0b0000_0011,
244 0b1111_1100, 0b0000_0011, 0b1101_1000,
245 ];
246 let mut reader = BitReader::new(bytes);
247 assert_eq!(reader.read_u8(4).unwrap(), 0b1111);
248 // Just some pattern that's definitely not in the bytes array
249 let mut output = [0b1010_1101; 3];
250 reader.read_u8_slice(&mut output).unwrap();
251 assert_eq!(&output, &[0u8, 255u8, 0u8]);
252
253 assert_eq!(reader.read_u8(1).unwrap(), 1);
254
255 reader.read_u8_slice(&mut output[1..2]).unwrap();
256 assert_eq!(&output, &[0u8, 0u8, 0u8]);
257
258 assert_eq!(reader.read_u8(1).unwrap(), 1);
259
260 output = [0b1010_1101; 3];
261 reader.read_u8_slice(&mut output).unwrap();
262 assert_eq!(&output, &[0u8, 255u8, 0u8]);
263
264 reader.read_u8_slice(&mut output[0..1]).unwrap();
265 assert_eq!(output[0], 0b1111_0110);
266
267 assert_eq!(reader.read_u8(2).unwrap(), 0);
268 }
269
270 #[test]
read_slice_too_much()271 fn read_slice_too_much() {
272 let bytes = &[
273 0b1111_1111, 0b1111_1111, 0b1111_1111, 0b1111_1111,
274 ];
275 let mut reader = BitReader::new(bytes);
276 assert_eq!(reader.read_u8(1).unwrap(), 1);
277
278 let mut output = [0u8; 4];
279 let should_be_error = reader.read_u8_slice(&mut output);
280 assert_eq!(should_be_error.unwrap_err(), BitReaderError::NotEnoughData {
281 position: 1,
282 length: (bytes.len() * 8) as u64,
283 requested: (&output.len() * 8) as u64
284 });
285 assert_eq!(&output, &[0u8; 4]);
286 }
287
288 #[test]
relative_reader()289 fn relative_reader() {
290 let bytes = &[
291 0b0001_0010, 0b0011_0100,
292 ];
293 let mut reader = BitReader::new(bytes);
294 assert_eq!(reader.read_u8(4).unwrap(), 0b0001);
295
296 let mut relative_reader = reader.relative_reader();
297
298 assert_eq!(reader.read_u8(4).unwrap(), 0b0010);
299 assert_eq!(reader.read_u8(4).unwrap(), 0b0011);
300 assert_eq!(reader.read_u8(4).unwrap(), 0b0100);
301
302 assert_eq!(reader.read_u8(1).unwrap_err(), BitReaderError::NotEnoughData {
303 position: 16,
304 length: 16,
305 requested: 1
306 });
307
308 assert_eq!(relative_reader.read_u8(4).unwrap(), 0b0010);
309 assert_eq!(relative_reader.read_u8(4).unwrap(), 0b0011);
310 assert_eq!(relative_reader.read_u8(4).unwrap(), 0b0100);
311
312 assert_eq!(relative_reader.read_u8(1).unwrap_err(), BitReaderError::NotEnoughData {
313 position: 12,
314 length: 12,
315 requested: 1
316 });
317 }
318
319 #[test]
test_read_u64_max()320 fn test_read_u64_max() {
321 let bytes = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
322 let mut reader = BitReader::new(bytes);
323 assert_eq!(reader.read_u64(64).unwrap(), u64::MAX);
324 }
325
326 #[test]
test_read_i64_max()327 fn test_read_i64_max() {
328 let bytes = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
329 let mut reader = BitReader::new(bytes);
330 assert_eq!(reader.read_i64(64).unwrap(), -1);
331 }
332