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