integer_encoding/
fixed_tests.rs

Help
1#[cfg(test)]
2mod tests {
3    use crate::fixed::FixedInt;
4
5    #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
6    use crate::reader::FixedIntAsyncReader;
7    #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
8    use crate::writer::FixedIntAsyncWriter;
9
10    use crate::reader::FixedIntReader;
11    use crate::writer::FixedIntWriter;
12
13    #[test]
14    fn test_u32_enc() {
15        let result = (32 as u32).encode_fixed_vec();
16        assert_eq!(result, vec![32, 0, 0, 0]);
17    }
18    #[test]
19    fn test_u16_enc() {
20        let result = (256 as u16).encode_fixed_vec();
21        assert_eq!(result, vec![0, 1]);
22    }
23    #[test]
24    fn test_u16_endian() {
25        let le = 1 as u16;
26        let be = le.switch_endianness();
27        assert_eq!(be, 256);
28    }
29    #[test]
30    fn test_u32_endian() {
31        let le = 1 as u32;
32        let be = le.switch_endianness();
33        assert_eq!(be, 1 << 24);
34        assert_eq!(be.switch_endianness(), 1);
35    }
36    #[test]
37    fn test_allones_endian() {
38        assert_eq!(u64::MAX.switch_endianness(), u64::MAX);
39    }
40    #[test]
41    fn test_signed_endian() {
42        // x86: two's complement, LE.
43        let le = -2 as i16;
44        let be = le.switch_endianness();
45        assert_eq!(be, -257);
46    }
47    #[test]
48    fn test_u8_enc() {
49        let result = (255 as u8).encode_fixed_vec();
50        assert_eq!(result, vec![255]);
51    }
52    #[test]
53    fn test_i8_enc() {
54        let result = (-1 as i8).encode_fixed_vec();
55        assert_eq!(result, vec![255]);
56    }
57    #[test]
58    fn test_i16_enc() {
59        let result = (-32768 as i16).encode_fixed_vec();
60        assert_eq!(result, vec![0, 128]);
61    }
62    #[test]
63    fn test_i32_enc() {
64        let result = (-32767 as i32).encode_fixed_vec();
65        assert_eq!(result, vec![1, 128, 255, 255]);
66    }
67
68    // This must fail to compile:
69    /*
70    fn test() -> &'static [u8] {
71        let int = -32767 as i32;
72        let result = int.encode_fixed_light();
73        assert_eq!(result, &[1, 128, 255, 255]);
74        result
75    }
76    */
77
78    #[test]
79    fn test_i32_enc_light() {
80        let int = -32767 as i32;
81        let result = int.encode_fixed_light();
82        assert_eq!(result, [1, 128, 255, 255]);
83    }
84    #[test]
85    fn test_all_identity() {
86        let a: u8 = 17;
87        let b: u16 = 17;
88        let c: u32 = 17;
89        let d: u64 = 17;
90        let e: i8 = -17;
91        let f: i16 = -17;
92        let g: i32 = -17;
93        let h: i64 = -17;
94
95        assert_eq!(a, FixedInt::decode_fixed(&a.encode_fixed_light()).unwrap());
96        assert_eq!(b, FixedInt::decode_fixed(&b.encode_fixed_light()).unwrap());
97        assert_eq!(c, FixedInt::decode_fixed(&c.encode_fixed_light()).unwrap());
98        assert_eq!(d, FixedInt::decode_fixed(&d.encode_fixed_light()).unwrap());
99        assert_eq!(e, FixedInt::decode_fixed(&e.encode_fixed_light()).unwrap());
100        assert_eq!(f, FixedInt::decode_fixed(&f.encode_fixed_light()).unwrap());
101        assert_eq!(g, FixedInt::decode_fixed(&g.encode_fixed_light()).unwrap());
102        assert_eq!(h, FixedInt::decode_fixed(&h.encode_fixed_light()).unwrap());
103    }
104
105    #[test]
106    fn test_reader_writer() {
107        let mut buf = Vec::with_capacity(128);
108
109        let i1: u32 = 123;
110        let i2: u32 = 124;
111        let i3: u32 = 125;
112
113        assert!(buf.write_fixedint(i1).is_ok());
114        assert!(buf.write_fixedint(i2).is_ok());
115        assert!(buf.write_fixedint(i3).is_ok());
116
117        assert_eq!(3 * 4, buf.len());
118
119        let mut reader: &[u8] = buf.as_ref();
120
121        let i1_res = reader.read_fixedint().unwrap();
122        let i2_res = reader.read_fixedint().unwrap();
123        let i3_res = reader.read_fixedint().unwrap();
124
125        assert_eq!(i1, i1_res);
126        assert_eq!(i2, i2_res);
127        assert_eq!(i3, i3_res);
128
129        assert!(reader.read_fixedint::<u32>().is_err());
130    }
131
132    #[should_panic]
133    #[test]
134    fn test_invalid_decode_size() {
135        assert_eq!(33, u64::decode_fixed(&[1, 0, 0, 0, 0, 1]).unwrap());
136    }
137    #[should_panic]
138    #[test]
139    fn test_invalid_encode_size() {
140        let mut buf = [0 as u8; 4];
141        (11 as u64).encode_fixed(&mut buf).unwrap();
142    }
143
144    #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
145    #[tokio::test]
146    async fn test_async_reader() {
147        let mut buf = Vec::with_capacity(128);
148
149        let i1: u32 = 1;
150        let i2: u32 = 65532;
151        let i3: u32 = 4200123456;
152        let i4: i64 = i3 as i64 * 1000;
153        let i5: i32 = -32456;
154        let i6: i8 = -128;
155        let i7: u8 = 255;
156
157        buf.write_fixedint_async(i1).await.unwrap();
158        buf.write_fixedint_async(i2).await.unwrap();
159        buf.write_fixedint_async(i3).await.unwrap();
160        buf.write_fixedint_async(i4).await.unwrap();
161        buf.write_fixedint_async(i5).await.unwrap();
162        buf.write_fixedint_async(i6).await.unwrap();
163        buf.write_fixedint_async(i7).await.unwrap();
164
165        let mut reader: &[u8] = buf.as_ref();
166
167        assert_eq!(i1, reader.read_fixedint_async().await.unwrap());
168        assert_eq!(i2, reader.read_fixedint_async().await.unwrap());
169        assert_eq!(i3, reader.read_fixedint_async().await.unwrap());
170        assert_eq!(i4, reader.read_fixedint_async().await.unwrap());
171        assert_eq!(i5, reader.read_fixedint_async().await.unwrap());
172        assert_eq!(i6, reader.read_fixedint_async().await.unwrap());
173        assert_eq!(i7, reader.read_fixedint_async().await.unwrap());
174        assert!(reader.read_fixedint_async::<u32>().await.is_err());
175    }
176}
integer_encoding/fixed_tests.rs

integer_encoding/
fixed_tests.rs
