oficina / docs Public

Download this file

1	pub mod read;
2	pub mod serde;
3	pub mod varint;
4	pub mod write;
5
6	#[cfg(test)]
7	mod 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	}
213