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 flexbuffers::*;
16 use serde::Serialize;
17
18 #[test]
store_13()19 fn store_13() {
20 let buf = singleton(13i32);
21 assert_eq!(&buf, &[13, 4, 1]);
22 }
23 #[test]
store_2pow20()24 fn store_2pow20() {
25 let buf = singleton(1_048_576i32);
26 assert_eq!(
27 &buf,
28 &[
29 0,
30 0,
31 16,
32 0, // 2^20 in LE bytes.
33 1 << 2 | 2, // Int 32bit
34 4 // Root width 32 bit
35 ]
36 );
37 }
38
39 #[test]
heterogenous_vector_of_string_because_width()40 fn heterogenous_vector_of_string_because_width() {
41 // Each string is 32 characters. They are 256 bytes altogether.
42 // This forces the vector to be W16 because of the large offsets.
43 let test_data = [
44 "0aaabbbbccccddddeeeeffffgggghhh",
45 "1aaabbbbccccddddeeeeffffgggghhh",
46 "2aaabbbbccccddddeeeeffffgggghhh",
47 "3aaabbbbccccddddeeeeffffgggghhh",
48 "4aaabbbbccccddddeeeeffffgggghhh",
49 "5aaabbbbccccddddeeeeffffgggghhh",
50 "6aaabbbbccccddddeeeeffffgggghhh",
51 "7aaabbbbccccddddeeeeffffgggghhh",
52 ];
53 let mut fxb = Builder::default();
54 let mut v = fxb.start_vector();
55 for &s in test_data.iter() {
56 v.push(s);
57 }
58 v.end_vector();
59 let mut expected = vec![];
60 for &s in test_data.iter() {
61 expected.push(s.len() as u8);
62 expected.extend(s.bytes());
63 expected.push(b'\0');
64 }
65 expected.extend(8u16.to_le_bytes().iter()); // Length.
66 for i in 0..test_data.len() as u16 {
67 let offset = 32 * (8 - i) + 9 + i;
68 expected.extend(offset.to_le_bytes().iter());
69 }
70 for _ in 0..test_data.len() {
71 expected.push(5 << 2 | 0); // String, W8.
72 }
73 expected.push(24); // Offset to Vector.
74 expected.push(10 << 2 | 1); // Vector, W16.
75 expected.push(1); // Root width W8.
76 assert_eq!(fxb.view(), expected.as_slice());
77 }
78
79 #[test]
store_vec_uint_16()80 fn store_vec_uint_16() {
81 let mut fxb = Builder::default();
82 let mut v = fxb.start_vector();
83 v.push(256u16);
84 v.push(257u16);
85 v.push(258u16);
86 v.push(259u16);
87 v.push(0u8); // This still becomes u16.
88 v.end_vector();
89 assert_eq!(
90 fxb.view(),
91 &[
92 5,
93 0,
94 0,
95 1,
96 1,
97 1,
98 2,
99 1,
100 3,
101 1,
102 0,
103 0, // Data
104 10, // Vector offset.
105 12 << 2 | 1, // (VectorUInt, W16 - referring to data).
106 1, // Root width W8 - referring to vector.
107 ]
108 );
109 }
110
111 #[cfg(not(miri))] // slow.
112 quickcheck! {
113 fn qc_f32(x: f32) -> bool {
114 let fxb = singleton(x);
115 let mut expected = x.to_le_bytes().to_vec();
116 expected.push(3 << 2 | 2); // Float W32.
117 expected.push(4); // Root width W32.
118 println!("{:?}: {:?} vs {:?} cmp {:?}", x, &fxb, &expected, fxb==expected);
119 fxb == expected
120 }
121 }
122
123 #[test]
singleton_vector_uint_4_16bit()124 fn singleton_vector_uint_4_16bit() {
125 let buf = singleton(&[4u16, 16, 64, 256]);
126 assert_eq!(
127 &buf,
128 &[
129 4,
130 0,
131 16,
132 0,
133 64,
134 0,
135 0,
136 1, // Data
137 8, // Vector offset.
138 23 << 2 | 1, // (VectorUInt, W16 - referring to data).
139 1, // Root width W8 - referring to vector.
140 ]
141 );
142 }
143 #[test]
store_u64()144 fn store_u64() {
145 let buf = singleton(u64::max_value() - 10);
146 assert_eq!(
147 &buf,
148 &[
149 245,
150 255,
151 255,
152 255,
153 255,
154 255,
155 255,
156 255, // max value - 10.
157 2 << 2 | 3, // (UInt, W64)
158 8, // Root width W64.
159 ]
160 );
161 }
162 #[test]
vector_uint4()163 fn vector_uint4() {
164 let mut fxb = Builder::default();
165 let mut v = fxb.start_vector();
166 v.push(2u8);
167 v.push(3u8);
168 v.push(5u8);
169 v.push(7u8);
170 v.end_vector();
171 assert_eq!(
172 &fxb.view(),
173 &[
174 2,
175 3,
176 5,
177 7, // data
178 4, // Root (offset)
179 23 << 2 | 0, // Root type VectorUInt4, BitWidth::W8
180 1, // Root bitwidth W8
181 ]
182 );
183 }
184 #[test]
nested_vector()185 fn nested_vector() {
186 let mut fxb = Builder::default();
187 let mut v = fxb.start_vector();
188 v.push(0u8);
189 {
190 let mut nested = v.start_vector();
191 nested.push(1u8);
192 nested.push(2u8);
193 nested.push(3u8);
194 }
195 v.push(-42i8);
196 v.end_vector();
197 assert_eq!(
198 fxb.view(),
199 &[
200 1,
201 2,
202 3, // Nested vector
203 3,
204 0,
205 5,
206 214, // Root Vector: size, v[0], v[1] (offset), v[2] as u8
207 2 << 2 | 0, // v[0]: (UInt, W8)
208 20 << 2 | 0, // v[1]: (VectorUInt3, W8)
209 1 << 2 | 0, // v[2]: (Int, W8)
210 6, // Root points to Root vector
211 10 << 2 | 0, // Root type and width (Vector, W8)
212 1, // Root bytes
213 ]
214 )
215 }
216
217 #[test]
nested_vector_push_direct()218 fn nested_vector_push_direct() {
219 let mut fxb = Builder::default();
220 let mut v = fxb.start_vector();
221 v.push(0u8);
222 v.push(&[1u8, 2, 3]);
223 v.push(-42i8);
224 v.end_vector();
225 assert_eq!(
226 fxb.view(),
227 &[
228 1,
229 2,
230 3, // Nested VectorUInt3
231 3,
232 0,
233 5,
234 214, // Root Vector: size, v[0], v[1] (offset), v[2] as u8
235 2 << 2 | 0, // v[0]: (UInt, W8)
236 20 << 2 | 0, // v[1]: (VectorUInt3, W8)
237 1 << 2 | 0, // v[2]: (Int, W8)
238 6, // Root points to Root vector
239 10 << 2 | 0, // Root type and width (Vector, W8)
240 1, // Root bytes
241 ]
242 )
243 }
244 #[test]
store_map_index_into_it()245 fn store_map_index_into_it() {
246 let mut fxb = Builder::default();
247 {
248 let mut m = fxb.start_map();
249 m.push("foo", 17u8);
250 m.push("bar", 33u16);
251 m.push("baz", 41u32);
252 }
253 assert_eq!(
254 fxb.view(),
255 &[
256 b'f',
257 b'o',
258 b'o',
259 b'\0',
260 b'b',
261 b'a',
262 b'r',
263 b'\0',
264 b'b',
265 b'a',
266 b'z',
267 b'\0',
268 3,
269 9,
270 6,
271 15, // Keys vector (note "bar" < "baz" < "foo").
272 3,
273 1,
274 3, // map prefix
275 33,
276 41,
277 17, // values
278 8,
279 8,
280 8, // types (UInt, W8) ~ (2 << 2 | 0)
281 6, // Offset to map (root)
282 9 << 2 | 0, // Root type (map)
283 1, // Root bytes
284 ]
285 );
286 }
287 #[test]
utf8_snowman()288 fn utf8_snowman() {
289 let buf = singleton("snowman ☃︎");
290 assert_eq!(
291 &buf,
292 &[
293 14, // Byte length (besides extra null terminator).
294 b's',
295 b'n',
296 b'o',
297 b'w',
298 b'm',
299 b'a',
300 b'n',
301 b' ',
302 226,
303 152,
304 131, // snowman bytes
305 239,
306 184,
307 142, // UTF Variation selector 15
308 0, // extra null terminator.
309 15, // Offset to string start.
310 5 << 2, // String, W8
311 1, // Root bytes
312 ]
313 );
314 let r = Reader::get_root(buf.as_ref()).unwrap();
315 assert_eq!(r.get_str(), Ok("snowman ☃︎"));
316 }
317 #[test]
indirect_numbers()318 fn indirect_numbers() {
319 let mut fxb = Builder::default();
320 let mut v = fxb.start_vector();
321 v.push(IndirectUInt(u64::max_value()));
322 v.push(IndirectInt(i64::min_value()));
323 // TODO(cneo): Something about Float EPSILON and casting leads to a different binary format.
324 v.push(IndirectFloat(std::f64::consts::PI));
325 v.push(0u32); // This is stored in 8 bits instead of 64 because of indirection.
326 v.end_vector();
327 assert_eq!(
328 fxb.view(),
329 vec![
330 255,
331 255,
332 255,
333 255,
334 255,
335 255,
336 255,
337 255, // u64 max
338 0,
339 0,
340 0,
341 0,
342 0,
343 0,
344 0,
345 128, // i64 min value
346 24,
347 45,
348 68,
349 84,
350 251,
351 33,
352 9,
353 64, // f64 PI.
354 4, // Vector length
355 25,
356 18,
357 11,
358 0, // offsets to the indirect numbers and zero.
359 7 << 2 | 3, // IndirectUInt 64 bit
360 6 << 2 | 3, // IndirectInt 64 bit
361 8 << 2 | 3, // IndirectFloat 64 bit
362 2 << 2 | 0, // (inline) UInt 8 bit
363 8, // Offset to Root.
364 10 << 2 | 0, // Vector 8 bit
365 1, // 1 byte root
366 ]
367 .as_slice()
368 )
369 }
370 #[test]
indirect_2p5x_smaller()371 fn indirect_2p5x_smaller() {
372 let mut builder = Builder::default();
373 let mut v = builder.start_vector();
374 for i in 0..512 {
375 v.push(i);
376 }
377 v.push(i64::max_value());
378 v.end_vector();
379 let len_without_indirect = builder.view().len() as f32;
380
381 let mut v = builder.start_vector();
382 for i in 0..512 {
383 v.push(i);
384 }
385 v.push(IndirectInt(i64::max_value()));
386 v.end_vector();
387 let len_with_indirect = builder.view().len() as f32;
388 dbg!(len_with_indirect, len_without_indirect);
389 assert!(len_with_indirect * 2.5 < len_without_indirect);
390 }
391 #[test]
key_pool()392 fn key_pool() {
393 let mut builder = Builder::default();
394 let mut vector = builder.start_vector();
395 for _ in 0..2 {
396 let mut m = vector.start_map();
397 m.push("a", 42u8);
398 m.push("b", 42u8);
399 m.push("c", 42u8);
400 }
401 vector.end_vector();
402
403 assert_eq!(
404 builder.view(),
405 vec![
406 b'a',
407 b'\0',
408 b'b',
409 b'\0',
410 b'c',
411 b'\0',
412 3,
413 7,
414 6,
415 5, // Key vector 0
416 3,
417 1,
418 3,
419 42,
420 42,
421 42,
422 2 << 2,
423 2 << 2,
424 2 << 2, // Map 0.
425 3,
426 20,
427 19,
428 18, // Key vector 1 (shares keys with key vector 0).
429 3,
430 1,
431 3,
432 42,
433 42,
434 42,
435 2 << 2,
436 2 << 2,
437 2 << 2, // Map 1.
438 2,
439 20,
440 8,
441 9 << 2,
442 9 << 2, // Vector containing the maps.
443 4,
444 10 << 2,
445 1, // Root.
446 ]
447 .as_slice()
448 );
449 }
450
451 #[test]
serialize_unit()452 fn serialize_unit() {
453 #[derive(Serialize)]
454 struct Foo;
455 let mut s = FlexbufferSerializer::new();
456 Foo.serialize(&mut s).unwrap();
457 assert_eq!(s.view(), &[0, 0, 1]);
458 }
459
460 #[test]
serialize_i8()461 fn serialize_i8() {
462 let mut s = FlexbufferSerializer::new();
463 13i8.serialize(&mut s).unwrap();
464 assert_eq!(s.view(), &[13, 4, 1]);
465 }
466 #[test]
serialize_tuple_struct_i8()467 fn serialize_tuple_struct_i8() {
468 #[derive(Serialize)]
469 struct Foo(i32);
470 let mut s = FlexbufferSerializer::new();
471 Foo(13).serialize(&mut s).unwrap();
472 assert_eq!(s.view(), &[13, 4, 1]);
473 }
474 #[test]
serialize_tuple_tuple_struct_i8_is_inlined()475 fn serialize_tuple_tuple_struct_i8_is_inlined() {
476 #[derive(Serialize)]
477 struct Foo(i32);
478 #[derive(Serialize)]
479 struct Bar(Foo);
480 let mut s = FlexbufferSerializer::new();
481 Bar(Foo(13)).serialize(&mut s).unwrap();
482 assert_eq!(s.view(), &[13, 4, 1]);
483 }
484 #[test]
align_8byte()485 fn align_8byte() {
486 let mut b = Builder::default();
487 let mut v = b.start_vector();
488 v.push(IndirectUInt(42));
489 v.push(&[u64::max_value(); 2]);
490 v.end_vector();
491 assert_eq!(
492 b.view()[..16],
493 [
494 42, 0, 0, 0, 0, 0, 0, 0, // padding
495 255, 255, 255, 255, 255, 255, 255, 255, // the first u64 max value.
496 ]
497 );
498 }
499 #[test]
align_4byte()500 fn align_4byte() {
501 let mut b = Builder::default();
502 let mut v = b.start_vector();
503 v.push(IndirectUInt(42));
504 v.push(&[u32::max_value(); 2]);
505 v.end_vector();
506 assert_eq!(
507 b.view()[..8],
508 [
509 42, 0, 0, 0, // padding
510 255, 255, 255, 255, // the first u32 max value.
511 ]
512 );
513 }
514 #[test]
align_2byte()515 fn align_2byte() {
516 let mut b = Builder::default();
517 let mut v = b.start_vector();
518 v.push(IndirectUInt(42));
519 v.push(&[u16::max_value(); 2]);
520 v.end_vector();
521 assert_eq!(
522 b.view()[..4],
523 [
524 42, 0, // padding
525 255, 255, // the first u16 max value.
526 ]
527 );
528 }
529 #[test]
align_1byte()530 fn align_1byte() {
531 let mut b = Builder::default();
532 let mut v = b.start_vector();
533 v.push(IndirectUInt(42));
534 v.push(&[u8::max_value(); 2]);
535 v.end_vector();
536 assert_eq!(b.view()[..2], [42, 255]); // No padding.
537 }
538