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