Debian Codegraph @

.cargo/vendor/bitstream-io/tests/write.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 bitstream_io::{BigEndian, BitWrite, BitWriter};
10 use std::io;
11
12 #[test]
13 fn test_writer_be() {
14 use bitstream_io::{BigEndian, BitWrite, BitWriter};
15
16 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
17
18 // writing individual bits
19 let mut w = BitWriter::endian(Vec::with_capacity(2), BigEndian);
20 w.write_bit(true).unwrap();
21 w.write_bit(false).unwrap();
22 w.write_bit(true).unwrap();
23 w.write_bit(true).unwrap();
24 w.write_bit(false).unwrap();
25 w.write_bit(false).unwrap();
26 w.write_bit(false).unwrap();
27 w.write_bit(true).unwrap();
28 w.write_bit(true).unwrap();
29 w.write_bit(true).unwrap();
30 w.write_bit(true).unwrap();
31 w.write_bit(false).unwrap();
32 w.write_bit(true).unwrap();
33 w.write_bit(true).unwrap();
34 w.write_bit(false).unwrap();
35 w.write_bit(true).unwrap();
36 assert_eq!(w.into_writer().as_slice(), &final_data[0..2]);
37
38 // writing unsigned values
39 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
40 assert!(w.byte_aligned());
41 w.write_var(2, 2u32).unwrap();
42 assert!(!w.byte_aligned());
43 w.write_var(3, 6u32).unwrap();
44 assert!(!w.byte_aligned());
45 w.write_var(5, 7u32).unwrap();
46 assert!(!w.byte_aligned());
47 w.write_var(3, 5u32).unwrap();
48 assert!(!w.byte_aligned());
49 w.write_var(19, 0x53BC1u32).unwrap();
50 assert!(w.byte_aligned());
51 assert_eq!(w.into_writer().as_slice(), &final_data);
52
53 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
54 assert!(w.byte_aligned());
55 w.write::<2, u32>(2).unwrap();
56 assert!(!w.byte_aligned());
57 w.write::<3, u32>(6).unwrap();
58 assert!(!w.byte_aligned());
59 w.write::<5, u32>(7).unwrap();
60 assert!(!w.byte_aligned());
61 w.write::<3, u32>(5).unwrap();
62 assert!(!w.byte_aligned());
63 w.write::<19, u32>(0x53BC1).unwrap();
64 assert!(w.byte_aligned());
65 assert_eq!(w.into_writer().as_slice(), &final_data);
66
67 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
68 assert!(w.byte_aligned());
69 w.write::<1, u8>(1).unwrap();
70 assert!(!w.byte_aligned());
71 w.write::<14, u16>(0b0110_0011_1101_10).unwrap();
72 assert!(!w.byte_aligned());
73 w.write::<16, u16>(0b1001_1101_1110_0000).unwrap();
74 assert!(!w.byte_aligned());
75 w.write::<1, u8>(1).unwrap();
76 assert!(w.byte_aligned());
77 assert_eq!(w.into_writer().as_slice(), &final_data);
78
79 // writing signed values
80 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
81 w.write_signed_var(2, -2).unwrap();
82 w.write_signed_var(3, -2).unwrap();
83 w.write_signed_var(5, 7).unwrap();
84 w.write_signed_var(3, -3).unwrap();
85 w.write_signed_var(19, -181311).unwrap();
86 assert_eq!(w.into_writer().as_slice(), &final_data);
87
88 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
89 w.write_signed::<2, i32>(-2).unwrap();
90 w.write_signed::<3, i32>(-2).unwrap();
91 w.write_signed::<5, i32>(7).unwrap();
92 w.write_signed::<3, i32>(-3).unwrap();
93 w.write_signed::<19, i32>(-181311).unwrap();
94 assert_eq!(w.into_writer().as_slice(), &final_data);
95
96 // writing unary 0 values
97 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
98 w.write_unary::<0>(1).unwrap();
99 w.write_unary::<0>(2).unwrap();
100 w.write_unary::<0>(0).unwrap();
101 w.write_unary::<0>(0).unwrap();
102 w.write_unary::<0>(4).unwrap();
103 w.write_unary::<0>(2).unwrap();
104 w.write_unary::<0>(1).unwrap();
105 w.write_unary::<0>(0).unwrap();
106 w.write_unary::<0>(3).unwrap();
107 w.write_unary::<0>(4).unwrap();
108 w.write_unary::<0>(0).unwrap();
109 w.write_unary::<0>(0).unwrap();
110 w.write_unary::<0>(0).unwrap();
111 w.write_unary::<0>(0).unwrap();
112 w.write_var(1, 1u32).unwrap();
113 assert_eq!(w.into_writer().as_slice(), &final_data);
114
115 // writing unary 1 values
116 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
117 w.write_unary::<1>(0).unwrap();
118 w.write_unary::<1>(1).unwrap();
119 w.write_unary::<1>(0).unwrap();
120 w.write_unary::<1>(3).unwrap();
121 w.write_unary::<1>(0).unwrap();
122 w.write_unary::<1>(0).unwrap();
123 w.write_unary::<1>(0).unwrap();
124 w.write_unary::<1>(1).unwrap();
125 w.write_unary::<1>(0).unwrap();
126 w.write_unary::<1>(1).unwrap();
127 w.write_unary::<1>(2).unwrap();
128 w.write_unary::<1>(0).unwrap();
129 w.write_unary::<1>(0).unwrap();
130 w.write_unary::<1>(1).unwrap();
131 w.write_unary::<1>(0).unwrap();
132 w.write_unary::<1>(0).unwrap();
133 w.write_unary::<1>(0).unwrap();
134 w.write_unary::<1>(5).unwrap();
135 assert_eq!(w.into_writer().as_slice(), &final_data);
136
137 // writing unsigned vbr
138 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
139 w.write_unsigned_vbr::<4, _>(11u8).unwrap(); // 001 011 -> <1>011 <0>001
140 w.write_unsigned_vbr::<4, _>(238u8).unwrap(); // 011 101 110 -> <1>110 <1>101 <0>011
141 w.write_unsigned_vbr::<4, _>(99u8).unwrap(); // 001 100 011 -> <1>011 <1>100 <0>001
142 assert_eq!(w.into_writer().as_slice(), &final_data);
143
144 // writing signed vbr
145 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
146 w.write_signed_vbr::<4, _>(-6i16).unwrap(); // 001 011 -> <1>011 <0>001
147 w.write_signed_vbr::<4, _>(119i16).unwrap(); // 011 101 110 -> <1>110 <1>101 <0>011
148 w.write_signed_vbr::<4, _>(-50i16).unwrap(); // 001 100 011 -> <1>011 <1>100 <0>001
149 assert_eq!(w.into_writer().as_slice(), &final_data);
150
151 // byte aligning
152 let aligned_data = [0xA0, 0xE0, 0x3B, 0xC0];
153 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
154 w.write_var(3, 5u32).unwrap();
155 w.byte_align().unwrap();
156 w.write_var(3, 7u32).unwrap();
157 w.byte_align().unwrap();
158 w.byte_align().unwrap();
159 w.write_var(8, 59u32).unwrap();
160 w.byte_align().unwrap();
161 w.write_var(4, 12u32).unwrap();
162 w.byte_align().unwrap();
163 assert_eq!(w.into_writer().as_slice(), &aligned_data);
164
165 // writing bytes, aligned
166 let final_data = [0xB1, 0xED];
167 let mut w = BitWriter::endian(Vec::with_capacity(2), BigEndian);
168 w.write_bytes(b"\xB1\xED").unwrap();
169 assert_eq!(w.into_writer().as_slice(), &final_data);
170
171 // writing bytes, un-aligned
172 let final_data = [0xBB, 0x1E, 0xD0];
173 let mut w = BitWriter::endian(Vec::with_capacity(3), BigEndian);
174 w.write_var(4, 11u32).unwrap();
175 w.write_bytes(b"\xB1\xED").unwrap();
176 w.byte_align().unwrap();
177 assert_eq!(w.into_writer().as_slice(), &final_data);
178 }
179
180 #[test]
181 fn test_writer_edge_cases_be() {
182 use bitstream_io::{BigEndian, BitWrite, BitWriter};
183
184 // 0 bit writes
185 let mut w = BitWriter::endian(Vec::new(), BigEndian);
186 w.write_var(0, 0u8).unwrap();
187 w.write_var(0, 0u16).unwrap();
188 w.write_var(0, 0u32).unwrap();
189 w.write_var(0, 0u64).unwrap();
190 assert!(w.into_writer().is_empty());
191
192 let mut w = BitWriter::endian(Vec::new(), BigEndian);
193 assert!(w.write_signed_var(0, 0i8).is_err());
194 assert!(w.write_signed_var(0, 0i16).is_err());
195 assert!(w.write_signed_var(0, 0i32).is_err());
196 assert!(w.write_signed_var(0, 0i64).is_err());
197 assert!(w.into_writer().is_empty());
198
199 let final_data: Vec<u8> = vec![
200 0, 0, 0, 0, 255, 255, 255, 255, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0,
201 255, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255, 255,
202 255, 255, 255,
203 ];
204
205 // unsigned 32 and 64-bit values
206 let mut w = BitWriter::endian(Vec::with_capacity(48), BigEndian);
207 w.write_var(32, 0u32).unwrap();
208 w.write_var(32, 4294967295u32).unwrap();
209 w.write_var(32, 2147483648u32).unwrap();
210 w.write_var(32, 2147483647u32).unwrap();
211 w.write_var(64, 0u64).unwrap();
212 w.write_var(64, 0xFFFFFFFFFFFFFFFFu64).unwrap();
213 w.write_var(64, 9223372036854775808u64).unwrap();
214 w.write_var(64, 9223372036854775807u64).unwrap();
215 assert_eq!(w.into_writer(), final_data);
216
217 let mut w = BitWriter::endian(Vec::with_capacity(48), BigEndian);
218 w.write::<32, u32>(0).unwrap();
219 w.write::<32, u32>(4294967295).unwrap();
220 w.write::<32, u32>(2147483648).unwrap();
221 w.write::<32, u32>(2147483647).unwrap();
222 w.write::<64, u64>(0).unwrap();
223 w.write::<64, u64>(0xFFFFFFFFFFFFFFFF).unwrap();
224 w.write::<64, u64>(9223372036854775808).unwrap();
225 w.write::<64, u64>(9223372036854775807).unwrap();
226 assert_eq!(w.into_writer(), final_data);
227
228 // signed 32 and 64-bit values
229 let mut w = BitWriter::endian(Vec::with_capacity(48), BigEndian);
230 w.write_signed_var(32, 0i32).unwrap();
231 w.write_signed_var(32, -1i32).unwrap();
232 w.write_signed_var(32, -2147483648i32).unwrap();
233 w.write_signed_var(32, 2147483647i32).unwrap();
234 w.write_signed_var(64, 0i64).unwrap();
235 w.write_signed_var(64, -1i64).unwrap();
236 w.write_signed_var(64, -9223372036854775808i64).unwrap();
237 w.write_signed_var(64, 9223372036854775807i64).unwrap();
238 assert_eq!(w.into_writer(), final_data);
239
240 let mut w = BitWriter::endian(Vec::with_capacity(48), BigEndian);
241 w.write_signed::<32, i32>(0).unwrap();
242 w.write_signed::<32, i32>(-1).unwrap();
243 w.write_signed::<32, i32>(-2147483648).unwrap();
244 w.write_signed::<32, i32>(2147483647).unwrap();
245 w.write_signed::<64, i64>(0).unwrap();
246 w.write_signed::<64, i64>(-1).unwrap();
247 w.write_signed::<64, i64>(-9223372036854775808).unwrap();
248 w.write_signed::<64, i64>(9223372036854775807).unwrap();
249 assert_eq!(w.into_writer(), final_data);
250
251 let mut bytes = Vec::new();
252 {
253 BitWriter::endian(&mut bytes, BigEndian)
254 .write_signed_var(8, core::i8::MAX)
255 .unwrap();
256 }
257 assert_eq!(bytes, core::i8::MAX.to_be_bytes());
258
259 let mut bytes = Vec::new();
260 {
261 BitWriter::endian(&mut bytes, BigEndian)
262 .write_signed_var(8, core::i8::MIN)
263 .unwrap();
264 }
265 assert_eq!(bytes, core::i8::MIN.to_be_bytes());
266
267 let mut bytes = Vec::new();
268 {
269 BitWriter::endian(&mut bytes, BigEndian)
270 .write_signed_var(16, core::i16::MAX)
271 .unwrap();
272 }
273 assert_eq!(bytes, core::i16::MAX.to_be_bytes());
274
275 let mut bytes = Vec::new();
276 {
277 BitWriter::endian(&mut bytes, BigEndian)
278 .write_signed_var(16, core::i16::MIN)
279 .unwrap();
280 }
281 assert_eq!(bytes, core::i16::MIN.to_be_bytes());
282
283 let mut bytes = Vec::new();
284 {
285 BitWriter::endian(&mut bytes, BigEndian)
286 .write_signed_var(32, core::i32::MAX)
287 .unwrap();
288 }
289 assert_eq!(bytes, core::i32::MAX.to_be_bytes());
290
291 let mut bytes = Vec::new();
292 {
293 BitWriter::endian(&mut bytes, BigEndian)
294 .write_signed_var(32, core::i32::MIN)
295 .unwrap();
296 }
297 assert_eq!(bytes, core::i32::MIN.to_be_bytes());
298
299 let mut bytes = Vec::new();
300 {
301 BitWriter::endian(&mut bytes, BigEndian)
302 .write_signed_var(64, core::i64::MAX)
303 .unwrap();
304 }
305 assert_eq!(bytes, core::i64::MAX.to_be_bytes());
306
307 let mut bytes = Vec::new();
308 {
309 BitWriter::endian(&mut bytes, BigEndian)
310 .write_signed_var(64, core::i64::MIN)
311 .unwrap();
312 }
313 assert_eq!(bytes, core::i64::MIN.to_be_bytes());
314
315 let mut bytes = Vec::new();
316 {
317 BitWriter::endian(&mut bytes, BigEndian)
318 .write_signed_var(128, core::i128::MAX)
319 .unwrap();
320 }
321 assert_eq!(bytes, core::i128::MAX.to_be_bytes());
322
323 let mut bytes = Vec::new();
324 {
325 BitWriter::endian(&mut bytes, BigEndian)
326 .write_signed_var(128, core::i128::MIN)
327 .unwrap();
328 }
329 assert_eq!(bytes, core::i128::MIN.to_be_bytes());
330 }
331
332 #[test]
333 fn test_writer_huffman_be() {
334 use bitstream_io::define_huffman_tree;
335 use bitstream_io::{BigEndian, BitWrite, BitWriter};
336
337 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
338 define_huffman_tree!(TreeName : i32 = [[[4, 3], 2], [1, 0]]);
339
340 let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
341 w.write_huffman::<TreeName>(1).unwrap();
342 w.write_huffman::<TreeName>(0).unwrap();
343 w.write_huffman::<TreeName>(4).unwrap();
344 w.write_huffman::<TreeName>(0).unwrap();
345 w.write_huffman::<TreeName>(0).unwrap();
346 w.write_huffman::<TreeName>(2).unwrap();
347 w.write_huffman::<TreeName>(1).unwrap();
348 w.write_huffman::<TreeName>(1).unwrap();
349 w.write_huffman::<TreeName>(2).unwrap();
350 w.write_huffman::<TreeName>(0).unwrap();
351 w.write_huffman::<TreeName>(2).unwrap();
352 w.write_huffman::<TreeName>(0).unwrap();
353 w.write_huffman::<TreeName>(1).unwrap();
354 w.write_huffman::<TreeName>(4).unwrap();
355 w.write_huffman::<TreeName>(2).unwrap();
356 w.byte_align().unwrap();
357 assert_eq!(w.into_writer().as_slice(), &final_data);
358 }
359
360 #[test]
361 fn test_write_chunks_be() {
362 use bitstream_io::{BigEndian, BitWrite, BitWriter};
363
364 let data: &[u8] = &[0b1011_0001, 0b1110_1101, 0b0011_1011, 0b1100_0001];
365
366 // test non-aligned chunk writing
367 let mut w = BitWriter::endian(vec![], BigEndian);
368 w.write::<2, u8>(0b10).unwrap();
369 w.write_bytes(&[0b11_0001_11, 0b10_1101_00]).unwrap();
370 w.write::<14, u16>(0b11_1011_1100_0001).unwrap();
371 assert_eq!(w.into_writer().as_slice(), data);
372
373 // test the smallest chunk
374 let mut w = BitWriter::endian(vec![], BigEndian);
375 w.write::<2, u8>(0b10).unwrap();
376 w.write_bytes(core::slice::from_ref(&0b11_0001_11)).unwrap();
377 w.write_bytes(core::slice::from_ref(&0b10_1101_00)).unwrap();
378 w.write::<14, u16>(0b11_1011_1100_0001).unwrap();
379 assert_eq!(w.into_writer().as_slice(), data);
380
381 // test a larger chunk
382 let mut w = BitWriter::endian(vec![], BigEndian);
383 w.write::<3, u8>(0b000).unwrap();
384 w.write_bytes(include_bytes!("random-3be.bin").as_slice())
385 .unwrap();
386 w.write::<5, u8>(0b10110).unwrap();
387 assert_eq!(
388 w.into_writer().as_slice(),
389 include_bytes!("random.bin").as_slice()
390 );
391 }
392
393 #[test]
394 fn test_writer_le() {
395 use bitstream_io::{BitWrite, BitWriter, LittleEndian};
396
397 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
398
399 // writing individual bits
400 let mut w = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
401 w.write_bit(true).unwrap();
402 w.write_bit(false).unwrap();
403 w.write_bit(false).unwrap();
404 w.write_bit(false).unwrap();
405 w.write_bit(true).unwrap();
406 w.write_bit(true).unwrap();
407 w.write_bit(false).unwrap();
408 w.write_bit(true).unwrap();
409 w.write_bit(true).unwrap();
410 w.write_bit(false).unwrap();
411 w.write_bit(true).unwrap();
412 w.write_bit(true).unwrap();
413 w.write_bit(false).unwrap();
414 w.write_bit(true).unwrap();
415 w.write_bit(true).unwrap();
416 w.write_bit(true).unwrap();
417 assert_eq!(w.into_writer().as_slice(), &final_data[0..2]);
418
419 // writing unsigned values
420 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
421 assert!(w.byte_aligned());
422 w.write_var(2, 1u32).unwrap();
423 assert!(!w.byte_aligned());
424 w.write_var(3, 4u32).unwrap();
425 assert!(!w.byte_aligned());
426 w.write_var(5, 13u32).unwrap();
427 assert!(!w.byte_aligned());
428 w.write_var(3, 3u32).unwrap();
429 assert!(!w.byte_aligned());
430 w.write_var(19, 0x609DFu32).unwrap();
431 assert!(w.byte_aligned());
432 assert_eq!(w.into_writer().as_slice(), &final_data);
433
434 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
435 assert!(w.byte_aligned());
436 w.write::<2, u32>(1).unwrap();
437 assert!(!w.byte_aligned());
438 w.write::<3, u32>(4).unwrap();
439 assert!(!w.byte_aligned());
440 w.write::<5, u32>(13).unwrap();
441 assert!(!w.byte_aligned());
442 w.write::<3, u32>(3).unwrap();
443 assert!(!w.byte_aligned());
444 w.write::<19, u32>(0x609DF).unwrap();
445 assert!(w.byte_aligned());
446 assert_eq!(w.into_writer().as_slice(), &final_data);
447
448 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
449 assert!(w.byte_aligned());
450 w.write::<1, u8>(1).unwrap();
451 assert!(!w.byte_aligned());
452 w.write::<14, u16>(0b1101_1011_0110_00).unwrap();
453 assert!(!w.byte_aligned());
454 w.write::<16, u16>(0b1000_0010_0111_0111).unwrap();
455 assert!(!w.byte_aligned());
456 w.write::<1, u8>(1).unwrap();
457 assert!(w.byte_aligned());
458 assert_eq!(w.into_writer().as_slice(), &final_data);
459
460 // writing signed values
461 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
462 w.write_signed_var(2, 1).unwrap();
463 w.write_signed_var(3, -4).unwrap();
464 w.write_signed_var(5, 13).unwrap();
465 w.write_signed_var(3, 3).unwrap();
466 w.write_signed_var(19, -128545).unwrap();
467 assert_eq!(w.into_writer().as_slice(), &final_data);
468
469 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
470 w.write_signed::<2, i32>(1).unwrap();
471 w.write_signed::<3, i32>(-4).unwrap();
472 w.write_signed::<5, i32>(13).unwrap();
473 w.write_signed::<3, i32>(3).unwrap();
474 w.write_signed::<19, i32>(-128545).unwrap();
475 assert_eq!(w.into_writer().as_slice(), &final_data);
476
477 // writing unary 0 values
478 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
479 w.write_unary::<0>(1).unwrap();
480 w.write_unary::<0>(0).unwrap();
481 w.write_unary::<0>(0).unwrap();
482 w.write_unary::<0>(2).unwrap();
483 w.write_unary::<0>(2).unwrap();
484 w.write_unary::<0>(2).unwrap();
485 w.write_unary::<0>(5).unwrap();
486 w.write_unary::<0>(3).unwrap();
487 w.write_unary::<0>(0).unwrap();
488 w.write_unary::<0>(1).unwrap();
489 w.write_unary::<0>(0).unwrap();
490 w.write_unary::<0>(0).unwrap();
491 w.write_unary::<0>(0).unwrap();
492 w.write_unary::<0>(0).unwrap();
493 w.write_var(2, 3u32).unwrap();
494 assert_eq!(w.into_writer().as_slice(), &final_data);
495
496 // writing unary 1 values
497 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
498 w.write_unary::<1>(0).unwrap();
499 w.write_unary::<1>(3).unwrap();
500 w.write_unary::<1>(0).unwrap();
501 w.write_unary::<1>(1).unwrap();
502 w.write_unary::<1>(0).unwrap();
503 w.write_unary::<1>(1).unwrap();
504 w.write_unary::<1>(0).unwrap();
505 w.write_unary::<1>(1).unwrap();
506 w.write_unary::<1>(0).unwrap();
507 w.write_unary::<1>(0).unwrap();
508 w.write_unary::<1>(0).unwrap();
509 w.write_unary::<1>(0).unwrap();
510 w.write_unary::<1>(1).unwrap();
511 w.write_unary::<1>(0).unwrap();
512 w.write_unary::<1>(0).unwrap();
513 w.write_unary::<1>(2).unwrap();
514 w.write_unary::<1>(5).unwrap();
515 w.write_unary::<1>(0).unwrap();
516 assert_eq!(w.into_writer().as_slice(), &final_data);
517
518 // byte aligning
519 let aligned_data = [0x05, 0x07, 0x3B, 0x0C];
520 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
521 w.write_var(3, 5u32).unwrap();
522 w.byte_align().unwrap();
523 w.write_var(3, 7u32).unwrap();
524 w.byte_align().unwrap();
525 w.byte_align().unwrap();
526 w.write_var(8, 59u32).unwrap();
527 w.byte_align().unwrap();
528 w.write_var(4, 12u32).unwrap();
529 w.byte_align().unwrap();
530 assert_eq!(w.into_writer().as_slice(), &aligned_data);
531
532 // writing bytes, aligned
533 let final_data = [0xB1, 0xED];
534 let mut w = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
535 w.write_bytes(b"\xB1\xED").unwrap();
536 assert_eq!(w.into_writer().as_slice(), &final_data);
537
538 // writing bytes, un-aligned
539 let final_data = [0x1B, 0xDB, 0x0E];
540 let mut w = BitWriter::endian(Vec::with_capacity(3), LittleEndian);
541 w.write_var(4, 11u32).unwrap();
542 w.write_bytes(b"\xB1\xED").unwrap();
543 w.byte_align().unwrap();
544 assert_eq!(w.into_writer().as_slice(), &final_data);
545 }
546
547 #[test]
548 fn test_writer_edge_cases_le() {
549 use bitstream_io::{BitWrite, BitWriter, LittleEndian};
550
551 // 0 bit writes
552 let mut w = BitWriter::endian(Vec::new(), LittleEndian);
553 w.write_var(0, 0u8).unwrap();
554 w.write_var(0, 0u16).unwrap();
555 w.write_var(0, 0u32).unwrap();
556 w.write_var(0, 0u64).unwrap();
557 assert!(w.into_writer().is_empty());
558
559 let mut w = BitWriter::endian(Vec::new(), LittleEndian);
560 assert!(w.write_signed_var(0, 0i8).is_err());
561 assert!(w.write_signed_var(0, 0i16).is_err());
562 assert!(w.write_signed_var(0, 0i32).is_err());
563 assert!(w.write_signed_var(0, 0i64).is_err());
564 assert!(w.into_writer().is_empty());
565
566 let final_data: Vec<u8> = vec![
567 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0,
568 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255,
569 255, 255, 127,
570 ];
571
572 // unsigned 32 and 64-bit values
573 let mut w = BitWriter::endian(Vec::with_capacity(48), LittleEndian);
574 w.write_var(32, 0u32).unwrap();
575 w.write_var(32, 4294967295u32).unwrap();
576 w.write_var(32, 2147483648u32).unwrap();
577 w.write_var(32, 2147483647u32).unwrap();
578 w.write_var(64, 0u64).unwrap();
579 w.write_var(64, 0xFFFFFFFFFFFFFFFFu64).unwrap();
580 w.write_var(64, 9223372036854775808u64).unwrap();
581 w.write_var(64, 9223372036854775807u64).unwrap();
582 assert_eq!(w.into_writer(), final_data);
583
584 let mut w = BitWriter::endian(Vec::with_capacity(48), LittleEndian);
585 w.write::<32, u32>(0).unwrap();
586 w.write::<32, u32>(4294967295).unwrap();
587 w.write::<32, u32>(2147483648).unwrap();
588 w.write::<32, u32>(2147483647).unwrap();
589 w.write::<64, u64>(0).unwrap();
590 w.write::<64, u64>(0xFFFFFFFFFFFFFFFF).unwrap();
591 w.write::<64, u64>(9223372036854775808).unwrap();
592 w.write::<64, u64>(9223372036854775807).unwrap();
593 assert_eq!(w.into_writer(), final_data);
594
595 // signed 32 and 64-bit values
596 let mut w = BitWriter::endian(Vec::with_capacity(48), LittleEndian);
597 w.write_signed_var(32, 0i32).unwrap();
598 w.write_signed_var(32, -1i32).unwrap();
599 w.write_signed_var(32, -2147483648i32).unwrap();
600 w.write_signed_var(32, 2147483647i32).unwrap();
601 w.write_signed_var(64, 0i64).unwrap();
602 w.write_signed_var(64, -1i64).unwrap();
603 w.write_signed_var(64, -9223372036854775808i64).unwrap();
604 w.write_signed_var(64, 9223372036854775807i64).unwrap();
605 assert_eq!(w.into_writer(), final_data);
606
607 let mut w = BitWriter::endian(Vec::with_capacity(48), LittleEndian);
608 w.write_signed::<32, i32>(0).unwrap();
609 w.write_signed::<32, i32>(-1).unwrap();
610 w.write_signed::<32, i32>(-2147483648).unwrap();
611 w.write_signed::<32, i32>(2147483647).unwrap();
612 w.write_signed::<64, i64>(0).unwrap();
613 w.write_signed::<64, i64>(-1).unwrap();
614 w.write_signed::<64, i64>(-9223372036854775808).unwrap();
615 w.write_signed::<64, i64>(9223372036854775807).unwrap();
616 assert_eq!(w.into_writer(), final_data);
617
618 let mut bytes = Vec::new();
619 {
620 BitWriter::endian(&mut bytes, LittleEndian)
621 .write_signed_var(8, core::i8::MAX)
622 .unwrap();
623 }
624 assert_eq!(bytes, core::i8::MAX.to_le_bytes());
625
626 let mut bytes = Vec::new();
627 {
628 BitWriter::endian(&mut bytes, LittleEndian)
629 .write_signed_var(8, core::i8::MIN)
630 .unwrap();
631 }
632 assert_eq!(bytes, core::i8::MIN.to_le_bytes());
633
634 let mut bytes = Vec::new();
635 {
636 BitWriter::endian(&mut bytes, LittleEndian)
637 .write_signed_var(16, core::i16::MAX)
638 .unwrap();
639 }
640 assert_eq!(bytes, core::i16::MAX.to_le_bytes());
641
642 let mut bytes = Vec::new();
643 {
644 BitWriter::endian(&mut bytes, LittleEndian)
645 .write_signed_var(16, core::i16::MIN)
646 .unwrap();
647 }
648 assert_eq!(bytes, core::i16::MIN.to_le_bytes());
649
650 let mut bytes = Vec::new();
651 {
652 BitWriter::endian(&mut bytes, LittleEndian)
653 .write_signed_var(32, core::i32::MAX)
654 .unwrap();
655 }
656 assert_eq!(bytes, core::i32::MAX.to_le_bytes());
657
658 let mut bytes = Vec::new();
659 {
660 BitWriter::endian(&mut bytes, LittleEndian)
661 .write_signed_var(32, core::i32::MIN)
662 .unwrap();
663 }
664 assert_eq!(bytes, core::i32::MIN.to_le_bytes());
665
666 let mut bytes = Vec::new();
667 {
668 BitWriter::endian(&mut bytes, LittleEndian)
669 .write_signed_var(64, core::i64::MAX)
670 .unwrap();
671 }
672 assert_eq!(bytes, core::i64::MAX.to_le_bytes());
673
674 let mut bytes = Vec::new();
675 {
676 BitWriter::endian(&mut bytes, LittleEndian)
677 .write_signed_var(64, core::i64::MIN)
678 .unwrap();
679 }
680 assert_eq!(bytes, core::i64::MIN.to_le_bytes());
681
682 let mut bytes = Vec::new();
683 {
684 BitWriter::endian(&mut bytes, LittleEndian)
685 .write_signed_var(128, core::i128::MAX)
686 .unwrap();
687 }
688 assert_eq!(bytes, core::i128::MAX.to_le_bytes());
689
690 let mut bytes = Vec::new();
691 {
692 BitWriter::endian(&mut bytes, LittleEndian)
693 .write_signed_var(128, core::i128::MIN)
694 .unwrap();
695 }
696 assert_eq!(bytes, core::i128::MIN.to_le_bytes());
697 }
698
699 #[test]
700 fn test_writer_huffman_le() {
701 use bitstream_io::define_huffman_tree;
702 use bitstream_io::{BitWrite, BitWriter, LittleEndian};
703
704 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
705 define_huffman_tree!(TreeName : i32= [[[4, 3], 2], [1, 0]]);
706
707 let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
708 w.write_huffman::<TreeName>(1).unwrap();
709 w.write_huffman::<TreeName>(3).unwrap();
710 w.write_huffman::<TreeName>(1).unwrap();
711 w.write_huffman::<TreeName>(0).unwrap();
712 w.write_huffman::<TreeName>(2).unwrap();
713 w.write_huffman::<TreeName>(1).unwrap();
714 w.write_huffman::<TreeName>(0).unwrap();
715 w.write_huffman::<TreeName>(0).unwrap();
716 w.write_huffman::<TreeName>(1).unwrap();
717 w.write_huffman::<TreeName>(0).unwrap();
718 w.write_huffman::<TreeName>(1).unwrap();
719 w.write_huffman::<TreeName>(2).unwrap();
720 w.write_huffman::<TreeName>(4).unwrap();
721 w.write_huffman::<TreeName>(3).unwrap();
722 w.write_var(1, 1u8).unwrap();
723 assert_eq!(w.into_writer().as_slice(), &final_data);
724 }
725
726 #[test]
727 fn test_write_chunks_le() {
728 use bitstream_io::{BitWrite, BitWriter, LittleEndian};
729
730 let data: &[u8] = &[0b1011_0001, 0b1110_1101, 0b0011_1011, 0b1100_0001];
731
732 // test non-aligned chunk writing
733 let mut w = BitWriter::endian(vec![], LittleEndian);
734 w.write::<2, u8>(0b01).unwrap();
735 w.write_bytes(&[0b01_1011_00, 0b11_1110_11]).unwrap();
736 w.write::<14, u16>(0b1100_0001_0011_10).unwrap();
737 assert_eq!(w.into_writer().as_slice(), data);
738
739 // test the smallest chunk
740 let mut w = BitWriter::endian(vec![], LittleEndian);
741 w.write::<2, u8>(0b01).unwrap();
742 w.write_bytes(core::slice::from_ref(&0b01_1011_00)).unwrap();
743 w.write_bytes(core::slice::from_ref(&0b11_1110_11)).unwrap();
744 w.write::<14, u16>(0b1100_0001_0011_10).unwrap();
745 assert_eq!(w.into_writer().as_slice(), data);
746
747 // test a larger chunk
748 let mut w = BitWriter::endian(vec![], LittleEndian);
749 w.write::<3, u8>(0b010).unwrap();
750 w.write_bytes(include_bytes!("random-3le.bin").as_slice())
751 .unwrap();
752 w.write::<5, u8>(0b00110).unwrap();
753 assert_eq!(
754 w.into_writer().as_slice(),
755 include_bytes!("random.bin").as_slice()
756 );
757 }
758
759 struct LimitedWriter {
760 can_write: usize,
761 }
762
763 impl LimitedWriter {
764 fn new(max_bytes: usize) -> LimitedWriter {
765 LimitedWriter {
766 can_write: max_bytes,
767 }
768 }
769 }
770
771 impl io::Write for LimitedWriter {
772 fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
773 let to_write = buf.len().min(self.can_write);
774 self.can_write -= to_write;
775 Ok(to_write)
776 }
777
778 fn flush(&mut self) -> Result<(), io::Error> {
779 Ok(())
780 }
781 }
782
783 #[test]
784 fn test_writer_io_errors_be() {
785 use bitstream_io::{BigEndian, BitWrite, BitWriter};
786 use io::ErrorKind;
787
788 // individual bits
789 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
790 assert!(w.write_bit(true).is_ok());
791 assert!(w.write_bit(false).is_ok());
792 assert!(w.write_bit(true).is_ok());
793 assert!(w.write_bit(true).is_ok());
794 assert!(w.write_bit(false).is_ok());
795 assert!(w.write_bit(false).is_ok());
796 assert!(w.write_bit(false).is_ok());
797 assert!(w.write_bit(true).is_ok());
798 assert!(w.write_bit(true).is_ok());
799 assert!(w.write_bit(true).is_ok());
800 assert!(w.write_bit(true).is_ok());
801 assert!(w.write_bit(false).is_ok());
802 assert!(w.write_bit(true).is_ok());
803 assert!(w.write_bit(true).is_ok());
804 assert!(w.write_bit(false).is_ok());
805 assert_eq!(w.write_bit(true).unwrap_err().kind(), ErrorKind::WriteZero);
806
807 // unsigned values
808 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
809 assert!(w.write_var(2, 2u32).is_ok());
810 assert!(w.write_var(3, 6u32).is_ok());
811 assert!(w.write_var(5, 7u32).is_ok());
812 assert!(w.write_var(3, 5u32).is_ok());
813 assert_eq!(
814 w.write_var(19, 0x53BC1u32).unwrap_err().kind(),
815 ErrorKind::WriteZero
816 );
817
818 // signed values
819 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
820 assert!(w.write_signed_var(2, -2).is_ok());
821 assert!(w.write_signed_var(3, -2).is_ok());
822 assert!(w.write_signed_var(5, 7).is_ok());
823 assert!(w.write_signed_var(3, -3).is_ok());
824 assert_eq!(
825 w.write_signed_var(19, -181311).unwrap_err().kind(),
826 ErrorKind::WriteZero
827 );
828
829 // unary 0 values
830 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
831 assert!(w.write_unary::<0>(1).is_ok());
832 assert!(w.write_unary::<0>(2).is_ok());
833 assert!(w.write_unary::<0>(0).is_ok());
834 assert!(w.write_unary::<0>(0).is_ok());
835 assert!(w.write_unary::<0>(4).is_ok());
836 assert!(w.write_unary::<0>(2).is_ok());
837 assert_eq!(
838 w.write_unary::<0>(1).unwrap_err().kind(),
839 ErrorKind::WriteZero
840 );
841
842 // unary 1 values
843 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
844 assert!(w.write_unary::<1>(0).is_ok());
845 assert!(w.write_unary::<1>(1).is_ok());
846 assert!(w.write_unary::<1>(0).is_ok());
847 assert!(w.write_unary::<1>(3).is_ok());
848 assert!(w.write_unary::<1>(0).is_ok());
849 assert!(w.write_unary::<1>(0).is_ok());
850 assert!(w.write_unary::<1>(0).is_ok());
851 assert!(w.write_unary::<1>(1).is_ok());
852 assert!(w.write_unary::<1>(0).is_ok());
853 assert_eq!(
854 w.write_unary::<1>(1).unwrap_err().kind(),
855 ErrorKind::WriteZero
856 );
857
858 // byte aligning
859 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
860 assert!(w.write_var::<u16>(9, 0b111111111).is_ok());
861 assert_eq!(w.byte_align().unwrap_err().kind(), ErrorKind::WriteZero);
862
863 // aligned bytes
864 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
865 assert_eq!(
866 w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
867 ErrorKind::WriteZero
868 );
869
870 // un-aligned bytes
871 let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
872 assert!(w.write_var(4, 11u8).is_ok());
873 assert_eq!(
874 w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
875 ErrorKind::WriteZero
876 );
877 }
878
879 #[test]
880 fn test_writer_io_errors_le() {
881 use bitstream_io::{BitWrite, BitWriter, LittleEndian};
882 use io::ErrorKind;
883
884 // individual bits
885 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
886 assert!(w.write_bit(true).is_ok());
887 assert!(w.write_bit(false).is_ok());
888 assert!(w.write_bit(false).is_ok());
889 assert!(w.write_bit(false).is_ok());
890 assert!(w.write_bit(true).is_ok());
891 assert!(w.write_bit(true).is_ok());
892 assert!(w.write_bit(false).is_ok());
893 assert!(w.write_bit(true).is_ok());
894 assert!(w.write_bit(true).is_ok());
895 assert!(w.write_bit(false).is_ok());
896 assert!(w.write_bit(true).is_ok());
897 assert!(w.write_bit(true).is_ok());
898 assert!(w.write_bit(false).is_ok());
899 assert!(w.write_bit(true).is_ok());
900 assert!(w.write_bit(true).is_ok());
901 assert_eq!(w.write_bit(true).unwrap_err().kind(), ErrorKind::WriteZero);
902
903 // unsigned values
904 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
905 assert!(w.write_var(2, 1u32).is_ok());
906 assert!(w.write_var(3, 4u32).is_ok());
907 assert!(w.write_var(5, 13u32).is_ok());
908 assert!(w.write_var(3, 3u32).is_ok());
909 assert_eq!(
910 w.write_var(19, 0x609DFu32).unwrap_err().kind(),
911 ErrorKind::WriteZero
912 );
913
914 // signed values
915 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
916 assert!(w.write_signed_var(2, 1).is_ok());
917 assert!(w.write_signed_var(3, -4).is_ok());
918 assert!(w.write_signed_var(5, 13).is_ok());
919 assert!(w.write_signed_var(3, 3).is_ok());
920 assert_eq!(
921 w.write_signed_var(19, -128545).unwrap_err().kind(),
922 ErrorKind::WriteZero
923 );
924
925 // unary 0 values
926 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
927 assert!(w.write_unary::<0>(1).is_ok());
928 assert!(w.write_unary::<0>(0).is_ok());
929 assert!(w.write_unary::<0>(0).is_ok());
930 assert!(w.write_unary::<0>(2).is_ok());
931 assert!(w.write_unary::<0>(2).is_ok());
932 assert!(w.write_unary::<0>(2).is_ok());
933 assert_eq!(
934 w.write_unary::<0>(5).unwrap_err().kind(),
935 ErrorKind::WriteZero
936 );
937
938 // unary 1 values
939 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
940 assert!(w.write_unary::<1>(0).is_ok());
941 assert!(w.write_unary::<1>(3).is_ok());
942 assert!(w.write_unary::<1>(0).is_ok());
943 assert!(w.write_unary::<1>(1).is_ok());
944 assert!(w.write_unary::<1>(0).is_ok());
945 assert!(w.write_unary::<1>(1).is_ok());
946 assert!(w.write_unary::<1>(0).is_ok());
947 assert!(w.write_unary::<1>(1).is_ok());
948 assert!(w.write_unary::<1>(0).is_ok());
949 assert_eq!(
950 w.write_unary::<1>(1).unwrap_err().kind(),
951 ErrorKind::WriteZero
952 );
953
954 // byte aligning
955 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
956 assert!(w.write_var::<u16>(9, 0b111111111).is_ok());
957 assert_eq!(w.byte_align().unwrap_err().kind(), ErrorKind::WriteZero);
958
959 // aligned bytes
960 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
961 assert_eq!(
962 w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
963 ErrorKind::WriteZero
964 );
965
966 // un-aligned bytes
967 let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
968 assert!(w.write_var(4, 11u8).is_ok());
969 assert_eq!(
970 w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
971 ErrorKind::WriteZero
972 );
973 }
974
975 #[test]
976 fn test_writer_bits_errors() {
977 use bitstream_io::{BigEndian, BitWrite, BitWriter, LittleEndian};
978 use io::{sink, ErrorKind};
979
980 let mut w = BitWriter::endian(sink(), BigEndian);
981 assert_eq!(
982 w.write_var(9, 0u8).unwrap_err().kind(),
983 ErrorKind::InvalidInput
984 );
985 assert_eq!(
986 w.write_var(17, 0u16).unwrap_err().kind(),
987 ErrorKind::InvalidInput
988 );
989 assert_eq!(
990 w.write_var(33, 0u32).unwrap_err().kind(),
991 ErrorKind::InvalidInput
992 );
993 assert_eq!(
994 w.write_var(65, 0u64).unwrap_err().kind(),
995 ErrorKind::InvalidInput
996 );
997
998 assert_eq!(
999 w.write_var(1, 0b10u8).unwrap_err().kind(),
1000 ErrorKind::InvalidInput
1001 );
1002 assert_eq!(
1003 w.write_var(2, 0b100u8).unwrap_err().kind(),
1004 ErrorKind::InvalidInput
1005 );
1006 assert_eq!(
1007 w.write_var(3, 0b1000u8).unwrap_err().kind(),
1008 ErrorKind::InvalidInput
1009 );
1010
1011 for bits in 1..8 {
1012 let val = 1u8 << bits;
1013 assert_eq!(
1014 w.write_var(bits, val).unwrap_err().kind(),
1015 ErrorKind::InvalidInput
1016 );
1017 }
1018 for bits in 8..16 {
1019 let val = 1u16 << bits;
1020 assert_eq!(
1021 w.write_var(bits, val).unwrap_err().kind(),
1022 ErrorKind::InvalidInput
1023 );
1024 }
1025 for bits in 16..32 {
1026 let val = 1u32 << bits;
1027 assert_eq!(
1028 w.write_var(bits, val).unwrap_err().kind(),
1029 ErrorKind::InvalidInput
1030 );
1031 }
1032 for bits in 32..64 {
1033 let val = 1u64 << bits;
1034 assert_eq!(
1035 w.write_var(bits, val).unwrap_err().kind(),
1036 ErrorKind::InvalidInput
1037 );
1038 }
1039
1040 assert_eq!(
1041 w.write_signed_var(9, 0i8).unwrap_err().kind(),
1042 ErrorKind::InvalidInput
1043 );
1044 assert_eq!(
1045 w.write_signed_var(17, 0i16).unwrap_err().kind(),
1046 ErrorKind::InvalidInput
1047 );
1048 assert_eq!(
1049 w.write_signed_var(33, 0i32).unwrap_err().kind(),
1050 ErrorKind::InvalidInput
1051 );
1052 assert_eq!(
1053 w.write_signed_var(65, 0i64).unwrap_err().kind(),
1054 ErrorKind::InvalidInput
1055 );
1056
1057 let mut w = BitWriter::endian(sink(), LittleEndian);
1058 assert_eq!(
1059 w.write_var(9, 0u8).unwrap_err().kind(),
1060 ErrorKind::InvalidInput
1061 );
1062 assert_eq!(
1063 w.write_var(17, 0u16).unwrap_err().kind(),
1064 ErrorKind::InvalidInput
1065 );
1066 assert_eq!(
1067 w.write_var(33, 0u32).unwrap_err().kind(),
1068 ErrorKind::InvalidInput
1069 );
1070 assert_eq!(
1071 w.write_var(65, 0u64).unwrap_err().kind(),
1072 ErrorKind::InvalidInput
1073 );
1074
1075 assert_eq!(
1076 w.write_var(1, 0b10u8).unwrap_err().kind(),
1077 ErrorKind::InvalidInput
1078 );
1079 assert_eq!(
1080 w.write_var(2, 0b100u8).unwrap_err().kind(),
1081 ErrorKind::InvalidInput
1082 );
1083 assert_eq!(
1084 w.write_var(3, 0b1000u8).unwrap_err().kind(),
1085 ErrorKind::InvalidInput
1086 );
1087
1088 for bits in 1..8 {
1089 let val = 1u8 << bits;
1090 assert_eq!(
1091 w.write_var(bits, val).unwrap_err().kind(),
1092 ErrorKind::InvalidInput
1093 );
1094 }
1095 for bits in 8..16 {
1096 let val = 1u16 << bits;
1097 assert_eq!(
1098 w.write_var(bits, val).unwrap_err().kind(),
1099 ErrorKind::InvalidInput
1100 );
1101 }
1102 for bits in 16..32 {
1103 let val = 1u32 << bits;
1104 assert_eq!(
1105 w.write_var(bits, val).unwrap_err().kind(),
1106 ErrorKind::InvalidInput
1107 );
1108 }
1109 for bits in 32..64 {
1110 let val = 1u64 << bits;
1111 assert_eq!(
1112 w.write_var(bits, val).unwrap_err().kind(),
1113 ErrorKind::InvalidInput
1114 );
1115 }
1116
1117 assert_eq!(
1118 w.write_signed_var(9, 0i8).unwrap_err().kind(),
1119 ErrorKind::InvalidInput
1120 );
1121 assert_eq!(
1122 w.write_signed_var(17, 0i16).unwrap_err().kind(),
1123 ErrorKind::InvalidInput
1124 );
1125 assert_eq!(
1126 w.write_signed_var(33, 0i32).unwrap_err().kind(),
1127 ErrorKind::InvalidInput
1128 );
1129 assert_eq!(
1130 w.write_signed_var(65, 0i64).unwrap_err().kind(),
1131 ErrorKind::InvalidInput
1132 );
1133 }
1134
1135 #[test]
1136 fn test_counter_be() {
1137 use bitstream_io::{BitWrite, BitsWritten};
1138
1139 // writing individual bits
1140 let mut w: BitsWritten<u32> = BitsWritten::new();
1141 w.write_bit(true).unwrap();
1142 w.write_bit(false).unwrap();
1143 w.write_bit(true).unwrap();
1144 w.write_bit(true).unwrap();
1145 w.write_bit(false).unwrap();
1146 w.write_bit(false).unwrap();
1147 w.write_bit(false).unwrap();
1148 w.write_bit(true).unwrap();
1149 w.write_bit(true).unwrap();
1150 w.write_bit(true).unwrap();
1151 w.write_bit(true).unwrap();
1152 w.write_bit(false).unwrap();
1153 w.write_bit(true).unwrap();
1154 w.write_bit(true).unwrap();
1155 w.write_bit(false).unwrap();
1156 w.write_bit(true).unwrap();
1157 assert_eq!(w.written(), 16);
1158
1159 // writing unsigned values
1160 let mut w: BitsWritten<u32> = BitsWritten::new();
1161 assert!(w.byte_aligned());
1162 w.write_var(2, 2u32).unwrap();
1163 assert!(!w.byte_aligned());
1164 w.write_var(3, 6u32).unwrap();
1165 assert!(!w.byte_aligned());
1166 w.write_var(5, 7u32).unwrap();
1167 assert!(!w.byte_aligned());
1168 w.write_var(3, 5u32).unwrap();
1169 assert!(!w.byte_aligned());
1170 w.write_var(19, 0x53BC1u32).unwrap();
1171 assert!(w.byte_aligned());
1172 assert_eq!(w.written(), 32);
1173
1174 // writing signed values
1175 let mut w: BitsWritten<u32> = BitsWritten::new();
1176 w.write_signed_var(2, -2).unwrap();
1177 w.write_signed_var(3, -2).unwrap();
1178 w.write_signed_var(5, 7).unwrap();
1179 w.write_signed_var(3, -3).unwrap();
1180 w.write_signed_var(19, -181311).unwrap();
1181 assert_eq!(w.written(), 32);
1182
1183 // writing unary 0 values
1184 let mut w: BitsWritten<u32> = BitsWritten::new();
1185 w.write_unary::<0>(1).unwrap();
1186 w.write_unary::<0>(2).unwrap();
1187 w.write_unary::<0>(0).unwrap();
1188 w.write_unary::<0>(0).unwrap();
1189 w.write_unary::<0>(4).unwrap();
1190 w.write_unary::<0>(2).unwrap();
1191 w.write_unary::<0>(1).unwrap();
1192 w.write_unary::<0>(0).unwrap();
1193 w.write_unary::<0>(3).unwrap();
1194 w.write_unary::<0>(4).unwrap();
1195 w.write_unary::<0>(0).unwrap();
1196 w.write_unary::<0>(0).unwrap();
1197 w.write_unary::<0>(0).unwrap();
1198 w.write_unary::<0>(0).unwrap();
1199 w.write_var(1, 1u32).unwrap();
1200 assert_eq!(w.written(), 32);
1201
1202 // writing unary 1 values
1203 let mut w: BitsWritten<u32> = BitsWritten::new();
1204 w.write_unary::<1>(0).unwrap();
1205 w.write_unary::<1>(1).unwrap();
1206 w.write_unary::<1>(0).unwrap();
1207 w.write_unary::<1>(3).unwrap();
1208 w.write_unary::<1>(0).unwrap();
1209 w.write_unary::<1>(0).unwrap();
1210 w.write_unary::<1>(0).unwrap();
1211 w.write_unary::<1>(1).unwrap();
1212 w.write_unary::<1>(0).unwrap();
1213 w.write_unary::<1>(1).unwrap();
1214 w.write_unary::<1>(2).unwrap();
1215 w.write_unary::<1>(0).unwrap();
1216 w.write_unary::<1>(0).unwrap();
1217 w.write_unary::<1>(1).unwrap();
1218 w.write_unary::<1>(0).unwrap();
1219 w.write_unary::<1>(0).unwrap();
1220 w.write_unary::<1>(0).unwrap();
1221 w.write_unary::<1>(5).unwrap();
1222 assert_eq!(w.written(), 32);
1223
1224 // byte aligning
1225 let mut w: BitsWritten<u32> = BitsWritten::new();
1226 w.write_var(3, 5u32).unwrap();
1227 w.byte_align().unwrap();
1228 w.write_var(3, 7u32).unwrap();
1229 w.byte_align().unwrap();
1230 w.byte_align().unwrap();
1231 w.write_var(8, 59u32).unwrap();
1232 w.byte_align().unwrap();
1233 w.write_var(4, 12u32).unwrap();
1234 w.byte_align().unwrap();
1235 assert_eq!(w.written(), 32);
1236
1237 // writing bytes, aligned
1238 let mut w: BitsWritten<u32> = BitsWritten::new();
1239 w.write_bytes(b"\xB1\xED").unwrap();
1240 assert_eq!(w.written(), 16);
1241
1242 // writing bytes, un-aligned
1243 let mut w: BitsWritten<u32> = BitsWritten::new();
1244 w.write_var(4, 11u32).unwrap();
1245 w.write_bytes(b"\xB1\xED").unwrap();
1246 w.byte_align().unwrap();
1247 assert_eq!(w.written(), 24);
1248 }
1249
1250 #[test]
1251 fn test_counter_huffman_be() {
1252 use bitstream_io::define_huffman_tree;
1253 use bitstream_io::{BitWrite, BitsWritten};
1254
1255 define_huffman_tree!(TreeName : i32 = [[[4, 3], 2], [1, 0]]);
1256
1257 let mut w: BitsWritten<u32> = BitsWritten::new();
1258 w.write_huffman::<TreeName>(1).unwrap();
1259 w.write_huffman::<TreeName>(0).unwrap();
1260 w.write_huffman::<TreeName>(4).unwrap();
1261 w.write_huffman::<TreeName>(0).unwrap();
1262 w.write_huffman::<TreeName>(0).unwrap();
1263 w.write_huffman::<TreeName>(2).unwrap();
1264 w.write_huffman::<TreeName>(1).unwrap();
1265 w.write_huffman::<TreeName>(1).unwrap();
1266 w.write_huffman::<TreeName>(2).unwrap();
1267 w.write_huffman::<TreeName>(0).unwrap();
1268 w.write_huffman::<TreeName>(2).unwrap();
1269 w.write_huffman::<TreeName>(0).unwrap();
1270 w.write_huffman::<TreeName>(1).unwrap();
1271 w.write_huffman::<TreeName>(4).unwrap();
1272 w.write_huffman::<TreeName>(2).unwrap();
1273 w.byte_align().unwrap();
1274 assert_eq!(w.written(), 32);
1275 }
1276
1277 #[test]
1278 fn test_counter_le() {
1279 use bitstream_io::{BitWrite, BitsWritten};
1280
1281 // writing individual bits
1282 let mut w: BitsWritten<u32> = BitsWritten::new();
1283 w.write_bit(true).unwrap();
1284 w.write_bit(false).unwrap();
1285 w.write_bit(false).unwrap();
1286 w.write_bit(false).unwrap();
1287 w.write_bit(true).unwrap();
1288 w.write_bit(true).unwrap();
1289 w.write_bit(false).unwrap();
1290 w.write_bit(true).unwrap();
1291 w.write_bit(true).unwrap();
1292 w.write_bit(false).unwrap();
1293 w.write_bit(true).unwrap();
1294 w.write_bit(true).unwrap();
1295 w.write_bit(false).unwrap();
1296 w.write_bit(true).unwrap();
1297 w.write_bit(true).unwrap();
1298 w.write_bit(true).unwrap();
1299 assert_eq!(w.written(), 16);
1300
1301 // writing unsigned values
1302 let mut w: BitsWritten<u32> = BitsWritten::new();
1303 assert!(w.byte_aligned());
1304 w.write_var(2, 1u32).unwrap();
1305 assert!(!w.byte_aligned());
1306 w.write_var(3, 4u32).unwrap();
1307 assert!(!w.byte_aligned());
1308 w.write_var(5, 13u32).unwrap();
1309 assert!(!w.byte_aligned());
1310 w.write_var(3, 3u32).unwrap();
1311 assert!(!w.byte_aligned());
1312 w.write_var(19, 0x609DFu32).unwrap();
1313 assert!(w.byte_aligned());
1314 assert_eq!(w.written(), 32);
1315
1316 // writing signed values
1317 let mut w: BitsWritten<u32> = BitsWritten::new();
1318 w.write_signed_var(2, 1).unwrap();
1319 w.write_signed_var(3, -4).unwrap();
1320 w.write_signed_var(5, 13).unwrap();
1321 w.write_signed_var(3, 3).unwrap();
1322 w.write_signed_var(19, -128545).unwrap();
1323 assert_eq!(w.written(), 32);
1324
1325 // writing unary 0 values
1326 let mut w: BitsWritten<u32> = BitsWritten::new();
1327 w.write_unary::<0>(1).unwrap();
1328 w.write_unary::<0>(0).unwrap();
1329 w.write_unary::<0>(0).unwrap();
1330 w.write_unary::<0>(2).unwrap();
1331 w.write_unary::<0>(2).unwrap();
1332 w.write_unary::<0>(2).unwrap();
1333 w.write_unary::<0>(5).unwrap();
1334 w.write_unary::<0>(3).unwrap();
1335 w.write_unary::<0>(0).unwrap();
1336 w.write_unary::<0>(1).unwrap();
1337 w.write_unary::<0>(0).unwrap();
1338 w.write_unary::<0>(0).unwrap();
1339 w.write_unary::<0>(0).unwrap();
1340 w.write_unary::<0>(0).unwrap();
1341 w.write_var(2, 3u32).unwrap();
1342 assert_eq!(w.written(), 32);
1343
1344 // writing unary 1 values
1345 let mut w: BitsWritten<u32> = BitsWritten::new();
1346 w.write_unary::<1>(0).unwrap();
1347 w.write_unary::<1>(3).unwrap();
1348 w.write_unary::<1>(0).unwrap();
1349 w.write_unary::<1>(1).unwrap();
1350 w.write_unary::<1>(0).unwrap();
1351 w.write_unary::<1>(1).unwrap();
1352 w.write_unary::<1>(0).unwrap();
1353 w.write_unary::<1>(1).unwrap();
1354 w.write_unary::<1>(0).unwrap();
1355 w.write_unary::<1>(0).unwrap();
1356 w.write_unary::<1>(0).unwrap();
1357 w.write_unary::<1>(0).unwrap();
1358 w.write_unary::<1>(1).unwrap();
1359 w.write_unary::<1>(0).unwrap();
1360 w.write_unary::<1>(0).unwrap();
1361 w.write_unary::<1>(2).unwrap();
1362 w.write_unary::<1>(5).unwrap();
1363 w.write_unary::<1>(0).unwrap();
1364 assert_eq!(w.written(), 32);
1365
1366 // byte aligning
1367 let mut w: BitsWritten<u32> = BitsWritten::new();
1368 w.write_var(3, 5u32).unwrap();
1369 w.byte_align().unwrap();
1370 w.write_var(3, 7u32).unwrap();
1371 w.byte_align().unwrap();
1372 w.byte_align().unwrap();
1373 w.write_var(8, 59u32).unwrap();
1374 w.byte_align().unwrap();
1375 w.write_var(4, 12u32).unwrap();
1376 w.byte_align().unwrap();
1377 assert_eq!(w.written(), 32);
1378
1379 // writing bytes, aligned
1380 let mut w: BitsWritten<u32> = BitsWritten::new();
1381 w.write_bytes(b"\xB1\xED").unwrap();
1382 assert_eq!(w.written(), 16);
1383
1384 // writing bytes, un-aligned
1385 let mut w: BitsWritten<u32> = BitsWritten::new();
1386 w.write_var(4, 11u32).unwrap();
1387 w.write_bytes(b"\xB1\xED").unwrap();
1388 w.byte_align().unwrap();
1389 assert_eq!(w.written(), 24);
1390 }
1391
1392 #[test]
1393 fn test_counter_huffman_le() {
1394 use bitstream_io::define_huffman_tree;
1395 use bitstream_io::{BitWrite, BitsWritten};
1396
1397 define_huffman_tree!(TreeName : i32= [[[4, 3], 2], [1, 0]]);
1398
1399 let mut w: BitsWritten<u32> = BitsWritten::new();
1400 w.write_huffman::<TreeName>(1).unwrap();
1401 w.write_huffman::<TreeName>(3).unwrap();
1402 w.write_huffman::<TreeName>(1).unwrap();
1403 w.write_huffman::<TreeName>(0).unwrap();
1404 w.write_huffman::<TreeName>(2).unwrap();
1405 w.write_huffman::<TreeName>(1).unwrap();
1406 w.write_huffman::<TreeName>(0).unwrap();
1407 w.write_huffman::<TreeName>(0).unwrap();
1408 w.write_huffman::<TreeName>(1).unwrap();
1409 w.write_huffman::<TreeName>(0).unwrap();
1410 w.write_huffman::<TreeName>(1).unwrap();
1411 w.write_huffman::<TreeName>(2).unwrap();
1412 w.write_huffman::<TreeName>(4).unwrap();
1413 w.write_huffman::<TreeName>(3).unwrap();
1414 w.write::<1, u8>(1).unwrap();
1415 assert_eq!(w.written(), 32);
1416 }
1417
1418 #[test]
1419 fn test_recorder_be() {
1420 use bitstream_io::{BigEndian, BitRecorder, BitWrite, BitWriter};
1421
1422 // partial writes
1423 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1424 w.write_bit(true).unwrap();
1425
1426 let mut w2 = BitWriter::endian(vec![], BigEndian);
1427 w.playback(&mut w2).unwrap();
1428 w2.byte_align().unwrap();
1429
1430 let mut w3 = BitWriter::endian(vec![], BigEndian);
1431 w3.write_bit(true).unwrap();
1432 w3.byte_align().unwrap();
1433
1434 assert_eq!(w2.into_writer(), w3.into_writer());
1435
1436 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1437
1438 // writing individual bits
1439 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1440 w.write_bit(true).unwrap();
1441 w.write_bit(false).unwrap();
1442 w.write_bit(true).unwrap();
1443 w.write_bit(true).unwrap();
1444 w.write_bit(false).unwrap();
1445 w.write_bit(false).unwrap();
1446 w.write_bit(false).unwrap();
1447 w.write_bit(true).unwrap();
1448 w.write_bit(true).unwrap();
1449 w.write_bit(true).unwrap();
1450 w.write_bit(true).unwrap();
1451 w.write_bit(false).unwrap();
1452 w.write_bit(true).unwrap();
1453 w.write_bit(true).unwrap();
1454 w.write_bit(false).unwrap();
1455 w.write_bit(true).unwrap();
1456 assert_eq!(w.written(), 16);
1457 let mut w2 = BitWriter::endian(Vec::with_capacity(2), BigEndian);
1458 w.playback(&mut w2).unwrap();
1459 assert_eq!(w2.into_writer().as_slice(), &final_data[0..2]);
1460
1461 // writing unsigned values
1462 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1463 assert!(w.byte_aligned());
1464 w.write_var(2, 2u32).unwrap();
1465 assert!(!w.byte_aligned());
1466 w.write_var(3, 6u32).unwrap();
1467 assert!(!w.byte_aligned());
1468 w.write_var(5, 7u32).unwrap();
1469 assert!(!w.byte_aligned());
1470 w.write_var(3, 5u32).unwrap();
1471 assert!(!w.byte_aligned());
1472 w.write_var(19, 0x53BC1u32).unwrap();
1473 assert!(w.byte_aligned());
1474 assert_eq!(w.written(), 32);
1475 let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1476 w.playback(&mut w2).unwrap();
1477 assert_eq!(w2.into_writer().as_slice(), &final_data);
1478
1479 // writing signed values
1480 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1481 w.write_signed_var(2, -2).unwrap();
1482 w.write_signed_var(3, -2).unwrap();
1483 w.write_signed_var(5, 7).unwrap();
1484 w.write_signed_var(3, -3).unwrap();
1485 w.write_signed_var(19, -181311).unwrap();
1486 assert_eq!(w.written(), 32);
1487 let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1488 w.playback(&mut w2).unwrap();
1489 assert_eq!(w2.into_writer().as_slice(), &final_data);
1490
1491 // writing unary 0 values
1492 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1493 w.write_unary::<0>(1).unwrap();
1494 w.write_unary::<0>(2).unwrap();
1495 w.write_unary::<0>(0).unwrap();
1496 w.write_unary::<0>(0).unwrap();
1497 w.write_unary::<0>(4).unwrap();
1498 w.write_unary::<0>(2).unwrap();
1499 w.write_unary::<0>(1).unwrap();
1500 w.write_unary::<0>(0).unwrap();
1501 w.write_unary::<0>(3).unwrap();
1502 w.write_unary::<0>(4).unwrap();
1503 w.write_unary::<0>(0).unwrap();
1504 w.write_unary::<0>(0).unwrap();
1505 w.write_unary::<0>(0).unwrap();
1506 w.write_unary::<0>(0).unwrap();
1507 w.write_var(1, 1u32).unwrap();
1508 assert_eq!(w.written(), 32);
1509 let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1510 w.playback(&mut w2).unwrap();
1511 assert_eq!(w2.into_writer().as_slice(), &final_data);
1512
1513 // writing unary 1 values
1514 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1515 w.write_unary::<1>(0).unwrap();
1516 w.write_unary::<1>(1).unwrap();
1517 w.write_unary::<1>(0).unwrap();
1518 w.write_unary::<1>(3).unwrap();
1519 w.write_unary::<1>(0).unwrap();
1520 w.write_unary::<1>(0).unwrap();
1521 w.write_unary::<1>(0).unwrap();
1522 w.write_unary::<1>(1).unwrap();
1523 w.write_unary::<1>(0).unwrap();
1524 w.write_unary::<1>(1).unwrap();
1525 w.write_unary::<1>(2).unwrap();
1526 w.write_unary::<1>(0).unwrap();
1527 w.write_unary::<1>(0).unwrap();
1528 w.write_unary::<1>(1).unwrap();
1529 w.write_unary::<1>(0).unwrap();
1530 w.write_unary::<1>(0).unwrap();
1531 w.write_unary::<1>(0).unwrap();
1532 w.write_unary::<1>(5).unwrap();
1533 assert_eq!(w.written(), 32);
1534 let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1535 w.playback(&mut w2).unwrap();
1536 assert_eq!(w2.into_writer().as_slice(), &final_data);
1537
1538 // byte aligning
1539 let aligned_data = [0xA0, 0xE0, 0x3B, 0xC0];
1540 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1541 w.write_var(3, 5u32).unwrap();
1542 w.byte_align().unwrap();
1543 w.write_var(3, 7u32).unwrap();
1544 w.byte_align().unwrap();
1545 w.byte_align().unwrap();
1546 w.write_var(8, 59u32).unwrap();
1547 w.byte_align().unwrap();
1548 w.write_var(4, 12u32).unwrap();
1549 w.byte_align().unwrap();
1550 assert_eq!(w.written(), 32);
1551 let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1552 w.playback(&mut w2).unwrap();
1553 assert_eq!(w2.into_writer().as_slice(), &aligned_data);
1554
1555 // writing bytes, aligned
1556 let final_data = [0xB1, 0xED];
1557 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1558 w.write_bytes(b"\xB1\xED").unwrap();
1559 assert_eq!(w.written(), 16);
1560 let mut w2 = BitWriter::endian(Vec::with_capacity(2), BigEndian);
1561 w.playback(&mut w2).unwrap();
1562 assert_eq!(w2.into_writer().as_slice(), &final_data);
1563
1564 // writing bytes, un-aligned
1565 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1566 let final_data = [0xBB, 0x1E, 0xD0];
1567 w.write_var(4, 11u32).unwrap();
1568 w.write_bytes(b"\xB1\xED").unwrap();
1569 w.byte_align().unwrap();
1570 let mut w2 = BitWriter::endian(Vec::with_capacity(3), BigEndian);
1571 w.playback(&mut w2).unwrap();
1572 assert_eq!(w2.into_writer().as_slice(), &final_data);
1573 }
1574
1575 #[test]
1576 fn test_recorder_huffman_be() {
1577 use bitstream_io::define_huffman_tree;
1578 use bitstream_io::{BigEndian, BitRecorder, BitWrite, BitWriter};
1579
1580 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1581 define_huffman_tree!(TreeName : i32 = [[[4, 3], 2], [1, 0]]);
1582
1583 let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1584 w.write_huffman::<TreeName>(1).unwrap();
1585 w.write_huffman::<TreeName>(0).unwrap();
1586 w.write_huffman::<TreeName>(4).unwrap();
1587 w.write_huffman::<TreeName>(0).unwrap();
1588 w.write_huffman::<TreeName>(0).unwrap();
1589 w.write_huffman::<TreeName>(2).unwrap();
1590 w.write_huffman::<TreeName>(1).unwrap();
1591 w.write_huffman::<TreeName>(1).unwrap();
1592 w.write_huffman::<TreeName>(2).unwrap();
1593 w.write_huffman::<TreeName>(0).unwrap();
1594 w.write_huffman::<TreeName>(2).unwrap();
1595 w.write_huffman::<TreeName>(0).unwrap();
1596 w.write_huffman::<TreeName>(1).unwrap();
1597 w.write_huffman::<TreeName>(4).unwrap();
1598 w.write_huffman::<TreeName>(2).unwrap();
1599 w.byte_align().unwrap();
1600 let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1601 w.playback(&mut w2).unwrap();
1602 assert_eq!(w2.into_writer().as_slice(), &final_data);
1603 }
1604
1605 #[test]
1606 fn test_recorder_le() {
1607 use bitstream_io::{BitRecorder, BitWrite, BitWriter, LittleEndian};
1608
1609 // partial writes
1610 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1611 w.write_bit(true).unwrap();
1612
1613 let mut w2 = BitWriter::endian(vec![], LittleEndian);
1614 w.playback(&mut w2).unwrap();
1615 w2.byte_align().unwrap();
1616
1617 let mut w3 = BitWriter::endian(vec![], LittleEndian);
1618 w3.write_bit(true).unwrap();
1619 w3.byte_align().unwrap();
1620
1621 assert_eq!(w2.into_writer(), w3.into_writer());
1622
1623 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1624
1625 // writing individual bits
1626 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1627 w.write_bit(true).unwrap();
1628 w.write_bit(false).unwrap();
1629 w.write_bit(false).unwrap();
1630 w.write_bit(false).unwrap();
1631 w.write_bit(true).unwrap();
1632 w.write_bit(true).unwrap();
1633 w.write_bit(false).unwrap();
1634 w.write_bit(true).unwrap();
1635 w.write_bit(true).unwrap();
1636 w.write_bit(false).unwrap();
1637 w.write_bit(true).unwrap();
1638 w.write_bit(true).unwrap();
1639 w.write_bit(false).unwrap();
1640 w.write_bit(true).unwrap();
1641 w.write_bit(true).unwrap();
1642 w.write_bit(true).unwrap();
1643 assert_eq!(w.written(), 16);
1644 let mut w2 = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
1645 w.playback(&mut w2).unwrap();
1646 assert_eq!(w2.into_writer().as_slice(), &final_data[0..2]);
1647
1648 // writing unsigned values
1649 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1650 assert!(w.byte_aligned());
1651 w.write_var(2, 1u32).unwrap();
1652 assert!(!w.byte_aligned());
1653 w.write_var(3, 4u32).unwrap();
1654 assert!(!w.byte_aligned());
1655 w.write_var(5, 13u32).unwrap();
1656 assert!(!w.byte_aligned());
1657 w.write_var(3, 3u32).unwrap();
1658 assert!(!w.byte_aligned());
1659 w.write_var(19, 0x609DFu32).unwrap();
1660 assert!(w.byte_aligned());
1661 assert_eq!(w.written(), 32);
1662 let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1663 w.playback(&mut w2).unwrap();
1664 assert_eq!(w2.into_writer().as_slice(), &final_data);
1665
1666 // writing signed values
1667 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1668 w.write_signed_var(2, 1).unwrap();
1669 w.write_signed_var(3, -4).unwrap();
1670 w.write_signed_var(5, 13).unwrap();
1671 w.write_signed_var(3, 3).unwrap();
1672 w.write_signed_var(19, -128545).unwrap();
1673 assert_eq!(w.written(), 32);
1674 let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1675 w.playback(&mut w2).unwrap();
1676 assert_eq!(w2.into_writer().as_slice(), &final_data);
1677
1678 // writing unary 0 values
1679 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1680 w.write_unary::<0>(1).unwrap();
1681 w.write_unary::<0>(0).unwrap();
1682 w.write_unary::<0>(0).unwrap();
1683 w.write_unary::<0>(2).unwrap();
1684 w.write_unary::<0>(2).unwrap();
1685 w.write_unary::<0>(2).unwrap();
1686 w.write_unary::<0>(5).unwrap();
1687 w.write_unary::<0>(3).unwrap();
1688 w.write_unary::<0>(0).unwrap();
1689 w.write_unary::<0>(1).unwrap();
1690 w.write_unary::<0>(0).unwrap();
1691 w.write_unary::<0>(0).unwrap();
1692 w.write_unary::<0>(0).unwrap();
1693 w.write_unary::<0>(0).unwrap();
1694 w.write_var(2, 3u32).unwrap();
1695 assert_eq!(w.written(), 32);
1696 let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1697 w.playback(&mut w2).unwrap();
1698 assert_eq!(w2.into_writer().as_slice(), &final_data);
1699
1700 // writing unary 1 values
1701 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1702 w.write_unary::<1>(0).unwrap();
1703 w.write_unary::<1>(3).unwrap();
1704 w.write_unary::<1>(0).unwrap();
1705 w.write_unary::<1>(1).unwrap();
1706 w.write_unary::<1>(0).unwrap();
1707 w.write_unary::<1>(1).unwrap();
1708 w.write_unary::<1>(0).unwrap();
1709 w.write_unary::<1>(1).unwrap();
1710 w.write_unary::<1>(0).unwrap();
1711 w.write_unary::<1>(0).unwrap();
1712 w.write_unary::<1>(0).unwrap();
1713 w.write_unary::<1>(0).unwrap();
1714 w.write_unary::<1>(1).unwrap();
1715 w.write_unary::<1>(0).unwrap();
1716 w.write_unary::<1>(0).unwrap();
1717 w.write_unary::<1>(2).unwrap();
1718 w.write_unary::<1>(5).unwrap();
1719 w.write_unary::<1>(0).unwrap();
1720 assert_eq!(w.written(), 32);
1721 let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1722 w.playback(&mut w2).unwrap();
1723 assert_eq!(w2.into_writer().as_slice(), &final_data);
1724
1725 // byte aligning
1726 let aligned_data = [0x05, 0x07, 0x3B, 0x0C];
1727 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1728 w.write_var(3, 5u32).unwrap();
1729 w.byte_align().unwrap();
1730 w.write_var(3, 7u32).unwrap();
1731 w.byte_align().unwrap();
1732 w.byte_align().unwrap();
1733 w.write_var(8, 59u32).unwrap();
1734 w.byte_align().unwrap();
1735 w.write_var(4, 12u32).unwrap();
1736 w.byte_align().unwrap();
1737 assert_eq!(w.written(), 32);
1738 let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1739 w.playback(&mut w2).unwrap();
1740 assert_eq!(w2.into_writer().as_slice(), &aligned_data);
1741
1742 // writing bytes, aligned
1743 let final_data = [0xB1, 0xED];
1744 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1745 w.write_bytes(b"\xB1\xED").unwrap();
1746 assert_eq!(w.written(), 16);
1747 let mut w2 = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
1748 w.playback(&mut w2).unwrap();
1749 assert_eq!(w2.into_writer().as_slice(), &final_data);
1750
1751 // writing bytes, un-aligned
1752 let final_data = [0x1B, 0xDB, 0x0E];
1753 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1754 w.write_var(4, 11u32).unwrap();
1755 w.write_bytes(b"\xB1\xED").unwrap();
1756 w.byte_align().unwrap();
1757 assert_eq!(w.written(), 24);
1758 let mut w2 = BitWriter::endian(Vec::with_capacity(3), LittleEndian);
1759 w.playback(&mut w2).unwrap();
1760 assert_eq!(w2.into_writer().as_slice(), &final_data);
1761 }
1762
1763 #[test]
1764 fn test_recorder_huffman_le() {
1765 use bitstream_io::define_huffman_tree;
1766 use bitstream_io::{BitRecorder, BitWrite, BitWriter, LittleEndian};
1767
1768 let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1769
1770 define_huffman_tree!(TreeName : i32 = [[[4, 3], 2], [1, 0]]);
1771
1772 let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1773 w.write_huffman::<TreeName>(1).unwrap();
1774 w.write_huffman::<TreeName>(3).unwrap();
1775 w.write_huffman::<TreeName>(1).unwrap();
1776 w.write_huffman::<TreeName>(0).unwrap();
1777 w.write_huffman::<TreeName>(2).unwrap();
1778 w.write_huffman::<TreeName>(1).unwrap();
1779 w.write_huffman::<TreeName>(0).unwrap();
1780 w.write_huffman::<TreeName>(0).unwrap();
1781 w.write_huffman::<TreeName>(1).unwrap();
1782 w.write_huffman::<TreeName>(0).unwrap();
1783 w.write_huffman::<TreeName>(1).unwrap();
1784 w.write_huffman::<TreeName>(2).unwrap();
1785 w.write_huffman::<TreeName>(4).unwrap();
1786 w.write_huffman::<TreeName>(3).unwrap();
1787 w.write::<1, u8>(1).unwrap();
1788 let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1789 w.playback(&mut w2).unwrap();
1790 assert_eq!(w2.into_writer().as_slice(), &final_data);
1791 }
1792
1793 #[test]
1794 fn test_pad() {
1795 use bitstream_io::{BigEndian, Endianness, LittleEndian};
1796
1797 fn test_pad_endian<E: Endianness>() {
1798 use bitstream_io::BitWriter;
1799
1800 let mut plain: BitWriter<_, E> = BitWriter::new(Vec::new());
1801 let mut padded: BitWriter<_, E> = BitWriter::new(Vec::new());
1802
1803 for bits in 1..64 {
1804 plain.write_bit(true).unwrap();
1805 plain.write_var(bits, 0u64).unwrap();
1806
1807 padded.write_bit(true).unwrap();
1808 padded.pad(bits).unwrap();
1809 }
1810 // plain.write_from([0u8; 1024]).unwrap();
1811 // plain.write_bit(true).unwrap();
1812
1813 // padded.pad(1024 * 8).unwrap();
1814 // padded.write_bit(true).unwrap();
1815
1816 plain.byte_align().unwrap();
1817 padded.byte_align().unwrap();
1818
1819 assert_eq!(plain.into_writer(), padded.into_writer());
1820 }
1821
1822 test_pad_endian::<BigEndian>();
1823 test_pad_endian::<LittleEndian>();
1824 }
1825
1826 #[test]
1827 fn test_counter_overflow() {
1828 use bitstream_io::BitsWritten;
1829
1830 // overflow u8 with many small writes
1831 let mut counter: BitsWritten<u8> = BitsWritten::new();
1832 for _ in 0..255 {
1833 assert!(counter.write_bit(false).is_ok());
1834 }
1835 assert!(counter.write_bit(false).is_err());
1836
1837 // overflow u8 with one big write
1838 let mut counter: BitsWritten<u8> = BitsWritten::new();
1839 assert!(counter.write_from([0u8; 31]).is_ok());
1840
1841 let mut counter: BitsWritten<u8> = BitsWritten::new();
1842 assert!(counter.write_from([0u8; 32]).is_err());
1843 }
1844
1845 #[test]
1846 fn test_negative_write() {
1847 let mut bit_writer = BitWriter::endian(Vec::new(), BigEndian);
1848 assert!(bit_writer.write_bit(false).is_ok());
1849 assert!(bit_writer.write_var(8, -1i8).is_ok());
1850 assert!(bit_writer.write_var(7, 0u8).is_ok());
1851 if let Some(writer) = bit_writer.writer() {
1852 assert_eq!(writer[0] >> 7, 0);
1853 } else {
1854 panic!("writer() returned None");
1855 }
1856 }
1857
1858 #[test]
1859 fn test_bitcount_write() {
1860 use bitstream_io::{BigEndian, BitCount, BitWrite, BitWriter};
1861
1862 // 1 bit count - writing 1 bit
1863 let bytes = vec![];
1864 let mut writer = BitWriter::endian(bytes, BigEndian);
1865 let count = BitCount::<0b1>::new::<1>();
1866 writer.write_count(count).unwrap();
1867 writer.write_counted::<1, u8>(count, 0b1).unwrap();
1868 writer.byte_align().unwrap();
1869 assert_eq!(writer.into_writer(), &[0b1_1_000000]);
1870
1871 // 2 bit count - writing 3 bits
1872 let bytes = vec![];
1873 let mut writer = BitWriter::endian(bytes, BigEndian);
1874 let count = BitCount::<0b11>::new::<0b11>();
1875 writer.write_count(count).unwrap();
1876 writer.write_counted::<0b11, u8>(count, 0b111).unwrap();
1877 writer.byte_align().unwrap();
1878 assert_eq!(writer.into_writer(), &[0b11_111_000]);
1879
1880 // 3 bit count - writing 7 bits
1881 let bytes = vec![];
1882 let mut writer = BitWriter::endian(bytes, BigEndian);
1883 let count = BitCount::<0b111>::new::<0b111>();
1884 writer.write_count(count).unwrap();
1885 writer
1886 .write_counted::<0b111, u8>(count, 0b11111_11)
1887 .unwrap();
1888 writer.byte_align().unwrap();
1889 assert_eq!(writer.into_writer(), &[0b111_11111, 0b11_000000]);
1890
1891 // 4 bit count - writing 15 bits
1892 let bytes = vec![];
1893 let mut writer = BitWriter::endian(bytes, BigEndian);
1894 let count = BitCount::<0b1111>::new::<0b1111>();
1895 writer.write_count(count).unwrap();
1896 writer
1897 .write_counted::<0b1111, u16>(count, 0b1111_11111111_111)
1898 .unwrap();
1899 writer.byte_align().unwrap();
1900 assert_eq!(
1901 writer.into_writer(),
1902 &[0b1111_1111, 0b11111111, 0b111_00000]
1903 );
1904
1905 // 5 bits count - writing 31 bits
1906 let bytes = vec![];
1907 let mut writer = BitWriter::endian(bytes, BigEndian);
1908 let count = BitCount::<0b11111>::new::<0b11111>();
1909 writer.write_count(count).unwrap();
1910 writer
1911 .write_counted::<0b11111, u32>(count, 0b111_11111111_11111111_11111111_1111)
1912 .unwrap();
1913 writer.byte_align().unwrap();
1914 assert_eq!(
1915 writer.into_writer(),
1916 &[0b11111_111, 0b11111111, 0b11111111, 0b11111111, 0b1111_0000]
1917 );
1918
1919 // 6 bits count - writing 63 bits
1920 let bytes = vec![];
1921 let mut writer = BitWriter::endian(bytes, BigEndian);
1922 let count = BitCount::<0b111111>::new::<0b111111>();
1923 writer.write_count(count).unwrap();
1924 writer
1925 .write_counted::<0b111111, u64>(
1926 count,
1927 0b11_11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111,
1928 )
1929 .unwrap();
1930 writer.byte_align().unwrap();
1931 assert_eq!(
1932 writer.into_writer(),
1933 &[
1934 0b111111_11,
1935 0b11111111,
1936 0b11111111,
1937 0b11111111,
1938 0b11111111,
1939 0b11111111,
1940 0b11111111,
1941 0b11111111,
1942 0b11111_000
1943 ]
1944 );
1945
1946 // 7 bits count - writing 127 bits
1947 let bytes = vec![];
1948 let mut writer = BitWriter::endian(bytes, BigEndian);
1949 let count = BitCount::<0b1111111>::new::<0b1111111>();
1950 writer.write_count(count).unwrap();
1951 writer
1952 .write_counted::<0b1111111, u128>(count, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
1953 .unwrap();
1954 writer.byte_align().unwrap();
1955 assert_eq!(
1956 writer.into_writer(),
1957 &[
1958 0b1111111_1,
1959 0b11111111,
1960 0b11111111,
1961 0b11111111,
1962 0b11111111,
1963 0b11111111,
1964 0b11111111,
1965 0b11111111,
1966 0b11111111,
1967 0b11111111,
1968 0b11111111,
1969 0b11111111,
1970 0b11111111,
1971 0b11111111,
1972 0b11111111,
1973 0b11111111,
1974 0b111111_00,
1975 ]
1976 );
1977 }
1978
1979 #[test]
1980 fn test_nonzero_writes() {
1981 use bitstream_io::{BigEndian, BitWrite, BitWriter, LittleEndian};
1982 use core::num::NonZero;
1983
1984 let mut w = BitWriter::endian(vec![], BigEndian);
1985 w.write::<3, u8>(1).unwrap();
1986 w.byte_align().unwrap();
1987 assert_eq!(w.into_writer(), &[0b001_00000]);
1988
1989 let mut w = BitWriter::endian(vec![], BigEndian);
1990 w.write::<3, NonZero<u8>>(NonZero::new(2).unwrap()).unwrap();
1991 w.byte_align().unwrap();
1992 assert_eq!(w.into_writer(), &[0b001_00000]);
1993
1994 let mut w = BitWriter::endian(vec![], BigEndian);
1995 w.write_var::<u8>(3, 1).unwrap();
1996 w.byte_align().unwrap();
1997 assert_eq!(w.into_writer(), &[0b001_00000]);
1998
1999 let mut w = BitWriter::endian(vec![], BigEndian);
2000 w.write_var::<NonZero<u8>>(3, NonZero::new(2).unwrap())
2001 .unwrap();
2002 w.byte_align().unwrap();
2003 assert_eq!(w.into_writer(), &[0b001_00000]);
2004
2005 let mut w = BitWriter::endian(vec![], LittleEndian);
2006 w.write::<3, u8>(1).unwrap();
2007 w.byte_align().unwrap();
2008 assert_eq!(w.into_writer(), &[0b00000_001]);
2009
2010 let mut w = BitWriter::endian(vec![], LittleEndian);
2011 w.write::<3, NonZero<u8>>(NonZero::new(2).unwrap()).unwrap();
2012 w.byte_align().unwrap();
2013 assert_eq!(w.into_writer(), &[0b00000_001]);
2014
2015 let mut w = BitWriter::endian(vec![], LittleEndian);
2016 w.write_var::<u8>(3, 1).unwrap();
2017 w.byte_align().unwrap();
2018 assert_eq!(w.into_writer(), &[0b00000_001]);
2019
2020 let mut w = BitWriter::endian(vec![], LittleEndian);
2021 w.write_var::<NonZero<u8>>(3, NonZero::new(2).unwrap())
2022 .unwrap();
2023 w.byte_align().unwrap();
2024 assert_eq!(w.into_writer(), &[0b00000_001]);
2025 }
2026
2027 #[test]
2028 fn test_const_writes() {
2029 use bitstream_io::{BigEndian, BitWrite, BitWriter, LittleEndian};
2030
2031 let mut w = BitWriter::endian(vec![], BigEndian);
2032 w.write_const::<0, 0b0>().unwrap();
2033 w.write_const::<1, 0b1>().unwrap();
2034 w.write_const::<2, 0b10>().unwrap();
2035 w.write_const::<3, 0b100>().unwrap();
2036 w.write_const::<4, 0b1000>().unwrap();
2037 w.write_const::<5, 0b10000>().unwrap();
2038 w.write_const::<6, 0b100000>().unwrap();
2039 w.write_const::<7, 0b1000000>().unwrap();
2040 w.write_const::<8, 0b10000000>().unwrap();
2041 w.write_const::<9, 0b100000000>().unwrap();
2042 w.write_const::<10, 0b1000000000>().unwrap();
2043 w.byte_align().unwrap();
2044
2045 assert_eq!(
2046 w.into_writer(),
2047 &[
2048 0b1_10_100_10,
2049 0b00_100001,
2050 0b00000_100,
2051 0b0000_1000,
2052 0b0000_1000,
2053 0b00000_100,
2054 0b00000000
2055 ]
2056 );
2057
2058 let mut w = BitWriter::endian(vec![], LittleEndian);
2059 w.write_const::<0, 0b0>().unwrap();
2060 w.write_const::<1, 0b1>().unwrap();
2061 w.write_const::<2, 0b10>().unwrap();
2062 w.write_const::<3, 0b100>().unwrap();
2063 w.write_const::<4, 0b1000>().unwrap();
2064 w.write_const::<5, 0b10000>().unwrap();
2065 w.write_const::<6, 0b100000>().unwrap();
2066 w.write_const::<7, 0b1000000>().unwrap();
2067 w.write_const::<8, 0b10000000>().unwrap();
2068 w.write_const::<9, 0b100000000>().unwrap();
2069 w.write_const::<10, 0b1000000000>().unwrap();
2070 w.byte_align().unwrap();
2071
2072 assert_eq!(
2073 w.into_writer(),
2074 &[
2075 0b00_100_10_1,
2076 0b0_10000_10,
2077 0b000_10000,
2078 0b0000_1000,
2079 0b0000_1000,
2080 0b000_10000,
2081 0b0_1000000
2082 ]
2083 );
2084 }
2085
2086 #[test]
2087 fn test_byte_count() {
2088 use bitstream_io::{ByteWrite, ToByteStream};
2089
2090 #[derive(Default)]
2091 struct Builder {
2092 a: u8,
2093 b: u16,
2094 c: u32,
2095 d: u64,
2096 e: u128,
2097 }
2098
2099 impl ToByteStream for Builder {
2100 type Error = io::Error;
2101
2102 fn to_writer<W: ByteWrite + ?Sized>(&self, w: &mut W) -> io::Result<()> {
2103 w.write(self.a)?;
2104 w.write(self.b)?;
2105 w.write(self.c)?;
2106 w.write(self.d)?;
2107 w.write(self.e)?;
2108 Ok(())
2109 }
2110 }
2111
2112 assert_eq!(
2113 Builder::default().bytes::<u32>().unwrap(),
2114 1 + 2 + 4 + 8 + 16
2115 );
2116 }