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