1 // Copyright 2017 Brian Langenberger
2 //
3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6 // option. This file may not be copied, modified, or distributed
7 // except according to those terms.
8 
9 extern crate bitstream_io;
10 
11 #[test]
test_write_queue_be()12 fn test_write_queue_be() {
13     use bitstream_io::{BitQueue, Numeric, BE};
14     let mut q: BitQueue<BE, u8> = BitQueue::new();
15     let mut v = BitQueue::<BE, u8>::from_value(0b10u8, 2);
16     q.push(2, v.pop(2).to_u8());
17     let mut v = BitQueue::<BE, u8>::from_value(0b110u8, 3);
18     q.push(3, v.pop(3).to_u8());
19     let mut v = BitQueue::<BE, u8>::from_value(0b001_11u8, 5);
20     q.push(3, v.pop(3).to_u8());
21     assert_eq!(q.len(), 8);
22     assert_eq!(q.pop(8), 0b10_110_001);
23     q.push(2, v.pop(2).to_u8());
24     let mut v = BitQueue::<BE, u8>::from_value(0b101u8, 3);
25     q.push(3, v.pop(3).to_u8());
26     let mut v = BitQueue::<BE, u32>::from_value(0b101_00111011_11000001, 19);
27     q.push(3, v.pop(3).to_u8());
28     assert_eq!(q.len(), 8);
29     assert_eq!(q.pop(8), 0b11_101_101);
30     q.push(8, v.pop(8).to_u8());
31     assert_eq!(q.len(), 8);
32     assert_eq!(q.pop(8), 0b00111011);
33     q.push(8, v.pop(8).to_u8());
34     assert_eq!(q.len(), 8);
35     assert_eq!(q.pop(8), 0b11000001);
36     assert!(v.is_empty());
37     assert!(q.is_empty());
38 }
39 
40 #[test]
test_write_queue_edge_be()41 fn test_write_queue_edge_be() {
42     use bitstream_io::{BitQueue, BE};
43 
44     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0, 0);
45     q.push(8, 0b11111111);
46     assert_eq!(q.pop(8), 0b11111111);
47 
48     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b1, 1);
49     q.push(7, 0b1111111);
50     assert_eq!(q.pop(8), 0b11111111);
51 
52     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b11, 2);
53     q.push(6, 0b111111);
54     assert_eq!(q.pop(8), 0b11111111);
55 
56     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b111, 3);
57     q.push(5, 0b11111);
58     assert_eq!(q.pop(8), 0b11111111);
59 
60     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b1111, 4);
61     q.push(4, 0b1111);
62     assert_eq!(q.pop(8), 0b11111111);
63 
64     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b11111, 5);
65     q.push(3, 0b111);
66     assert_eq!(q.pop(8), 0b11111111);
67 
68     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b111111, 6);
69     q.push(2, 0b11);
70     assert_eq!(q.pop(8), 0b11111111);
71 
72     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b1111111, 7);
73     q.push(1, 0b1);
74     assert_eq!(q.pop(8), 0b11111111);
75 
76     let mut q: BitQueue<BE, u8> = BitQueue::from_value(0b11111111, 8);
77     q.push(0, 0);
78     assert_eq!(q.pop(8), 0b11111111);
79 }
80 
81 #[test]
test_write_queue_le()82 fn test_write_queue_le() {
83     use bitstream_io::{BitQueue, Numeric, LE};
84     let mut q: BitQueue<LE, u8> = BitQueue::new();
85     let mut v = BitQueue::<LE, u8>::from_value(0b01u8, 2);
86     q.push(2, v.pop(2).to_u8());
87     let mut v = BitQueue::<LE, u8>::from_value(0b100u8, 3);
88     q.push(3, v.pop(3).to_u8());
89     let mut v = BitQueue::<LE, u8>::from_value(0b01_101u8, 5);
90     q.push(3, v.pop(3).to_u8());
91     assert_eq!(q.len(), 8);
92     assert_eq!(q.pop(8), 0b101_100_01);
93     q.push(2, v.pop(2).to_u8());
94     let mut v = BitQueue::<LE, u8>::from_value(0b011u8, 3);
95     q.push(3, v.pop(3).to_u8());
96     let mut v = BitQueue::<LE, u32>::from_value(0b11000001_00111011_111, 19);
97     q.push(3, v.pop(3).to_u8());
98     assert_eq!(q.len(), 8);
99     assert_eq!(q.pop(8), 0b111_011_01);
100     q.push(8, v.pop(8).to_u8());
101     assert_eq!(q.len(), 8);
102     assert_eq!(q.pop(8), 0b00111011);
103     q.push(8, v.pop(8).to_u8());
104     assert_eq!(q.len(), 8);
105     assert_eq!(q.pop(8), 0b11000001);
106     assert!(v.is_empty());
107     assert!(q.is_empty());
108 }
109 
110 #[test]
test_write_queue_edge_le()111 fn test_write_queue_edge_le() {
112     use bitstream_io::{BitQueue, LE};
113 
114     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0, 0);
115     q.push(8, 0b11111111);
116     assert_eq!(q.pop(8), 0b11111111);
117 
118     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b1, 1);
119     q.push(7, 0b1111111);
120     assert_eq!(q.pop(8), 0b11111111);
121 
122     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b11, 2);
123     q.push(6, 0b111111);
124     assert_eq!(q.pop(8), 0b11111111);
125 
126     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b111, 3);
127     q.push(5, 0b11111);
128     assert_eq!(q.pop(8), 0b11111111);
129 
130     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b1111, 4);
131     q.push(4, 0b1111);
132     assert_eq!(q.pop(8), 0b11111111);
133 
134     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b11111, 5);
135     q.push(3, 0b111);
136     assert_eq!(q.pop(8), 0b11111111);
137 
138     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b111111, 6);
139     q.push(2, 0b11);
140     assert_eq!(q.pop(8), 0b11111111);
141 
142     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b1111111, 7);
143     q.push(1, 0b1);
144     assert_eq!(q.pop(8), 0b11111111);
145 
146     let mut q: BitQueue<LE, u8> = BitQueue::from_value(0b11111111, 8);
147     q.push(0, 0);
148     assert_eq!(q.pop(8), 0b11111111);
149 }
150 
151 #[test]
test_writer_be()152 fn test_writer_be() {
153     use bitstream_io::{BigEndian, BitWrite, BitWriter};
154 
155     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
156 
157     /*writing individual bits*/
158     let mut w = BitWriter::endian(Vec::with_capacity(2), BigEndian);
159     w.write_bit(true).unwrap();
160     w.write_bit(false).unwrap();
161     w.write_bit(true).unwrap();
162     w.write_bit(true).unwrap();
163     w.write_bit(false).unwrap();
164     w.write_bit(false).unwrap();
165     w.write_bit(false).unwrap();
166     w.write_bit(true).unwrap();
167     w.write_bit(true).unwrap();
168     w.write_bit(true).unwrap();
169     w.write_bit(true).unwrap();
170     w.write_bit(false).unwrap();
171     w.write_bit(true).unwrap();
172     w.write_bit(true).unwrap();
173     w.write_bit(false).unwrap();
174     w.write_bit(true).unwrap();
175     assert_eq!(w.into_writer().as_slice(), &final_data[0..2]);
176 
177     /*writing unsigned values*/
178     let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
179     assert!(w.byte_aligned());
180     w.write(2, 2u32).unwrap();
181     assert!(!w.byte_aligned());
182     w.write(3, 6u32).unwrap();
183     assert!(!w.byte_aligned());
184     w.write(5, 7u32).unwrap();
185     assert!(!w.byte_aligned());
186     w.write(3, 5u32).unwrap();
187     assert!(!w.byte_aligned());
188     w.write(19, 0x53BC1u32).unwrap();
189     assert!(w.byte_aligned());
190     assert_eq!(w.into_writer().as_slice(), &final_data);
191 
192     /*writing signed values*/
193     let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
194     w.write_signed(2, -2).unwrap();
195     w.write_signed(3, -2).unwrap();
196     w.write_signed(5, 7).unwrap();
197     w.write_signed(3, -3).unwrap();
198     w.write_signed(19, -181311).unwrap();
199     assert_eq!(w.into_writer().as_slice(), &final_data);
200 
201     /*writing unary 0 values*/
202     let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
203     w.write_unary0(1).unwrap();
204     w.write_unary0(2).unwrap();
205     w.write_unary0(0).unwrap();
206     w.write_unary0(0).unwrap();
207     w.write_unary0(4).unwrap();
208     w.write_unary0(2).unwrap();
209     w.write_unary0(1).unwrap();
210     w.write_unary0(0).unwrap();
211     w.write_unary0(3).unwrap();
212     w.write_unary0(4).unwrap();
213     w.write_unary0(0).unwrap();
214     w.write_unary0(0).unwrap();
215     w.write_unary0(0).unwrap();
216     w.write_unary0(0).unwrap();
217     w.write(1, 1u32).unwrap();
218     assert_eq!(w.into_writer().as_slice(), &final_data);
219 
220     /*writing unary 1 values*/
221     let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
222     w.write_unary1(0).unwrap();
223     w.write_unary1(1).unwrap();
224     w.write_unary1(0).unwrap();
225     w.write_unary1(3).unwrap();
226     w.write_unary1(0).unwrap();
227     w.write_unary1(0).unwrap();
228     w.write_unary1(0).unwrap();
229     w.write_unary1(1).unwrap();
230     w.write_unary1(0).unwrap();
231     w.write_unary1(1).unwrap();
232     w.write_unary1(2).unwrap();
233     w.write_unary1(0).unwrap();
234     w.write_unary1(0).unwrap();
235     w.write_unary1(1).unwrap();
236     w.write_unary1(0).unwrap();
237     w.write_unary1(0).unwrap();
238     w.write_unary1(0).unwrap();
239     w.write_unary1(5).unwrap();
240     assert_eq!(w.into_writer().as_slice(), &final_data);
241 
242     /*byte aligning*/
243     let aligned_data = [0xA0, 0xE0, 0x3B, 0xC0];
244     let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
245     w.write(3, 5u32).unwrap();
246     w.byte_align().unwrap();
247     w.write(3, 7u32).unwrap();
248     w.byte_align().unwrap();
249     w.byte_align().unwrap();
250     w.write(8, 59u32).unwrap();
251     w.byte_align().unwrap();
252     w.write(4, 12u32).unwrap();
253     w.byte_align().unwrap();
254     assert_eq!(w.into_writer().as_slice(), &aligned_data);
255 
256     /*writing bytes, aligned*/
257     let final_data = [0xB1, 0xED];
258     let mut w = BitWriter::endian(Vec::with_capacity(2), BigEndian);
259     w.write_bytes(b"\xB1\xED").unwrap();
260     assert_eq!(w.into_writer().as_slice(), &final_data);
261 
262     /*writing bytes, un-aligned*/
263     let final_data = [0xBB, 0x1E, 0xD0];
264     let mut w = BitWriter::endian(Vec::with_capacity(3), BigEndian);
265     w.write(4, 11u32).unwrap();
266     w.write_bytes(b"\xB1\xED").unwrap();
267     w.byte_align().unwrap();
268     assert_eq!(w.into_writer().as_slice(), &final_data);
269 }
270 
271 #[test]
test_writer_edge_cases_be()272 fn test_writer_edge_cases_be() {
273     use bitstream_io::{BigEndian, BitWrite, BitWriter};
274 
275     let final_data: Vec<u8> = vec![
276         0, 0, 0, 0, 255, 255, 255, 255, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0,
277         255, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255, 255,
278         255, 255, 255,
279     ];
280 
281     /*unsigned 32 and 64-bit values*/
282     let mut w = BitWriter::endian(Vec::with_capacity(48), BigEndian);
283     w.write(32, 0u32).unwrap();
284     w.write(32, 4294967295u32).unwrap();
285     w.write(32, 2147483648u32).unwrap();
286     w.write(32, 2147483647u32).unwrap();
287     w.write(64, 0u64).unwrap();
288     w.write(64, 0xFFFFFFFFFFFFFFFFu64).unwrap();
289     w.write(64, 9223372036854775808u64).unwrap();
290     w.write(64, 9223372036854775807u64).unwrap();
291     assert_eq!(w.into_writer(), final_data);
292 
293     /*signed 32 and 64-bit values*/
294     let mut w = BitWriter::endian(Vec::with_capacity(48), BigEndian);
295     w.write(32, 0i64).unwrap();
296     w.write(32, -1i64).unwrap();
297     w.write(32, -2147483648i64).unwrap();
298     w.write(32, 2147483647i64).unwrap();
299     w.write(64, 0i64).unwrap();
300     w.write(64, -1i64).unwrap();
301     w.write(64, -9223372036854775808i64).unwrap();
302     w.write(64, 9223372036854775807i64).unwrap();
303     assert_eq!(w.into_writer(), final_data);
304 
305     let mut bytes = Vec::new();
306     {
307         BitWriter::endian(&mut bytes, BigEndian)
308             .write_signed(8, std::i8::MAX)
309             .unwrap();
310     }
311     assert_eq!(bytes, std::i8::MAX.to_be_bytes());
312 
313     let mut bytes = Vec::new();
314     {
315         BitWriter::endian(&mut bytes, BigEndian)
316             .write_signed(8, std::i8::MIN)
317             .unwrap();
318     }
319     assert_eq!(bytes, std::i8::MIN.to_be_bytes());
320 
321     let mut bytes = Vec::new();
322     {
323         BitWriter::endian(&mut bytes, BigEndian)
324             .write_signed(16, std::i16::MAX)
325             .unwrap();
326     }
327     assert_eq!(bytes, std::i16::MAX.to_be_bytes());
328 
329     let mut bytes = Vec::new();
330     {
331         BitWriter::endian(&mut bytes, BigEndian)
332             .write_signed(16, std::i16::MIN)
333             .unwrap();
334     }
335     assert_eq!(bytes, std::i16::MIN.to_be_bytes());
336 
337     let mut bytes = Vec::new();
338     {
339         BitWriter::endian(&mut bytes, BigEndian)
340             .write_signed(32, std::i32::MAX)
341             .unwrap();
342     }
343     assert_eq!(bytes, std::i32::MAX.to_be_bytes());
344 
345     let mut bytes = Vec::new();
346     {
347         BitWriter::endian(&mut bytes, BigEndian)
348             .write_signed(32, std::i32::MIN)
349             .unwrap();
350     }
351     assert_eq!(bytes, std::i32::MIN.to_be_bytes());
352 
353     let mut bytes = Vec::new();
354     {
355         BitWriter::endian(&mut bytes, BigEndian)
356             .write_signed(64, std::i64::MAX)
357             .unwrap();
358     }
359     assert_eq!(bytes, std::i64::MAX.to_be_bytes());
360 
361     let mut bytes = Vec::new();
362     {
363         BitWriter::endian(&mut bytes, BigEndian)
364             .write_signed(64, std::i64::MIN)
365             .unwrap();
366     }
367     assert_eq!(bytes, std::i64::MIN.to_be_bytes());
368 
369     let mut bytes = Vec::new();
370     {
371         BitWriter::endian(&mut bytes, BigEndian)
372             .write_signed(128, std::i128::MAX)
373             .unwrap();
374     }
375     assert_eq!(bytes, std::i128::MAX.to_be_bytes());
376 
377     let mut bytes = Vec::new();
378     {
379         BitWriter::endian(&mut bytes, BigEndian)
380             .write_signed(128, std::i128::MIN)
381             .unwrap();
382     }
383     assert_eq!(bytes, std::i128::MIN.to_be_bytes());
384 }
385 
386 #[test]
test_writer_huffman_be()387 fn test_writer_huffman_be() {
388     use bitstream_io::huffman::compile_write_tree;
389     use bitstream_io::{BigEndian, BitWrite, BitWriter, HuffmanWrite};
390 
391     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
392     let tree = compile_write_tree(vec![
393         (0, vec![1, 1]),
394         (1, vec![1, 0]),
395         (2, vec![0, 1]),
396         (3, vec![0, 0, 1]),
397         (4, vec![0, 0, 0]),
398     ])
399     .unwrap();
400     let mut w = BitWriter::endian(Vec::with_capacity(4), BigEndian);
401     w.write_huffman(&tree, 1).unwrap();
402     w.write_huffman(&tree, 0).unwrap();
403     w.write_huffman(&tree, 4).unwrap();
404     w.write_huffman(&tree, 0).unwrap();
405     w.write_huffman(&tree, 0).unwrap();
406     w.write_huffman(&tree, 2).unwrap();
407     w.write_huffman(&tree, 1).unwrap();
408     w.write_huffman(&tree, 1).unwrap();
409     w.write_huffman(&tree, 2).unwrap();
410     w.write_huffman(&tree, 0).unwrap();
411     w.write_huffman(&tree, 2).unwrap();
412     w.write_huffman(&tree, 0).unwrap();
413     w.write_huffman(&tree, 1).unwrap();
414     w.write_huffman(&tree, 4).unwrap();
415     w.write_huffman(&tree, 2).unwrap();
416     w.byte_align().unwrap();
417     assert_eq!(w.into_writer().as_slice(), &final_data);
418 }
419 
420 #[test]
test_writer_le()421 fn test_writer_le() {
422     use bitstream_io::{BitWrite, BitWriter, LittleEndian};
423 
424     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
425 
426     /*writing individual bits*/
427     let mut w = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
428     w.write_bit(true).unwrap();
429     w.write_bit(false).unwrap();
430     w.write_bit(false).unwrap();
431     w.write_bit(false).unwrap();
432     w.write_bit(true).unwrap();
433     w.write_bit(true).unwrap();
434     w.write_bit(false).unwrap();
435     w.write_bit(true).unwrap();
436     w.write_bit(true).unwrap();
437     w.write_bit(false).unwrap();
438     w.write_bit(true).unwrap();
439     w.write_bit(true).unwrap();
440     w.write_bit(false).unwrap();
441     w.write_bit(true).unwrap();
442     w.write_bit(true).unwrap();
443     w.write_bit(true).unwrap();
444     assert_eq!(w.into_writer().as_slice(), &final_data[0..2]);
445 
446     /*writing unsigned values*/
447     let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
448     assert!(w.byte_aligned());
449     w.write(2, 1u32).unwrap();
450     assert!(!w.byte_aligned());
451     w.write(3, 4u32).unwrap();
452     assert!(!w.byte_aligned());
453     w.write(5, 13u32).unwrap();
454     assert!(!w.byte_aligned());
455     w.write(3, 3u32).unwrap();
456     assert!(!w.byte_aligned());
457     w.write(19, 0x609DFu32).unwrap();
458     assert!(w.byte_aligned());
459     assert_eq!(w.into_writer().as_slice(), &final_data);
460 
461     /*writing signed values*/
462     let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
463     w.write_signed(2, 1).unwrap();
464     w.write_signed(3, -4).unwrap();
465     w.write_signed(5, 13).unwrap();
466     w.write_signed(3, 3).unwrap();
467     w.write_signed(19, -128545).unwrap();
468     assert_eq!(w.into_writer().as_slice(), &final_data);
469 
470     /*writing unary 0 values*/
471     let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
472     w.write_unary0(1).unwrap();
473     w.write_unary0(0).unwrap();
474     w.write_unary0(0).unwrap();
475     w.write_unary0(2).unwrap();
476     w.write_unary0(2).unwrap();
477     w.write_unary0(2).unwrap();
478     w.write_unary0(5).unwrap();
479     w.write_unary0(3).unwrap();
480     w.write_unary0(0).unwrap();
481     w.write_unary0(1).unwrap();
482     w.write_unary0(0).unwrap();
483     w.write_unary0(0).unwrap();
484     w.write_unary0(0).unwrap();
485     w.write_unary0(0).unwrap();
486     w.write(2, 3u32).unwrap();
487     assert_eq!(w.into_writer().as_slice(), &final_data);
488 
489     /*writing unary 1 values*/
490     let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
491     w.write_unary1(0).unwrap();
492     w.write_unary1(3).unwrap();
493     w.write_unary1(0).unwrap();
494     w.write_unary1(1).unwrap();
495     w.write_unary1(0).unwrap();
496     w.write_unary1(1).unwrap();
497     w.write_unary1(0).unwrap();
498     w.write_unary1(1).unwrap();
499     w.write_unary1(0).unwrap();
500     w.write_unary1(0).unwrap();
501     w.write_unary1(0).unwrap();
502     w.write_unary1(0).unwrap();
503     w.write_unary1(1).unwrap();
504     w.write_unary1(0).unwrap();
505     w.write_unary1(0).unwrap();
506     w.write_unary1(2).unwrap();
507     w.write_unary1(5).unwrap();
508     w.write_unary1(0).unwrap();
509     assert_eq!(w.into_writer().as_slice(), &final_data);
510 
511     /*byte aligning*/
512     let aligned_data = [0x05, 0x07, 0x3B, 0x0C];
513     let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
514     w.write(3, 5u32).unwrap();
515     w.byte_align().unwrap();
516     w.write(3, 7u32).unwrap();
517     w.byte_align().unwrap();
518     w.byte_align().unwrap();
519     w.write(8, 59u32).unwrap();
520     w.byte_align().unwrap();
521     w.write(4, 12u32).unwrap();
522     w.byte_align().unwrap();
523     assert_eq!(w.into_writer().as_slice(), &aligned_data);
524 
525     /*writing bytes, aligned*/
526     let final_data = [0xB1, 0xED];
527     let mut w = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
528     w.write_bytes(b"\xB1\xED").unwrap();
529     assert_eq!(w.into_writer().as_slice(), &final_data);
530 
531     /*writing bytes, un-aligned*/
532     let final_data = [0x1B, 0xDB, 0x0E];
533     let mut w = BitWriter::endian(Vec::with_capacity(3), LittleEndian);
534     w.write(4, 11u32).unwrap();
535     w.write_bytes(b"\xB1\xED").unwrap();
536     w.byte_align().unwrap();
537     assert_eq!(w.into_writer().as_slice(), &final_data);
538 }
539 
540 #[test]
test_writer_edge_cases_le()541 fn test_writer_edge_cases_le() {
542     use bitstream_io::{BitWrite, BitWriter, LittleEndian};
543 
544     let final_data: Vec<u8> = vec![
545         0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0,
546         255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255,
547         255, 255, 127,
548     ];
549 
550     /*unsigned 32 and 64-bit values*/
551     let mut w = BitWriter::endian(Vec::with_capacity(48), LittleEndian);
552     w.write(32, 0u32).unwrap();
553     w.write(32, 4294967295u32).unwrap();
554     w.write(32, 2147483648u32).unwrap();
555     w.write(32, 2147483647u32).unwrap();
556     w.write(64, 0u64).unwrap();
557     w.write(64, 0xFFFFFFFFFFFFFFFFu64).unwrap();
558     w.write(64, 9223372036854775808u64).unwrap();
559     w.write(64, 9223372036854775807u64).unwrap();
560     assert_eq!(w.into_writer(), final_data);
561 
562     /*signed 32 and 64-bit values*/
563     let mut w = BitWriter::endian(Vec::with_capacity(48), LittleEndian);
564     w.write(32, 0i64).unwrap();
565     w.write(32, -1i64).unwrap();
566     w.write(32, -2147483648i64).unwrap();
567     w.write(32, 2147483647i64).unwrap();
568     w.write(64, 0i64).unwrap();
569     w.write(64, -1i64).unwrap();
570     w.write(64, -9223372036854775808i64).unwrap();
571     w.write(64, 9223372036854775807i64).unwrap();
572     assert_eq!(w.into_writer(), final_data);
573 
574     let mut bytes = Vec::new();
575     {
576         BitWriter::endian(&mut bytes, LittleEndian)
577             .write_signed(8, std::i8::MAX)
578             .unwrap();
579     }
580     assert_eq!(bytes, std::i8::MAX.to_le_bytes());
581 
582     let mut bytes = Vec::new();
583     {
584         BitWriter::endian(&mut bytes, LittleEndian)
585             .write_signed(8, std::i8::MIN)
586             .unwrap();
587     }
588     assert_eq!(bytes, std::i8::MIN.to_le_bytes());
589 
590     let mut bytes = Vec::new();
591     {
592         BitWriter::endian(&mut bytes, LittleEndian)
593             .write_signed(16, std::i16::MAX)
594             .unwrap();
595     }
596     assert_eq!(bytes, std::i16::MAX.to_le_bytes());
597 
598     let mut bytes = Vec::new();
599     {
600         BitWriter::endian(&mut bytes, LittleEndian)
601             .write_signed(16, std::i16::MIN)
602             .unwrap();
603     }
604     assert_eq!(bytes, std::i16::MIN.to_le_bytes());
605 
606     let mut bytes = Vec::new();
607     {
608         BitWriter::endian(&mut bytes, LittleEndian)
609             .write_signed(32, std::i32::MAX)
610             .unwrap();
611     }
612     assert_eq!(bytes, std::i32::MAX.to_le_bytes());
613 
614     let mut bytes = Vec::new();
615     {
616         BitWriter::endian(&mut bytes, LittleEndian)
617             .write_signed(32, std::i32::MIN)
618             .unwrap();
619     }
620     assert_eq!(bytes, std::i32::MIN.to_le_bytes());
621 
622     let mut bytes = Vec::new();
623     {
624         BitWriter::endian(&mut bytes, LittleEndian)
625             .write_signed(64, std::i64::MAX)
626             .unwrap();
627     }
628     assert_eq!(bytes, std::i64::MAX.to_le_bytes());
629 
630     let mut bytes = Vec::new();
631     {
632         BitWriter::endian(&mut bytes, LittleEndian)
633             .write_signed(64, std::i64::MIN)
634             .unwrap();
635     }
636     assert_eq!(bytes, std::i64::MIN.to_le_bytes());
637 
638     let mut bytes = Vec::new();
639     {
640         BitWriter::endian(&mut bytes, LittleEndian)
641             .write_signed(128, std::i128::MAX)
642             .unwrap();
643     }
644     assert_eq!(bytes, std::i128::MAX.to_le_bytes());
645 
646     let mut bytes = Vec::new();
647     {
648         BitWriter::endian(&mut bytes, LittleEndian)
649             .write_signed(128, std::i128::MIN)
650             .unwrap();
651     }
652     assert_eq!(bytes, std::i128::MIN.to_le_bytes());
653 }
654 
655 #[test]
test_writer_huffman_le()656 fn test_writer_huffman_le() {
657     use bitstream_io::huffman::compile_write_tree;
658     use bitstream_io::{BitWrite, BitWriter, HuffmanWrite, LittleEndian};
659 
660     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
661     let tree = compile_write_tree(vec![
662         (0, vec![1, 1]),
663         (1, vec![1, 0]),
664         (2, vec![0, 1]),
665         (3, vec![0, 0, 1]),
666         (4, vec![0, 0, 0]),
667     ])
668     .unwrap();
669     let mut w = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
670     w.write_huffman(&tree, 1).unwrap();
671     w.write_huffman(&tree, 3).unwrap();
672     w.write_huffman(&tree, 1).unwrap();
673     w.write_huffman(&tree, 0).unwrap();
674     w.write_huffman(&tree, 2).unwrap();
675     w.write_huffman(&tree, 1).unwrap();
676     w.write_huffman(&tree, 0).unwrap();
677     w.write_huffman(&tree, 0).unwrap();
678     w.write_huffman(&tree, 1).unwrap();
679     w.write_huffman(&tree, 0).unwrap();
680     w.write_huffman(&tree, 1).unwrap();
681     w.write_huffman(&tree, 2).unwrap();
682     w.write_huffman(&tree, 4).unwrap();
683     w.write_huffman(&tree, 3).unwrap();
684     w.write(1, 1).unwrap();
685     assert_eq!(w.into_writer().as_slice(), &final_data);
686 }
687 
688 struct LimitedWriter {
689     can_write: usize,
690 }
691 
692 impl LimitedWriter {
new(max_bytes: usize) -> LimitedWriter693     fn new(max_bytes: usize) -> LimitedWriter {
694         LimitedWriter {
695             can_write: max_bytes,
696         }
697     }
698 }
699 
700 impl std::io::Write for LimitedWriter {
write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error>701     fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
702         use std::cmp::min;
703 
704         let to_write = min(buf.len(), self.can_write);
705         self.can_write -= to_write;
706         Ok(to_write)
707     }
708 
flush(&mut self) -> Result<(), std::io::Error>709     fn flush(&mut self) -> Result<(), std::io::Error> {
710         Ok(())
711     }
712 }
713 
714 #[test]
test_writer_io_errors_be()715 fn test_writer_io_errors_be() {
716     use bitstream_io::{BigEndian, BitWrite, BitWriter};
717     use std::io::ErrorKind;
718 
719     /*individual bits*/
720     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
721     assert!(w.write_bit(true).is_ok());
722     assert!(w.write_bit(false).is_ok());
723     assert!(w.write_bit(true).is_ok());
724     assert!(w.write_bit(true).is_ok());
725     assert!(w.write_bit(false).is_ok());
726     assert!(w.write_bit(false).is_ok());
727     assert!(w.write_bit(false).is_ok());
728     assert!(w.write_bit(true).is_ok());
729     assert!(w.write_bit(true).is_ok());
730     assert!(w.write_bit(true).is_ok());
731     assert!(w.write_bit(true).is_ok());
732     assert!(w.write_bit(false).is_ok());
733     assert!(w.write_bit(true).is_ok());
734     assert!(w.write_bit(true).is_ok());
735     assert!(w.write_bit(false).is_ok());
736     assert_eq!(w.write_bit(true).unwrap_err().kind(), ErrorKind::WriteZero);
737 
738     /*unsigned values*/
739     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
740     assert!(w.write(2, 2u32).is_ok());
741     assert!(w.write(3, 6u32).is_ok());
742     assert!(w.write(5, 7u32).is_ok());
743     assert!(w.write(3, 5u32).is_ok());
744     assert_eq!(
745         w.write(19, 0x53BC1u32).unwrap_err().kind(),
746         ErrorKind::WriteZero
747     );
748 
749     /*signed values*/
750     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
751     assert!(w.write_signed(2, -2).is_ok());
752     assert!(w.write_signed(3, -2).is_ok());
753     assert!(w.write_signed(5, 7).is_ok());
754     assert!(w.write_signed(3, -3).is_ok());
755     assert_eq!(
756         w.write_signed(19, -181311).unwrap_err().kind(),
757         ErrorKind::WriteZero
758     );
759 
760     /*unary 0 values*/
761     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
762     assert!(w.write_unary0(1).is_ok());
763     assert!(w.write_unary0(2).is_ok());
764     assert!(w.write_unary0(0).is_ok());
765     assert!(w.write_unary0(0).is_ok());
766     assert!(w.write_unary0(4).is_ok());
767     assert!(w.write_unary0(2).is_ok());
768     assert_eq!(w.write_unary0(1).unwrap_err().kind(), ErrorKind::WriteZero);
769 
770     /*unary 1 values*/
771     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
772     assert!(w.write_unary1(0).is_ok());
773     assert!(w.write_unary1(1).is_ok());
774     assert!(w.write_unary1(0).is_ok());
775     assert!(w.write_unary1(3).is_ok());
776     assert!(w.write_unary1(0).is_ok());
777     assert!(w.write_unary1(0).is_ok());
778     assert!(w.write_unary1(0).is_ok());
779     assert!(w.write_unary1(1).is_ok());
780     assert!(w.write_unary1(0).is_ok());
781     assert_eq!(w.write_unary1(1).unwrap_err().kind(), ErrorKind::WriteZero);
782 
783     /*byte aligning*/
784     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
785     assert!(w.write::<u16>(9, 0b111111111).is_ok());
786     assert_eq!(w.byte_align().unwrap_err().kind(), ErrorKind::WriteZero);
787 
788     /*aligned bytes*/
789     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
790     assert_eq!(
791         w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
792         ErrorKind::WriteZero
793     );
794 
795     /*un-aligned bytes*/
796     let mut w = BitWriter::endian(LimitedWriter::new(1), BigEndian);
797     assert!(w.write(4, 11).is_ok());
798     assert_eq!(
799         w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
800         ErrorKind::WriteZero
801     );
802 }
803 
804 #[test]
test_writer_io_errors_le()805 fn test_writer_io_errors_le() {
806     use bitstream_io::{BitWrite, BitWriter, LittleEndian};
807     use std::io::ErrorKind;
808 
809     /*individual bits*/
810     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
811     assert!(w.write_bit(true).is_ok());
812     assert!(w.write_bit(false).is_ok());
813     assert!(w.write_bit(false).is_ok());
814     assert!(w.write_bit(false).is_ok());
815     assert!(w.write_bit(true).is_ok());
816     assert!(w.write_bit(true).is_ok());
817     assert!(w.write_bit(false).is_ok());
818     assert!(w.write_bit(true).is_ok());
819     assert!(w.write_bit(true).is_ok());
820     assert!(w.write_bit(false).is_ok());
821     assert!(w.write_bit(true).is_ok());
822     assert!(w.write_bit(true).is_ok());
823     assert!(w.write_bit(false).is_ok());
824     assert!(w.write_bit(true).is_ok());
825     assert!(w.write_bit(true).is_ok());
826     assert_eq!(w.write_bit(true).unwrap_err().kind(), ErrorKind::WriteZero);
827 
828     /*unsigned values*/
829     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
830     assert!(w.write(2, 1u32).is_ok());
831     assert!(w.write(3, 4u32).is_ok());
832     assert!(w.write(5, 13u32).is_ok());
833     assert!(w.write(3, 3u32).is_ok());
834     assert_eq!(
835         w.write(19, 0x609DFu32).unwrap_err().kind(),
836         ErrorKind::WriteZero
837     );
838 
839     /*signed values*/
840     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
841     assert!(w.write_signed(2, 1).is_ok());
842     assert!(w.write_signed(3, -4).is_ok());
843     assert!(w.write_signed(5, 13).is_ok());
844     assert!(w.write_signed(3, 3).is_ok());
845     assert_eq!(
846         w.write_signed(19, -128545).unwrap_err().kind(),
847         ErrorKind::WriteZero
848     );
849 
850     /*unary 0 values*/
851     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
852     assert!(w.write_unary0(1).is_ok());
853     assert!(w.write_unary0(0).is_ok());
854     assert!(w.write_unary0(0).is_ok());
855     assert!(w.write_unary0(2).is_ok());
856     assert!(w.write_unary0(2).is_ok());
857     assert!(w.write_unary0(2).is_ok());
858     assert_eq!(w.write_unary0(5).unwrap_err().kind(), ErrorKind::WriteZero);
859 
860     /*unary 1 values*/
861     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
862     assert!(w.write_unary1(0).is_ok());
863     assert!(w.write_unary1(3).is_ok());
864     assert!(w.write_unary1(0).is_ok());
865     assert!(w.write_unary1(1).is_ok());
866     assert!(w.write_unary1(0).is_ok());
867     assert!(w.write_unary1(1).is_ok());
868     assert!(w.write_unary1(0).is_ok());
869     assert!(w.write_unary1(1).is_ok());
870     assert!(w.write_unary1(0).is_ok());
871     assert_eq!(w.write_unary1(1).unwrap_err().kind(), ErrorKind::WriteZero);
872 
873     /*byte aligning*/
874     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
875     assert!(w.write::<u16>(9, 0b111111111).is_ok());
876     assert_eq!(w.byte_align().unwrap_err().kind(), ErrorKind::WriteZero);
877 
878     /*aligned bytes*/
879     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
880     assert_eq!(
881         w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
882         ErrorKind::WriteZero
883     );
884 
885     /*un-aligned bytes*/
886     let mut w = BitWriter::endian(LimitedWriter::new(1), LittleEndian);
887     assert!(w.write(4, 11).is_ok());
888     assert_eq!(
889         w.write_bytes(b"\xB1\xED").unwrap_err().kind(),
890         ErrorKind::WriteZero
891     );
892 }
893 
894 #[test]
test_writer_bits_errors()895 fn test_writer_bits_errors() {
896     use bitstream_io::{BigEndian, BitWrite, BitWriter, LittleEndian};
897     use std::io::{sink, ErrorKind};
898 
899     let mut w = BitWriter::endian(sink(), BigEndian);
900     assert_eq!(w.write(9, 0u8).unwrap_err().kind(), ErrorKind::InvalidInput);
901     assert_eq!(
902         w.write(17, 0u16).unwrap_err().kind(),
903         ErrorKind::InvalidInput
904     );
905     assert_eq!(
906         w.write(33, 0u32).unwrap_err().kind(),
907         ErrorKind::InvalidInput
908     );
909     assert_eq!(
910         w.write(65, 0u64).unwrap_err().kind(),
911         ErrorKind::InvalidInput
912     );
913 
914     assert_eq!(
915         w.write(1, 0b10).unwrap_err().kind(),
916         ErrorKind::InvalidInput
917     );
918     assert_eq!(
919         w.write(2, 0b100).unwrap_err().kind(),
920         ErrorKind::InvalidInput
921     );
922     assert_eq!(
923         w.write(3, 0b1000).unwrap_err().kind(),
924         ErrorKind::InvalidInput
925     );
926 
927     for bits in 1..8 {
928         let val = 1u8 << bits;
929         assert_eq!(
930             w.write(bits, val).unwrap_err().kind(),
931             ErrorKind::InvalidInput
932         );
933     }
934     for bits in 8..16 {
935         let val = 1u16 << bits;
936         assert_eq!(
937             w.write(bits, val).unwrap_err().kind(),
938             ErrorKind::InvalidInput
939         );
940     }
941     for bits in 16..32 {
942         let val = 1u32 << bits;
943         assert_eq!(
944             w.write(bits, val).unwrap_err().kind(),
945             ErrorKind::InvalidInput
946         );
947     }
948     for bits in 32..64 {
949         let val = 1u64 << bits;
950         assert_eq!(
951             w.write(bits, val).unwrap_err().kind(),
952             ErrorKind::InvalidInput
953         );
954     }
955 
956     assert_eq!(
957         w.write_signed(9, 0i8).unwrap_err().kind(),
958         ErrorKind::InvalidInput
959     );
960     assert_eq!(
961         w.write_signed(17, 0i16).unwrap_err().kind(),
962         ErrorKind::InvalidInput
963     );
964     assert_eq!(
965         w.write_signed(33, 0i32).unwrap_err().kind(),
966         ErrorKind::InvalidInput
967     );
968     assert_eq!(
969         w.write_signed(65, 0i64).unwrap_err().kind(),
970         ErrorKind::InvalidInput
971     );
972 
973     let mut w = BitWriter::endian(sink(), LittleEndian);
974     assert_eq!(w.write(9, 0u8).unwrap_err().kind(), ErrorKind::InvalidInput);
975     assert_eq!(
976         w.write(17, 0u16).unwrap_err().kind(),
977         ErrorKind::InvalidInput
978     );
979     assert_eq!(
980         w.write(33, 0u32).unwrap_err().kind(),
981         ErrorKind::InvalidInput
982     );
983     assert_eq!(
984         w.write(65, 0u64).unwrap_err().kind(),
985         ErrorKind::InvalidInput
986     );
987 
988     assert_eq!(
989         w.write(1, 0b10).unwrap_err().kind(),
990         ErrorKind::InvalidInput
991     );
992     assert_eq!(
993         w.write(2, 0b100).unwrap_err().kind(),
994         ErrorKind::InvalidInput
995     );
996     assert_eq!(
997         w.write(3, 0b1000).unwrap_err().kind(),
998         ErrorKind::InvalidInput
999     );
1000 
1001     for bits in 1..8 {
1002         let val = 1u8 << bits;
1003         assert_eq!(
1004             w.write(bits, val).unwrap_err().kind(),
1005             ErrorKind::InvalidInput
1006         );
1007     }
1008     for bits in 8..16 {
1009         let val = 1u16 << bits;
1010         assert_eq!(
1011             w.write(bits, val).unwrap_err().kind(),
1012             ErrorKind::InvalidInput
1013         );
1014     }
1015     for bits in 16..32 {
1016         let val = 1u32 << bits;
1017         assert_eq!(
1018             w.write(bits, val).unwrap_err().kind(),
1019             ErrorKind::InvalidInput
1020         );
1021     }
1022     for bits in 32..64 {
1023         let val = 1u64 << bits;
1024         assert_eq!(
1025             w.write(bits, val).unwrap_err().kind(),
1026             ErrorKind::InvalidInput
1027         );
1028     }
1029 
1030     assert_eq!(
1031         w.write_signed(9, 0i8).unwrap_err().kind(),
1032         ErrorKind::InvalidInput
1033     );
1034     assert_eq!(
1035         w.write_signed(17, 0i16).unwrap_err().kind(),
1036         ErrorKind::InvalidInput
1037     );
1038     assert_eq!(
1039         w.write_signed(33, 0i32).unwrap_err().kind(),
1040         ErrorKind::InvalidInput
1041     );
1042     assert_eq!(
1043         w.write_signed(65, 0i64).unwrap_err().kind(),
1044         ErrorKind::InvalidInput
1045     );
1046 }
1047 
1048 #[test]
test_counter_be()1049 fn test_counter_be() {
1050     use bitstream_io::{BigEndian, BitCounter, BitWrite};
1051 
1052     /*writing individual bits*/
1053     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1054     w.write_bit(true).unwrap();
1055     w.write_bit(false).unwrap();
1056     w.write_bit(true).unwrap();
1057     w.write_bit(true).unwrap();
1058     w.write_bit(false).unwrap();
1059     w.write_bit(false).unwrap();
1060     w.write_bit(false).unwrap();
1061     w.write_bit(true).unwrap();
1062     w.write_bit(true).unwrap();
1063     w.write_bit(true).unwrap();
1064     w.write_bit(true).unwrap();
1065     w.write_bit(false).unwrap();
1066     w.write_bit(true).unwrap();
1067     w.write_bit(true).unwrap();
1068     w.write_bit(false).unwrap();
1069     w.write_bit(true).unwrap();
1070     assert_eq!(w.written(), 16);
1071 
1072     /*writing unsigned values*/
1073     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1074     assert!(w.byte_aligned());
1075     w.write(2, 2u32).unwrap();
1076     assert!(!w.byte_aligned());
1077     w.write(3, 6u32).unwrap();
1078     assert!(!w.byte_aligned());
1079     w.write(5, 7u32).unwrap();
1080     assert!(!w.byte_aligned());
1081     w.write(3, 5u32).unwrap();
1082     assert!(!w.byte_aligned());
1083     w.write(19, 0x53BC1u32).unwrap();
1084     assert!(w.byte_aligned());
1085     assert_eq!(w.written(), 32);
1086 
1087     /*writing signed values*/
1088     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1089     w.write_signed(2, -2).unwrap();
1090     w.write_signed(3, -2).unwrap();
1091     w.write_signed(5, 7).unwrap();
1092     w.write_signed(3, -3).unwrap();
1093     w.write_signed(19, -181311).unwrap();
1094     assert_eq!(w.written(), 32);
1095 
1096     /*writing unary 0 values*/
1097     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1098     w.write_unary0(1).unwrap();
1099     w.write_unary0(2).unwrap();
1100     w.write_unary0(0).unwrap();
1101     w.write_unary0(0).unwrap();
1102     w.write_unary0(4).unwrap();
1103     w.write_unary0(2).unwrap();
1104     w.write_unary0(1).unwrap();
1105     w.write_unary0(0).unwrap();
1106     w.write_unary0(3).unwrap();
1107     w.write_unary0(4).unwrap();
1108     w.write_unary0(0).unwrap();
1109     w.write_unary0(0).unwrap();
1110     w.write_unary0(0).unwrap();
1111     w.write_unary0(0).unwrap();
1112     w.write(1, 1u32).unwrap();
1113     assert_eq!(w.written(), 32);
1114 
1115     /*writing unary 1 values*/
1116     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1117     w.write_unary1(0).unwrap();
1118     w.write_unary1(1).unwrap();
1119     w.write_unary1(0).unwrap();
1120     w.write_unary1(3).unwrap();
1121     w.write_unary1(0).unwrap();
1122     w.write_unary1(0).unwrap();
1123     w.write_unary1(0).unwrap();
1124     w.write_unary1(1).unwrap();
1125     w.write_unary1(0).unwrap();
1126     w.write_unary1(1).unwrap();
1127     w.write_unary1(2).unwrap();
1128     w.write_unary1(0).unwrap();
1129     w.write_unary1(0).unwrap();
1130     w.write_unary1(1).unwrap();
1131     w.write_unary1(0).unwrap();
1132     w.write_unary1(0).unwrap();
1133     w.write_unary1(0).unwrap();
1134     w.write_unary1(5).unwrap();
1135     assert_eq!(w.written(), 32);
1136 
1137     /*byte aligning*/
1138     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1139     w.write(3, 5u32).unwrap();
1140     w.byte_align().unwrap();
1141     w.write(3, 7u32).unwrap();
1142     w.byte_align().unwrap();
1143     w.byte_align().unwrap();
1144     w.write(8, 59u32).unwrap();
1145     w.byte_align().unwrap();
1146     w.write(4, 12u32).unwrap();
1147     w.byte_align().unwrap();
1148     assert_eq!(w.written(), 32);
1149 
1150     /*writing bytes, aligned*/
1151     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1152     w.write_bytes(b"\xB1\xED").unwrap();
1153     assert_eq!(w.written(), 16);
1154 
1155     /*writing bytes, un-aligned*/
1156     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1157     w.write(4, 11u32).unwrap();
1158     w.write_bytes(b"\xB1\xED").unwrap();
1159     w.byte_align().unwrap();
1160     assert_eq!(w.written(), 24);
1161 }
1162 
1163 #[test]
test_counter_huffman_be()1164 fn test_counter_huffman_be() {
1165     use bitstream_io::huffman::compile_write_tree;
1166     use bitstream_io::{BigEndian, BitCounter, BitWrite, HuffmanWrite};
1167 
1168     let tree = compile_write_tree(vec![
1169         (0, vec![1, 1]),
1170         (1, vec![1, 0]),
1171         (2, vec![0, 1]),
1172         (3, vec![0, 0, 1]),
1173         (4, vec![0, 0, 0]),
1174     ])
1175     .unwrap();
1176     let mut w: BitCounter<u32, BigEndian> = BitCounter::new();
1177     w.write_huffman(&tree, 1).unwrap();
1178     w.write_huffman(&tree, 0).unwrap();
1179     w.write_huffman(&tree, 4).unwrap();
1180     w.write_huffman(&tree, 0).unwrap();
1181     w.write_huffman(&tree, 0).unwrap();
1182     w.write_huffman(&tree, 2).unwrap();
1183     w.write_huffman(&tree, 1).unwrap();
1184     w.write_huffman(&tree, 1).unwrap();
1185     w.write_huffman(&tree, 2).unwrap();
1186     w.write_huffman(&tree, 0).unwrap();
1187     w.write_huffman(&tree, 2).unwrap();
1188     w.write_huffman(&tree, 0).unwrap();
1189     w.write_huffman(&tree, 1).unwrap();
1190     w.write_huffman(&tree, 4).unwrap();
1191     w.write_huffman(&tree, 2).unwrap();
1192     w.byte_align().unwrap();
1193     assert_eq!(w.written(), 32);
1194 }
1195 
1196 #[test]
test_counter_le()1197 fn test_counter_le() {
1198     use bitstream_io::{BitCounter, BitWrite, LittleEndian};
1199 
1200     /*writing individual bits*/
1201     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1202     w.write_bit(true).unwrap();
1203     w.write_bit(false).unwrap();
1204     w.write_bit(false).unwrap();
1205     w.write_bit(false).unwrap();
1206     w.write_bit(true).unwrap();
1207     w.write_bit(true).unwrap();
1208     w.write_bit(false).unwrap();
1209     w.write_bit(true).unwrap();
1210     w.write_bit(true).unwrap();
1211     w.write_bit(false).unwrap();
1212     w.write_bit(true).unwrap();
1213     w.write_bit(true).unwrap();
1214     w.write_bit(false).unwrap();
1215     w.write_bit(true).unwrap();
1216     w.write_bit(true).unwrap();
1217     w.write_bit(true).unwrap();
1218     assert_eq!(w.written(), 16);
1219 
1220     /*writing unsigned values*/
1221     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1222     assert!(w.byte_aligned());
1223     w.write(2, 1u32).unwrap();
1224     assert!(!w.byte_aligned());
1225     w.write(3, 4u32).unwrap();
1226     assert!(!w.byte_aligned());
1227     w.write(5, 13u32).unwrap();
1228     assert!(!w.byte_aligned());
1229     w.write(3, 3u32).unwrap();
1230     assert!(!w.byte_aligned());
1231     w.write(19, 0x609DFu32).unwrap();
1232     assert!(w.byte_aligned());
1233     assert_eq!(w.written(), 32);
1234 
1235     /*writing signed values*/
1236     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1237     w.write_signed(2, 1).unwrap();
1238     w.write_signed(3, -4).unwrap();
1239     w.write_signed(5, 13).unwrap();
1240     w.write_signed(3, 3).unwrap();
1241     w.write_signed(19, -128545).unwrap();
1242     assert_eq!(w.written(), 32);
1243 
1244     /*writing unary 0 values*/
1245     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1246     w.write_unary0(1).unwrap();
1247     w.write_unary0(0).unwrap();
1248     w.write_unary0(0).unwrap();
1249     w.write_unary0(2).unwrap();
1250     w.write_unary0(2).unwrap();
1251     w.write_unary0(2).unwrap();
1252     w.write_unary0(5).unwrap();
1253     w.write_unary0(3).unwrap();
1254     w.write_unary0(0).unwrap();
1255     w.write_unary0(1).unwrap();
1256     w.write_unary0(0).unwrap();
1257     w.write_unary0(0).unwrap();
1258     w.write_unary0(0).unwrap();
1259     w.write_unary0(0).unwrap();
1260     w.write(2, 3u32).unwrap();
1261     assert_eq!(w.written(), 32);
1262 
1263     /*writing unary 1 values*/
1264     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1265     w.write_unary1(0).unwrap();
1266     w.write_unary1(3).unwrap();
1267     w.write_unary1(0).unwrap();
1268     w.write_unary1(1).unwrap();
1269     w.write_unary1(0).unwrap();
1270     w.write_unary1(1).unwrap();
1271     w.write_unary1(0).unwrap();
1272     w.write_unary1(1).unwrap();
1273     w.write_unary1(0).unwrap();
1274     w.write_unary1(0).unwrap();
1275     w.write_unary1(0).unwrap();
1276     w.write_unary1(0).unwrap();
1277     w.write_unary1(1).unwrap();
1278     w.write_unary1(0).unwrap();
1279     w.write_unary1(0).unwrap();
1280     w.write_unary1(2).unwrap();
1281     w.write_unary1(5).unwrap();
1282     w.write_unary1(0).unwrap();
1283     assert_eq!(w.written(), 32);
1284 
1285     /*byte aligning*/
1286     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1287     w.write(3, 5u32).unwrap();
1288     w.byte_align().unwrap();
1289     w.write(3, 7u32).unwrap();
1290     w.byte_align().unwrap();
1291     w.byte_align().unwrap();
1292     w.write(8, 59u32).unwrap();
1293     w.byte_align().unwrap();
1294     w.write(4, 12u32).unwrap();
1295     w.byte_align().unwrap();
1296     assert_eq!(w.written(), 32);
1297 
1298     /*writing bytes, aligned*/
1299     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1300     w.write_bytes(b"\xB1\xED").unwrap();
1301     assert_eq!(w.written(), 16);
1302 
1303     /*writing bytes, un-aligned*/
1304     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1305     w.write(4, 11u32).unwrap();
1306     w.write_bytes(b"\xB1\xED").unwrap();
1307     w.byte_align().unwrap();
1308     assert_eq!(w.written(), 24);
1309 }
1310 
1311 #[test]
test_counter_huffman_le()1312 fn test_counter_huffman_le() {
1313     use bitstream_io::huffman::compile_write_tree;
1314     use bitstream_io::{BitCounter, BitWrite, HuffmanWrite, LittleEndian};
1315 
1316     let tree = compile_write_tree(vec![
1317         (0, vec![1, 1]),
1318         (1, vec![1, 0]),
1319         (2, vec![0, 1]),
1320         (3, vec![0, 0, 1]),
1321         (4, vec![0, 0, 0]),
1322     ])
1323     .unwrap();
1324     let mut w: BitCounter<u32, LittleEndian> = BitCounter::new();
1325     w.write_huffman(&tree, 1).unwrap();
1326     w.write_huffman(&tree, 3).unwrap();
1327     w.write_huffman(&tree, 1).unwrap();
1328     w.write_huffman(&tree, 0).unwrap();
1329     w.write_huffman(&tree, 2).unwrap();
1330     w.write_huffman(&tree, 1).unwrap();
1331     w.write_huffman(&tree, 0).unwrap();
1332     w.write_huffman(&tree, 0).unwrap();
1333     w.write_huffman(&tree, 1).unwrap();
1334     w.write_huffman(&tree, 0).unwrap();
1335     w.write_huffman(&tree, 1).unwrap();
1336     w.write_huffman(&tree, 2).unwrap();
1337     w.write_huffman(&tree, 4).unwrap();
1338     w.write_huffman(&tree, 3).unwrap();
1339     w.write(1, 1).unwrap();
1340     assert_eq!(w.written(), 32);
1341 }
1342 
1343 #[test]
test_recorder_be()1344 fn test_recorder_be() {
1345     use bitstream_io::{BigEndian, BitRecorder, BitWrite, BitWriter};
1346 
1347     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1348 
1349     /*writing individual bits*/
1350     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1351     w.write_bit(true).unwrap();
1352     w.write_bit(false).unwrap();
1353     w.write_bit(true).unwrap();
1354     w.write_bit(true).unwrap();
1355     w.write_bit(false).unwrap();
1356     w.write_bit(false).unwrap();
1357     w.write_bit(false).unwrap();
1358     w.write_bit(true).unwrap();
1359     w.write_bit(true).unwrap();
1360     w.write_bit(true).unwrap();
1361     w.write_bit(true).unwrap();
1362     w.write_bit(false).unwrap();
1363     w.write_bit(true).unwrap();
1364     w.write_bit(true).unwrap();
1365     w.write_bit(false).unwrap();
1366     w.write_bit(true).unwrap();
1367     assert_eq!(w.written(), 16);
1368     let mut w2 = BitWriter::endian(Vec::with_capacity(2), BigEndian);
1369     w.playback(&mut w2).unwrap();
1370     assert_eq!(w2.into_writer().as_slice(), &final_data[0..2]);
1371 
1372     /*writing unsigned values*/
1373     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1374     assert!(w.byte_aligned());
1375     w.write(2, 2u32).unwrap();
1376     assert!(!w.byte_aligned());
1377     w.write(3, 6u32).unwrap();
1378     assert!(!w.byte_aligned());
1379     w.write(5, 7u32).unwrap();
1380     assert!(!w.byte_aligned());
1381     w.write(3, 5u32).unwrap();
1382     assert!(!w.byte_aligned());
1383     w.write(19, 0x53BC1u32).unwrap();
1384     assert!(w.byte_aligned());
1385     assert_eq!(w.written(), 32);
1386     let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1387     w.playback(&mut w2).unwrap();
1388     assert_eq!(w2.into_writer().as_slice(), &final_data);
1389 
1390     /*writing signed values*/
1391     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1392     w.write_signed(2, -2).unwrap();
1393     w.write_signed(3, -2).unwrap();
1394     w.write_signed(5, 7).unwrap();
1395     w.write_signed(3, -3).unwrap();
1396     w.write_signed(19, -181311).unwrap();
1397     assert_eq!(w.written(), 32);
1398     let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1399     w.playback(&mut w2).unwrap();
1400     assert_eq!(w2.into_writer().as_slice(), &final_data);
1401 
1402     /*writing unary 0 values*/
1403     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1404     w.write_unary0(1).unwrap();
1405     w.write_unary0(2).unwrap();
1406     w.write_unary0(0).unwrap();
1407     w.write_unary0(0).unwrap();
1408     w.write_unary0(4).unwrap();
1409     w.write_unary0(2).unwrap();
1410     w.write_unary0(1).unwrap();
1411     w.write_unary0(0).unwrap();
1412     w.write_unary0(3).unwrap();
1413     w.write_unary0(4).unwrap();
1414     w.write_unary0(0).unwrap();
1415     w.write_unary0(0).unwrap();
1416     w.write_unary0(0).unwrap();
1417     w.write_unary0(0).unwrap();
1418     w.write(1, 1u32).unwrap();
1419     assert_eq!(w.written(), 32);
1420     let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1421     w.playback(&mut w2).unwrap();
1422     assert_eq!(w2.into_writer().as_slice(), &final_data);
1423 
1424     /*writing unary 1 values*/
1425     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1426     w.write_unary1(0).unwrap();
1427     w.write_unary1(1).unwrap();
1428     w.write_unary1(0).unwrap();
1429     w.write_unary1(3).unwrap();
1430     w.write_unary1(0).unwrap();
1431     w.write_unary1(0).unwrap();
1432     w.write_unary1(0).unwrap();
1433     w.write_unary1(1).unwrap();
1434     w.write_unary1(0).unwrap();
1435     w.write_unary1(1).unwrap();
1436     w.write_unary1(2).unwrap();
1437     w.write_unary1(0).unwrap();
1438     w.write_unary1(0).unwrap();
1439     w.write_unary1(1).unwrap();
1440     w.write_unary1(0).unwrap();
1441     w.write_unary1(0).unwrap();
1442     w.write_unary1(0).unwrap();
1443     w.write_unary1(5).unwrap();
1444     assert_eq!(w.written(), 32);
1445     let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1446     w.playback(&mut w2).unwrap();
1447     assert_eq!(w2.into_writer().as_slice(), &final_data);
1448 
1449     /*byte aligning*/
1450     let aligned_data = [0xA0, 0xE0, 0x3B, 0xC0];
1451     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1452     w.write(3, 5u32).unwrap();
1453     w.byte_align().unwrap();
1454     w.write(3, 7u32).unwrap();
1455     w.byte_align().unwrap();
1456     w.byte_align().unwrap();
1457     w.write(8, 59u32).unwrap();
1458     w.byte_align().unwrap();
1459     w.write(4, 12u32).unwrap();
1460     w.byte_align().unwrap();
1461     assert_eq!(w.written(), 32);
1462     let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1463     w.playback(&mut w2).unwrap();
1464     assert_eq!(w2.into_writer().as_slice(), &aligned_data);
1465 
1466     /*writing bytes, aligned*/
1467     let final_data = [0xB1, 0xED];
1468     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1469     w.write_bytes(b"\xB1\xED").unwrap();
1470     assert_eq!(w.written(), 16);
1471     let mut w2 = BitWriter::endian(Vec::with_capacity(2), BigEndian);
1472     w.playback(&mut w2).unwrap();
1473     assert_eq!(w2.into_writer().as_slice(), &final_data);
1474 
1475     /*writing bytes, un-aligned*/
1476     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1477     let final_data = [0xBB, 0x1E, 0xD0];
1478     w.write(4, 11u32).unwrap();
1479     w.write_bytes(b"\xB1\xED").unwrap();
1480     w.byte_align().unwrap();
1481     let mut w2 = BitWriter::endian(Vec::with_capacity(3), BigEndian);
1482     w.playback(&mut w2).unwrap();
1483     assert_eq!(w2.into_writer().as_slice(), &final_data);
1484 }
1485 
1486 #[test]
test_recorder_huffman_be()1487 fn test_recorder_huffman_be() {
1488     use bitstream_io::huffman::compile_write_tree;
1489     use bitstream_io::{BigEndian, BitRecorder, BitWrite, BitWriter, HuffmanWrite};
1490 
1491     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1492     let tree = compile_write_tree(vec![
1493         (0, vec![1, 1]),
1494         (1, vec![1, 0]),
1495         (2, vec![0, 1]),
1496         (3, vec![0, 0, 1]),
1497         (4, vec![0, 0, 0]),
1498     ])
1499     .unwrap();
1500     let mut w: BitRecorder<u32, BigEndian> = BitRecorder::new();
1501     w.write_huffman(&tree, 1).unwrap();
1502     w.write_huffman(&tree, 0).unwrap();
1503     w.write_huffman(&tree, 4).unwrap();
1504     w.write_huffman(&tree, 0).unwrap();
1505     w.write_huffman(&tree, 0).unwrap();
1506     w.write_huffman(&tree, 2).unwrap();
1507     w.write_huffman(&tree, 1).unwrap();
1508     w.write_huffman(&tree, 1).unwrap();
1509     w.write_huffman(&tree, 2).unwrap();
1510     w.write_huffman(&tree, 0).unwrap();
1511     w.write_huffman(&tree, 2).unwrap();
1512     w.write_huffman(&tree, 0).unwrap();
1513     w.write_huffman(&tree, 1).unwrap();
1514     w.write_huffman(&tree, 4).unwrap();
1515     w.write_huffman(&tree, 2).unwrap();
1516     w.byte_align().unwrap();
1517     let mut w2 = BitWriter::endian(Vec::with_capacity(4), BigEndian);
1518     w.playback(&mut w2).unwrap();
1519     assert_eq!(w2.into_writer().as_slice(), &final_data);
1520 }
1521 
1522 #[test]
test_recorder_le()1523 fn test_recorder_le() {
1524     use bitstream_io::{BitRecorder, BitWrite, BitWriter, LittleEndian};
1525 
1526     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1527 
1528     /*writing individual bits*/
1529     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1530     w.write_bit(true).unwrap();
1531     w.write_bit(false).unwrap();
1532     w.write_bit(false).unwrap();
1533     w.write_bit(false).unwrap();
1534     w.write_bit(true).unwrap();
1535     w.write_bit(true).unwrap();
1536     w.write_bit(false).unwrap();
1537     w.write_bit(true).unwrap();
1538     w.write_bit(true).unwrap();
1539     w.write_bit(false).unwrap();
1540     w.write_bit(true).unwrap();
1541     w.write_bit(true).unwrap();
1542     w.write_bit(false).unwrap();
1543     w.write_bit(true).unwrap();
1544     w.write_bit(true).unwrap();
1545     w.write_bit(true).unwrap();
1546     assert_eq!(w.written(), 16);
1547     let mut w2 = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
1548     w.playback(&mut w2).unwrap();
1549     assert_eq!(w2.into_writer().as_slice(), &final_data[0..2]);
1550 
1551     /*writing unsigned values*/
1552     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1553     assert!(w.byte_aligned());
1554     w.write(2, 1u32).unwrap();
1555     assert!(!w.byte_aligned());
1556     w.write(3, 4u32).unwrap();
1557     assert!(!w.byte_aligned());
1558     w.write(5, 13u32).unwrap();
1559     assert!(!w.byte_aligned());
1560     w.write(3, 3u32).unwrap();
1561     assert!(!w.byte_aligned());
1562     w.write(19, 0x609DFu32).unwrap();
1563     assert!(w.byte_aligned());
1564     assert_eq!(w.written(), 32);
1565     let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1566     w.playback(&mut w2).unwrap();
1567     assert_eq!(w2.into_writer().as_slice(), &final_data);
1568 
1569     /*writing signed values*/
1570     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1571     w.write_signed(2, 1).unwrap();
1572     w.write_signed(3, -4).unwrap();
1573     w.write_signed(5, 13).unwrap();
1574     w.write_signed(3, 3).unwrap();
1575     w.write_signed(19, -128545).unwrap();
1576     assert_eq!(w.written(), 32);
1577     let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1578     w.playback(&mut w2).unwrap();
1579     assert_eq!(w2.into_writer().as_slice(), &final_data);
1580 
1581     /*writing unary 0 values*/
1582     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1583     w.write_unary0(1).unwrap();
1584     w.write_unary0(0).unwrap();
1585     w.write_unary0(0).unwrap();
1586     w.write_unary0(2).unwrap();
1587     w.write_unary0(2).unwrap();
1588     w.write_unary0(2).unwrap();
1589     w.write_unary0(5).unwrap();
1590     w.write_unary0(3).unwrap();
1591     w.write_unary0(0).unwrap();
1592     w.write_unary0(1).unwrap();
1593     w.write_unary0(0).unwrap();
1594     w.write_unary0(0).unwrap();
1595     w.write_unary0(0).unwrap();
1596     w.write_unary0(0).unwrap();
1597     w.write(2, 3u32).unwrap();
1598     assert_eq!(w.written(), 32);
1599     let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1600     w.playback(&mut w2).unwrap();
1601     assert_eq!(w2.into_writer().as_slice(), &final_data);
1602 
1603     /*writing unary 1 values*/
1604     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1605     w.write_unary1(0).unwrap();
1606     w.write_unary1(3).unwrap();
1607     w.write_unary1(0).unwrap();
1608     w.write_unary1(1).unwrap();
1609     w.write_unary1(0).unwrap();
1610     w.write_unary1(1).unwrap();
1611     w.write_unary1(0).unwrap();
1612     w.write_unary1(1).unwrap();
1613     w.write_unary1(0).unwrap();
1614     w.write_unary1(0).unwrap();
1615     w.write_unary1(0).unwrap();
1616     w.write_unary1(0).unwrap();
1617     w.write_unary1(1).unwrap();
1618     w.write_unary1(0).unwrap();
1619     w.write_unary1(0).unwrap();
1620     w.write_unary1(2).unwrap();
1621     w.write_unary1(5).unwrap();
1622     w.write_unary1(0).unwrap();
1623     assert_eq!(w.written(), 32);
1624     let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1625     w.playback(&mut w2).unwrap();
1626     assert_eq!(w2.into_writer().as_slice(), &final_data);
1627 
1628     /*byte aligning*/
1629     let aligned_data = [0x05, 0x07, 0x3B, 0x0C];
1630     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1631     w.write(3, 5u32).unwrap();
1632     w.byte_align().unwrap();
1633     w.write(3, 7u32).unwrap();
1634     w.byte_align().unwrap();
1635     w.byte_align().unwrap();
1636     w.write(8, 59u32).unwrap();
1637     w.byte_align().unwrap();
1638     w.write(4, 12u32).unwrap();
1639     w.byte_align().unwrap();
1640     assert_eq!(w.written(), 32);
1641     let mut w2 = BitWriter::endian(Vec::with_capacity(4), LittleEndian);
1642     w.playback(&mut w2).unwrap();
1643     assert_eq!(w2.into_writer().as_slice(), &aligned_data);
1644 
1645     /*writing bytes, aligned*/
1646     let final_data = [0xB1, 0xED];
1647     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1648     w.write_bytes(b"\xB1\xED").unwrap();
1649     assert_eq!(w.written(), 16);
1650     let mut w2 = BitWriter::endian(Vec::with_capacity(2), LittleEndian);
1651     w.playback(&mut w2).unwrap();
1652     assert_eq!(w2.into_writer().as_slice(), &final_data);
1653 
1654     /*writing bytes, un-aligned*/
1655     let final_data = [0x1B, 0xDB, 0x0E];
1656     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1657     w.write(4, 11u32).unwrap();
1658     w.write_bytes(b"\xB1\xED").unwrap();
1659     w.byte_align().unwrap();
1660     assert_eq!(w.written(), 24);
1661     let mut w2 = BitWriter::endian(Vec::with_capacity(3), LittleEndian);
1662     w.playback(&mut w2).unwrap();
1663     assert_eq!(w2.into_writer().as_slice(), &final_data);
1664 }
1665 
1666 #[test]
test_recorder_huffman_le()1667 fn test_recorder_huffman_le() {
1668     use bitstream_io::huffman::compile_write_tree;
1669     use bitstream_io::{BitRecorder, BitWrite, BitWriter, HuffmanWrite, LittleEndian};
1670 
1671     let final_data: [u8; 4] = [0xB1, 0xED, 0x3B, 0xC1];
1672     let tree = compile_write_tree(vec![
1673         (0, vec![1, 1]),
1674         (1, vec![1, 0]),
1675         (2, vec![0, 1]),
1676         (3, vec![0, 0, 1]),
1677         (4, vec![0, 0, 0]),
1678     ])
1679     .unwrap();
1680     let mut w: BitRecorder<u32, LittleEndian> = BitRecorder::new();
1681     w.write_huffman(&tree, 1).unwrap();
1682     w.write_huffman(&tree, 3).unwrap();
1683     w.write_huffman(&tree, 1).unwrap();
1684     w.write_huffman(&tree, 0).unwrap();
1685     w.write_huffman(&tree, 2).unwrap();
1686     w.write_huffman(&tree, 1).unwrap();
1687     w.write_huffman(&tree, 0).unwrap();
1688     w.write_huffman(&tree, 0).unwrap();
1689     w.write_huffman(&tree, 1).unwrap();
1690     w.write_huffman(&tree, 0).unwrap();
1691     w.write_huffman(&tree, 1).unwrap();
1692     w.write_huffman(&tree, 2).unwrap();
1693     w.write_huffman(&tree, 4).unwrap();
1694     w.write_huffman(&tree, 3).unwrap();
1695     w.write(1, 1).unwrap();
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