1 // Copyright 2019 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Read what you wrote.
16 use flexbuffers::*;
17 #[cfg(not(miri))] // slow.
18 use quickcheck;
19 use serde::{Deserialize, Serialize};
20
21 // TODO(cneo): Upstream this to the quickcheck crate. Also, write a macro to derive Arbitrary.
22 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Serialize, Deserialize)]
23 pub struct NonNullString(String);
24 impl quickcheck::Arbitrary for NonNullString {
arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self25 fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self {
26 let size = std::cmp::min(1, usize::arbitrary(g));
27 NonNullString(
28 (0..)
29 .map(|_| <char>::arbitrary(g))
30 .filter(|&b| b != '\0')
31 .take(size)
32 .collect(),
33 )
34 }
35 }
36
37 #[cfg(not(miri))] // slow.
38 quickcheck! {
39 fn qc_vec_bool(xs: Vec<bool>) -> bool {
40 let mut builder = Builder::default();
41 let mut v = builder.start_vector();
42 for &x in &xs {
43 v.push(x);
44 }
45 v.end_vector();
46 let r = Reader::get_root(builder.view()).unwrap().as_vector();
47 xs.iter().enumerate().all(|(i, &x)| r.index(i).unwrap().get_bool().unwrap() == x)
48 }
49 fn qc_vec_uint(xs: Vec<u64>) -> bool {
50 let mut builder = Builder::default();
51 let mut v = builder.start_vector();
52 for &x in &xs {
53 v.push(x);
54 }
55 v.end_vector();
56 let r = Reader::get_root(builder.view()).unwrap().as_vector();
57 xs.iter().enumerate().all(|(i, &x)| r.idx(i).as_u64() == x)
58 }
59 fn qc_vec_int(xs: Vec<i64>) -> bool {
60 let mut builder = Builder::default();
61 let mut v = builder.start_vector();
62 for &x in &xs {
63 v.push(x);
64 }
65 v.end_vector();
66 let r = Reader::get_root(builder.view()).unwrap().as_vector();
67 xs.iter().enumerate().all(|(i, &x)| r.idx(i).as_i64() == x)
68 }
69 fn qc_vec_float(xs: Vec<f64>) -> bool {
70 let mut builder = Builder::default();
71 let mut v = builder.start_vector();
72 for &x in &xs {
73 v.push(x);
74 }
75 v.end_vector();
76 let r = Reader::get_root(builder.view()).unwrap().as_vector();
77 xs.iter().enumerate().all(|(i, &x)| (r.idx(i).as_f64() - x).abs() < std::f64::EPSILON)
78 }
79 fn qc_vec_string(xs: Vec<String>) -> bool {
80 let mut builder = Builder::default();
81 let mut v = builder.start_vector();
82 for x in &xs {
83 v.push(x as &str);
84 }
85 v.end_vector();
86 let r = Reader::get_root(builder.view()).unwrap().as_vector();
87 xs.iter().enumerate().all(|(i, x)| (r.idx(i).as_str() == x))
88 }
89 fn qc_map_int(xs: std::collections::BTreeMap<NonNullString, i64>) -> bool {
90 let mut builder = Builder::default();
91 let mut m = builder.start_map();
92 for (k, &v) in &xs {
93 m.push(&k.0, v);
94 }
95 m.end_map();
96 let r = Reader::get_root(builder.view()).unwrap().as_map();
97 xs.iter().enumerate().all(|(i, (k, &v))| {
98 r.idx(i).as_i64() == v && r.idx(k.0.as_str()).as_i64() == v
99 })
100 }
101 fn qc_map_string(xs: std::collections::BTreeMap<NonNullString, String>) -> bool {
102 let mut builder = Builder::default();
103 let mut m = builder.start_map();
104 for (k, v) in &xs {
105 m.push(&k.0, v as &str);
106 }
107 m.end_map();
108 let r = Reader::get_root(builder.view()).unwrap().as_map();
109 xs.iter().enumerate().all(|(i, (k, v))| {
110 r.idx(i).as_str() == v && r.idx(k.0.as_str()).as_str() == v
111 })
112 }
113 fn qc_blob(xs: Vec<Vec<u8>>) -> bool {
114 let mut builder = Builder::default();
115 let mut v = builder.start_vector();
116 for x in &xs {
117 v.push(Blob(x.as_ref()));
118 }
119 v.end_vector();
120 let r = Reader::get_root(builder.view()).unwrap().as_vector();
121 xs.iter().enumerate().all(
122 |(i, x)| r.idx(i).get_blob().unwrap().0.iter().eq(x.iter())
123 )
124 }
125 fn qc_serde_ints(
126 u8s: Vec<u8>,
127 u16s: Vec<u16>,
128 u32s: Vec<u32>,
129 u64s: Vec<u64>,
130 i8s: Vec<i8>,
131 i16s: Vec<i16>,
132 i32s: Vec<i32>,
133 i64s: Vec<i64>
134 ) -> bool {
135 #[derive(Serialize, Deserialize, PartialEq)]
136 struct Foo {
137 u8s: Vec<u8>,
138 u16s: Vec<u16>,
139 u32s: Vec<u32>,
140 u64s: Vec<u64>,
141 i8s: Vec<i8>,
142 i16s: Vec<i16>,
143 i32s: Vec<i32>,
144 i64s: Vec<i64>,
145 }
146 let mut ser = FlexbufferSerializer::new();
147 let foo1 = Foo { u8s, u16s, u32s, u64s, i8s, i16s, i32s, i64s };
148 foo1.serialize(&mut ser).unwrap();
149 let r = Reader::get_root(ser.view()).unwrap();
150 let foo2 = Foo::deserialize(r).unwrap();
151 foo1 == foo2
152 }
153 fn qc_serde_others(
154 bools: Vec<bool>,
155 strings: Vec<String>,
156 f32s: Vec<f32>,
157 f64s: Vec<f64>
158 ) -> bool {
159 #[derive(Serialize, Deserialize, PartialEq)]
160 struct Foo {
161 bools: Vec<bool>,
162 strings: Vec<String>,
163 f32s: Vec<f32>,
164 f64s: Vec<f64>,
165 }
166 let mut ser = FlexbufferSerializer::new();
167 let foo1 = Foo { bools, strings, f32s, f64s };
168 foo1.serialize(&mut ser).unwrap();
169 let r = Reader::get_root(ser.view()).unwrap();
170 let foo2 = Foo::deserialize(r).unwrap();
171 foo1 == foo2
172 }
173 fn qc_serde_others2(
174 bools: Vec<bool>,
175 strings: Vec<String>,
176 f32s: Vec<f32>,
177 f64s: Vec<f64>
178 ) -> bool {
179 #[derive(Serialize, Deserialize, PartialEq)]
180 struct Foo (Vec<bool>, Vec<String>, Vec<f32>, Vec<f64>);
181 let mut ser = FlexbufferSerializer::new();
182 let foo1 = Foo(bools, strings, f32s, f64s);
183 foo1.serialize(&mut ser).unwrap();
184 let r = Reader::get_root(ser.view()).unwrap();
185 let foo2 = Foo::deserialize(r).unwrap();
186 foo1 == foo2
187 }
188
189 }
190
191 #[test]
empty_vectors()192 fn empty_vectors() {
193 #[derive(PartialEq, Serialize, Deserialize, Default, Debug)]
194 struct Foo(Vec<u8>, Vec<i8>);
195 let foo1 = Foo::default();
196 let mut s = FlexbufferSerializer::new();
197 foo1.serialize(&mut s).unwrap();
198 dbg!(s.view());
199 let r = Reader::get_root(s.view()).unwrap();
200 let foo2 = Foo::deserialize(r).unwrap();
201 assert_eq!(foo1, foo2);
202 }
203
204 #[test]
string()205 fn string() {
206 let mut builder = Builder::default();
207 let mut v = builder.start_vector();
208 v.push("foo");
209 v.push("barrr");
210 v.push("bazzzzzz");
211 v.end_vector();
212 let r = Reader::get_root(builder.view()).unwrap().as_vector();
213 assert_eq!(r.idx(0).as_str(), "foo");
214 assert_eq!(r.idx(1).as_str(), "barrr");
215 assert_eq!(r.idx(2).as_str(), "bazzzzzz");
216 }
217
218 #[test]
store_13()219 fn store_13() {
220 let finished = singleton::<i32>(13);
221 let r = Reader::get_root(finished.as_ref()).unwrap();
222 assert_eq!(r.as_i32(), 13);
223 }
224 #[test]
singleton_vector_uint_4_16bit()225 fn singleton_vector_uint_4_16bit() {
226 let mut builder = Builder::default();
227 let mut v = builder.start_vector();
228 v.push(2u8);
229 v.push(3u8);
230 v.push(5u8);
231 v.end_vector();
232 let buf1 = builder.view();
233 let buf2 = singleton(&[2u8, 3, 5]);
234 assert_eq!(buf1, buf2.as_slice());
235
236 let r = Reader::get_root(buf1).unwrap().as_vector();
237 assert_eq!(r.idx(0).get_u64(), Ok(2));
238 assert_eq!(r.idx(1).get_u64(), Ok(3));
239 assert_eq!(r.idx(2).get_u64(), Ok(5));
240 assert_eq!(r.index(3).unwrap_err(), ReaderError::IndexOutOfBounds);
241 }
242 #[test]
vector_uint4()243 fn vector_uint4() {
244 let mut fxb = Builder::default();
245 let mut v = fxb.start_vector();
246 v.push(2u8);
247 v.push(3u8);
248 v.push(5u8);
249 v.push(7u8);
250 v.end_vector();
251 let r = Reader::get_root(fxb.view()).unwrap();
252 let v = r.as_vector();
253 assert_eq!(v.idx(0).get_u64(), Ok(2));
254 assert_eq!(v.idx(1).get_u64(), Ok(3));
255 assert_eq!(v.idx(2).get_u64(), Ok(5));
256 assert_eq!(v.idx(3).get_u64(), Ok(7));
257 assert!(v.index(4).is_err());
258 #[allow(deprecated)]
259 #[cfg(target_endian = "little")]
260 {
261 assert_eq!(r.get_slice::<u8>().unwrap(), [2, 3, 5, 7]);
262 }
263 }
264 #[test]
store_and_read_blob()265 fn store_and_read_blob() {
266 let mut fxb = Builder::default();
267 let mut v = fxb.start_vector();
268 v.push(Blob([1, 2, 3, 4].as_ref()));
269 v.push(Blob([5, 6, 7].as_ref()));
270 v.end_vector();
271
272 let r = Reader::get_root(fxb.view()).unwrap().as_vector();
273 assert_eq!(r.idx(0).get_blob(), Ok(Blob([1, 2, 3, 4].as_ref())));
274 assert_eq!(r.idx(1).get_blob(), Ok(Blob([5, 6, 7].as_ref())));
275 }
276 #[test]
map_64bit()277 fn map_64bit() {
278 let mut fxb = Builder::default();
279 let mut m = fxb.start_map();
280 m.push("a", 257u16);
281 m.push("b", u64::max_value() - 3);
282 m.end_map();
283
284 let r = Reader::get_root(fxb.view()).unwrap().as_map();
285 assert_eq!(r.idx("a").as_u16(), 257);
286 assert_eq!(r.idx("b").as_u64(), u64::max_value() - 3);
287 }
288 #[test]
index_map()289 fn index_map() {
290 let mut fxb = Builder::default();
291 let mut m = fxb.start_map();
292 m.push("foo", 17u8);
293 m.push("bar", 33u16);
294 m.push("baz", 41u32);
295 m.end_map();
296
297 let r = Reader::get_root(fxb.view()).unwrap().as_map();
298 assert_eq!(r.idx(0).get_u64(), Ok(33));
299 assert_eq!(r.idx(1).get_u64(), Ok(41));
300 assert_eq!(r.idx(2).as_u8(), 17);
301 assert_eq!(r.index(3).unwrap_err(), ReaderError::IndexOutOfBounds);
302
303 assert_eq!(r.idx("bar").as_u64(), 33);
304 assert_eq!(r.idx("baz").as_u32(), 41);
305 assert_eq!(r.idx("foo").as_u16(), 17);
306 assert_eq!(r.index("???").unwrap_err(), ReaderError::KeyNotFound);
307 }
308
309 #[test]
map_strings()310 fn map_strings() {
311 let mut fxb = Builder::default();
312 {
313 let mut m = fxb.start_map();
314 let mut a = m.start_vector("a");
315 for &s in ["b", "c", "d", "e"].iter() {
316 a.push(s);
317 }
318 a.end_vector();
319 let mut f = m.start_vector("f");
320 for &s in ["gh", "ij"].iter() {
321 f.push(s);
322 }
323 }
324 let r = Reader::get_root(fxb.view()).unwrap().as_map();
325 let a = r.idx("a").as_vector();
326
327 assert_eq!(a.idx(0).as_str(), "b");
328 assert_eq!(a.idx(1).as_str(), "c");
329 assert_eq!(a.idx(2).as_str(), "d");
330 assert_eq!(a.idx(3).as_str(), "e");
331
332 let f = r.idx("f").as_vector();
333 assert_eq!(f.idx(0).as_str(), "gh");
334 assert_eq!(f.idx(1).as_str(), "ij");
335
336 // Defaults to empty string for index errors.
337 assert_eq!(r.idx("a").as_vector().idx(4).as_str(), "");
338 assert_eq!(r.idx("b").as_vector().idx(2).as_str(), "");
339 assert_eq!(r.idx("c").as_str(), "");
340 }
341
342 #[test]
store_u64()343 fn store_u64() {
344 let finished = singleton(u64::max_value() - 10);
345 let r = Reader::get_root(finished.as_ref()).unwrap();
346 assert_eq!(r.get_u64(), Ok(u64::max_value() - 10));
347 }
348 #[test]
store_indirects()349 fn store_indirects() {
350 let mut b = Builder::default();
351 let mut v = b.start_vector();
352 v.push(IndirectInt(-42));
353 v.push(IndirectUInt(9000));
354 v.push(IndirectFloat(3.14));
355 v.end_vector();
356 let r = Reader::get_root(b.view()).unwrap().as_vector();
357 assert_eq!(r.idx(0).get_i64().unwrap(), -42);
358 assert_eq!(r.idx(1).get_u64().unwrap(), 9000);
359 assert_eq!(r.idx(2).get_f64().unwrap(), 3.14);
360 }
361
362 #[derive(Serialize, Deserialize, Debug, PartialEq)]
363 struct Foo {
364 a: i8,
365 b: f64,
366 c: Vec<u32>,
367 d: String,
368 }
369
370 #[cfg(not(miri))] // slow.
371 quickcheck! {
372 fn serde_foo(a: i8,
373 b: f64,
374 c: Vec<u32>,
375 d: String) -> bool {
376 let mut s = FlexbufferSerializer::new();
377 let data = Foo { a, b, c, d };
378 data.serialize(&mut s).unwrap();
379
380 let read = Foo::deserialize(Reader::get_root(s.view()).unwrap()).unwrap();
381 data == read
382 }
383 }
384
385 #[test]
serde_serious()386 fn serde_serious() {
387 #[derive(Debug, PartialEq, Serialize, Deserialize)]
388 enum MyEnum {
389 Unit,
390 NewType([i32; 3]),
391 Tuple(f32, f64),
392 Struct { a: u8, b: u16, c: u32 },
393 }
394 #[derive(Debug, PartialEq, Serialize, Deserialize)]
395 struct MyNewType;
396
397 #[derive(Debug, PartialEq, Serialize, Deserialize)]
398 struct MyStruct {
399 a: u8,
400 b: u16,
401 c: u32,
402 d: u64,
403 }
404
405 #[derive(Debug, PartialEq, Serialize, Deserialize)]
406 struct MyUnitStruct(Vec<String>);
407
408 #[derive(Debug, PartialEq, Serialize, Deserialize)]
409 struct MyTupleStruct(MyNewType, MyUnitStruct, MyStruct, Vec<MyEnum>);
410
411 let data = MyTupleStruct(
412 MyNewType,
413 MyUnitStruct(vec!["Hello".to_string(), "World".to_string()]),
414 MyStruct {
415 a: 2,
416 b: 4,
417 c: 8,
418 d: 16,
419 },
420 vec![
421 MyEnum::Unit,
422 MyEnum::NewType([-1, 0, 1]),
423 MyEnum::Unit,
424 MyEnum::Tuple(3.14, 2.71),
425 MyEnum::Struct {
426 a: 32,
427 b: 64,
428 c: 128,
429 },
430 ],
431 );
432
433 let mut s = FlexbufferSerializer::new();
434 data.serialize(&mut s).unwrap();
435
436 let reader = Reader::get_root(s.view()).unwrap();
437 let read = MyTupleStruct::deserialize(reader).unwrap();
438 assert_eq!(data, read);
439 }
440 #[test]
serialize_serde_with_bytes_as_blob()441 fn serialize_serde_with_bytes_as_blob() {
442 #[derive(Serialize, Deserialize)]
443 struct Foo(#[serde(with = "serde_bytes")] Vec<u8>);
444 let mut s = FlexbufferSerializer::new();
445 Foo(vec![5, 6, 7, 8]).serialize(&mut s).unwrap();
446 let reader = Reader::get_root(s.view()).unwrap();
447 assert_eq!(reader.flexbuffer_type(), FlexBufferType::Blob);
448 assert_eq!(reader.as_blob(), Blob([5, 6, 7, 8].as_ref()));
449 }
450 #[test]
iter()451 fn iter() {
452 let mut fxb = Builder::default();
453 {
454 let mut m = fxb.start_map();
455 m.push("a", "42");
456 m.push("b", 250i64);
457 m.push("c", 5000u16);
458 }
459 let r = Reader::get_root(fxb.view()).unwrap();
460
461 let v: Vec<u32> = r.as_vector().iter().map(|x| x.as_u32()).collect();
462 assert_eq!(&v, &[42, 250, 5000]);
463 }
464
465 #[test]
deserialize_newtype_i8()466 fn deserialize_newtype_i8() {
467 #[derive(Deserialize)]
468 struct Foo(u8);
469 let data = [13, 4, 1];
470 let r = Reader::get_root(data.as_ref()).unwrap();
471 let foo = Foo::deserialize(r).unwrap();
472 assert_eq!(foo.0, 13);
473 }
474 #[test]
deserialize_newtype_str()475 fn deserialize_newtype_str() {
476 #[derive(Deserialize)]
477 struct Foo<'a>(&'a str);
478 let data = [5, b'h', b'e', b'l', b'l', b'o', b'\0', 6, 5 << 2, 1];
479 let r = Reader::get_root(data.as_ref()).unwrap();
480 let foo = Foo::deserialize(r).unwrap();
481 assert_eq!(foo.0, "hello");
482 }
483 #[test]
484 #[rustfmt::skip]
deserialize_tuple_struct_to_vec_uint4()485 fn deserialize_tuple_struct_to_vec_uint4() {
486 #[derive(Deserialize)]
487 struct Foo(u8, u16, u32, u64);
488 let data = [
489 4, 0, 16, 0, 64, 0, 0, 1, // Data
490 8, // Vector offset.
491 23 << 2 | 1, // (VectorUInt4, W16 - referring to data).
492 1, // Root width W8 - referring to vector.
493 ];
494 let r = Reader::get_root(data.as_ref()).unwrap();
495 let foo = Foo::deserialize(r).unwrap();
496 assert_eq!(foo.0, 4);
497 assert_eq!(foo.1, 16);
498 assert_eq!(foo.2, 64);
499 assert_eq!(foo.3, 256);
500
501 let data = [
502 1, 2, 3, 4, // The vector.
503 4, // Root data (offset).
504 23 << 2, // Root type: VectorUInt4, W8.
505 1, // Root width: W8.
506 ];
507 let r = Reader::get_root(data.as_ref()).unwrap();
508 let foo = Foo::deserialize(r).unwrap();
509 assert_eq!(foo.0, 1);
510 assert_eq!(foo.1, 2);
511 assert_eq!(foo.2, 3);
512 assert_eq!(foo.3, 4);
513 }
514