Debian Codegraph @

.cargo/vendor/bitstream-io/tests/read.rs

raw
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 use std::io;
10
11 #[test]
12 fn test_reader_be() {
13 use bitstream_io::{BigEndian, BitRead, BitReader};
14
15 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
16
17 // reading individual bits
18 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
19 assert_eq!(r.read_bit().unwrap(), true);
20 assert_eq!(r.read_bit().unwrap(), false);
21 assert_eq!(r.read_bit().unwrap(), true);
22 assert_eq!(r.read_bit().unwrap(), true);
23 assert_eq!(r.read_bit().unwrap(), false);
24 assert_eq!(r.read_bit().unwrap(), false);
25 assert_eq!(r.read_bit().unwrap(), false);
26 assert_eq!(r.read_bit().unwrap(), true);
27 assert_eq!(r.read_bit().unwrap(), true);
28 assert_eq!(r.read_bit().unwrap(), true);
29 assert_eq!(r.read_bit().unwrap(), true);
30 assert_eq!(r.read_bit().unwrap(), false);
31 assert_eq!(r.read_bit().unwrap(), true);
32 assert_eq!(r.read_bit().unwrap(), true);
33 assert_eq!(r.read_bit().unwrap(), false);
34 assert_eq!(r.read_bit().unwrap(), true);
35
36 // reading unsigned values
37 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
38 assert!(r.byte_aligned());
39 assert_eq!(r.read_var::<u32>(2).unwrap(), 2);
40 assert!(!r.byte_aligned());
41 assert_eq!(r.read_var::<u32>(3).unwrap(), 6);
42 assert!(!r.byte_aligned());
43 assert_eq!(r.read_var::<u32>(5).unwrap(), 7);
44 assert!(!r.byte_aligned());
45 assert_eq!(r.read_var::<u32>(3).unwrap(), 5);
46 assert!(!r.byte_aligned());
47 assert_eq!(r.read_var::<u32>(19).unwrap(), 0x53BC1);
48 assert!(r.byte_aligned());
49 assert!(r.read_var::<u32>(1).is_err());
50
51 // reading const unsigned values
52 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
53 assert!(r.byte_aligned());
54 assert_eq!(r.read::<2, u32>().unwrap(), 2);
55 assert!(!r.byte_aligned());
56 assert_eq!(r.read::<3, u32>().unwrap(), 6);
57 assert!(!r.byte_aligned());
58 assert_eq!(r.read::<5, u32>().unwrap(), 7);
59 assert!(!r.byte_aligned());
60 assert_eq!(r.read::<3, u32>().unwrap(), 5);
61 assert!(!r.byte_aligned());
62 assert_eq!(r.read::<19, u32>().unwrap(), 0x53BC1);
63 assert!(r.byte_aligned());
64 assert!(r.read::<1, u32>().is_err());
65
66 // 16-bit values
67 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
68 assert_eq!(r.read::<1, u8>().unwrap(), 1);
69 assert_eq!(r.read::<14, u16>().unwrap(), 0b0110_0011_1101_10);
70 assert_eq!(r.read::<16, u16>().unwrap(), 0b1001_1101_1110_0000);
71 assert_eq!(r.read::<1, u8>().unwrap(), 1);
72
73 // skipping bits
74 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
75 assert_eq!(r.read_var::<u32>(2).unwrap(), 2);
76 assert!(r.skip(3).is_ok());
77 assert_eq!(r.read_var::<u32>(5).unwrap(), 7);
78 assert!(r.skip(3).is_ok());
79 assert_eq!(r.read_var::<u32>(19).unwrap(), 0x53BC1);
80
81 // reading signed values
82 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
83 assert_eq!(r.read_signed_var::<i32>(2).unwrap(), -2);
84 assert_eq!(r.read_signed_var::<i32>(3).unwrap(), -2);
85 assert_eq!(r.read_signed_var::<i32>(5).unwrap(), 7);
86 assert_eq!(r.read_signed_var::<i32>(3).unwrap(), -3);
87 assert_eq!(r.read_signed_var::<i32>(19).unwrap(), -181311);
88
89 // reading const signed values
90 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
91 assert_eq!(r.read_signed::<2, i32>().unwrap(), -2);
92 assert_eq!(r.read_signed::<3, i32>().unwrap(), -2);
93 assert_eq!(r.read_signed::<5, i32>().unwrap(), 7);
94 assert_eq!(r.read_signed::<3, i32>().unwrap(), -3);
95 assert_eq!(r.read_signed::<19, i32>().unwrap(), -181311);
96
97 // reading unary 0 values
98 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
99 assert_eq!(r.read_unary::<0>().unwrap(), 1);
100 assert_eq!(r.read_unary::<0>().unwrap(), 2);
101 assert_eq!(r.read_unary::<0>().unwrap(), 0);
102 assert_eq!(r.read_unary::<0>().unwrap(), 0);
103 assert_eq!(r.read_unary::<0>().unwrap(), 4);
104
105 // reading unary 1 values
106 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
107 assert_eq!(r.read_unary::<1>().unwrap(), 0);
108 assert_eq!(r.read_unary::<1>().unwrap(), 1);
109 assert_eq!(r.read_unary::<1>().unwrap(), 0);
110 assert_eq!(r.read_unary::<1>().unwrap(), 3);
111 assert_eq!(r.read_unary::<1>().unwrap(), 0);
112
113 // reading unsigned vbr
114 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
115 assert_eq!(r.read_unsigned_vbr::<4, u8>().unwrap(), 11);
116 assert_eq!(r.read_unsigned_vbr::<4, u8>().unwrap(), 238);
117 assert_eq!(r.read_unsigned_vbr::<4, u8>().unwrap(), 99);
118 assert!(r.read_unsigned_vbr::<4, u8>().is_err());
119
120 // reading signed vbr
121 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
122 assert_eq!(r.read_signed_vbr::<4, i8>().unwrap(), -6);
123 assert_eq!(r.read_signed_vbr::<4, i8>().unwrap(), 119);
124 assert_eq!(r.read_signed_vbr::<4, i8>().unwrap(), -50);
125 assert!(r.read_signed_vbr::<4, i8>().is_err());
126
127 // byte aligning
128 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
129 assert_eq!(r.read_var::<u32>(3).unwrap(), 5);
130 r.byte_align();
131 assert_eq!(r.read_var::<u32>(3).unwrap(), 7);
132 r.byte_align();
133 r.byte_align();
134 assert_eq!(r.read_var::<u32>(8).unwrap(), 59);
135 r.byte_align();
136 assert_eq!(r.read_var::<u32>(4).unwrap(), 12);
137
138 // reading bytes, aligned
139 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
140 let mut sub_data = [0; 2];
141 assert!(r.read_bytes(&mut sub_data).is_ok());
142 assert_eq!(&sub_data, b"\xB1\xED");
143
144 // reading bytes, un-aligned
145 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
146 let mut sub_data = [0; 2];
147 assert_eq!(r.read_var::<u32>(4).unwrap(), 11);
148 assert!(r.read_bytes(&mut sub_data).is_ok());
149 assert_eq!(&sub_data, b"\x1E\xD3");
150 }
151
152 #[test]
153 fn test_edge_cases_be() {
154 use bitstream_io::{BigEndian, BitRead, BitReader};
155
156 let data: Vec<u8> = vec![
157 0, 0, 0, 0, 255, 255, 255, 255, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0,
158 255, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255, 255,
159 255, 255, 255,
160 ];
161
162 // 0 bit reads
163 let mut r = BitReader::endian([255; 1].as_slice(), BigEndian);
164 assert_eq!(r.read_var::<u8>(0).unwrap(), 0);
165 assert_eq!(r.read_var::<u16>(0).unwrap(), 0);
166 assert_eq!(r.read_var::<u32>(0).unwrap(), 0);
167 assert_eq!(r.read_var::<u64>(0).unwrap(), 0);
168 assert_eq!(r.read_var::<u8>(8).unwrap(), 255);
169
170 let mut r = BitReader::endian([255; 1].as_slice(), BigEndian);
171 assert_eq!(r.read::<0, u8>().unwrap(), 0);
172 assert_eq!(r.read::<0, u16>().unwrap(), 0);
173 assert_eq!(r.read::<0, u32>().unwrap(), 0);
174 assert_eq!(r.read::<0, u64>().unwrap(), 0);
175 assert_eq!(r.read::<8, u8>().unwrap(), 255);
176
177 let mut r = BitReader::endian([255; 1].as_slice(), BigEndian);
178 assert!(r.read_signed_var::<i8>(0).is_err());
179 assert!(r.read_signed_var::<i16>(0).is_err());
180 assert!(r.read_signed_var::<i32>(0).is_err());
181 assert!(r.read_signed_var::<i64>(0).is_err());
182
183 // unsigned 32 and 64-bit values
184 let mut r = BitReader::endian(data.as_slice(), BigEndian);
185 assert_eq!(r.read_var::<u32>(32).unwrap(), 0);
186 assert_eq!(r.read_var::<u32>(32).unwrap(), 4294967295);
187 assert_eq!(r.read_var::<u32>(32).unwrap(), 2147483648);
188 assert_eq!(r.read_var::<u32>(32).unwrap(), 2147483647);
189 assert_eq!(r.read_var::<u64>(64).unwrap(), 0);
190 assert_eq!(r.read_var::<u64>(64).unwrap(), 0xFFFFFFFFFFFFFFFF);
191 assert_eq!(r.read_var::<u64>(64).unwrap(), 9223372036854775808);
192 assert_eq!(r.read_var::<u64>(64).unwrap(), 9223372036854775807);
193
194 let mut r = BitReader::endian(data.as_slice(), BigEndian);
195 assert_eq!(r.read::<32, u32>().unwrap(), 0);
196 assert_eq!(r.read::<32, u32>().unwrap(), 4294967295);
197 assert_eq!(r.read::<32, u32>().unwrap(), 2147483648);
198 assert_eq!(r.read::<32, u32>().unwrap(), 2147483647);
199 assert_eq!(r.read::<64, u64>().unwrap(), 0);
200 assert_eq!(r.read::<64, u64>().unwrap(), 0xFFFFFFFFFFFFFFFF);
201 assert_eq!(r.read::<64, u64>().unwrap(), 9223372036854775808);
202 assert_eq!(r.read::<64, u64>().unwrap(), 9223372036854775807);
203
204 // signed 32 and 64-bit values
205 let mut r = BitReader::endian(data.as_slice(), BigEndian);
206 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), 0);
207 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), -1);
208 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), -2147483648);
209 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), 2147483647);
210 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), 0);
211 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), -1);
212 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), -9223372036854775808);
213 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), 9223372036854775807);
214
215 let mut r = BitReader::endian(data.as_slice(), BigEndian);
216 assert_eq!(r.read_signed::<32, i32>().unwrap(), 0);
217 assert_eq!(r.read_signed::<32, i32>().unwrap(), -1);
218 assert_eq!(r.read_signed::<32, i32>().unwrap(), -2147483648);
219 assert_eq!(r.read_signed::<32, i32>().unwrap(), 2147483647);
220 assert_eq!(r.read_signed::<64, i64>().unwrap(), 0);
221 assert_eq!(r.read_signed::<64, i64>().unwrap(), -1);
222 assert_eq!(r.read_signed::<64, i64>().unwrap(), -9223372036854775808);
223 assert_eq!(r.read_signed::<64, i64>().unwrap(), 9223372036854775807);
224 }
225
226 #[test]
227 fn test_reader_huffman_be() {
228 use bitstream_io::define_huffman_tree;
229 use bitstream_io::{BigEndian, BitRead, BitReader};
230
231 define_huffman_tree!(SomeTree : i32 = [[[4, 3], 2], [1, 0]]);
232
233 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
234 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
235
236 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
237 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
238 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 4);
239 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
240 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
241 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 2);
242 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
243 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
244 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 2);
245 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
246 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 2);
247 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
248 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
249 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 4);
250 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 2);
251 }
252
253 #[test]
254 fn test_read_chunks_be() {
255 use bitstream_io::{BigEndian, BitRead, BitReader};
256
257 let data: &[u8] = &[0b1011_0001, 0b1110_1101, 0b0011_1011, 0b1100_0001];
258 let mut chunk: [u8; 2] = [0; 2];
259
260 // test non-aligned chunk reading
261 let mut r = BitReader::endian(data, BigEndian);
262 assert_eq!(r.read::<2, u8>().unwrap(), 0b10);
263 r.read_bytes(&mut chunk).unwrap();
264 assert_eq!(&chunk, &[0b11_0001_11, 0b10_1101_00]);
265 assert_eq!(r.read::<14, u16>().unwrap(), 0b11_1011_1100_0001);
266
267 // test the smallest chunk
268 let mut chunk = 0;
269 let mut r = BitReader::endian(data, BigEndian);
270 assert_eq!(r.read::<2, u8>().unwrap(), 0b10);
271 r.read_bytes(core::slice::from_mut(&mut chunk)).unwrap();
272 assert_eq!(chunk, 0b11_0001_11);
273 r.read_bytes(core::slice::from_mut(&mut chunk)).unwrap();
274 assert_eq!(chunk, 0b10_1101_00);
275 assert_eq!(r.read::<14, u16>().unwrap(), 0b11_1011_1100_0001);
276
277 // test a larger chunk
278 let data = include_bytes!("random.bin");
279 let mut chunk: [u8; 127] = [0; 127];
280
281 let mut r = BitReader::endian(data.as_slice(), BigEndian);
282 assert_eq!(r.read::<3, u8>().unwrap(), 0b000);
283 r.read_bytes(&mut chunk).unwrap();
284 assert_eq!(
285 chunk.as_slice(),
286 include_bytes!("random-3be.bin").as_slice()
287 );
288 assert_eq!(r.read::<5, u8>().unwrap(), 0b10110);
289 }
290
291 #[test]
292 fn test_reader_le() {
293 use bitstream_io::{BitRead, BitReader, LittleEndian};
294
295 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
296
297 // reading individual bits
298 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
299 assert_eq!(r.read_bit().unwrap(), true);
300 assert_eq!(r.read_bit().unwrap(), false);
301 assert_eq!(r.read_bit().unwrap(), false);
302 assert_eq!(r.read_bit().unwrap(), false);
303 assert_eq!(r.read_bit().unwrap(), true);
304 assert_eq!(r.read_bit().unwrap(), true);
305 assert_eq!(r.read_bit().unwrap(), false);
306 assert_eq!(r.read_bit().unwrap(), true);
307 assert_eq!(r.read_bit().unwrap(), true);
308 assert_eq!(r.read_bit().unwrap(), false);
309 assert_eq!(r.read_bit().unwrap(), true);
310 assert_eq!(r.read_bit().unwrap(), true);
311 assert_eq!(r.read_bit().unwrap(), false);
312 assert_eq!(r.read_bit().unwrap(), true);
313 assert_eq!(r.read_bit().unwrap(), true);
314 assert_eq!(r.read_bit().unwrap(), true);
315
316 // reading unsigned values
317 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
318 assert!(r.byte_aligned());
319 assert_eq!(r.read_var::<u32>(2).unwrap(), 1);
320 assert!(!r.byte_aligned());
321 assert_eq!(r.read_var::<u32>(3).unwrap(), 4);
322 assert!(!r.byte_aligned());
323 assert_eq!(r.read_var::<u32>(5).unwrap(), 13);
324 assert!(!r.byte_aligned());
325 assert_eq!(r.read_var::<u32>(3).unwrap(), 3);
326 assert!(!r.byte_aligned());
327 assert_eq!(r.read_var::<u32>(19).unwrap(), 0x609DF);
328 assert!(r.byte_aligned());
329 assert!(r.read_var::<u32>(1).is_err());
330
331 // reading const unsigned values
332 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
333 assert!(r.byte_aligned());
334 assert_eq!(r.read::<2, u32>().unwrap(), 1);
335 assert!(!r.byte_aligned());
336 assert_eq!(r.read::<3, u32>().unwrap(), 4);
337 assert!(!r.byte_aligned());
338 assert_eq!(r.read::<5, u32>().unwrap(), 13);
339 assert!(!r.byte_aligned());
340 assert_eq!(r.read::<3, u32>().unwrap(), 3);
341 assert!(!r.byte_aligned());
342 assert_eq!(r.read::<19, u32>().unwrap(), 0x609DF);
343 assert!(r.byte_aligned());
344 assert!(r.read::<1, u32>().is_err());
345
346 // 16-bit values
347 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
348 assert_eq!(r.read::<1, u8>().unwrap(), 1);
349 assert_eq!(r.read::<14, u16>().unwrap(), 0b1101_1011_0110_00);
350 assert_eq!(r.read::<16, u16>().unwrap(), 0b1000_0010_0111_0111);
351 assert_eq!(r.read::<1, u8>().unwrap(), 1);
352
353 // skipping bits
354 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
355 assert_eq!(r.read_var::<u32>(2).unwrap(), 1);
356 assert!(r.skip(3).is_ok());
357 assert_eq!(r.read_var::<u32>(5).unwrap(), 13);
358 assert!(r.skip(3).is_ok());
359 assert_eq!(r.read_var::<u32>(19).unwrap(), 0x609DF);
360
361 // reading signed values
362 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
363 assert_eq!(r.read_signed_var::<i32>(2).unwrap(), 1);
364 assert_eq!(r.read_signed_var::<i32>(3).unwrap(), -4);
365 assert_eq!(r.read_signed_var::<i32>(5).unwrap(), 13);
366 assert_eq!(r.read_signed_var::<i32>(3).unwrap(), 3);
367 assert_eq!(r.read_signed_var::<i32>(19).unwrap(), -128545);
368
369 // reading const signed values
370 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
371 assert_eq!(r.read_signed::<2, i32>().unwrap(), 1);
372 assert_eq!(r.read_signed::<3, i32>().unwrap(), -4);
373 assert_eq!(r.read_signed::<5, i32>().unwrap(), 13);
374 assert_eq!(r.read_signed::<3, i32>().unwrap(), 3);
375 assert_eq!(r.read_signed::<19, i32>().unwrap(), -128545);
376
377 // reading unary 0 values
378 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
379 assert_eq!(r.read_unary::<0>().unwrap(), 1);
380 assert_eq!(r.read_unary::<0>().unwrap(), 0);
381 assert_eq!(r.read_unary::<0>().unwrap(), 0);
382 assert_eq!(r.read_unary::<0>().unwrap(), 2);
383 assert_eq!(r.read_unary::<0>().unwrap(), 2);
384
385 // reading unary 1 values
386 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
387 assert_eq!(r.read_unary::<1>().unwrap(), 0);
388 assert_eq!(r.read_unary::<1>().unwrap(), 3);
389 assert_eq!(r.read_unary::<1>().unwrap(), 0);
390 assert_eq!(r.read_unary::<1>().unwrap(), 1);
391 assert_eq!(r.read_unary::<1>().unwrap(), 0);
392
393 // byte aligning
394 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
395 assert_eq!(r.read_var::<u32>(3).unwrap(), 1);
396 r.byte_align();
397 assert_eq!(r.read_var::<u32>(3).unwrap(), 5);
398 r.byte_align();
399 r.byte_align();
400 assert_eq!(r.read_var::<u32>(8).unwrap(), 59);
401 r.byte_align();
402 assert_eq!(r.read_var::<u32>(4).unwrap(), 1);
403
404 // reading bytes, aligned
405 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
406 let mut sub_data = [0; 2];
407 assert!(r.read_bytes(&mut sub_data).is_ok());
408 assert_eq!(&sub_data, b"\xB1\xED");
409
410 // reading bytes, un-aligned
411 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
412 let mut sub_data = [0; 2];
413 assert_eq!(r.read_var::<u32>(4).unwrap(), 1);
414 assert!(r.read_bytes(&mut sub_data).is_ok());
415 assert_eq!(&sub_data, b"\xDB\xBE");
416 }
417
418 #[test]
419 fn test_edge_cases_le() {
420 use bitstream_io::{BitRead, BitReader, LittleEndian};
421
422 let data: Vec<u8> = vec![
423 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0,
424 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255,
425 255, 255, 127,
426 ];
427
428 // 0 bit reads
429 let mut r = BitReader::endian([255; 1].as_slice(), LittleEndian);
430 assert_eq!(r.read_var::<u8>(0).unwrap(), 0);
431 assert_eq!(r.read_var::<u16>(0).unwrap(), 0);
432 assert_eq!(r.read_var::<u32>(0).unwrap(), 0);
433 assert_eq!(r.read_var::<u64>(0).unwrap(), 0);
434 assert_eq!(r.read_var::<u8>(8).unwrap(), 255);
435
436 let mut r = BitReader::endian([255; 1].as_slice(), LittleEndian);
437 assert_eq!(r.read::<0, u8>().unwrap(), 0);
438 assert_eq!(r.read::<0, u16>().unwrap(), 0);
439 assert_eq!(r.read::<0, u32>().unwrap(), 0);
440 assert_eq!(r.read::<0, u64>().unwrap(), 0);
441 assert_eq!(r.read::<8, u8>().unwrap(), 255);
442
443 let mut r = BitReader::endian([255; 1].as_slice(), LittleEndian);
444 assert!(r.read_signed_var::<i8>(0).is_err());
445 assert!(r.read_signed_var::<i16>(0).is_err());
446 assert!(r.read_signed_var::<i32>(0).is_err());
447 assert!(r.read_signed_var::<i64>(0).is_err());
448
449 // unsigned 32 and 64-bit values
450 let mut r = BitReader::endian(data.as_slice(), LittleEndian);
451 assert_eq!(r.read_var::<u32>(32).unwrap(), 0);
452 assert_eq!(r.read_var::<u32>(32).unwrap(), 4294967295);
453 assert_eq!(r.read_var::<u32>(32).unwrap(), 2147483648);
454 assert_eq!(r.read_var::<u32>(32).unwrap(), 2147483647);
455 assert_eq!(r.read_var::<u64>(64).unwrap(), 0);
456 assert_eq!(r.read_var::<u64>(64).unwrap(), 0xFFFFFFFFFFFFFFFF);
457 assert_eq!(r.read_var::<u64>(64).unwrap(), 9223372036854775808);
458 assert_eq!(r.read_var::<u64>(64).unwrap(), 9223372036854775807);
459
460 let mut r = BitReader::endian(data.as_slice(), LittleEndian);
461 assert_eq!(r.read::<32, u32>().unwrap(), 0);
462 assert_eq!(r.read::<32, u32>().unwrap(), 4294967295);
463 assert_eq!(r.read::<32, u32>().unwrap(), 2147483648);
464 assert_eq!(r.read::<32, u32>().unwrap(), 2147483647);
465 assert_eq!(r.read::<64, u64>().unwrap(), 0);
466 assert_eq!(r.read::<64, u64>().unwrap(), 0xFFFFFFFFFFFFFFFF);
467 assert_eq!(r.read::<64, u64>().unwrap(), 9223372036854775808);
468 assert_eq!(r.read::<64, u64>().unwrap(), 9223372036854775807);
469
470 let mut r = BitReader::endian(data.as_slice(), LittleEndian);
471 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), 0);
472 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), -1);
473 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), -2147483648);
474 assert_eq!(r.read_signed_var::<i32>(32).unwrap(), 2147483647);
475 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), 0);
476 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), -1);
477 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), -9223372036854775808);
478 assert_eq!(r.read_signed_var::<i64>(64).unwrap(), 9223372036854775807);
479
480 let mut r = BitReader::endian(data.as_slice(), LittleEndian);
481 assert_eq!(r.read_signed::<32, i32>().unwrap(), 0);
482 assert_eq!(r.read_signed::<32, i32>().unwrap(), -1);
483 assert_eq!(r.read_signed::<32, i32>().unwrap(), -2147483648);
484 assert_eq!(r.read_signed::<32, i32>().unwrap(), 2147483647);
485 assert_eq!(r.read_signed::<64, i64>().unwrap(), 0);
486 assert_eq!(r.read_signed::<64, i64>().unwrap(), -1);
487 assert_eq!(r.read_signed::<64, i64>().unwrap(), -9223372036854775808);
488 assert_eq!(r.read_signed::<64, i64>().unwrap(), 9223372036854775807);
489 }
490
491 #[test]
492 fn test_reader_huffman_le() {
493 use bitstream_io::define_huffman_tree;
494 use bitstream_io::{BitRead, BitReader, LittleEndian};
495
496 define_huffman_tree!(SomeTree : i32 = [[[4, 3], 2], [1, 0]]);
497
498 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
499 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
500
501 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
502 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 3);
503 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
504 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
505 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 2);
506 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
507 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
508 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
509 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
510 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 0);
511 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 1);
512 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 2);
513 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 4);
514 assert_eq!(r.read_huffman::<SomeTree>().unwrap(), 3);
515 }
516
517 #[test]
518 fn test_read_chunks_le() {
519 use bitstream_io::{BitRead, BitReader, LittleEndian};
520
521 let data: &[u8] = &[0b1011_0001, 0b1110_1101, 0b0011_1011, 0b1100_0001];
522 let mut chunk: [u8; 2] = [0; 2];
523
524 // test non-aligned chunk reading
525 let mut r = BitReader::endian(data, LittleEndian);
526 assert_eq!(r.read::<2, u8>().unwrap(), 0b01);
527 r.read_bytes(&mut chunk).unwrap();
528 assert_eq!(&chunk, &[0b01_1011_00, 0b11_1110_11]);
529 assert_eq!(r.read::<14, u16>().unwrap(), 0b1100_0001_0011_10);
530
531 // test the smallest chunk
532 let mut chunk = 0;
533 let mut r = BitReader::endian(data, LittleEndian);
534 assert_eq!(r.read::<2, u8>().unwrap(), 0b01);
535 r.read_bytes(core::slice::from_mut(&mut chunk)).unwrap();
536 assert_eq!(chunk, 0b01_1011_00);
537 r.read_bytes(core::slice::from_mut(&mut chunk)).unwrap();
538 assert_eq!(chunk, 0b11_1110_11);
539 assert_eq!(r.read::<14, u16>().unwrap(), 0b1100_0001_0011_10);
540
541 // test a larger chunk
542 let data = include_bytes!("random.bin");
543 let mut chunk: [u8; 127] = [0; 127];
544
545 let mut r = BitReader::endian(data.as_slice(), LittleEndian);
546 assert_eq!(r.read::<3, u8>().unwrap(), 0b010);
547 r.read_bytes(&mut chunk).unwrap();
548 assert_eq!(
549 chunk.as_slice(),
550 include_bytes!("random-3le.bin").as_slice()
551 );
552 assert_eq!(r.read::<5, u8>().unwrap(), 0b00110);
553 }
554
555 #[test]
556 fn test_reader_io_errors_be() {
557 use bitstream_io::{BigEndian, BitRead, BitReader};
558 use io::ErrorKind;
559
560 let actual_data: [u8; 1] = [0xB1];
561
562 // individual bits
563 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
564 assert!(r.read_bit().is_ok());
565 assert!(r.read_bit().is_ok());
566 assert!(r.read_bit().is_ok());
567 assert!(r.read_bit().is_ok());
568 assert!(r.read_bit().is_ok());
569 assert!(r.read_bit().is_ok());
570 assert!(r.read_bit().is_ok());
571 assert!(r.read_bit().is_ok());
572 assert_eq!(r.read_bit().unwrap_err().kind(), ErrorKind::UnexpectedEof);
573
574 // skipping bits
575 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
576 assert!(r.read_var::<u32>(7).is_ok());
577 assert_eq!(r.skip(5).unwrap_err().kind(), ErrorKind::UnexpectedEof);
578
579 // signed values
580 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
581 assert!(r.read_signed_var::<i32>(2).is_ok());
582 assert!(r.read_signed_var::<i32>(3).is_ok());
583 assert_eq!(
584 r.read_signed_var::<i32>(5).unwrap_err().kind(),
585 ErrorKind::UnexpectedEof
586 );
587
588 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
589 assert!(r.read_signed::<2, i32>().is_ok());
590 assert!(r.read_signed::<3, i32>().is_ok());
591 assert_eq!(
592 r.read_signed::<5, i32>().unwrap_err().kind(),
593 ErrorKind::UnexpectedEof
594 );
595
596 // unary 0 values
597 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
598 assert!(r.read_unary::<0>().is_ok());
599 assert!(r.read_unary::<0>().is_ok());
600 assert!(r.read_unary::<0>().is_ok());
601 assert!(r.read_unary::<0>().is_ok());
602 assert_eq!(
603 r.read_unary::<0>().unwrap_err().kind(),
604 ErrorKind::UnexpectedEof
605 );
606
607 // unary 1 values
608 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
609 assert!(r.read_unary::<1>().is_ok());
610 assert!(r.read_unary::<1>().is_ok());
611 assert!(r.read_unary::<1>().is_ok());
612 assert!(r.read_unary::<1>().is_ok());
613 assert_eq!(
614 r.read_unary::<1>().unwrap_err().kind(),
615 ErrorKind::UnexpectedEof
616 );
617
618 // reading bytes, aligned
619 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
620 let mut sub_data = [0; 2];
621 assert_eq!(
622 r.read_bytes(&mut sub_data).unwrap_err().kind(),
623 ErrorKind::UnexpectedEof
624 );
625
626 // reading bytes, un-aligned
627 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
628 let mut sub_data = [0; 2];
629 assert!(r.read_var::<u32>(4).is_ok());
630 assert_eq!(
631 r.read_bytes(&mut sub_data).unwrap_err().kind(),
632 ErrorKind::UnexpectedEof
633 );
634 }
635
636 #[test]
637 fn test_reader_io_errors_le() {
638 use bitstream_io::{BitRead, BitReader, LittleEndian};
639 use io::ErrorKind;
640
641 let actual_data: [u8; 1] = [0xB1];
642
643 // individual bits
644 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
645 assert!(r.read_bit().is_ok());
646 assert!(r.read_bit().is_ok());
647 assert!(r.read_bit().is_ok());
648 assert!(r.read_bit().is_ok());
649 assert!(r.read_bit().is_ok());
650 assert!(r.read_bit().is_ok());
651 assert!(r.read_bit().is_ok());
652 assert!(r.read_bit().is_ok());
653 assert_eq!(r.read_bit().unwrap_err().kind(), ErrorKind::UnexpectedEof);
654
655 // skipping bits
656 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
657 assert!(r.read_var::<u32>(7).is_ok());
658 assert_eq!(r.skip(5).unwrap_err().kind(), ErrorKind::UnexpectedEof);
659
660 // signed values
661 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
662 assert!(r.read_signed_var::<i32>(2).is_ok());
663 assert!(r.read_signed_var::<i32>(3).is_ok());
664 assert_eq!(
665 r.read_signed_var::<i32>(5).unwrap_err().kind(),
666 ErrorKind::UnexpectedEof
667 );
668
669 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
670 assert!(r.read_signed::<2, i32>().is_ok());
671 assert!(r.read_signed::<3, i32>().is_ok());
672 assert_eq!(
673 r.read_signed::<5, i32>().unwrap_err().kind(),
674 ErrorKind::UnexpectedEof
675 );
676
677 // unary 0 values
678 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
679 assert!(r.read_unary::<0>().is_ok());
680 assert!(r.read_unary::<0>().is_ok());
681 assert!(r.read_unary::<0>().is_ok());
682 assert!(r.read_unary::<0>().is_ok());
683 assert_eq!(
684 r.read_unary::<0>().unwrap_err().kind(),
685 ErrorKind::UnexpectedEof
686 );
687
688 // unary 1 values
689 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
690 assert!(r.read_unary::<1>().is_ok());
691 assert!(r.read_unary::<1>().is_ok());
692 assert!(r.read_unary::<1>().is_ok());
693 assert!(r.read_unary::<1>().is_ok());
694 assert_eq!(
695 r.read_unary::<1>().unwrap_err().kind(),
696 ErrorKind::UnexpectedEof
697 );
698
699 // reading bytes, aligned
700 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
701 let mut sub_data = [0; 2];
702 assert_eq!(
703 r.read_bytes(&mut sub_data).unwrap_err().kind(),
704 ErrorKind::UnexpectedEof
705 );
706
707 // reading bytes, un-aligned
708 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
709 let mut sub_data = [0; 2];
710 assert!(r.read_var::<u32>(4).is_ok());
711 assert_eq!(
712 r.read_bytes(&mut sub_data).unwrap_err().kind(),
713 ErrorKind::UnexpectedEof
714 );
715 }
716
717 #[test]
718 fn test_reader_bits_errors() {
719 use bitstream_io::{BigEndian, BitRead, BitReader, LittleEndian};
720 use io::ErrorKind;
721 let actual_data = [0u8; 10];
722
723 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
724
725 assert_eq!(
726 r.read_var::<u8>(9).unwrap_err().kind(),
727 ErrorKind::InvalidInput
728 );
729 assert_eq!(
730 r.read_var::<u16>(17).unwrap_err().kind(),
731 ErrorKind::InvalidInput
732 );
733 assert_eq!(
734 r.read_var::<u32>(33).unwrap_err().kind(),
735 ErrorKind::InvalidInput
736 );
737 assert_eq!(
738 r.read_var::<u64>(65).unwrap_err().kind(),
739 ErrorKind::InvalidInput
740 );
741
742 assert_eq!(
743 r.read_signed_var::<i8>(9).unwrap_err().kind(),
744 ErrorKind::InvalidInput
745 );
746 assert_eq!(
747 r.read_signed_var::<i16>(17).unwrap_err().kind(),
748 ErrorKind::InvalidInput
749 );
750 assert_eq!(
751 r.read_signed_var::<i32>(33).unwrap_err().kind(),
752 ErrorKind::InvalidInput
753 );
754 assert_eq!(
755 r.read_signed_var::<i64>(65).unwrap_err().kind(),
756 ErrorKind::InvalidInput
757 );
758
759 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
760
761 assert_eq!(
762 r.read_var::<u8>(9).unwrap_err().kind(),
763 ErrorKind::InvalidInput
764 );
765 assert_eq!(
766 r.read_var::<u16>(17).unwrap_err().kind(),
767 ErrorKind::InvalidInput
768 );
769 assert_eq!(
770 r.read_var::<u32>(33).unwrap_err().kind(),
771 ErrorKind::InvalidInput
772 );
773 assert_eq!(
774 r.read_var::<u64>(65).unwrap_err().kind(),
775 ErrorKind::InvalidInput
776 );
777
778 assert_eq!(
779 r.read_signed_var::<i8>(9).unwrap_err().kind(),
780 ErrorKind::InvalidInput
781 );
782 assert_eq!(
783 r.read_signed_var::<i16>(17).unwrap_err().kind(),
784 ErrorKind::InvalidInput
785 );
786 assert_eq!(
787 r.read_signed_var::<i32>(33).unwrap_err().kind(),
788 ErrorKind::InvalidInput
789 );
790 assert_eq!(
791 r.read_signed_var::<i64>(65).unwrap_err().kind(),
792 ErrorKind::InvalidInput
793 );
794 }
795
796 #[test]
797 fn test_clone() {
798 use bitstream_io::{BigEndian, BitRead, BitReader};
799
800 // Reading unsigned examples, cloning while unaligned.
801 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
802 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
803 assert!(r.byte_aligned());
804 assert_eq!(r.read_var::<u32>(4).unwrap(), 0xB);
805 let mut r2 = r.clone();
806 assert!(!r.byte_aligned());
807 assert_eq!(r.read_var::<u32>(4).unwrap(), 0x1);
808 assert_eq!(r.read_var::<u32>(8).unwrap(), 0xED);
809 assert!(!r2.byte_aligned());
810 assert_eq!(r2.read_var::<u32>(4).unwrap(), 0x1);
811 assert_eq!(r2.read_var::<u32>(8).unwrap(), 0xED);
812
813 // Can still instantiate a BitReader when the backing std::io::Read is
814 // !Clone.
815 struct NotCloneRead<'a>(&'a [u8]);
816 impl<'a> io::Read for NotCloneRead<'a> {
817 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
818 self.0.read(buf)
819 }
820 }
821 let _r = BitReader::endian(NotCloneRead(&actual_data[..]), BigEndian);
822 }
823
824 #[test]
825 fn test_read_bytes() {
826 use bitstream_io::{BigEndian, BitRead, BitReader, LittleEndian};
827
828 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
829 let mut r = BitReader::endian(actual_data.as_slice(), BigEndian);
830 let read_data: [u8; 4] = r.read_to().unwrap();
831 assert_eq!(actual_data, read_data);
832
833 let actual_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
834 let mut r = BitReader::endian(actual_data.as_slice(), LittleEndian);
835 let read_data: [u8; 4] = r.read_to().unwrap();
836 assert_eq!(actual_data, read_data);
837 }
838
839 #[test]
840 fn test_large_reads() {
841 use bitstream_io::{BigEndian, BitRead, BitReader, ByteRead, ByteReader, LittleEndian};
842
843 for size in [0, 1, 4096, 4097, 10000] {
844 let input = (0..255).cycle().take(size).collect::<Vec<u8>>();
845 assert_eq!(input.len(), size);
846
847 let mut r = BitReader::endian(input.as_slice(), BigEndian);
848 let output = r.read_to_vec(size).unwrap();
849 assert_eq!(input, output);
850
851 let mut r = BitReader::endian(input.as_slice(), LittleEndian);
852 let output = r.read_to_vec(size).unwrap();
853 assert_eq!(input, output);
854
855 let mut r = ByteReader::endian(input.as_slice(), BigEndian);
856 let output = r.read_to_vec(size).unwrap();
857 assert_eq!(input, output);
858
859 let mut r = ByteReader::endian(input.as_slice(), LittleEndian);
860 let output = r.read_to_vec(size).unwrap();
861 assert_eq!(input, output);
862 }
863
864 let input: [u8; 5] = [0, 0, 0, 0, 0];
865
866 let mut r = BitReader::endian(input.as_slice(), BigEndian);
867 assert!(r.read_to_vec(usize::MAX).is_err());
868
869 let mut r = BitReader::endian(input.as_slice(), LittleEndian);
870 assert!(r.read_to_vec(usize::MAX).is_err());
871
872 let mut r = ByteReader::endian(input.as_slice(), BigEndian);
873 assert!(r.read_to_vec(usize::MAX).is_err());
874
875 let mut r = ByteReader::endian(input.as_slice(), LittleEndian);
876 assert!(r.read_to_vec(usize::MAX).is_err());
877 }
878
879 #[test]
880 fn test_bitcount_read() {
881 use bitstream_io::{BigEndian, BitCount, BitRead, BitReader};
882
883 // 1 bit count - reading 1 bit
884 let bytes = &[0b1_1_000000];
885 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
886 let count = reader.read_count::<0b1>().unwrap();
887 assert_eq!(count, BitCount::new::<1>());
888 assert_eq!(reader.read_counted::<1, u8>(count).unwrap(), 0b1);
889
890 // 2 bits count - reading 3 bits
891 let bytes = &[0b11_111_000];
892 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
893 let count = reader.read_count::<0b11>().unwrap();
894 assert_eq!(count, BitCount::new::<0b11>());
895 assert_eq!(reader.read_counted::<0b11, u8>(count).unwrap(), 0b111);
896
897 // 3 bits count - reading 7 bits
898 let bytes = &[0b111_11111, 0b11_000000];
899 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
900 let count = reader.read_count::<0b111>().unwrap();
901 assert_eq!(count, BitCount::new::<0b111>());
902 assert_eq!(reader.read_counted::<0b111, u8>(count).unwrap(), 0b11111_11);
903
904 // 4 bits count - reading 15 bits
905 let bytes = &[0b1111_1111, 0b11111111, 0b111_00000];
906 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
907 let count = reader.read_count::<0b1111>().unwrap();
908 assert_eq!(count, BitCount::new::<0b1111>());
909 assert_eq!(
910 reader.read_counted::<0b1111, u16>(count).unwrap(),
911 0b1111_11111111_111
912 );
913
914 // 5 bits count - reading 31 bits
915 let bytes = &[0b11111_111, 0b11111111, 0b11111111, 0b11111111, 0b1111_0000];
916 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
917 let count = reader.read_count::<0b11111>().unwrap();
918 assert_eq!(count, BitCount::new::<0b11111>());
919 assert_eq!(
920 reader.read_counted::<0b11111, u32>(count).unwrap(),
921 0b111_11111111_11111111_11111111_1111,
922 );
923
924 // 6 bits count - reading 63 bits
925 let bytes = &[
926 0b111111_11,
927 0b11111111,
928 0b11111111,
929 0b11111111,
930 0b11111111,
931 0b11111111,
932 0b11111111,
933 0b11111111,
934 0b11111_000,
935 ];
936 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
937 let count = reader.read_count::<0b111111>().unwrap();
938 assert_eq!(count, BitCount::new::<0b111111>());
939 assert_eq!(
940 reader.read_counted::<0b111111, u64>(count).unwrap(),
941 0b11_11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111,
942 );
943
944 // 7 bits count - reading 127 bits
945 let bytes = &[
946 0b1111111_1,
947 0b11111111,
948 0b11111111,
949 0b11111111,
950 0b11111111,
951 0b11111111,
952 0b11111111,
953 0b11111111,
954 0b11111111,
955 0b11111111,
956 0b11111111,
957 0b11111111,
958 0b11111111,
959 0b11111111,
960 0b11111111,
961 0b11111111,
962 0b111111_00,
963 ];
964 let mut reader = BitReader::endian(bytes.as_slice(), BigEndian);
965 let count = reader.read_count::<0b1111111>().unwrap();
966 assert_eq!(count, BitCount::new::<0b1111111>());
967 assert_eq!(
968 reader.read_counted::<0b1111111, u128>(count).unwrap(),
969 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
970 );
971
972 // We have to stop here because no primitive type gets any larger.
973 // So while BitCount technically extends out to 32 bits,
974 // it's not practical to get anywhere near that.
975 }
976
977 #[test]
978 fn test_nonzero_reads() {
979 use bitstream_io::{BigEndian, BitRead, BitReader, LittleEndian};
980 use core::num::NonZero;
981
982 let data: &[u8] = &[0b001_00000, 0];
983
984 assert_eq!(
985 BitReader::endian(data, BigEndian).read::<3, u8>().unwrap(),
986 1,
987 );
988 assert_eq!(
989 BitReader::endian(data, BigEndian)
990 .read::<3, NonZero<u8>>()
991 .unwrap()
992 .get(),
993 2,
994 );
995 assert_eq!(
996 BitReader::endian(data, BigEndian)
997 .read_var::<u8>(3)
998 .unwrap(),
999 1,
1000 );
1001 assert_eq!(
1002 BitReader::endian(data, BigEndian)
1003 .read_var::<NonZero<u8>>(3)
1004 .unwrap()
1005 .get(),
1006 2,
1007 );
1008 assert!(BitReader::endian(data, BigEndian)
1009 .read_var::<NonZero<u8>>(8)
1010 .is_err());
1011
1012 let data: &[u8] = &[0b00000_001, 0];
1013
1014 assert_eq!(
1015 BitReader::endian(data, LittleEndian)
1016 .read::<3, u8>()
1017 .unwrap(),
1018 1,
1019 );
1020 assert_eq!(
1021 BitReader::endian(data, LittleEndian)
1022 .read::<3, NonZero<u8>>()
1023 .unwrap()
1024 .get(),
1025 2,
1026 );
1027 assert_eq!(
1028 BitReader::endian(data, LittleEndian)
1029 .read_var::<u8>(3)
1030 .unwrap(),
1031 1,
1032 );
1033 assert_eq!(
1034 BitReader::endian(data, LittleEndian)
1035 .read_var::<NonZero<u8>>(3)
1036 .unwrap()
1037 .get(),
1038 2,
1039 );
1040 assert!(BitReader::endian(data, LittleEndian)
1041 .read_var::<NonZero<u8>>(8)
1042 .is_err());
1043 }