1 // Copyright 2017 Brian Langenberger
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 extern crate bitstream_io;
10 use std::io::Cursor;
11 
12 #[test]
test_read_queue_be()13 fn test_read_queue_be() {
14     use bitstream_io::{BitQueue, BE};
15     let mut q: BitQueue<BE, u32> = BitQueue::new();
16     assert!(q.is_empty());
17     assert_eq!(q.len(), 0);
18     q.push(8, 0b10_110_001);
19     assert_eq!(q.len(), 8);
20     assert_eq!(q.pop(2), 0b10);
21     assert_eq!(q.len(), 6);
22     assert_eq!(q.pop(3), 0b110);
23     assert_eq!(q.len(), 3);
24     q.push(8, 0b11_101_101);
25     assert_eq!(q.len(), 11);
26     assert_eq!(q.pop(5), 0b001_11);
27     assert_eq!(q.len(), 6);
28     assert_eq!(q.pop(3), 0b101);
29     q.push(8, 0b00111011);
30     q.push(8, 0b11000001);
31     assert_eq!(q.pop(19), 0b101_00111011_11000001);
32     assert!(q.is_empty());
33     assert_eq!(q.value(), 0);
34 }
35 
36 #[test]
test_read_queue_le()37 fn test_read_queue_le() {
38     use bitstream_io::{BitQueue, LE};
39     let mut q: BitQueue<LE, u32> = BitQueue::new();
40     assert!(q.is_empty());
41     assert_eq!(q.len(), 0);
42     q.push(8, 0b101_100_01);
43     assert_eq!(q.len(), 8);
44     assert_eq!(q.pop(2), 0b01);
45     assert_eq!(q.len(), 6);
46     assert_eq!(q.pop(3), 0b100);
47     assert_eq!(q.len(), 3);
48     q.push(8, 0b111_011_01);
49     assert_eq!(q.len(), 11);
50     assert_eq!(q.pop(5), 0b01_101);
51     assert_eq!(q.len(), 6);
52     assert_eq!(q.pop(3), 0b011);
53     q.push(8, 0b00111011);
54     q.push(8, 0b11000001);
55     assert_eq!(q.pop(19), 0b11000001_00111011_111);
56     assert!(q.is_empty());
57     assert_eq!(q.value(), 0);
58 }
59 
60 #[test]
test_reader_be()61 fn test_reader_be() {
62     use bitstream_io::{BigEndian, BitRead, BitReader};
63 
64     let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
65 
66     /*reading individual bits*/
67     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
68     assert_eq!(r.read_bit().unwrap(), true);
69     assert_eq!(r.read_bit().unwrap(), false);
70     assert_eq!(r.read_bit().unwrap(), true);
71     assert_eq!(r.read_bit().unwrap(), true);
72     assert_eq!(r.read_bit().unwrap(), false);
73     assert_eq!(r.read_bit().unwrap(), false);
74     assert_eq!(r.read_bit().unwrap(), false);
75     assert_eq!(r.read_bit().unwrap(), true);
76     assert_eq!(r.read_bit().unwrap(), true);
77     assert_eq!(r.read_bit().unwrap(), true);
78     assert_eq!(r.read_bit().unwrap(), true);
79     assert_eq!(r.read_bit().unwrap(), false);
80     assert_eq!(r.read_bit().unwrap(), true);
81     assert_eq!(r.read_bit().unwrap(), true);
82     assert_eq!(r.read_bit().unwrap(), false);
83     assert_eq!(r.read_bit().unwrap(), true);
84 
85     /*reading unsigned values*/
86     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
87     assert!(r.byte_aligned());
88     assert_eq!(r.read::<u32>(2).unwrap(), 2);
89     assert!(!r.byte_aligned());
90     assert_eq!(r.read::<u32>(3).unwrap(), 6);
91     assert!(!r.byte_aligned());
92     assert_eq!(r.read::<u32>(5).unwrap(), 7);
93     assert!(!r.byte_aligned());
94     assert_eq!(r.read::<u32>(3).unwrap(), 5);
95     assert!(!r.byte_aligned());
96     assert_eq!(r.read::<u32>(19).unwrap(), 0x53BC1);
97     assert!(r.byte_aligned());
98     assert!(r.read::<u32>(1).is_err());
99 
100     /*skipping bits*/
101     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
102     assert_eq!(r.read::<u32>(2).unwrap(), 2);
103     assert!(r.skip(3).is_ok());
104     assert_eq!(r.read::<u32>(5).unwrap(), 7);
105     assert!(r.skip(3).is_ok());
106     assert_eq!(r.read::<u32>(19).unwrap(), 0x53BC1);
107 
108     /*reading signed values*/
109     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
110     assert_eq!(r.read_signed::<i32>(2).unwrap(), -2);
111     assert_eq!(r.read_signed::<i32>(3).unwrap(), -2);
112     assert_eq!(r.read_signed::<i32>(5).unwrap(), 7);
113     assert_eq!(r.read_signed::<i32>(3).unwrap(), -3);
114     assert_eq!(r.read_signed::<i32>(19).unwrap(), -181311);
115 
116     /*reading unary 0 values*/
117     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
118     assert_eq!(r.read_unary0().unwrap(), 1);
119     assert_eq!(r.read_unary0().unwrap(), 2);
120     assert_eq!(r.read_unary0().unwrap(), 0);
121     assert_eq!(r.read_unary0().unwrap(), 0);
122     assert_eq!(r.read_unary0().unwrap(), 4);
123 
124     /*reading unary 1 values*/
125     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
126     assert_eq!(r.read_unary1().unwrap(), 0);
127     assert_eq!(r.read_unary1().unwrap(), 1);
128     assert_eq!(r.read_unary1().unwrap(), 0);
129     assert_eq!(r.read_unary1().unwrap(), 3);
130     assert_eq!(r.read_unary1().unwrap(), 0);
131 
132     /*byte aligning*/
133     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
134     assert_eq!(r.read::<u32>(3).unwrap(), 5);
135     r.byte_align();
136     assert_eq!(r.read::<u32>(3).unwrap(), 7);
137     r.byte_align();
138     r.byte_align();
139     assert_eq!(r.read::<u32>(8).unwrap(), 59);
140     r.byte_align();
141     assert_eq!(r.read::<u32>(4).unwrap(), 12);
142 
143     /*reading bytes, aligned*/
144     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
145     let mut sub_data = [0; 2];
146     assert!(r.read_bytes(&mut sub_data).is_ok());
147     assert_eq!(&sub_data, b"\xB1\xED");
148 
149     /*reading bytes, un-aligned*/
150     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
151     let mut sub_data = [0; 2];
152     assert_eq!(r.read::<u32>(4).unwrap(), 11);
153     assert!(r.read_bytes(&mut sub_data).is_ok());
154     assert_eq!(&sub_data, b"\x1E\xD3");
155 }
156 
157 #[test]
test_edge_cases_be()158 fn test_edge_cases_be() {
159     use bitstream_io::{BigEndian, BitRead, BitReader};
160 
161     let data: Vec<u8> = vec![
162         0, 0, 0, 0, 255, 255, 255, 255, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0,
163         255, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255, 255,
164         255, 255, 255,
165     ];
166 
167     /*0 bit reads*/
168     let mut r = BitReader::endian(Cursor::new(vec![255]), BigEndian);
169     assert_eq!(r.read::<u8>(0).unwrap(), 0);
170     assert_eq!(r.read::<u16>(0).unwrap(), 0);
171     assert_eq!(r.read::<u32>(0).unwrap(), 0);
172     assert_eq!(r.read::<u64>(0).unwrap(), 0);
173     assert_eq!(r.read::<u8>(8).unwrap(), 255);
174 
175     /*unsigned 32 and 64-bit values*/
176     let mut r = BitReader::endian(Cursor::new(&data), BigEndian);
177     assert_eq!(r.read::<u32>(32).unwrap(), 0);
178     assert_eq!(r.read::<u32>(32).unwrap(), 4294967295);
179     assert_eq!(r.read::<u32>(32).unwrap(), 2147483648);
180     assert_eq!(r.read::<u32>(32).unwrap(), 2147483647);
181     assert_eq!(r.read::<u64>(64).unwrap(), 0);
182     assert_eq!(r.read::<u64>(64).unwrap(), 0xFFFFFFFFFFFFFFFF);
183     assert_eq!(r.read::<u64>(64).unwrap(), 9223372036854775808);
184     assert_eq!(r.read::<u64>(64).unwrap(), 9223372036854775807);
185 
186     /*signed 32 and 64-bit values*/
187     let mut r = BitReader::endian(Cursor::new(&data), BigEndian);
188     assert_eq!(r.read::<i32>(32).unwrap(), 0);
189     assert_eq!(r.read::<i32>(32).unwrap(), -1);
190     assert_eq!(r.read::<i32>(32).unwrap(), -2147483648);
191     assert_eq!(r.read::<i32>(32).unwrap(), 2147483647);
192     assert_eq!(r.read::<i64>(64).unwrap(), 0);
193     assert_eq!(r.read::<i64>(64).unwrap(), -1);
194     assert_eq!(r.read::<i64>(64).unwrap(), -9223372036854775808);
195     assert_eq!(r.read::<i64>(64).unwrap(), 9223372036854775807);
196 }
197 
198 #[test]
test_reader_huffman_be()199 fn test_reader_huffman_be() {
200     use bitstream_io::huffman::compile_read_tree;
201     use bitstream_io::{BigEndian, BitReader, HuffmanRead};
202 
203     let tree = compile_read_tree(vec![
204         (0, vec![1, 1]),
205         (1, vec![1, 0]),
206         (2, vec![0, 1]),
207         (3, vec![0, 0, 1]),
208         (4, vec![0, 0, 0]),
209     ])
210     .unwrap();
211 
212     let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
213     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
214 
215     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
216     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
217     assert_eq!(r.read_huffman(&tree).unwrap(), 4);
218     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
219     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
220     assert_eq!(r.read_huffman(&tree).unwrap(), 2);
221     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
222     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
223     assert_eq!(r.read_huffman(&tree).unwrap(), 2);
224     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
225     assert_eq!(r.read_huffman(&tree).unwrap(), 2);
226     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
227     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
228     assert_eq!(r.read_huffman(&tree).unwrap(), 4);
229     assert_eq!(r.read_huffman(&tree).unwrap(), 2);
230 }
231 
232 #[test]
test_reader_le()233 fn test_reader_le() {
234     use bitstream_io::{BitRead, BitReader, LittleEndian};
235 
236     let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
237 
238     /*reading individual bits*/
239     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
240     assert_eq!(r.read_bit().unwrap(), true);
241     assert_eq!(r.read_bit().unwrap(), false);
242     assert_eq!(r.read_bit().unwrap(), false);
243     assert_eq!(r.read_bit().unwrap(), false);
244     assert_eq!(r.read_bit().unwrap(), true);
245     assert_eq!(r.read_bit().unwrap(), true);
246     assert_eq!(r.read_bit().unwrap(), false);
247     assert_eq!(r.read_bit().unwrap(), true);
248     assert_eq!(r.read_bit().unwrap(), true);
249     assert_eq!(r.read_bit().unwrap(), false);
250     assert_eq!(r.read_bit().unwrap(), true);
251     assert_eq!(r.read_bit().unwrap(), true);
252     assert_eq!(r.read_bit().unwrap(), false);
253     assert_eq!(r.read_bit().unwrap(), true);
254     assert_eq!(r.read_bit().unwrap(), true);
255     assert_eq!(r.read_bit().unwrap(), true);
256 
257     /*reading unsigned values*/
258     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
259     assert!(r.byte_aligned());
260     assert_eq!(r.read::<u32>(2).unwrap(), 1);
261     assert!(!r.byte_aligned());
262     assert_eq!(r.read::<u32>(3).unwrap(), 4);
263     assert!(!r.byte_aligned());
264     assert_eq!(r.read::<u32>(5).unwrap(), 13);
265     assert!(!r.byte_aligned());
266     assert_eq!(r.read::<u32>(3).unwrap(), 3);
267     assert!(!r.byte_aligned());
268     assert_eq!(r.read::<u32>(19).unwrap(), 0x609DF);
269     assert!(r.byte_aligned());
270     assert!(r.read::<u32>(1).is_err());
271 
272     /*skipping bits*/
273     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
274     assert_eq!(r.read::<u32>(2).unwrap(), 1);
275     assert!(r.skip(3).is_ok());
276     assert_eq!(r.read::<u32>(5).unwrap(), 13);
277     assert!(r.skip(3).is_ok());
278     assert_eq!(r.read::<u32>(19).unwrap(), 0x609DF);
279 
280     /*reading signed values*/
281     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
282     assert_eq!(r.read_signed::<i32>(2).unwrap(), 1);
283     assert_eq!(r.read_signed::<i32>(3).unwrap(), -4);
284     assert_eq!(r.read_signed::<i32>(5).unwrap(), 13);
285     assert_eq!(r.read_signed::<i32>(3).unwrap(), 3);
286     assert_eq!(r.read_signed::<i32>(19).unwrap(), -128545);
287 
288     /*reading unary 0 values*/
289     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
290     assert_eq!(r.read_unary0().unwrap(), 1);
291     assert_eq!(r.read_unary0().unwrap(), 0);
292     assert_eq!(r.read_unary0().unwrap(), 0);
293     assert_eq!(r.read_unary0().unwrap(), 2);
294     assert_eq!(r.read_unary0().unwrap(), 2);
295 
296     /*reading unary 1 values*/
297     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
298     assert_eq!(r.read_unary1().unwrap(), 0);
299     assert_eq!(r.read_unary1().unwrap(), 3);
300     assert_eq!(r.read_unary1().unwrap(), 0);
301     assert_eq!(r.read_unary1().unwrap(), 1);
302     assert_eq!(r.read_unary1().unwrap(), 0);
303 
304     /*byte aligning*/
305     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
306     assert_eq!(r.read::<u32>(3).unwrap(), 1);
307     r.byte_align();
308     assert_eq!(r.read::<u32>(3).unwrap(), 5);
309     r.byte_align();
310     r.byte_align();
311     assert_eq!(r.read::<u32>(8).unwrap(), 59);
312     r.byte_align();
313     assert_eq!(r.read::<u32>(4).unwrap(), 1);
314 
315     /*reading bytes, aligned*/
316     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
317     let mut sub_data = [0; 2];
318     assert!(r.read_bytes(&mut sub_data).is_ok());
319     assert_eq!(&sub_data, b"\xB1\xED");
320 
321     /*reading bytes, un-aligned*/
322     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
323     let mut sub_data = [0; 2];
324     assert_eq!(r.read::<u32>(4).unwrap(), 1);
325     assert!(r.read_bytes(&mut sub_data).is_ok());
326     assert_eq!(&sub_data, b"\xDB\xBE");
327 }
328 
329 #[test]
test_edge_cases_le()330 fn test_edge_cases_le() {
331     use bitstream_io::{BitRead, BitReader, LittleEndian};
332 
333     let data: Vec<u8> = vec![
334         0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0,
335         255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255,
336         255, 255, 127,
337     ];
338 
339     /*0 bit reads*/
340     let mut r = BitReader::endian(Cursor::new(vec![255]), LittleEndian);
341     assert_eq!(r.read::<u8>(0).unwrap(), 0);
342     assert_eq!(r.read::<u16>(0).unwrap(), 0);
343     assert_eq!(r.read::<u32>(0).unwrap(), 0);
344     assert_eq!(r.read::<u64>(0).unwrap(), 0);
345     assert_eq!(r.read::<u8>(8).unwrap(), 255);
346 
347     /*unsigned 32 and 64-bit values*/
348     let mut r = BitReader::endian(Cursor::new(&data), LittleEndian);
349     assert_eq!(r.read::<u32>(32).unwrap(), 0);
350     assert_eq!(r.read::<u32>(32).unwrap(), 4294967295);
351     assert_eq!(r.read::<u32>(32).unwrap(), 2147483648);
352     assert_eq!(r.read::<u32>(32).unwrap(), 2147483647);
353     assert_eq!(r.read::<u64>(64).unwrap(), 0);
354     assert_eq!(r.read::<u64>(64).unwrap(), 0xFFFFFFFFFFFFFFFF);
355     assert_eq!(r.read::<u64>(64).unwrap(), 9223372036854775808);
356     assert_eq!(r.read::<u64>(64).unwrap(), 9223372036854775807);
357 
358     let mut r = BitReader::endian(Cursor::new(&data), LittleEndian);
359     assert_eq!(r.read_signed::<i32>(32).unwrap(), 0);
360     assert_eq!(r.read_signed::<i32>(32).unwrap(), -1);
361     assert_eq!(r.read_signed::<i32>(32).unwrap(), -2147483648);
362     assert_eq!(r.read_signed::<i32>(32).unwrap(), 2147483647);
363     assert_eq!(r.read_signed::<i64>(64).unwrap(), 0);
364     assert_eq!(r.read_signed::<i64>(64).unwrap(), -1);
365     assert_eq!(r.read_signed::<i64>(64).unwrap(), -9223372036854775808);
366     assert_eq!(r.read_signed::<i64>(64).unwrap(), 9223372036854775807);
367 }
368 
369 #[test]
test_reader_huffman_le()370 fn test_reader_huffman_le() {
371     use bitstream_io::huffman::compile_read_tree;
372     use bitstream_io::{BitReader, HuffmanRead, LittleEndian};
373 
374     let tree = compile_read_tree(vec![
375         (0, vec![1, 1]),
376         (1, vec![1, 0]),
377         (2, vec![0, 1]),
378         (3, vec![0, 0, 1]),
379         (4, vec![0, 0, 0]),
380     ])
381     .unwrap();
382 
383     let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
384     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
385 
386     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
387     assert_eq!(r.read_huffman(&tree).unwrap(), 3);
388     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
389     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
390     assert_eq!(r.read_huffman(&tree).unwrap(), 2);
391     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
392     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
393     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
394     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
395     assert_eq!(r.read_huffman(&tree).unwrap(), 0);
396     assert_eq!(r.read_huffman(&tree).unwrap(), 1);
397     assert_eq!(r.read_huffman(&tree).unwrap(), 2);
398     assert_eq!(r.read_huffman(&tree).unwrap(), 4);
399     assert_eq!(r.read_huffman(&tree).unwrap(), 3);
400 }
401 
402 #[test]
test_reader_io_errors_be()403 fn test_reader_io_errors_be() {
404     use bitstream_io::{BigEndian, BitRead, BitReader};
405     use std::io::ErrorKind;
406 
407     let actual_data: [u8; 1] = [0xB1];
408 
409     /*individual bits*/
410     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
411     assert!(r.read_bit().is_ok());
412     assert!(r.read_bit().is_ok());
413     assert!(r.read_bit().is_ok());
414     assert!(r.read_bit().is_ok());
415     assert!(r.read_bit().is_ok());
416     assert!(r.read_bit().is_ok());
417     assert!(r.read_bit().is_ok());
418     assert!(r.read_bit().is_ok());
419     assert_eq!(r.read_bit().unwrap_err().kind(), ErrorKind::UnexpectedEof);
420 
421     /*skipping bits*/
422     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
423     assert!(r.read::<u32>(7).is_ok());
424     assert_eq!(r.skip(5).unwrap_err().kind(), ErrorKind::UnexpectedEof);
425 
426     /*signed values*/
427     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
428     assert!(r.read_signed::<i32>(2).is_ok());
429     assert!(r.read_signed::<i32>(3).is_ok());
430     assert_eq!(
431         r.read_signed::<i32>(5).unwrap_err().kind(),
432         ErrorKind::UnexpectedEof
433     );
434 
435     /*unary 0 values*/
436     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
437     assert!(r.read_unary0().is_ok());
438     assert!(r.read_unary0().is_ok());
439     assert!(r.read_unary0().is_ok());
440     assert!(r.read_unary0().is_ok());
441     assert_eq!(
442         r.read_unary0().unwrap_err().kind(),
443         ErrorKind::UnexpectedEof
444     );
445 
446     /*unary 1 values*/
447     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
448     assert!(r.read_unary1().is_ok());
449     assert!(r.read_unary1().is_ok());
450     assert!(r.read_unary1().is_ok());
451     assert!(r.read_unary1().is_ok());
452     assert_eq!(
453         r.read_unary1().unwrap_err().kind(),
454         ErrorKind::UnexpectedEof
455     );
456 
457     /*reading bytes, aligned*/
458     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
459     let mut sub_data = [0; 2];
460     assert_eq!(
461         r.read_bytes(&mut sub_data).unwrap_err().kind(),
462         ErrorKind::UnexpectedEof
463     );
464 
465     /*reading bytes, un-aligned*/
466     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
467     let mut sub_data = [0; 2];
468     assert!(r.read::<u32>(4).is_ok());
469     assert_eq!(
470         r.read_bytes(&mut sub_data).unwrap_err().kind(),
471         ErrorKind::UnexpectedEof
472     );
473 }
474 
475 #[test]
test_reader_io_errors_le()476 fn test_reader_io_errors_le() {
477     use bitstream_io::{BitRead, BitReader, LittleEndian};
478     use std::io::ErrorKind;
479 
480     let actual_data: [u8; 1] = [0xB1];
481 
482     /*individual bits*/
483     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
484     assert!(r.read_bit().is_ok());
485     assert!(r.read_bit().is_ok());
486     assert!(r.read_bit().is_ok());
487     assert!(r.read_bit().is_ok());
488     assert!(r.read_bit().is_ok());
489     assert!(r.read_bit().is_ok());
490     assert!(r.read_bit().is_ok());
491     assert!(r.read_bit().is_ok());
492     assert_eq!(r.read_bit().unwrap_err().kind(), ErrorKind::UnexpectedEof);
493 
494     /*skipping bits*/
495     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
496     assert!(r.read::<u32>(7).is_ok());
497     assert_eq!(r.skip(5).unwrap_err().kind(), ErrorKind::UnexpectedEof);
498 
499     /*signed values*/
500     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
501     assert!(r.read_signed::<i32>(2).is_ok());
502     assert!(r.read_signed::<i32>(3).is_ok());
503     assert_eq!(
504         r.read_signed::<i32>(5).unwrap_err().kind(),
505         ErrorKind::UnexpectedEof
506     );
507 
508     /*unary 0 values*/
509     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
510     assert!(r.read_unary0().is_ok());
511     assert!(r.read_unary0().is_ok());
512     assert!(r.read_unary0().is_ok());
513     assert!(r.read_unary0().is_ok());
514     assert_eq!(
515         r.read_unary0().unwrap_err().kind(),
516         ErrorKind::UnexpectedEof
517     );
518 
519     /*unary 1 values*/
520     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
521     assert!(r.read_unary1().is_ok());
522     assert!(r.read_unary1().is_ok());
523     assert!(r.read_unary1().is_ok());
524     assert!(r.read_unary1().is_ok());
525     assert_eq!(
526         r.read_unary1().unwrap_err().kind(),
527         ErrorKind::UnexpectedEof
528     );
529 
530     /*reading bytes, aligned*/
531     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
532     let mut sub_data = [0; 2];
533     assert_eq!(
534         r.read_bytes(&mut sub_data).unwrap_err().kind(),
535         ErrorKind::UnexpectedEof
536     );
537 
538     /*reading bytes, un-aligned*/
539     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
540     let mut sub_data = [0; 2];
541     assert!(r.read::<u32>(4).is_ok());
542     assert_eq!(
543         r.read_bytes(&mut sub_data).unwrap_err().kind(),
544         ErrorKind::UnexpectedEof
545     );
546 }
547 
548 #[test]
test_reader_bits_errors()549 fn test_reader_bits_errors() {
550     use bitstream_io::{BigEndian, BitRead, BitReader, LittleEndian};
551     use std::io::ErrorKind;
552     let actual_data = [0u8; 10];
553 
554     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
555 
556     assert_eq!(r.read::<u8>(9).unwrap_err().kind(), ErrorKind::InvalidInput);
557     assert_eq!(
558         r.read::<u16>(17).unwrap_err().kind(),
559         ErrorKind::InvalidInput
560     );
561     assert_eq!(
562         r.read::<u32>(33).unwrap_err().kind(),
563         ErrorKind::InvalidInput
564     );
565     assert_eq!(
566         r.read::<u64>(65).unwrap_err().kind(),
567         ErrorKind::InvalidInput
568     );
569 
570     assert_eq!(
571         r.read_signed::<i8>(9).unwrap_err().kind(),
572         ErrorKind::InvalidInput
573     );
574     assert_eq!(
575         r.read_signed::<i16>(17).unwrap_err().kind(),
576         ErrorKind::InvalidInput
577     );
578     assert_eq!(
579         r.read_signed::<i32>(33).unwrap_err().kind(),
580         ErrorKind::InvalidInput
581     );
582     assert_eq!(
583         r.read_signed::<i64>(65).unwrap_err().kind(),
584         ErrorKind::InvalidInput
585     );
586 
587     let mut r = BitReader::endian(Cursor::new(&actual_data), LittleEndian);
588 
589     assert_eq!(r.read::<u8>(9).unwrap_err().kind(), ErrorKind::InvalidInput);
590     assert_eq!(
591         r.read::<u16>(17).unwrap_err().kind(),
592         ErrorKind::InvalidInput
593     );
594     assert_eq!(
595         r.read::<u32>(33).unwrap_err().kind(),
596         ErrorKind::InvalidInput
597     );
598     assert_eq!(
599         r.read::<u64>(65).unwrap_err().kind(),
600         ErrorKind::InvalidInput
601     );
602 
603     assert_eq!(
604         r.read_signed::<i8>(9).unwrap_err().kind(),
605         ErrorKind::InvalidInput
606     );
607     assert_eq!(
608         r.read_signed::<i16>(17).unwrap_err().kind(),
609         ErrorKind::InvalidInput
610     );
611     assert_eq!(
612         r.read_signed::<i32>(33).unwrap_err().kind(),
613         ErrorKind::InvalidInput
614     );
615     assert_eq!(
616         r.read_signed::<i64>(65).unwrap_err().kind(),
617         ErrorKind::InvalidInput
618     );
619 }
620 
621 #[test]
test_clone()622 fn test_clone() {
623     use bitstream_io::{BigEndian, BitRead, BitReader};
624 
625     // Reading unsigned examples, cloning while unaligned.
626     let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
627     let mut r = BitReader::endian(Cursor::new(&actual_data), BigEndian);
628     assert!(r.byte_aligned());
629     assert_eq!(r.read::<u32>(4).unwrap(), 0xB);
630     let mut r2 = r.clone();
631     assert!(!r.byte_aligned());
632     assert_eq!(r.read::<u32>(4).unwrap(), 0x1);
633     assert_eq!(r.read::<u32>(8).unwrap(), 0xED);
634     assert!(!r2.byte_aligned());
635     assert_eq!(r2.read::<u32>(4).unwrap(), 0x1);
636     assert_eq!(r2.read::<u32>(8).unwrap(), 0xED);
637 
638     // Can still instantiate a BitReader when the backing std::io::Read is
639     // !Clone.
640     struct NotCloneRead<'a>(&'a [u8]);
641     impl<'a> std::io::Read for NotCloneRead<'a> {
642         fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
643             self.0.read(buf)
644         }
645     }
646     let _r = BitReader::endian(NotCloneRead(&actual_data[..]), BigEndian);
647 }
648