parquet_format_safe/thrift/varint/
mod.rs

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

parquet_format_safe/thrift/varint/
mod.rs
