1 // Copyright 2017 Brian Langenberger
2 //
3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6 // option. This file may not be copied, modified, or distributed
7 // except according to those terms.
8 
9 extern crate bitstream_io;
10 use bitstream_io::{BigEndian, BitRead, BitReader, BitWrite, BitWriter, LittleEndian};
11 use std::io::Cursor;
12 
13 macro_rules! define_roundtrip {
14     ($func_name:ident, $endianness:ident) => {
15         #[test]
16         fn $func_name() {
17             /*unsigned values*/
18             for bits in 1..17 {
19                 let max = 1 << bits;
20                 let mut output: Vec<u8> = Vec::with_capacity(max);
21                 {
22                     let mut writer = BitWriter::endian(&mut output, $endianness);
23                     for value in 0..max {
24                         writer.write(bits, value as u32).unwrap();
25                     }
26                     writer.byte_align().unwrap();
27                 }
28                 {
29                     let mut c = Cursor::new(&output);
30                     let mut reader = BitReader::endian(&mut c, $endianness);
31                     for value in 0..max {
32                         assert_eq!(reader.read::<u32>(bits).unwrap(), value as u32);
33                     }
34                 }
35             }
36 
37             /*signed values*/
38             for bits in 2..17 {
39                 let min = -1i32 << (bits - 1);
40                 let max = 1i32 << (bits - 1);
41                 let mut output: Vec<u8> = Vec::with_capacity(max as usize);
42                 {
43                     let mut writer = BitWriter::endian(&mut output, $endianness);
44                     for value in min..max {
45                         writer.write_signed(bits, value as i32).unwrap();
46                     }
47                     writer.byte_align().unwrap();
48                 }
49                 {
50                     let mut c = Cursor::new(&output);
51                     let mut reader = BitReader::endian(&mut c, $endianness);
52                     for value in min..max {
53                         assert_eq!(reader.read_signed::<i32>(bits).unwrap(), value as i32);
54                     }
55                 }
56             }
57         }
58     };
59 }
60 
61 define_roundtrip!(test_roundtrip_be, BigEndian);
62 define_roundtrip!(test_roundtrip_le, LittleEndian);
63 
64 macro_rules! define_unary_roundtrip {
65     ($func_name:ident, $endianness:ident) => {
66         #[test]
67         fn $func_name() {
68             let mut output: Vec<u8> = Vec::new();
69             {
70                 let mut writer = BitWriter::endian(&mut output, $endianness);
71                 for value in 0..1024 {
72                     writer.write_unary0(value).unwrap();
73                 }
74                 writer.byte_align().unwrap();
75             }
76             {
77                 let mut c = Cursor::new(&output);
78                 let mut reader = BitReader::endian(&mut c, $endianness);
79                 for value in 0..1024 {
80                     assert_eq!(reader.read_unary0().unwrap(), value);
81                 }
82             }
83 
84             let mut output: Vec<u8> = Vec::new();
85             {
86                 let mut writer = BitWriter::endian(&mut output, $endianness);
87                 for value in 0..1024 {
88                     writer.write_unary1(value).unwrap();
89                 }
90                 writer.byte_align().unwrap();
91             }
92             {
93                 let mut c = Cursor::new(&output);
94                 let mut reader = BitReader::endian(&mut c, $endianness);
95                 for value in 0..1024 {
96                     assert_eq!(reader.read_unary1().unwrap(), value);
97                 }
98             }
99         }
100     };
101 }
102 
103 define_unary_roundtrip!(test_unary_roundtrip_be, BigEndian);
104 define_unary_roundtrip!(test_unary_roundtrip_le, LittleEndian);
105