1#[cfg(test)]
2mod tests {
3 #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
4 use crate::reader::VarIntAsyncReader;
5 #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
6 use crate::writer::VarIntAsyncWriter;
7
8 use crate::reader::VarIntReader;
9 use crate::varint::VarInt;
10 use crate::writer::VarIntWriter;
11
12 #[test]
13 fn test_required_space() {
14 assert_eq!((0 as u32).required_space(), 1);
15 assert_eq!((1 as u32).required_space(), 1);
16 assert_eq!((128 as u32).required_space(), 2);
17 assert_eq!((16384 as u32).required_space(), 3);
18 assert_eq!((2097151 as u32).required_space(), 3);
19 assert_eq!((2097152 as u32).required_space(), 4);
20 }
21
22 #[test]
23 fn test_encode_u64() {
24 assert_eq!((0 as u32).encode_var_vec(), vec![0b00000000]);
25 assert_eq!((300 as u32).encode_var_vec(), vec![0b10101100, 0b00000010]);
26 }
27
28 #[test]
29 fn test_identity_u64() {
30 for i in 1 as u64..100 {
31 assert_eq!(
32 u64::decode_var(i.encode_var_vec().as_slice()).unwrap(),
33 (i, 1)
34 );
35 }
36 for i in 16400 as u64..16500 {
37 assert_eq!(
38 u64::decode_var(&i.encode_var_vec().as_slice()).unwrap(),
39 (i, 3)
40 );
41 }
42 }
43
44 #[test]
45 fn test_decode_max_u64() {
46 let max_vec_encoded = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01];
47 assert_eq!(
48 u64::decode_var(max_vec_encoded.as_slice()).unwrap().0,
49 u64::max_value()
50 );
51 }
52
53 #[test]
54 fn test_encode_i64() {
55 assert_eq!((0 as i64).encode_var_vec(), (0 as u32).encode_var_vec());
56 assert_eq!((150 as i64).encode_var_vec(), (300 as u32).encode_var_vec());
57 assert_eq!(
58 (-150 as i64).encode_var_vec(),
59 (299 as u32).encode_var_vec()
60 );
61 assert_eq!(
62 (-2147483648 as i64).encode_var_vec(),
63 (4294967295 as u64).encode_var_vec()
64 );
65 assert_eq!(
66 (i64::max_value() as i64).encode_var_vec(),
67 &[0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]
68 );
69 assert_eq!(
70 (i64::min_value() as i64).encode_var_vec(),
71 &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]
72 );
73 }
74
75 #[test]
76 fn test_decode_min_i64() {
77 let min_vec_encoded = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01];
78 assert_eq!(
79 i64::decode_var(min_vec_encoded.as_slice()).unwrap().0,
80 i64::min_value()
81 );
82 }
83
84 #[test]
85 fn test_decode_max_i64() {
86 let max_vec_encoded = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01];
87 assert_eq!(
88 i64::decode_var(max_vec_encoded.as_slice()).unwrap().0,
89 i64::max_value()
90 );
91 }
92
93 #[test]
94 fn test_encode_i16() {
95 assert_eq!((150 as i16).encode_var_vec(), (300 as u32).encode_var_vec());
96 assert_eq!(
97 (-150 as i16).encode_var_vec(),
98 (299 as u32).encode_var_vec()
99 );
100 }
101
102 #[test]
103 fn test_reader_writer() {
104 let mut buf = Vec::with_capacity(128);
105
106 let i1: u32 = 1;
107 let i2: u32 = 65532;
108 let i3: u32 = 4200123456;
109 let i4: i64 = i3 as i64 * 1000;
110 let i5: i32 = -32456;
111
112 assert!(buf.write_varint(i1).is_ok());
113 assert!(buf.write_varint(i2).is_ok());
114 assert!(buf.write_varint(i3).is_ok());
115 assert!(buf.write_varint(i4).is_ok());
116 assert!(buf.write_varint(i5).is_ok());
117
118 let mut reader: &[u8] = buf.as_ref();
119
120 assert_eq!(i1, reader.read_varint().unwrap());
121 assert_eq!(i2, reader.read_varint().unwrap());
122 assert_eq!(i3, reader.read_varint().unwrap());
123 assert_eq!(i4, reader.read_varint().unwrap());
124 assert_eq!(i5, reader.read_varint().unwrap());
125
126 assert!(reader.read_varint::<u32>().is_err());
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
140 buf.write_varint_async(i1).await.unwrap();
141 buf.write_varint_async(i2).await.unwrap();
142 buf.write_varint_async(i3).await.unwrap();
143 buf.write_varint_async(i4).await.unwrap();
144 buf.write_varint_async(i5).await.unwrap();
145
146 let mut reader: &[u8] = buf.as_ref();
147
148 assert_eq!(i1, reader.read_varint_async().await.unwrap());
149 assert_eq!(i2, reader.read_varint_async().await.unwrap());
150 assert_eq!(i3, reader.read_varint_async().await.unwrap());
151 assert_eq!(i4, reader.read_varint_async().await.unwrap());
152 assert_eq!(i5, reader.read_varint_async().await.unwrap());
153 assert!(reader.read_varint_async::<u32>().await.is_err());
154 }
155
156 #[test]
157 fn test_unterminated_varint() {
158 let buf = vec![0xff as u8; 12];
159 let mut read = buf.as_slice();
160 assert!(read.read_varint::<u64>().is_err());
161 }
162
163 #[test]
164 fn test_unterminated_varint_2() {
165 let buf = [0xff, 0xff];
166 let mut read = &buf[..];
167 assert!(read.read_varint::<u64>().is_err());
168 }
169
170 #[test]
171 fn test_decode_extra_bytes_u64() {
172 let mut encoded = 0x12345u64.encode_var_vec();
173 assert_eq!(u64::decode_var(&encoded[..]), Some((0x12345, 3)));
174
175 encoded.push(0x99);
176 assert_eq!(u64::decode_var(&encoded[..]), Some((0x12345, 3)));
177
178 let encoded = [0xFF, 0xFF, 0xFF];
179 assert_eq!(u64::decode_var(&encoded[..]), None);
180
181 let mut encoded = vec![0xFF; 64];
183 encoded.push(0x00);
184 assert_eq!(u64::decode_var(&encoded[..]), None);
185 }
186
187 #[test]
188 fn test_decode_extra_bytes_i64() {
189 let mut encoded = (-0x12345i64).encode_var_vec();
190 assert_eq!(i64::decode_var(&encoded[..]), Some((-0x12345, 3)));
191
192 encoded.push(0x99);
193 assert_eq!(i64::decode_var(&encoded[..]), Some((-0x12345, 3)));
194
195 let encoded = [0xFF, 0xFF, 0xFF];
196 assert_eq!(i64::decode_var(&encoded[..]), None);
197
198 let mut encoded = vec![0xFF; 64];
200 encoded.push(0x00);
201 assert_eq!(i64::decode_var(&encoded[..]), None);
202 }
203
204 #[test]
205 fn test_regression_22() {
206 let encoded: Vec<u8> = (0x112233 as u64).encode_var_vec();
207 assert_eq!(
208 encoded.as_slice().read_varint::<i8>().unwrap_err().kind(),
209 std::io::ErrorKind::InvalidData
210 );
211 }
212}