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_u8_enc() {
25        let result = (255 as u8).encode_fixed_vec();
26        assert_eq!(result, vec![255]);
27    }
28    #[test]
29    fn test_i8_enc() {
30        let result = (-1 as i8).encode_fixed_vec();
31        assert_eq!(result, vec![255]);
32    }
33    #[test]
34    fn test_i16_enc() {
35        let result = (-32768 as i16).encode_fixed_vec();
36        assert_eq!(result, vec![0, 128]);
37    }
38    #[test]
39    fn test_i32_enc() {
40        let result = (-32767 as i32).encode_fixed_vec();
41        assert_eq!(result, vec![1, 128, 255, 255]);
42    }
43
44    // This must fail to compile:
45    /*
46    fn test() -> &'static [u8] {
47        let int = -32767 as i32;
48        let result = int.encode_fixed_light();
49        assert_eq!(result, &[1, 128, 255, 255]);
50        result
51    }
52    */
53
54    #[test]
55    fn test_i32_enc_light() {
56        let int = -32767 as i32;
57        let result = int.encode_fixed_light();
58        assert_eq!(result, &[1, 128, 255, 255]);
59    }
60    #[test]
61    fn test_all_identity() {
62        let a: u8 = 17;
63        let b: u16 = 17;
64        let c: u32 = 17;
65        let d: u64 = 17;
66        let e: i8 = -17;
67        let f: i16 = -17;
68        let g: i32 = -17;
69        let h: i64 = -17;
70
71        assert_eq!(a, FixedInt::decode_fixed_vec(&a.encode_fixed_vec()));
72        assert_eq!(b, FixedInt::decode_fixed_vec(&b.encode_fixed_vec()));
73        assert_eq!(c, FixedInt::decode_fixed_vec(&c.encode_fixed_vec()));
74        assert_eq!(d, FixedInt::decode_fixed_vec(&d.encode_fixed_vec()));
75        assert_eq!(e, FixedInt::decode_fixed_vec(&e.encode_fixed_vec()));
76        assert_eq!(f, FixedInt::decode_fixed_vec(&f.encode_fixed_vec()));
77        assert_eq!(g, FixedInt::decode_fixed_vec(&g.encode_fixed_vec()));
78        assert_eq!(h, FixedInt::decode_fixed_vec(&h.encode_fixed_vec()));
79
80        assert_eq!(a, FixedInt::decode_fixed(&a.encode_fixed_light()));
81        assert_eq!(b, FixedInt::decode_fixed(&b.encode_fixed_light()));
82        assert_eq!(c, FixedInt::decode_fixed(&c.encode_fixed_light()));
83        assert_eq!(d, FixedInt::decode_fixed(&d.encode_fixed_light()));
84        assert_eq!(e, FixedInt::decode_fixed(&e.encode_fixed_light()));
85        assert_eq!(f, FixedInt::decode_fixed(&f.encode_fixed_light()));
86        assert_eq!(g, FixedInt::decode_fixed(&g.encode_fixed_light()));
87        assert_eq!(h, FixedInt::decode_fixed(&h.encode_fixed_light()));
88    }
89
90    #[test]
91    fn test_reader_writer() {
92        let mut buf = Vec::with_capacity(128);
93
94        let i1: u32 = 123;
95        let i2: u32 = 124;
96        let i3: u32 = 125;
97
98        assert!(buf.write_fixedint(i1).is_ok());
99        assert!(buf.write_fixedint(i2).is_ok());
100        assert!(buf.write_fixedint(i3).is_ok());
101
102        assert_eq!(3 * 4, buf.len());
103
104        let mut reader: &[u8] = buf.as_ref();
105
106        let i1_res = reader.read_fixedint().unwrap();
107        let i2_res = reader.read_fixedint().unwrap();
108        let i3_res = reader.read_fixedint().unwrap();
109
110        assert_eq!(i1, i1_res);
111        assert_eq!(i2, i2_res);
112        assert_eq!(i3, i3_res);
113
114        assert!(reader.read_fixedint::<u32>().is_err());
115    }
116
117    #[should_panic]
118    #[test]
119    fn test_invalid_decode_size() {
120        assert_eq!(33, u64::decode_fixed(&[1, 0, 0, 0, 0, 1]));
121    }
122    #[should_panic]
123    #[test]
124    fn test_invalid_encode_size() {
125        let mut buf = [0 as u8; 4];
126        (11 as u64).encode_fixed(&mut buf);
127    }
128
129    #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
130    #[tokio::test]
131    async fn test_async_reader() {
132        let mut buf = Vec::with_capacity(128);
133
134        let i1: u32 = 1;
135        let i2: u32 = 65532;
136        let i3: u32 = 4200123456;
137        let i4: i64 = i3 as i64 * 1000;
138        let i5: i32 = -32456;
139        let i6: i8 = -128;
140        let i7: u8 = 255;
141
142        buf.write_fixedint_async(i1).await.unwrap();
143        buf.write_fixedint_async(i2).await.unwrap();
144        buf.write_fixedint_async(i3).await.unwrap();
145        buf.write_fixedint_async(i4).await.unwrap();
146        buf.write_fixedint_async(i5).await.unwrap();
147        buf.write_fixedint_async(i6).await.unwrap();
148        buf.write_fixedint_async(i7).await.unwrap();
149
150        let mut reader: &[u8] = buf.as_ref();
151
152        assert_eq!(i1, reader.read_fixedint_async().await.unwrap());
153        assert_eq!(i2, reader.read_fixedint_async().await.unwrap());
154        assert_eq!(i3, reader.read_fixedint_async().await.unwrap());
155        assert_eq!(i4, reader.read_fixedint_async().await.unwrap());
156        assert_eq!(i5, reader.read_fixedint_async().await.unwrap());
157        assert_eq!(i6, reader.read_fixedint_async().await.unwrap());
158        assert_eq!(i7, reader.read_fixedint_async().await.unwrap());
159        assert!(reader.read_fixedint_async::<u32>().await.is_err());
160    }
161}
integer_encoding/fixed_tests.rs

integer_encoding/
fixed_tests.rs
