1pub mod read;
2pub mod serde;
3pub mod varint;
4pub mod write;
5
6#[cfg(test)]
7mod test {
8 use crate::encoding::read::{Cursor, Read};
9 use crate::encoding::write::Write;
10 use crate::Any;
11 use proptest::prelude::*;
12 use proptest_derive::Arbitrary;
13
14 pub fn arb_any() -> impl Strategy<Value = Any> {
15 let leaf = prop_oneof![
16 Just(Any::Null),
17 Just(Any::Undefined),
18 any::<bool>().prop_map(Any::Bool),
19 any::<f64>().prop_map(Any::from),
20 any::<i64>().prop_map(Any::from),
21 any::<String>().prop_map(Any::from),
22 any::<Vec<u8>>().prop_map(Any::from),
23 ]
24 .boxed();
25
26 leaf.prop_recursive(8, 256, 10, |inner| {
27 prop_oneof![
28 prop::collection::vec(inner.clone(), 0..10).prop_map(Any::from),
29 prop::collection::hash_map(".*", inner, 0..10).prop_map(Any::from),
30 ]
31 })
32 }
33
34 proptest! {
35 #[test]
36 fn encoding_any_prop(any in arb_any()) {
37 let mut encoder = Vec::with_capacity(1024);
38 any.encode(&mut encoder);
39 let mut decoder = Cursor::new(encoder.as_slice());
40 let copy = Any::decode(&mut decoder).unwrap();
41 assert_eq!(any, copy);
42 }
43 }
44
45 #[derive(Debug, Arbitrary)]
46 enum EncodingTypes {
47 Byte(u8),
48 Uint8(u8),
49 Uint16(u16),
50 Uint32(u32),
51 Uint32BigEndian(u32),
52 VarUint32(u32),
53 VarUint64(u64),
54 VarUint128(u128),
55 VarUintUsize(usize),
56 VarInt(i64),
57 Buffer(Vec<u8>),
58 VarBuffer(Vec<u8>),
59 VarString(String),
60 Float32(f32),
61 Float64(f64),
62 BigInt64(i64),
63 BigUInt64(u64),
64 #[proptest(strategy = "arb_any().prop_map(EncodingTypes::Any)")]
65 Any(Any),
66 }
67
68 impl EncodingTypes {
69 fn write<W: Write>(&self, encoder: &mut W) {
70 match self {
71 EncodingTypes::Byte(input) => encoder.write_u8(*input),
72 EncodingTypes::Uint8(input) => {
73 encoder.write_u8(*input);
74 }
75 EncodingTypes::Uint16(input) => {
76 encoder.write_u16(*input);
77 }
78 EncodingTypes::Uint32(input) => {
79 encoder.write_u32(*input);
80 }
81 EncodingTypes::Uint32BigEndian(input) => {
82 encoder.write_u32_be(*input);
83 }
84 EncodingTypes::VarUint32(input) => {
85 encoder.write_var(*input);
86 }
87 EncodingTypes::VarUint64(input) => {
88 encoder.write_var(*input);
89 }
90 EncodingTypes::VarUint128(input) => {
91 encoder.write_var(*input);
92 }
93 EncodingTypes::VarUintUsize(input) => {
94 encoder.write_var(*input);
95 }
96 EncodingTypes::VarInt(input) => {
97 encoder.write_var(*input);
98 }
99 EncodingTypes::Buffer(input) => {
100 encoder.write_all(input);
101 }
102 EncodingTypes::VarBuffer(input) => {
103 encoder.write_buf(input);
104 }
105 EncodingTypes::VarString(input) => {
106 encoder.write_string(input);
107 }
108 EncodingTypes::Float32(input) => {
109 encoder.write_f32(*input);
110 }
111 EncodingTypes::Float64(input) => {
112 encoder.write_f64(*input);
113 }
114 EncodingTypes::BigInt64(input) => {
115 encoder.write_i64(*input);
116 }
117 EncodingTypes::BigUInt64(input) => {
118 encoder.write_u64(*input);
119 }
120 EncodingTypes::Any(input) => {
121 input.encode(encoder);
122 }
123 }
124 }
125 fn read(&self, decoder: &mut Cursor) {
126 match self {
127 EncodingTypes::Byte(input) => {
128 let read = decoder.read_u8().unwrap();
129 assert_eq!(read, *input);
130 }
131 EncodingTypes::Uint8(input) => {
132 let read = decoder.read_u8().unwrap();
133 assert_eq!(read, *input);
134 }
135 EncodingTypes::Uint16(input) => {
136 let read = decoder.read_u16().unwrap();
137 assert_eq!(read, *input);
138 }
139 EncodingTypes::Uint32(input) => {
140 let read = decoder.read_u32().unwrap();
141 assert_eq!(read, *input);
142 }
143 EncodingTypes::Uint32BigEndian(input) => {
144 let read = decoder.read_u32_be().unwrap();
145 assert_eq!(read, *input);
146 }
147 EncodingTypes::VarUint32(input) => {
148 let read: u32 = decoder.read_var().unwrap();
149 assert_eq!(read, *input);
150 }
151 EncodingTypes::VarUint64(input) => {
152 let read: u64 = decoder.read_var().unwrap();
153 assert_eq!(read, *input);
154 }
155 EncodingTypes::VarUint128(input) => {
156 let read: u128 = decoder.read_var().unwrap();
157 assert_eq!(read, *input);
158 }
159 EncodingTypes::VarUintUsize(input) => {
160 let read: usize = decoder.read_var().unwrap();
161 assert_eq!(read, *input);
162 }
163 EncodingTypes::VarInt(input) => {
164 let read = decoder.read_var::<i64>().unwrap();
165 assert_eq!(read, *input);
166 }
167 EncodingTypes::Buffer(input) => {
168 let read = decoder.read_exact(input.len()).unwrap();
169 assert_eq!(read, *input);
170 }
171 EncodingTypes::VarBuffer(input) => {
172 let read = decoder.read_buf().unwrap();
173 assert_eq!(read, *input);
174 }
175 EncodingTypes::VarString(input) => {
176 let read = decoder.read_string().unwrap();
177 assert_eq!(read, *input);
178 }
179 EncodingTypes::Float32(input) => {
180 let read = decoder.read_f32().unwrap();
181 assert_eq!(read, *input);
182 }
183 EncodingTypes::Float64(input) => {
184 let read = decoder.read_f64().unwrap();
185 assert_eq!(read, *input);
186 }
187 EncodingTypes::BigInt64(input) => {
188 let read = decoder.read_i64().unwrap();
189 assert_eq!(read, *input);
190 }
191 EncodingTypes::BigUInt64(input) => {
192 let read = decoder.read_u64().unwrap();
193 assert_eq!(read, *input);
194 }
195 EncodingTypes::Any(input) => {
196 let read = Any::decode(decoder).unwrap();
197 assert_eq!(read, *input);
198 }
199 }
200 }
201 }
202
203 proptest! {
204 #[test]
205 fn encoding_prop(val: EncodingTypes) {
206 let mut encoder = Vec::new();
207 val.write(&mut encoder);
208 let mut decoder = Cursor::new(encoder.as_slice());
209 val.read(&mut decoder)
210 }
211 }
212}