Gitiles
Code Review Sign In
gerrit.omnirom.org / android_frameworks_native / 7f58a95cb4a7f820a77264372c1d0ad9bbfaf458 / . / libs / vr / libpdx / serialization_tests.cpp
blob: ee800f699e0447afaab4cf73aec70bf55c0fcf62 [file] [log] [blame]
Alex Vakulenkoe4eec202017-01-27 14:41:04 -0800[diff] [blame]1#include <errno.h>
2#include <fcntl.h>
3#include <unistd.h>
4
5#include <memory>
6#include <string>
7#include <thread>
8#include <utility>
9
10#include <gtest/gtest.h>
11#include <pdx/rpc/argument_encoder.h>
12#include <pdx/rpc/array_wrapper.h>
13#include <pdx/rpc/default_initialization_allocator.h>
14#include <pdx/rpc/payload.h>
15#include <pdx/rpc/serializable.h>
16#include <pdx/rpc/serialization.h>
17#include <pdx/rpc/string_wrapper.h>
18#include <pdx/utility.h>
19
20using namespace android::pdx;
21using namespace android::pdx::rpc;
22
23// Tests the serialization/deserialization of all supported types, verifying all
24// reasonable boundary conditions for types with multiple encodings.
25//
26// NOTE: Sometimes this file uses the construct "var = decltype(var)({...})"
27// instead of the equivalent "var = {...}" to construct vectors. This is to
28// prevent clang-format from producing annoyingly vertical code from long
29// initializers.
30
31// TODO(eieio): Automatically generate some of these tests?
32
33namespace {
34
35// Test data for serialization/deserialization of floats.
36const float kZeroFloat = 0.0f;
37const float kOneFloat = 1.0f;
38const auto kZeroFloatBytes = reinterpret_cast<const std::uint8_t*>(&kZeroFloat);
39const auto kOneFloatBytes = reinterpret_cast<const std::uint8_t*>(&kOneFloat);
40const double kZeroDouble = 0.0;
41const double kOneDouble = 1.0;
42const auto kZeroDoubleBytes =
43 reinterpret_cast<const std::uint8_t*>(&kZeroDouble);
44const auto kOneDoubleBytes = reinterpret_cast<const std::uint8_t*>(&kOneDouble);
45
46struct TestType {
47 enum class Foo { kFoo, kBar, kBaz };
48
49 int a;
50 float b;
51 std::string c;
52 Foo d;
53
54 TestType() {}
55 TestType(int a, float b, const std::string& c, Foo d)
56 : a(a), b(b), c(c), d(d) {}
57
58 // Make gtest expressions simpler by defining equality operator. This is not
59 // needed for serialization.
60 bool operator==(const TestType& other) const {
61 return a == other.a && b == other.b && c == other.c && d == other.d;
62 }
63
64 private:
65 PDX_SERIALIZABLE_MEMBERS(TestType, a, b, c, d);
66};
67
68template <typename FileHandleType>
69struct TestTemplateType {
70 FileHandleType fd;
71
72 TestTemplateType() {}
Chih-Hung Hsieh79e7f1b2018-12-20 15:53:43 -0800[diff] [blame]73 explicit TestTemplateType(FileHandleType fd) : fd(std::move(fd)) {}
Alex Vakulenkoe4eec202017-01-27 14:41:04 -0800[diff] [blame]74
75 bool operator==(const TestTemplateType& other) const {
76 return fd.Get() == other.fd.Get();
77 }
78
79 private:
80 PDX_SERIALIZABLE_MEMBERS(TestTemplateType<FileHandleType>, fd);
81};
82
83// Utilities to generate test maps and payloads.
84template <typename MapType>
85MapType MakeMap(std::size_t size) {
86 MapType result;
87 for (std::size_t i = 0; i < size; i++) {
88 result.emplace(i, i);
89 }
90 return result;
91}
92
93template <typename MapType>
94void InsertKeyValue(MessageWriter* writer, std::size_t size) {
95 MapType map;
96 for (std::size_t i = 0; i < size; i++) {
97 map.emplace(i, i);
98 }
99 for (const auto& element : map) {
100 Serialize(element.first, writer);
101 Serialize(element.second, writer);
102 }
103}
104
105} // anonymous namespace
106
107TEST(SerializableTypes, Constructor) {
108 TestType tt(1, 2.0, "three", TestType::Foo::kBar);
109 EXPECT_EQ(1, tt.a);
110 EXPECT_EQ(2.0, tt.b);
111 EXPECT_EQ("three", tt.c);
112 EXPECT_EQ(TestType::Foo::kBar, tt.d);
113}
114
115TEST(SerializationTest, bool) {
116 Payload result;
117 Payload expected;
118 bool value;
119
120 // True.
121 value = true;
122 Serialize(value, &result);
123 expected = {ENCODING_TYPE_TRUE};
124 EXPECT_EQ(expected, result);
125 result.Clear();
126
127 // False.
128 value = false;
129 Serialize(value, &result);
130 expected = {ENCODING_TYPE_FALSE};
131 EXPECT_EQ(expected, result);
132 result.Clear();
133}
134
135TEST(SerializationTest, uint8_t) {
136 Payload result;
137 Payload expected;
138 uint8_t value;
139
140 // Min FIXINT.
141 value = 0;
142 Serialize(value, &result);
143 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
144 EXPECT_EQ(expected, result);
145 result.Clear();
146
147 // Max FIXINT.
148 value = (1 << 7) - 1;
149 Serialize(value, &result);
150 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
151 EXPECT_EQ(expected, result);
152 result.Clear();
153
154 // Min UINT8.
155 value = (1 << 7);
156 Serialize(value, &result);
157 expected = {ENCODING_TYPE_UINT8, (1 << 7)};
158 EXPECT_EQ(expected, result);
159 result.Clear();
160
161 // Max UINT8.
162 value = 0xff;
163 Serialize(value, &result);
164 expected = {ENCODING_TYPE_UINT8, 0xff};
165 EXPECT_EQ(expected, result);
166 result.Clear();
167}
168
169TEST(SerializationTest, uint16_t) {
170 Payload result;
171 Payload expected;
172 uint16_t value;
173
174 // Min FIXINT.
175 value = 0;
176 Serialize(value, &result);
177 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
178 EXPECT_EQ(expected, result);
179 result.Clear();
180
181 // Max FIXINT.
182 value = (1 << 7) - 1;
183 Serialize(value, &result);
184 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
185 EXPECT_EQ(expected, result);
186 result.Clear();
187
188 // Min UINT8.
189 value = (1 << 7);
190 Serialize(value, &result);
191 expected = {ENCODING_TYPE_UINT8, (1 << 7)};
192 EXPECT_EQ(expected, result);
193 result.Clear();
194
195 // Max UINT8.
196 value = 0xff;
197 Serialize(value, &result);
198 expected = {ENCODING_TYPE_UINT8, 0xff};
199 EXPECT_EQ(expected, result);
200 result.Clear();
201
202 // Min UINT16.
203 value = (1 << 8);
204 Serialize(value, &result);
205 expected = {ENCODING_TYPE_UINT16, 0, 1};
206 EXPECT_EQ(expected, result);
207 result.Clear();
208
209 // Max UINT16.
210 value = 0xffff;
211 Serialize(value, &result);
212 expected = {ENCODING_TYPE_UINT16, 0xff, 0xff};
213 EXPECT_EQ(expected, result);
214 result.Clear();
215}
216
217TEST(SerializationTest, uint32_t) {
218 Payload result;
219 Payload expected;
220 uint32_t value;
221
222 // Min FIXINT.
223 value = 0;
224 Serialize(value, &result);
225 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
226 EXPECT_EQ(expected, result);
227 result.Clear();
228
229 // Max FIXINT.
230 value = (1 << 7) - 1;
231 Serialize(value, &result);
232 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
233 EXPECT_EQ(expected, result);
234 result.Clear();
235
236 // Min UINT8.
237 value = (1 << 7);
238 Serialize(value, &result);
239 expected = {ENCODING_TYPE_UINT8, (1 << 7)};
240 EXPECT_EQ(expected, result);
241 result.Clear();
242
243 // Max UINT8.
244 value = 0xff;
245 Serialize(value, &result);
246 expected = {ENCODING_TYPE_UINT8, 0xff};
247 EXPECT_EQ(expected, result);
248 result.Clear();
249
250 // Min UINT16.
251 value = (1 << 8);
252 Serialize(value, &result);
253 expected = {ENCODING_TYPE_UINT16, 0, 1};
254 EXPECT_EQ(expected, result);
255 result.Clear();
256
257 // Max UINT16.
258 value = 0xffff;
259 Serialize(value, &result);
260 expected = {ENCODING_TYPE_UINT16, 0xff, 0xff};
261 EXPECT_EQ(expected, result);
262 result.Clear();
263
264 // Min UINT32.
265 value = (1 << 16);
266 Serialize(value, &result);
267 expected = {ENCODING_TYPE_UINT32, 0, 0, 1, 0};
268 EXPECT_EQ(expected, result);
269 result.Clear();
270
271 // Max UINT32.
272 value = 0xffffffff;
273 Serialize(value, &result);
274 expected = {ENCODING_TYPE_UINT32, 0xff, 0xff, 0xff, 0xff};
275 EXPECT_EQ(expected, result);
276 result.Clear();
277}
278
279TEST(SerializationTest, uint64_t) {
280 Payload result;
281 Payload expected;
282 uint64_t value;
283
284 // Min FIXINT.
285 value = 0;
286 Serialize(value, &result);
287 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
288 EXPECT_EQ(expected, result);
289 result.Clear();
290
291 // Max FIXINT.
292 value = (1 << 7) - 1;
293 Serialize(value, &result);
294 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
295 EXPECT_EQ(expected, result);
296 result.Clear();
297
298 // Min UINT8.
299 value = (1 << 7);
300 Serialize(value, &result);
301 expected = {ENCODING_TYPE_UINT8, (1 << 7)};
302 EXPECT_EQ(expected, result);
303 result.Clear();
304
305 // Max UINT8.
306 value = 0xff;
307 Serialize(value, &result);
308 expected = {ENCODING_TYPE_UINT8, 0xff};
309 EXPECT_EQ(expected, result);
310 result.Clear();
311
312 // Min UINT16.
313 value = (1 << 8);
314 Serialize(value, &result);
315 expected = {ENCODING_TYPE_UINT16, 0, 1};
316 EXPECT_EQ(expected, result);
317 result.Clear();
318
319 // Max UINT16.
320 value = 0xffff;
321 Serialize(value, &result);
322 expected = {ENCODING_TYPE_UINT16, 0xff, 0xff};
323 EXPECT_EQ(expected, result);
324 result.Clear();
325
326 // Min UINT32.
327 value = (1 << 16);
328 Serialize(value, &result);
329 expected = {ENCODING_TYPE_UINT32, 0, 0, 1, 0};
330 EXPECT_EQ(expected, result);
331 result.Clear();
332
333 // Max UINT32.
334 value = 0xffffffff;
335 Serialize(value, &result);
336 expected = {ENCODING_TYPE_UINT32, 0xff, 0xff, 0xff, 0xff};
337 EXPECT_EQ(expected, result);
338 result.Clear();
339
340 // Min UINT64.
341 value = (1ULL << 32);
342 Serialize(value, &result);
343 expected = {ENCODING_TYPE_UINT64, 0, 0, 0, 0, 1, 0, 0, 0};
344 EXPECT_EQ(expected, result);
345 result.Clear();
346
347 // Max UINT64.
348 value = 0xffffffffffffffffULL;
349 Serialize(value, &result);
350 expected = {
351 ENCODING_TYPE_UINT64, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
352 EXPECT_EQ(expected, result);
353 result.Clear();
354}
355
356TEST(SerializationTest, int8_t) {
357 Payload result;
358 Payload expected;
359 int8_t value;
360
361 // Min NEGATIVE FIXINT.
362 value = -32;
363 Serialize(value, &result);
364 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
365 EXPECT_EQ(expected, result);
366 result.Clear();
367
368 // Max NEGATIVE FIXINT.
369 value = -1;
370 Serialize(value, &result);
371 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
372 EXPECT_EQ(expected, result);
373 result.Clear();
374
375 // Min FIXINT.
376 value = 0;
377 Serialize(value, &result);
378 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
379 EXPECT_EQ(expected, result);
380 result.Clear();
381
382 // Max FIXINT.
383 value = 127;
384 Serialize(value, &result);
385 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
386 EXPECT_EQ(expected, result);
387 result.Clear();
388
389 // Min INT8.
390 value = -128;
391 Serialize(value, &result);
392 expected = {ENCODING_TYPE_INT8, 0x80};
393 EXPECT_EQ(expected, result);
394 result.Clear();
395
396 // Max INT8.
397 value = -33;
398 Serialize(value, &result);
399 expected = {ENCODING_TYPE_INT8, 0xdf};
400 EXPECT_EQ(expected, result);
401 result.Clear();
402}
403
404TEST(SerializationTest, int16_t) {
405 Payload result;
406 Payload expected;
407 int16_t value;
408
409 // Min NEGATIVE FIXINT.
410 value = -32;
411 Serialize(value, &result);
412 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
413 EXPECT_EQ(expected, result);
414 result.Clear();
415
416 // Max NEGATIVE FIXINT.
417 value = -1;
418 Serialize(value, &result);
419 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
420 EXPECT_EQ(expected, result);
421 result.Clear();
422
423 // Min FIXINT.
424 value = 0;
425 Serialize(value, &result);
426 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
427 EXPECT_EQ(expected, result);
428 result.Clear();
429
430 // Max FIXINT.
431 value = 127;
432 Serialize(value, &result);
433 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
434 EXPECT_EQ(expected, result);
435 result.Clear();
436
437 // Min INT8.
438 value = -128;
439 Serialize(value, &result);
440 expected = {ENCODING_TYPE_INT8, 0x80};
441 EXPECT_EQ(expected, result);
442 result.Clear();
443
444 // Max INT8.
445 value = -33;
446 Serialize(value, &result);
447 expected = {ENCODING_TYPE_INT8, 0xdf};
448 EXPECT_EQ(expected, result);
449 result.Clear();
450
451 // Min INT16.
452 value = -32768;
453 Serialize(value, &result);
454 expected = {ENCODING_TYPE_INT16, 0x00, 0x80};
455 EXPECT_EQ(expected, result);
456 result.Clear();
457
458 // Max INT16.
459 value = 32767;
460 Serialize(value, &result);
461 expected = {ENCODING_TYPE_INT16, 0xff, 0x7f};
462 EXPECT_EQ(expected, result);
463 result.Clear();
464}
465
466TEST(SerializationTest, int32_t) {
467 Payload result;
468 Payload expected;
469 int32_t value;
470
471 // Min NEGATIVE FIXINT.
472 value = -32;
473 Serialize(value, &result);
474 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
475 EXPECT_EQ(expected, result);
476 result.Clear();
477
478 // Max NEGATIVE FIXINT.
479 value = -1;
480 Serialize(value, &result);
481 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
482 EXPECT_EQ(expected, result);
483 result.Clear();
484
485 // Min FIXINT.
486 value = 0;
487 Serialize(value, &result);
488 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
489 EXPECT_EQ(expected, result);
490 result.Clear();
491
492 // Max FIXINT.
493 value = 127;
494 Serialize(value, &result);
495 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
496 EXPECT_EQ(expected, result);
497 result.Clear();
498
499 // Min INT8.
500 value = -128;
501 Serialize(value, &result);
502 expected = {ENCODING_TYPE_INT8, 0x80};
503 EXPECT_EQ(expected, result);
504 result.Clear();
505
506 // Max INT8.
507 value = -33;
508 Serialize(value, &result);
509 expected = {ENCODING_TYPE_INT8, 0xdf};
510 EXPECT_EQ(expected, result);
511 result.Clear();
512
513 // Min INT16.
514 value = -32768;
515 Serialize(value, &result);
516 expected = {ENCODING_TYPE_INT16, 0x00, 0x80};
517 EXPECT_EQ(expected, result);
518 result.Clear();
519
520 // Max INT16.
521 value = 32767;
522 Serialize(value, &result);
523 expected = {ENCODING_TYPE_INT16, 0xff, 0x7f};
524 EXPECT_EQ(expected, result);
525 result.Clear();
526
527 // Min INT32.
528 value = -2147483648;
529 Serialize(value, &result);
530 expected = {ENCODING_TYPE_INT32, 0x00, 0x00, 0x00, 0x80};
531 EXPECT_EQ(expected, result);
532 result.Clear();
533
534 // Max INT32.
535 value = 2147483647;
536 Serialize(value, &result);
537 expected = {ENCODING_TYPE_INT32, 0xff, 0xff, 0xff, 0x7f};
538 EXPECT_EQ(expected, result);
539 result.Clear();
540}
541
542TEST(SerializationTest, int64_t) {
543 Payload result;
544 Payload expected;
545 int64_t value;
546
547 // Min NEGATIVE FIXINT.
548 value = -32;
549 Serialize(value, &result);
550 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
551 EXPECT_EQ(expected, result);
552 result.Clear();
553
554 // Max NEGATIVE FIXINT.
555 value = -1;
556 Serialize(value, &result);
557 expected = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
558 EXPECT_EQ(expected, result);
559 result.Clear();
560
561 // Min FIXINT.
562 value = 0;
563 Serialize(value, &result);
564 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
565 EXPECT_EQ(expected, result);
566 result.Clear();
567
568 // Max FIXINT.
569 value = 127;
570 Serialize(value, &result);
571 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
572 EXPECT_EQ(expected, result);
573 result.Clear();
574
575 // Min INT8.
576 value = -128;
577 Serialize(value, &result);
578 expected = {ENCODING_TYPE_INT8, 0x80};
579 EXPECT_EQ(expected, result);
580 result.Clear();
581
582 // Max INT8.
583 value = -33;
584 Serialize(value, &result);
585 expected = {ENCODING_TYPE_INT8, 0xdf};
586 EXPECT_EQ(expected, result);
587 result.Clear();
588
589 // Min INT16.
590 value = -32768;
591 Serialize(value, &result);
592 expected = {ENCODING_TYPE_INT16, 0x00, 0x80};
593 EXPECT_EQ(expected, result);
594 result.Clear();
595
596 // Max INT16.
597 value = 32767;
598 Serialize(value, &result);
599 expected = {ENCODING_TYPE_INT16, 0xff, 0x7f};
600 EXPECT_EQ(expected, result);
601 result.Clear();
602
603 // Min INT32.
604 value = -2147483648;
605 Serialize(value, &result);
606 expected = {ENCODING_TYPE_INT32, 0x00, 0x00, 0x00, 0x80};
607 EXPECT_EQ(expected, result);
608 result.Clear();
609
610 // Max INT32.
611 value = 2147483647;
612 Serialize(value, &result);
613 expected = {ENCODING_TYPE_INT32, 0xff, 0xff, 0xff, 0x7f};
614 EXPECT_EQ(expected, result);
615 result.Clear();
616
617 // Min INT64.
618 value = -9223372036854775808ULL;
619 Serialize(value, &result);
620 expected = {
621 ENCODING_TYPE_INT64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80};
622 EXPECT_EQ(expected, result);
623 result.Clear();
624
625 // Max INT64.
626 value = 9223372036854775807ULL;
627 Serialize(value, &result);
628 expected = {
629 ENCODING_TYPE_INT64, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
630 EXPECT_EQ(expected, result);
631 result.Clear();
632}
633
634TEST(SerializationTest, float) {
635 Payload result;
636 Payload expected;
637 float value;
638
639 value = 0.0f;
640 Serialize(value, &result);
641 expected = {ENCODING_TYPE_FLOAT32, kZeroFloatBytes[0], kZeroFloatBytes[1],
642 kZeroFloatBytes[2], kZeroFloatBytes[3]};
643 EXPECT_EQ(expected, result);
644 result.Clear();
645
646 value = 1.0f;
647 Serialize(value, &result);
648 expected = {ENCODING_TYPE_FLOAT32, kOneFloatBytes[0], kOneFloatBytes[1],
649 kOneFloatBytes[2], kOneFloatBytes[3]};
650 EXPECT_EQ(expected, result);
651 result.Clear();
652}
653
654TEST(SerializationTest, double) {
655 Payload result;
656 Payload expected;
657 double value;
658
659 value = 0.0f;
660 Serialize(value, &result);
661 expected = {ENCODING_TYPE_FLOAT64, kZeroDoubleBytes[0], kZeroDoubleBytes[1],
662 kZeroDoubleBytes[2], kZeroDoubleBytes[3], kZeroDoubleBytes[4],
663 kZeroDoubleBytes[5], kZeroDoubleBytes[6], kZeroDoubleBytes[7]};
664 EXPECT_EQ(expected, result);
665 result.Clear();
666
667 value = 1.0f;
668 Serialize(value, &result);
669 expected = {ENCODING_TYPE_FLOAT64, kOneDoubleBytes[0], kOneDoubleBytes[1],
670 kOneDoubleBytes[2], kOneDoubleBytes[3], kOneDoubleBytes[4],
671 kOneDoubleBytes[5], kOneDoubleBytes[6], kOneDoubleBytes[7]};
672 EXPECT_EQ(expected, result);
673 result.Clear();
674}
675
676TEST(SerializationTest, Enum) {
677 Payload result;
678 Payload expected;
679
680 enum Foo { kFoo, kBar, kBaz };
681 Foo value = kBar;
682 Serialize(value, &result);
683 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1};
684 EXPECT_EQ(expected, result);
685 result.Clear();
686}
687
688TEST(SerializationTest, EnumClass) {
689 Payload result;
690 Payload expected;
691
692 enum class Foo { kFoo, kBar, kBaz };
693 Foo value = Foo::kBaz;
694 Serialize(value, &result);
695 expected = {ENCODING_TYPE_POSITIVE_FIXINT_MIN + 2};
696 EXPECT_EQ(expected, result);
697 result.Clear();
698}
699
700TEST(SerializationTest, LocalHandle) {
701 Payload result;
702 Payload expected;
703 LocalHandle fd1;
704 LocalHandle fd2;
705
706 fd1 = LocalHandle(100);
707 Serialize(fd1, &result);
708 expected = {ENCODING_TYPE_FIXEXT2, ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0, 0};
709 EXPECT_EQ(expected, result);
710 EXPECT_EQ(1u, result.FdCount());
711 EXPECT_EQ(100, result.FdArray()[0]);
712 result.Clear();
713
714 fd2 = LocalHandle(200);
715 Serialize(std::forward_as_tuple(fd1, fd2), &result);
716 expected = decltype(expected)(
717 {ENCODING_TYPE_FIXARRAY_MIN + 2, ENCODING_TYPE_FIXEXT2,
718 ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0, 0, ENCODING_TYPE_FIXEXT2,
719 ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 1, 0});
720 EXPECT_EQ(expected, result);
721 EXPECT_EQ(2u, result.FdCount());
722 EXPECT_EQ(100, result.FdArray()[0]);
723 EXPECT_EQ(200, result.FdArray()[1]);
724 result.Clear();
725
726 fd1.Release(); // Don't try to close fd 100.
727 fd2.Release(); // Don't try to close fd 200.
728
729 fd1 = LocalHandle(-2);
730 Serialize(fd1, &result);
731 expected = {ENCODING_TYPE_FIXEXT2, ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0xfe,
732 0xff};
733 EXPECT_EQ(expected, result);
734 EXPECT_EQ(0u, result.FdCount());
735 result.Clear();
736}
737
738TEST(SerializationTest, string) {
739 Payload result;
740 Payload expected;
741 std::string value;
742
743 // Min FIXSTR.
744 value = "";
745 Serialize(value, &result);
746 expected = {ENCODING_TYPE_FIXSTR_MIN};
747 EXPECT_EQ(expected, result);
748 result.Clear();
749
750 // Max FIXSTR.
751 value = std::string((1 << 5) - 1, 'x');
752 Serialize(value, &result);
753 expected = {ENCODING_TYPE_FIXSTR_MAX};
754 expected.Append((1 << 5) - 1, 'x');
755 EXPECT_EQ(expected, result);
756 result.Clear();
757
758 // Min STR8.
759 value = std::string((1 << 5), 'x');
760 Serialize(value, &result);
761 expected = {ENCODING_TYPE_STR8, (1 << 5)};
762 expected.Append((1 << 5), 'x');
763 EXPECT_EQ(expected, result);
764 result.Clear();
765
766 // Max STR8.
767 value = std::string((1 << 8) - 1, 'x');
768 Serialize(value, &result);
769 expected = {ENCODING_TYPE_STR8, (1 << 8) - 1};
770 expected.Append((1 << 8) - 1, 'x');
771 EXPECT_EQ(expected, result);
772 result.Clear();
773
774 // Min STR16.
775 value = std::string((1 << 8), 'x');
776 Serialize(value, &result);
777 expected = {ENCODING_TYPE_STR16, 0x00, 0x01};
778 expected.Append((1 << 8), 'x');
779 EXPECT_EQ(expected, result);
780 result.Clear();
781
782 // Max STR16.
783 value = std::string((1 << 16) - 1, 'x');
784 Serialize(value, &result);
785 expected = {ENCODING_TYPE_STR16, 0xff, 0xff};
786 expected.Append((1 << 16) - 1, 'x');
787 EXPECT_EQ(expected, result);
788 result.Clear();
789
790 // Min STR32.
791 value = std::string((1 << 16), 'x');
792 Serialize(value, &result);
793 expected = {ENCODING_TYPE_STR32, 0x00, 0x00, 0x01, 0x00};
794 expected.Append((1 << 16), 'x');
795 EXPECT_EQ(expected, result);
796 result.Clear();
797}
798
799TEST(SerializationTest, StringWrapper) {
800 Payload result;
801 Payload expected;
802 std::string value;
803
804 // Min FIXSTR.
805 value = "";
806 Serialize(WrapString(value), &result);
807 expected = {ENCODING_TYPE_FIXSTR_MIN};
808 EXPECT_EQ(expected, result);
809 result.Clear();
810
811 // Max FIXSTR.
812 value = std::string((1 << 5) - 1, 'x');
813 Serialize(WrapString(value), &result);
814 expected = {ENCODING_TYPE_FIXSTR_MAX};
815 expected.Append((1 << 5) - 1, 'x');
816 EXPECT_EQ(expected, result);
817 result.Clear();
818
819 // Min STR8.
820 value = std::string((1 << 5), 'x');
821 Serialize(WrapString(value), &result);
822 expected = {ENCODING_TYPE_STR8, (1 << 5)};
823 expected.Append((1 << 5), 'x');
824 EXPECT_EQ(expected, result);
825 result.Clear();
826
827 // Max STR8.
828 value = std::string((1 << 8) - 1, 'x');
829 Serialize(WrapString(value), &result);
830 expected = {ENCODING_TYPE_STR8, (1 << 8) - 1};
831 expected.Append((1 << 8) - 1, 'x');
832 EXPECT_EQ(expected, result);
833 result.Clear();
834
835 // Min STR16.
836 value = std::string((1 << 8), 'x');
837 Serialize(WrapString(value), &result);
838 expected = {ENCODING_TYPE_STR16, 0x00, 0x01};
839 expected.Append((1 << 8), 'x');
840 EXPECT_EQ(expected, result);
841 result.Clear();
842
843 // Max STR16.
844 value = std::string((1 << 16) - 1, 'x');
845 Serialize(WrapString(value), &result);
846 expected = {ENCODING_TYPE_STR16, 0xff, 0xff};
847 expected.Append((1 << 16) - 1, 'x');
848 EXPECT_EQ(expected, result);
849 result.Clear();
850
851 // Min STR32.
852 value = std::string((1 << 16), 'x');
853 Serialize(WrapString(value), &result);
854 expected = {ENCODING_TYPE_STR32, 0x00, 0x00, 0x01, 0x00};
855 expected.Append((1 << 16), 'x');
856 EXPECT_EQ(expected, result);
857 result.Clear();
858}
859
860TEST(SerializationTest, vector) {
861 Payload result;
862 Payload expected;
863 std::vector<uint8_t> value;
864
865 // Min FIXARRAY.
866 value = {};
867 Serialize(value, &result);
868 expected = {ENCODING_TYPE_FIXARRAY_MIN};
869 EXPECT_EQ(expected, result);
870 result.Clear();
871
872 // Max FIXARRAY.
873 value = decltype(value)((1 << 4) - 1, 'x');
874 Serialize(value, &result);
875 expected = {ENCODING_TYPE_FIXARRAY_MAX};
876 expected.Append((1 << 4) - 1, 'x');
877 EXPECT_EQ(expected, result);
878 result.Clear();
879
880 // Min ARRAY16.
881 value = decltype(value)((1 << 4), 'x');
882 Serialize(value, &result);
883 expected = {ENCODING_TYPE_ARRAY16, 0x10, 0x00};
884 expected.Append((1 << 4), 'x');
885 EXPECT_EQ(expected, result);
886 result.Clear();
887
888 // Max ARRAY16.
889 value = decltype(value)((1 << 16) - 1, 'x');
890 Serialize(value, &result);
891 expected = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
892 expected.Append((1 << 16) - 1, 'x');
893 EXPECT_EQ(expected, result);
894 result.Clear();
895
896 // Min ARRAY32.
897 value = decltype(value)((1 << 16), 'x');
898 Serialize(value, &result);
899 expected = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
900 expected.Append((1 << 16), 'x');
901 EXPECT_EQ(expected, result);
902 result.Clear();
903}
904
905TEST(SerializationTest, map) {
906 Payload result;
907 Payload expected;
908 std::map<std::uint32_t, std::uint32_t> value;
909
910 // Min FIXMAP.
911 value = {};
912 Serialize(value, &result);
913 expected = {ENCODING_TYPE_FIXMAP_MIN};
914 EXPECT_EQ(expected, result);
915 result.Clear();
916
917 // Max FIXMAP.
918 value = MakeMap<decltype(value)>((1 << 4) - 1);
919 Serialize(value, &result);
920 expected = {ENCODING_TYPE_FIXMAP_MAX};
921 InsertKeyValue<decltype(value)>(&expected, (1 << 4) - 1);
922 EXPECT_EQ(expected, result);
923 result.Clear();
924
925 // Min MAP16.
926 value = MakeMap<decltype(value)>((1 << 4));
927 Serialize(value, &result);
928 expected = {ENCODING_TYPE_MAP16, 0x10, 0x00};
929 InsertKeyValue<decltype(value)>(&expected, (1 << 4));
930 EXPECT_EQ(expected, result);
931 result.Clear();
932
933 // Max MAP16.
934 value = MakeMap<decltype(value)>((1 << 16) - 1);
935 Serialize(value, &result);
936 expected = {ENCODING_TYPE_MAP16, 0xff, 0xff};
937 InsertKeyValue<decltype(value)>(&expected, (1 << 16) - 1);
938 EXPECT_EQ(expected, result);
939 result.Clear();
940
941 // Min MAP32.
942 value = MakeMap<decltype(value)>((1 << 16));
943 Serialize(value, &result);
944 expected = {ENCODING_TYPE_MAP32, 0x00, 0x00, 0x01, 0x00};
945 InsertKeyValue<decltype(value)>(&expected, (1 << 16));
946 EXPECT_EQ(expected, result);
947 result.Clear();
948}
949
950TEST(SerializationTest, unordered_map) {
951 Payload result;
952 Payload expected;
953 std::unordered_map<std::uint32_t, std::uint32_t> value;
954
955 // Min FIXMAP.
956 value = {};
957 Serialize(value, &result);
958 expected = {ENCODING_TYPE_FIXMAP_MIN};
959 EXPECT_EQ(expected, result);
960 result.Clear();
961
962 // Max FIXMAP.
963 value = MakeMap<decltype(value)>((1 << 4) - 1);
964 Serialize(value, &result);
965 expected = {ENCODING_TYPE_FIXMAP_MAX};
966 InsertKeyValue<decltype(value)>(&expected, (1 << 4) - 1);
967 EXPECT_EQ(expected, result);
968 result.Clear();
969
970 // Min MAP16.
971 value = MakeMap<decltype(value)>((1 << 4));
972 Serialize(value, &result);
973 expected = {ENCODING_TYPE_MAP16, 0x10, 0x00};
974 InsertKeyValue<decltype(value)>(&expected, (1 << 4));
975 EXPECT_EQ(expected, result);
976 result.Clear();
977
978 // Max MAP16.
979 value = MakeMap<decltype(value)>((1 << 16) - 1);
980 Serialize(value, &result);
981 expected = {ENCODING_TYPE_MAP16, 0xff, 0xff};
982 InsertKeyValue<decltype(value)>(&expected, (1 << 16) - 1);
983 EXPECT_EQ(expected, result);
984 result.Clear();
985
986 // Min MAP32.
987 value = MakeMap<decltype(value)>((1 << 16));
988 Serialize(value, &result);
989 expected = {ENCODING_TYPE_MAP32, 0x00, 0x00, 0x01, 0x00};
990 InsertKeyValue<decltype(value)>(&expected, (1 << 16));
991 EXPECT_EQ(expected, result);
992 result.Clear();
993}
994
995TEST(SerializationTest, array) {
996 Payload result;
997 Payload expected;
998
999 // Min FIXARRAY.
1000 std::array<std::uint8_t, 0> a0;
1001 Serialize(a0, &result);
1002 expected = {ENCODING_TYPE_FIXARRAY_MIN};
1003 EXPECT_EQ(expected, result);
1004 result.Clear();
1005
1006 // Max FIXARRAY.
1007 std::array<std::uint8_t, (1 << 4) - 1> a1;
1008 for (auto& element : a1)
1009 element = 'x';
1010 Serialize(a1, &result);
1011 expected = {ENCODING_TYPE_FIXARRAY_MAX};
1012 expected.Append((1 << 4) - 1, 'x');
1013 EXPECT_EQ(expected, result);
1014 result.Clear();
1015
1016 // Min ARRAY16.
1017 std::array<std::uint8_t, (1 << 4)> a2;
1018 for (auto& element : a2)
1019 element = 'x';
1020 Serialize(a2, &result);
1021 expected = {ENCODING_TYPE_ARRAY16, 0x10, 0x00};
1022 expected.Append((1 << 4), 'x');
1023 EXPECT_EQ(expected, result);
1024 result.Clear();
1025
1026 // Max ARRAY16.
1027 std::array<std::uint8_t, (1 << 16) - 1> a3;
1028 for (auto& element : a3)
1029 element = 'x';
1030 Serialize(a3, &result);
1031 expected = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
1032 expected.Append((1 << 16) - 1, 'x');
1033 EXPECT_EQ(expected, result);
1034 result.Clear();
1035
1036 // Min ARRAY32.
1037 std::array<std::uint8_t, (1 << 16)> a4;
1038 for (auto& element : a4)
1039 element = 'x';
1040 Serialize(a4, &result);
1041 expected = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
1042 expected.Append((1 << 16), 'x');
1043 EXPECT_EQ(expected, result);
1044 result.Clear();
1045}
1046
1047TEST(SerializationTest, ArrayWrapper) {
1048 Payload result;
1049 Payload expected;
1050 std::vector<std::uint8_t, DefaultInitializationAllocator<std::uint8_t>> value;
1051 ArrayWrapper<std::uint8_t> wrapper;
1052
1053 // Min FIXARRAY.
1054 value = {};
1055 Serialize(wrapper, &result);
1056 expected = {ENCODING_TYPE_FIXARRAY_MIN};
1057 EXPECT_EQ(expected, result);
1058 result.Clear();
1059
1060 // Max FIXARRAY.
1061 value = decltype(value)((1 << 4) - 1, 'x');
1062 wrapper = decltype(wrapper)(value.data(), value.capacity(), value.size());
1063 Serialize(wrapper, &result);
1064 expected = {ENCODING_TYPE_FIXARRAY_MAX};
1065 expected.Append((1 << 4) - 1, 'x');
1066 EXPECT_EQ(expected, result);
1067 result.Clear();
1068
1069 // Min ARRAY16.
1070 value = decltype(value)((1 << 4), 'x');
1071 wrapper = decltype(wrapper)(value.data(), value.capacity(), value.size());
1072 Serialize(wrapper, &result);
1073 expected = {ENCODING_TYPE_ARRAY16, 0x10, 0x00};
1074 expected.Append((1 << 4), 'x');
1075 EXPECT_EQ(expected, result);
1076 result.Clear();
1077
1078 // Max ARRAY16.
1079 value = decltype(value)((1 << 16) - 1, 'x');
1080 wrapper = decltype(wrapper)(value.data(), value.capacity(), value.size());
1081 Serialize(wrapper, &result);
1082 expected = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
1083 expected.Append((1 << 16) - 1, 'x');
1084 EXPECT_EQ(expected, result);
1085 result.Clear();
1086
1087 // Min ARRAY32.
1088 value = decltype(value)((1 << 16), 'x');
1089 wrapper = decltype(wrapper)(value.data(), value.capacity(), value.size());
1090 Serialize(wrapper, &result);
1091 expected = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
1092 expected.Append((1 << 16), 'x');
1093 EXPECT_EQ(expected, result);
1094 result.Clear();
1095}
1096
1097TEST(SerializationTest, pair) {
1098 Payload result;
1099 Payload expected;
1100
1101 auto p1 = std::make_pair(1, 2);
1102 Serialize(p1, &result);
1103 expected = {ENCODING_TYPE_FIXARRAY_MIN + 2, 1, 2};
1104 EXPECT_EQ(expected, result);
1105 result.Clear();
1106
1107 auto p2 = std::make_pair('x', std::string("12345"));
1108 Serialize(p2, &result);
1109 expected = decltype(expected)({ENCODING_TYPE_FIXARRAY_MIN + 2, 'x',
1110 ENCODING_TYPE_FIXSTR_MIN + 5, '1', '2', '3',
1111 '4', '5'});
1112 EXPECT_EQ(expected, result);
1113 result.Clear();
1114}
1115
1116TEST(SerializationTest, tuple) {
1117 Payload result;
1118 Payload expected;
1119
1120 // Min FIXARRAY.
1121 auto t1 = std::make_tuple();
1122 Serialize(t1, &result);
1123 expected = {ENCODING_TYPE_FIXARRAY_MIN};
1124 EXPECT_EQ(expected, result);
1125 result.Clear();
1126
1127 // Max FIXARRAY.
1128 auto t2 = GetNTuple<15>('x');
1129 Serialize(t2, &result);
1130 expected = {ENCODING_TYPE_FIXARRAY_MAX};
1131 expected.Append((1 << 4) - 1, 'x');
1132 EXPECT_EQ(expected, result);
1133 result.Clear();
1134
1135 // Min ARRAY16.
1136 auto t3 = GetNTuple<(1 << 4)>('x');
1137 Serialize(t3, &result);
1138 expected = {ENCODING_TYPE_ARRAY16, 0x10, 0x00};
1139 expected.Append((1 << 4), 'x');
1140 EXPECT_EQ(expected, result);
1141 result.Clear();
1142
1143// Template instantiation depth is an issue for these tests. They are commented
1144// out to document the expected behavior, even though tuples of this order are
1145// not expected in practice.
1146#if 0
1147 // Max ARRAY16.
1148 auto t4 = GetNTuple<(1 << 16)-1>('x');
1149 Serialize(t4, &result);
1150 expected = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
1151 expected.Append((1 << 16)-1, 'x');
1152 EXPECT_EQ(expected, result);
1153 result.Clear();
1154
1155 // Min ARRAY32.
1156 auto t5 = GetNTuple<(1 << 16)>('x');
1157 Serialize(t5, &result);
1158 expected = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
1159 expected.Append((1 << 16), 'x');
1160 EXPECT_EQ(expected, result);
1161 result.Clear();
1162#endif
1163}
1164
1165// TODO(eieio): More exhaustive testing of type nesting.
1166TEST(SerializationTest, NestedTuple) {
1167 Payload result;
1168 Payload expected;
1169
1170 auto t1 = std::make_tuple('x', std::make_tuple<int, int>(1, 2));
1171 Serialize(t1, &result);
1172 expected = decltype(expected)({ENCODING_TYPE_FIXARRAY_MIN + 2, 'x',
1173 ENCODING_TYPE_FIXARRAY_MIN + 2, 1, 2});
1174 EXPECT_EQ(expected, result);
1175 result.Clear();
1176
1177 auto t2 = std::make_tuple('x', std::make_tuple<int, int>(1, 2),
1178 std::string("0123456789"));
1179 Serialize(t2, &result);
1180 expected = decltype(expected)({ENCODING_TYPE_FIXARRAY_MIN + 3, 'x',
1181 ENCODING_TYPE_FIXARRAY_MIN + 2, 1, 2,
1182 ENCODING_TYPE_FIXSTR | 10, '0', '1', '2', '3',
1183 '4', '5', '6', '7', '8', '9'});
1184 EXPECT_EQ(expected, result);
1185 result.Clear();
1186
1187 auto t3 = std::make_tuple(0.0f, std::uint64_t(10ULL),
1188 std::vector<char>{'a', 'b', 'c'});
1189 Serialize(t3, &result);
1190 expected = decltype(expected)(
1191 {ENCODING_TYPE_FIXARRAY_MIN + 3, ENCODING_TYPE_FLOAT32,
1192 kZeroFloatBytes[0], kZeroFloatBytes[1], kZeroFloatBytes[2],
1193 kZeroFloatBytes[3], ENCODING_TYPE_POSITIVE_FIXINT_MIN + 10,
1194 ENCODING_TYPE_FIXARRAY_MIN + 3, 'a', 'b', 'c'});
1195 EXPECT_EQ(expected, result);
1196 result.Clear();
1197}
1198
1199TEST(SerializationTest, NestedMap) {
1200 Payload result;
1201 Payload expected;
1202
1203 std::map<int, std::pair<std::string, int>> m1 = {{0, {"a", 2}},
1204 {1, {"b", 10}}};
1205 Serialize(m1, &result);
1206 expected = decltype(expected)(
1207 {ENCODING_TYPE_FIXMAP_MIN + 2, 0, ENCODING_TYPE_FIXARRAY_MIN + 2,
1208 ENCODING_TYPE_FIXSTR_MIN + 1, 'a', 2, 1, ENCODING_TYPE_FIXARRAY_MIN + 2,
1209 ENCODING_TYPE_FIXSTR_MIN + 1, 'b', 10});
1210 EXPECT_EQ(expected, result);
1211 result.Clear();
1212}
1213
1214TEST(SerializationTest, Serializable) {
1215 Payload result;
1216 Payload expected;
1217
1218 TestType t1{10, 0.0, "12345", TestType::Foo::kBaz};
1219 Serialize(t1, &result);
1220 expected = decltype(expected)(
1221 {ENCODING_TYPE_FIXARRAY_MIN + 4, 10, ENCODING_TYPE_FLOAT32,
1222 kZeroFloatBytes[0], kZeroFloatBytes[1], kZeroFloatBytes[2],
1223 kZeroFloatBytes[3], ENCODING_TYPE_FIXSTR_MIN + 5, '1', '2', '3', '4',
1224 '5', ENCODING_TYPE_POSITIVE_FIXINT_MIN + 2});
1225 EXPECT_EQ(expected, result);
1226 result.Clear();
1227
1228 TestTemplateType<LocalHandle> tt{LocalHandle(-1)};
1229 Serialize(tt, &result);
1230 expected =
1231 decltype(expected)({ENCODING_TYPE_FIXARRAY_MIN + 1, ENCODING_TYPE_FIXEXT2,
1232 ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0xff, 0xff});
1233 EXPECT_EQ(expected, result);
1234}
1235
1236TEST(SerializationTest, Variant) {
1237 Payload result;
1238 Payload expected;
1239
1240 Variant<int, bool, float> v;
1241
1242 // Empty variant.
1243 Serialize(v, &result);
1244 expected = {ENCODING_TYPE_FIXMAP_MIN + 1, ENCODING_TYPE_NEGATIVE_FIXINT_MAX,
1245 ENCODING_TYPE_NIL};
1246 EXPECT_EQ(expected, result);
1247 result.Clear();
1248
1249 v = 10;
1250 Serialize(v, &result);
1251 expected = {ENCODING_TYPE_FIXMAP_MIN + 1,
1252 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 0,
1253 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 10};
1254 EXPECT_EQ(expected, result);
1255 result.Clear();
1256
1257 v = true;
1258 Serialize(v, &result);
1259 expected = {ENCODING_TYPE_FIXMAP_MIN + 1,
1260 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1, ENCODING_TYPE_TRUE};
1261 EXPECT_EQ(expected, result);
1262 result.Clear();
1263
1264 v = false;
1265 Serialize(v, &result);
1266 expected = {ENCODING_TYPE_FIXMAP_MIN + 1,
1267 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1, ENCODING_TYPE_FALSE};
1268 EXPECT_EQ(expected, result);
1269 result.Clear();
1270
1271 v = 1.0f;
1272 Serialize(v, &result);
1273 expected = {ENCODING_TYPE_FIXMAP_MIN + 1,
1274 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 2,
1275 ENCODING_TYPE_FLOAT32,
1276 kOneFloatBytes[0],
1277 kOneFloatBytes[1],
1278 kOneFloatBytes[2],
1279 kOneFloatBytes[3]};
1280 EXPECT_EQ(expected, result);
1281 result.Clear();
1282
1283 // TODO(eieio): Add more serialization tests for Variant.
1284}
1285
1286TEST(DeserializationTest, bool) {
1287 Payload buffer;
1288 bool result = false;
1289 ErrorType error;
1290
1291 // True.
1292 buffer = {ENCODING_TYPE_TRUE};
1293 error = Deserialize(&result, &buffer);
1294 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1295 EXPECT_EQ(1, result); // Gtest generates warning from bool literals.
1296
1297 // False.
1298 buffer = {ENCODING_TYPE_FALSE};
1299 error = Deserialize(&result, &buffer);
1300 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1301 EXPECT_EQ(0, result); // Gtest generates warning from bool literals.
1302}
1303
1304TEST(DeserializationTest, uint8_t) {
1305 Payload buffer;
1306 std::uint8_t result = 0;
1307 ErrorType error;
1308
1309 // Min FIXINT.
1310 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1311 error = Deserialize(&result, &buffer);
1312 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1313 EXPECT_EQ(0U, result);
1314
1315 // Max FIXINT.
1316 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1317 error = Deserialize(&result, &buffer);
1318 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1319 EXPECT_EQ(127U, result);
1320
1321 // Min UINT8.
1322 buffer = {ENCODING_TYPE_UINT8, 0x00};
1323 error = Deserialize(&result, &buffer);
1324 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1325 EXPECT_EQ(0U, result);
1326
1327 // Max UINT8.
1328 buffer = {ENCODING_TYPE_UINT8, 0xff};
1329 error = Deserialize(&result, &buffer);
1330 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1331 EXPECT_EQ(0xffU, result);
1332
1333 // UINT16 out of range.
1334 buffer = {ENCODING_TYPE_UINT16};
1335 error = Deserialize(&result, &buffer);
1336 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1337 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
1338 EXPECT_EQ(ENCODING_TYPE_UINT16, error.encoding_type());
1339
1340 // UINT32 out of range.
1341 buffer = {ENCODING_TYPE_UINT32};
1342 error = Deserialize(&result, &buffer);
1343 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1344 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
1345 EXPECT_EQ(ENCODING_TYPE_UINT32, error.encoding_type());
1346
1347 // UINT64 out of range.
1348 buffer = {ENCODING_TYPE_UINT64};
1349 error = Deserialize(&result, &buffer);
1350 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1351 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
1352 EXPECT_EQ(ENCODING_TYPE_UINT64, error.encoding_type());
1353}
1354
1355TEST(DeserializationTest, uint16_t) {
1356 Payload buffer;
1357 std::uint16_t result = 0;
1358 ErrorType error;
1359
1360 // Min FIXINT.
1361 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1362 error = Deserialize(&result, &buffer);
1363 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1364 EXPECT_EQ(0U, result);
1365
1366 // Max FIXINT.
1367 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1368 error = Deserialize(&result, &buffer);
1369 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1370 EXPECT_EQ(127U, result);
1371
1372 // Min UINT8.
1373 buffer = {ENCODING_TYPE_UINT8, 0x00};
1374 error = Deserialize(&result, &buffer);
1375 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1376 EXPECT_EQ(0U, result);
1377
1378 // Max UINT8.
1379 buffer = {ENCODING_TYPE_UINT8, 0xff};
1380 error = Deserialize(&result, &buffer);
1381 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1382 EXPECT_EQ(0xffU, result);
1383
1384 // Min UINT16.
1385 buffer = {ENCODING_TYPE_UINT16, 0x00, 0x00};
1386 error = Deserialize(&result, &buffer);
1387 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1388 EXPECT_EQ(0U, result);
1389
1390 // Max UINT16.
1391 buffer = {ENCODING_TYPE_UINT16, 0xff, 0xff};
1392 error = Deserialize(&result, &buffer);
1393 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1394 EXPECT_EQ(0xffffU, result);
1395
1396 // UINT32 out of range.
1397 buffer = {ENCODING_TYPE_UINT32};
1398 error = Deserialize(&result, &buffer);
1399 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1400 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
1401 EXPECT_EQ(ENCODING_TYPE_UINT32, error.encoding_type());
1402
1403 // UINT64 out of range.
1404 buffer = {ENCODING_TYPE_UINT64};
1405 error = Deserialize(&result, &buffer);
1406 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1407 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
1408 EXPECT_EQ(ENCODING_TYPE_UINT64, error.encoding_type());
1409}
1410
1411TEST(DeserializationTest, uint32_t) {
1412 Payload buffer;
1413 std::uint32_t result = 0;
1414 ErrorType error;
1415
1416 // Min FIXINT.
1417 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1418 error = Deserialize(&result, &buffer);
1419 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1420 EXPECT_EQ(0U, result);
1421
1422 // Max FIXINT.
1423 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1424 error = Deserialize(&result, &buffer);
1425 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1426 EXPECT_EQ(127U, result);
1427
1428 // Min UINT8.
1429 buffer = {ENCODING_TYPE_UINT8, 0x00};
1430 error = Deserialize(&result, &buffer);
1431 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1432 EXPECT_EQ(0U, result);
1433
1434 // Max UINT8.
1435 buffer = {ENCODING_TYPE_UINT8, 0xff};
1436 error = Deserialize(&result, &buffer);
1437 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1438 EXPECT_EQ(0xffU, result);
1439
1440 // Min UINT16.
1441 buffer = {ENCODING_TYPE_UINT16, 0x00, 0x00};
1442 error = Deserialize(&result, &buffer);
1443 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1444 EXPECT_EQ(0U, result);
1445
1446 // Max UINT16.
1447 buffer = {ENCODING_TYPE_UINT16, 0xff, 0xff};
1448 error = Deserialize(&result, &buffer);
1449 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1450 EXPECT_EQ(0xffffU, result);
1451
1452 // Min UINT32.
1453 buffer = {ENCODING_TYPE_UINT32, 0x00, 0x00, 0x00, 0x00};
1454 error = Deserialize(&result, &buffer);
1455 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1456 EXPECT_EQ(0U, result);
1457
1458 // Max UINT32.
1459 buffer = {ENCODING_TYPE_UINT32, 0xff, 0xff, 0xff, 0xff};
1460 error = Deserialize(&result, &buffer);
1461 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1462 EXPECT_EQ(0xffffffffU, result);
1463
1464 // UINT64 out of range.
1465 buffer = {ENCODING_TYPE_UINT64};
1466 error = Deserialize(&result, &buffer);
1467 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1468 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
1469 EXPECT_EQ(ENCODING_TYPE_UINT64, error.encoding_type());
1470}
1471
1472TEST(DeserializationTest, uint64_t) {
1473 Payload buffer;
1474 std::uint64_t result = 0;
1475 ErrorType error;
1476
1477 // Min FIXINT.
1478 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1479 error = Deserialize(&result, &buffer);
1480 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1481 EXPECT_EQ(0U, result);
1482
1483 // Max FIXINT.
1484 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1485 error = Deserialize(&result, &buffer);
1486 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1487 EXPECT_EQ(127U, result);
1488
1489 // Min UINT8.
1490 buffer = {ENCODING_TYPE_UINT8, 0x00};
1491 error = Deserialize(&result, &buffer);
1492 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1493 EXPECT_EQ(0U, result);
1494
1495 // Max UINT8.
1496 buffer = {ENCODING_TYPE_UINT8, 0xff};
1497 error = Deserialize(&result, &buffer);
1498 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1499 EXPECT_EQ(0xffU, result);
1500
1501 // Min UINT16.
1502 buffer = {ENCODING_TYPE_UINT16, 0x00, 0x00};
1503 error = Deserialize(&result, &buffer);
1504 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1505 EXPECT_EQ(0U, result);
1506
1507 // Max UINT16.
1508 buffer = {ENCODING_TYPE_UINT16, 0xff, 0xff};
1509 error = Deserialize(&result, &buffer);
1510 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1511 EXPECT_EQ(0xffffU, result);
1512
1513 // Min UINT32.
1514 buffer = {ENCODING_TYPE_UINT32, 0x00, 0x00, 0x00, 0x00};
1515 error = Deserialize(&result, &buffer);
1516 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1517 EXPECT_EQ(0U, result);
1518
1519 // Max UINT32.
1520 buffer = {ENCODING_TYPE_UINT32, 0xff, 0xff, 0xff, 0xff};
1521 error = Deserialize(&result, &buffer);
1522 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1523 EXPECT_EQ(0xffffffffU, result);
1524
1525 // Min UINT64.
1526 buffer = {
1527 ENCODING_TYPE_UINT64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1528 error = Deserialize(&result, &buffer);
1529 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1530 EXPECT_EQ(0U, result);
1531
1532 // Max UINT64.
1533 buffer = {
1534 ENCODING_TYPE_UINT64, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1535 error = Deserialize(&result, &buffer);
1536 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1537 EXPECT_EQ(0xffffffffffffffffUL, result);
1538}
1539
1540TEST(DeserializationTest, int8_t) {
1541 Payload buffer;
1542 std::int8_t result = 0;
1543 ErrorType error;
1544
1545 // Min NEGATIVE FIXINT.
1546 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
1547 error = Deserialize(&result, &buffer);
1548 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1549 EXPECT_EQ(-32, result);
1550
1551 // Max NEGATIVE FIXINT.
1552 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
1553 error = Deserialize(&result, &buffer);
1554 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1555 EXPECT_EQ(-1, result);
1556
1557 // Min FIXINT.
1558 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1559 error = Deserialize(&result, &buffer);
1560 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1561 EXPECT_EQ(0, result);
1562
1563 // Max FIXINT.
1564 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1565 error = Deserialize(&result, &buffer);
1566 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1567 EXPECT_EQ(127, result);
1568
1569 // Min INT8.
1570 buffer = {ENCODING_TYPE_INT8, 0x80};
1571 error = Deserialize(&result, &buffer);
1572 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1573 EXPECT_EQ(-128, result);
1574
1575 // Max INT8.
1576 buffer = {ENCODING_TYPE_INT8, 0x7f};
1577 error = Deserialize(&result, &buffer);
1578 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1579 EXPECT_EQ(127, result);
1580
1581 // INT16 out of range.
1582 buffer = {ENCODING_TYPE_INT16};
1583 error = Deserialize(&result, &buffer);
1584 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1585 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
1586 EXPECT_EQ(ENCODING_TYPE_INT16, error.encoding_type());
1587
1588 // INT32 out of range.
1589 buffer = {ENCODING_TYPE_INT32};
1590 error = Deserialize(&result, &buffer);
1591 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1592 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
1593 EXPECT_EQ(ENCODING_TYPE_INT32, error.encoding_type());
1594
1595 // INT64 out of range.
1596 buffer = {ENCODING_TYPE_INT64};
1597 error = Deserialize(&result, &buffer);
1598 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1599 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
1600 EXPECT_EQ(ENCODING_TYPE_INT64, error.encoding_type());
1601}
1602
1603TEST(DeserializationTest, int16_t) {
1604 Payload buffer;
1605 std::int16_t result = 0;
1606 ErrorType error;
1607
1608 // Min NEGATIVE FIXINT.
1609 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
1610 error = Deserialize(&result, &buffer);
1611 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1612 EXPECT_EQ(-32, result);
1613
1614 // Max NEGATIVE FIXINT.
1615 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
1616 error = Deserialize(&result, &buffer);
1617 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1618 EXPECT_EQ(-1, result);
1619
1620 // Min FIXINT.
1621 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1622 error = Deserialize(&result, &buffer);
1623 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1624 EXPECT_EQ(0, result);
1625
1626 // Max FIXINT.
1627 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1628 error = Deserialize(&result, &buffer);
1629 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1630 EXPECT_EQ(127, result);
1631
1632 // Min INT8.
1633 buffer = {ENCODING_TYPE_INT8, 0x80};
1634 error = Deserialize(&result, &buffer);
1635 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1636 EXPECT_EQ(-128, result);
1637
1638 // Max INT8.
1639 buffer = {ENCODING_TYPE_INT8, 0x7f};
1640 error = Deserialize(&result, &buffer);
1641 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1642 EXPECT_EQ(127, result);
1643
1644 // Min INT16.
1645 buffer = {ENCODING_TYPE_INT16, 0x00, 0x80};
1646 error = Deserialize(&result, &buffer);
1647 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1648 EXPECT_EQ(-32768, result);
1649
1650 // Max INT16.
1651 buffer = {ENCODING_TYPE_INT16, 0xff, 0x7f};
1652 error = Deserialize(&result, &buffer);
1653 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1654 EXPECT_EQ(32767, result);
1655
1656 // INT32 out of range.
1657 buffer = {ENCODING_TYPE_INT32};
1658 error = Deserialize(&result, &buffer);
1659 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1660 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
1661 EXPECT_EQ(ENCODING_TYPE_INT32, error.encoding_type());
1662
1663 // INT64 out of range.
1664 buffer = {ENCODING_TYPE_INT64};
1665 error = Deserialize(&result, &buffer);
1666 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1667 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
1668 EXPECT_EQ(ENCODING_TYPE_INT64, error.encoding_type());
1669}
1670
1671TEST(DeserializationTest, int32_t) {
1672 Payload buffer;
1673 std::int32_t result = 0;
1674 ErrorType error;
1675
1676 // Min NEGATIVE FIXINT.
1677 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
1678 error = Deserialize(&result, &buffer);
1679 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1680 EXPECT_EQ(-32, result);
1681
1682 // Max NEGATIVE FIXINT.
1683 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
1684 error = Deserialize(&result, &buffer);
1685 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1686 EXPECT_EQ(-1, result);
1687
1688 // Min FIXINT.
1689 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1690 error = Deserialize(&result, &buffer);
1691 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1692 EXPECT_EQ(0, result);
1693
1694 // Max FIXINT.
1695 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1696 error = Deserialize(&result, &buffer);
1697 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1698 EXPECT_EQ(127, result);
1699
1700 // Min INT8.
1701 buffer = {ENCODING_TYPE_INT8, 0x80};
1702 error = Deserialize(&result, &buffer);
1703 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1704 EXPECT_EQ(-128, result);
1705
1706 // Max INT8.
1707 buffer = {ENCODING_TYPE_INT8, 0x7f};
1708 error = Deserialize(&result, &buffer);
1709 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1710 EXPECT_EQ(127, result);
1711
1712 // Min INT16.
1713 buffer = {ENCODING_TYPE_INT16, 0x00, 0x80};
1714 error = Deserialize(&result, &buffer);
1715 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1716 EXPECT_EQ(-32768, result);
1717
1718 // Max INT16.
1719 buffer = {ENCODING_TYPE_INT16, 0xff, 0x7f};
1720 error = Deserialize(&result, &buffer);
1721 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1722 EXPECT_EQ(32767, result);
1723
1724 // Min INT32.
1725 buffer = {ENCODING_TYPE_INT32, 0x00, 0x00, 0x00, 0x80};
1726 error = Deserialize(&result, &buffer);
1727 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1728 EXPECT_EQ(-2147483648, result);
1729
1730 // Max INT32.
1731 buffer = {ENCODING_TYPE_INT32, 0xff, 0xff, 0xff, 0x7f};
1732 error = Deserialize(&result, &buffer);
1733 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1734 EXPECT_EQ(2147483647, result);
1735
1736 // INT64 out of range.
1737 buffer = {ENCODING_TYPE_INT64};
1738 error = Deserialize(&result, &buffer);
1739 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
1740 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
1741 EXPECT_EQ(ENCODING_TYPE_INT64, error.encoding_type());
1742}
1743
1744TEST(DeserializationTest, int64_t) {
1745 Payload buffer;
1746 std::int64_t result = 0;
1747 ErrorType error;
1748
1749 // Min NEGATIVE FIXINT.
1750 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MIN};
1751 error = Deserialize(&result, &buffer);
1752 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1753 EXPECT_EQ(-32, result);
1754
1755 // Max NEGATIVE FIXINT.
1756 buffer = {ENCODING_TYPE_NEGATIVE_FIXINT_MAX};
1757 error = Deserialize(&result, &buffer);
1758 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1759 EXPECT_EQ(-1, result);
1760
1761 // Min FIXINT.
1762 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN};
1763 error = Deserialize(&result, &buffer);
1764 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1765 EXPECT_EQ(0, result);
1766
1767 // Max FIXINT.
1768 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MAX};
1769 error = Deserialize(&result, &buffer);
1770 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1771 EXPECT_EQ(127, result);
1772
1773 // Min INT8.
1774 buffer = {ENCODING_TYPE_INT8, 0x80};
1775 error = Deserialize(&result, &buffer);
1776 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1777 EXPECT_EQ(-128, result);
1778
1779 // Max INT8.
1780 buffer = {ENCODING_TYPE_INT8, 0x7f};
1781 error = Deserialize(&result, &buffer);
1782 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1783 EXPECT_EQ(127, result);
1784
1785 // Min INT16.
1786 buffer = {ENCODING_TYPE_INT16, 0x00, 0x80};
1787 error = Deserialize(&result, &buffer);
1788 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1789 EXPECT_EQ(-32768, result);
1790
1791 // Max INT16.
1792 buffer = {ENCODING_TYPE_INT16, 0xff, 0x7f};
1793 error = Deserialize(&result, &buffer);
1794 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1795 EXPECT_EQ(32767, result);
1796
1797 // Min INT32.
1798 buffer = {ENCODING_TYPE_INT32, 0x00, 0x00, 0x00, 0x80};
1799 error = Deserialize(&result, &buffer);
1800 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1801 EXPECT_EQ(-2147483648, result);
1802
1803 // Max INT32.
1804 buffer = {ENCODING_TYPE_INT32, 0xff, 0xff, 0xff, 0x7f};
1805 error = Deserialize(&result, &buffer);
1806 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1807 EXPECT_EQ(2147483647, result);
1808
1809 // Min INT64.
1810 buffer = {
1811 ENCODING_TYPE_INT64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80};
1812 error = Deserialize(&result, &buffer);
1813 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1814 // Believe it or not, this is actually the correct way to specify the most
1815 // negative signed long long.
1816 EXPECT_EQ(-9223372036854775807LL - 1, result);
1817
1818 // Max INT64.
1819 buffer = {
1820 ENCODING_TYPE_INT64, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
1821 error = Deserialize(&result, &buffer);
1822 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1823 EXPECT_EQ(9223372036854775807LL, result);
1824}
1825
1826TEST(DeserializationTest, float) {
1827 Payload buffer;
1828 float result;
1829 ErrorType error;
1830
1831 // FLOAT32.
1832 buffer = {ENCODING_TYPE_FLOAT32, kZeroFloatBytes[0], kZeroFloatBytes[1],
1833 kZeroFloatBytes[2], kZeroFloatBytes[3]};
1834 error = Deserialize(&result, &buffer);
1835 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1836 EXPECT_EQ(kZeroFloat, result);
1837
1838 // FLOAT32.
1839 buffer = {ENCODING_TYPE_FLOAT32, kOneFloatBytes[0], kOneFloatBytes[1],
1840 kOneFloatBytes[2], kOneFloatBytes[3]};
1841 error = Deserialize(&result, &buffer);
1842 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1843 EXPECT_EQ(kOneFloat, result);
1844}
1845
1846TEST(DeserializationTest, double) {
1847 Payload buffer;
1848 double result;
1849 ErrorType error;
1850
1851 // FLOAT32.
1852 buffer = {ENCODING_TYPE_FLOAT32, kZeroFloatBytes[0], kZeroFloatBytes[1],
1853 kZeroFloatBytes[2], kZeroFloatBytes[3]};
1854 error = Deserialize(&result, &buffer);
1855 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1856 EXPECT_EQ(kZeroDouble, result);
1857
1858 // FLOAT64.
1859 buffer = {ENCODING_TYPE_FLOAT64, kZeroDoubleBytes[0], kZeroDoubleBytes[1],
1860 kZeroDoubleBytes[2], kZeroDoubleBytes[3], kZeroDoubleBytes[4],
1861 kZeroDoubleBytes[5], kZeroDoubleBytes[6], kZeroDoubleBytes[7]};
1862 error = Deserialize(&result, &buffer);
1863 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1864 EXPECT_EQ(kZeroDouble, result);
1865
1866 // FLOAT32.
1867 buffer = {ENCODING_TYPE_FLOAT32, kOneFloatBytes[0], kOneFloatBytes[1],
1868 kOneFloatBytes[2], kOneFloatBytes[3]};
1869 error = Deserialize(&result, &buffer);
1870 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1871 EXPECT_EQ(kOneDouble, result);
1872
1873 // FLOAT64.
1874 buffer = {ENCODING_TYPE_FLOAT64, kOneDoubleBytes[0], kOneDoubleBytes[1],
1875 kOneDoubleBytes[2], kOneDoubleBytes[3], kOneDoubleBytes[4],
1876 kOneDoubleBytes[5], kOneDoubleBytes[6], kOneDoubleBytes[7]};
1877 error = Deserialize(&result, &buffer);
1878 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1879 EXPECT_EQ(kOneDouble, result);
1880}
1881
1882TEST(DeserializationTest, Enum) {
1883 Payload buffer;
1884 enum Foo { kFoo, kBar, kBaz } result;
1885 ErrorType error;
1886
1887 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1};
1888 error = Deserialize(&result, &buffer);
1889 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1890 EXPECT_EQ(kBar, result);
1891}
1892
1893TEST(DeserializationTest, EnumClass) {
1894 Payload buffer;
1895 enum Foo { kFoo, kBar, kBaz } result;
1896 ErrorType error;
1897
1898 buffer = {ENCODING_TYPE_POSITIVE_FIXINT_MIN + 2};
1899 error = Deserialize(&result, &buffer);
1900 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1901 EXPECT_EQ(Foo::kBaz, result);
1902}
1903
1904TEST(DeserializationTest, LocalHandle) {
1905 Payload buffer;
1906 LocalHandle result1;
1907 LocalHandle result2;
1908 ErrorType error;
1909
1910 buffer = {ENCODING_TYPE_FIXEXT2, ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0, 0};
1911 error = Deserialize(&result1, &buffer);
1912 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1913 EXPECT_EQ(0, result1.Get());
1914 result1.Release(); // Don't close fd 0.
1915
1916 std::tuple<LocalHandle&, LocalHandle&> t1(result1, result2);
1917 buffer = decltype(buffer)(
1918 {ENCODING_TYPE_FIXARRAY_MIN + 2, ENCODING_TYPE_FIXEXT2,
1919 ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0, 0, ENCODING_TYPE_FIXEXT2,
1920 ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 1, 0});
1921 error = Deserialize(&t1, &buffer);
1922 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1923 EXPECT_EQ(0, result1.Get());
1924 EXPECT_EQ(1, result2.Get());
1925 result1.Release(); // Don't close fd 0.
1926 result2.Release(); // Don't close fd 1.
1927
1928 buffer = {ENCODING_TYPE_FIXEXT2, ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0xfe,
1929 0xff};
1930 error = Deserialize(&result1, &buffer);
1931 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1932 EXPECT_EQ(-2, result1.Get());
1933}
1934
1935TEST(DeserializationTest, string) {
1936 Payload buffer;
1937 std::string result = "";
1938 ErrorType error;
1939
1940 // Min FIXSTR.
1941 buffer = {ENCODING_TYPE_FIXSTR_MIN};
1942 error = Deserialize(&result, &buffer);
1943 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1944 EXPECT_EQ("", result);
1945
1946 // Max FIXSTR.
1947 buffer = {ENCODING_TYPE_FIXSTR_MAX};
1948 buffer.Append((1 << 5) - 1, 'x');
1949 error = Deserialize(&result, &buffer);
1950 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1951 EXPECT_EQ(std::string((1 << 5) - 1, 'x'), result);
1952
1953 // Min STR8.
1954 buffer = {ENCODING_TYPE_STR8, 0x00};
1955 error = Deserialize(&result, &buffer);
1956 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1957 EXPECT_EQ("", result);
1958
1959 // Max STR8.
1960 buffer = {ENCODING_TYPE_STR8, 0xff};
1961 buffer.Append(0xff, 'x');
1962 error = Deserialize(&result, &buffer);
1963 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1964 EXPECT_EQ(std::string(0xff, 'x'), result);
1965
1966 // Min STR16.
1967 buffer = {ENCODING_TYPE_STR16, 0x00, 0x00};
1968 error = Deserialize(&result, &buffer);
1969 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1970 EXPECT_EQ("", result);
1971
1972 // Max STR16.
1973 buffer = {ENCODING_TYPE_STR16, 0xff, 0xff};
1974 buffer.Append(0xffff, 'x');
1975 error = Deserialize(&result, &buffer);
1976 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1977 EXPECT_EQ(std::string(0xffff, 'x'), result);
1978
1979 // Min STR32.
1980 buffer = {ENCODING_TYPE_STR32, 0x00, 0x00, 0x00, 0x00};
1981 error = Deserialize(&result, &buffer);
1982 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1983 EXPECT_EQ("", result);
1984
1985 // Test STR32 with max STR16 + 1 bytes. It's not practical to test max
1986 // STR32.
1987 buffer = {ENCODING_TYPE_STR32, 0x00, 0x00, 0x01, 0x00};
1988 buffer.Append(0x10000, 'x');
1989 error = Deserialize(&result, &buffer);
1990 EXPECT_EQ(ErrorCode::NO_ERROR, error);
1991 EXPECT_EQ(std::string(0x10000, 'x'), result);
1992}
1993
1994TEST(DeserializationTest, vector) {
1995 Payload buffer;
1996 std::vector<std::uint8_t, DefaultInitializationAllocator<std::uint8_t>>
1997 result;
1998 Payload expected;
1999 ErrorType error;
2000
2001 // Min FIXARRAY.
2002 buffer = {ENCODING_TYPE_FIXARRAY_MIN};
2003 error = Deserialize(&result, &buffer);
2004 expected = {};
2005 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2006 EXPECT_EQ(expected, result);
2007
2008 // Max FIXARRAY.
2009 buffer = {ENCODING_TYPE_FIXARRAY_MAX};
2010 buffer.Append((1 << 4) - 1, 1);
2011 error = Deserialize(&result, &buffer);
2012 expected = decltype(expected)((1 << 4) - 1, 1);
2013 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2014 EXPECT_EQ(expected, result);
2015
2016 // Min ARRAY16.
2017 buffer = {ENCODING_TYPE_ARRAY16, 0x00, 0x00};
2018 error = Deserialize(&result, &buffer);
2019 expected = {};
2020 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2021 EXPECT_EQ(expected, result);
2022
2023 // Max ARRAY16.
2024 buffer = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
2025 buffer.Append(0xffff, 1);
2026 error = Deserialize(&result, &buffer);
2027 expected = decltype(expected)(0xffff, 1);
2028 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2029 EXPECT_EQ(expected, result);
2030
2031 // Min ARRAY32.
2032 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x00, 0x00};
2033 error = Deserialize(&result, &buffer);
2034 expected = {};
2035 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2036 EXPECT_EQ(expected, result);
2037
2038 // ARRAY32 with max ARRAY16 + 1. It's not practical to test max ARRAY32.
2039 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
2040 buffer.Append(0x10000, 1);
2041 error = Deserialize(&result, &buffer);
2042 expected = decltype(expected)(0x10000, 1);
2043 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2044 EXPECT_EQ(expected, result);
2045}
2046
2047TEST(DeserializationTest, map) {
2048 Payload buffer;
2049 std::map<std::uint32_t, std::uint32_t> result;
2050 std::map<std::uint32_t, std::uint32_t> expected;
2051 ErrorType error;
2052
2053 // Min FIXMAP.
2054 buffer = {ENCODING_TYPE_FIXMAP_MIN};
2055 error = Deserialize(&result, &buffer);
2056 expected = {};
2057 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2058 EXPECT_EQ(expected, result);
2059
2060 // Size mismatch.
2061 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1};
2062 error = Deserialize(&result, &buffer);
2063 EXPECT_EQ(ErrorCode::INSUFFICIENT_BUFFER, error);
2064
2065 // Max FIXMAP.
2066 buffer = {ENCODING_TYPE_FIXMAP_MAX};
2067 InsertKeyValue<decltype(result)>(&buffer, (1 << 4) - 1);
2068 error = Deserialize(&result, &buffer);
2069 expected = MakeMap<decltype(expected)>((1 << 4) - 1);
2070 EXPECT_EQ(ErrorCode::NO_ERROR, error) << std::string(error);
2071 EXPECT_EQ(expected, result);
2072
2073 // Min MAP16.
2074 buffer = {ENCODING_TYPE_MAP16, 0x00, 0x00};
2075 error = Deserialize(&result, &buffer);
2076 expected = {};
2077 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2078 EXPECT_EQ(expected, result);
2079
2080 // Max MAP16.
2081 buffer = {ENCODING_TYPE_MAP16, 0xff, 0xff};
2082 InsertKeyValue<decltype(result)>(&buffer, (1 << 16) - 1);
2083 error = Deserialize(&result, &buffer);
2084 expected = MakeMap<decltype(expected)>((1 << 16) - 1);
2085 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2086 EXPECT_EQ(expected, result);
2087
2088 // Min MAP32.
2089 buffer = {ENCODING_TYPE_MAP32, 0x00, 0x00, 0x00, 0x00};
2090 error = Deserialize(&result, &buffer);
2091 expected = {};
2092 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2093 EXPECT_EQ(expected, result);
2094
2095 // MAP32 with max MAP16 + 1. It's not practical to test max MAP32.
2096 buffer = {ENCODING_TYPE_MAP32, 0x00, 0x00, 0x01, 0x00};
2097 InsertKeyValue<decltype(result)>(&buffer, (1 << 16));
2098 error = Deserialize(&result, &buffer);
2099 expected = MakeMap<decltype(expected)>((1 << 16));
2100 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2101 EXPECT_EQ(expected, result);
2102}
2103
2104TEST(DeserializationTest, unordered_map) {
2105 Payload buffer;
2106 std::unordered_map<std::uint32_t, std::uint32_t> result;
2107 std::unordered_map<std::uint32_t, std::uint32_t> expected;
2108 ErrorType error;
2109
2110 // Min FIXMAP.
2111 buffer = {ENCODING_TYPE_FIXMAP_MIN};
2112 error = Deserialize(&result, &buffer);
2113 expected = {};
2114 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2115 EXPECT_EQ(expected, result);
2116
2117 // Size mismatch.
2118 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1};
2119 error = Deserialize(&result, &buffer);
2120 EXPECT_EQ(ErrorCode::INSUFFICIENT_BUFFER, error);
2121
2122 // Max FIXMAP.
2123 buffer = {ENCODING_TYPE_FIXMAP_MAX};
2124 InsertKeyValue<decltype(result)>(&buffer, (1 << 4) - 1);
2125 error = Deserialize(&result, &buffer);
2126 expected = MakeMap<decltype(expected)>((1 << 4) - 1);
2127 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2128 EXPECT_EQ(expected, result);
2129
2130 // Min MAP16.
2131 buffer = {ENCODING_TYPE_MAP16, 0x00, 0x00};
2132 error = Deserialize(&result, &buffer);
2133 expected = {};
2134 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2135 EXPECT_EQ(expected, result);
2136
2137 // Max MAP16.
2138 buffer = {ENCODING_TYPE_MAP16, 0xff, 0xff};
2139 InsertKeyValue<decltype(result)>(&buffer, (1 << 16) - 1);
2140 error = Deserialize(&result, &buffer);
2141 expected = MakeMap<decltype(expected)>((1 << 16) - 1);
2142 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2143 EXPECT_EQ(expected, result);
2144
2145 // Min MAP32.
2146 buffer = {ENCODING_TYPE_MAP32, 0x00, 0x00, 0x00, 0x00};
2147 error = Deserialize(&result, &buffer);
2148 expected = {};
2149 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2150 EXPECT_EQ(expected, result);
2151
2152 // MAP32 with max MAP16 + 1. It's not practical to test max MAP32.
2153 buffer = {ENCODING_TYPE_MAP32, 0x00, 0x00, 0x01, 0x00};
2154 InsertKeyValue<decltype(result)>(&buffer, (1 << 16));
2155 error = Deserialize(&result, &buffer);
2156 expected = MakeMap<decltype(expected)>((1 << 16));
2157 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2158 EXPECT_EQ(expected, result);
2159}
2160
2161TEST(DeserializationTest, array) {
2162 Payload buffer;
2163 ErrorType error;
2164
2165 // Min FIXARRAY.
2166 buffer = {ENCODING_TYPE_FIXARRAY_MIN};
2167 std::array<std::uint8_t, 0> a0;
2168 error = Deserialize(&a0, &buffer);
2169 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2170
2171 // Size mismatch.
2172 buffer = {ENCODING_TYPE_FIXARRAY_MIN + 1};
2173 error = Deserialize(&a0, &buffer);
2174 EXPECT_EQ(ErrorCode::INSUFFICIENT_DESTINATION_SIZE, error);
2175
2176 // Max FIXARRAY.
2177 buffer = {ENCODING_TYPE_FIXARRAY_MAX};
2178 buffer.Append((1 << 4) - 1, 'x');
2179 std::array<std::uint8_t, (1 << 4) - 1> a1, expected1;
2180 for (auto& element : expected1)
2181 element = 'x';
2182 error = Deserialize(&a1, &buffer);
2183 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2184 EXPECT_EQ(expected1, a1);
2185
2186 // Min ARRAY16.
2187 buffer = {ENCODING_TYPE_ARRAY16, 0x00, 0x00};
2188 error = Deserialize(&a0, &buffer);
2189 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2190
2191 // Max ARRAY16.
2192 buffer = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
2193 buffer.Append((1 << 16) - 1, 'x');
2194 std::array<std::uint8_t, (1 << 16) - 1> a3, expected3;
2195 for (auto& element : expected3)
2196 element = 'x';
2197 error = Deserialize(&a3, &buffer);
2198 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2199 EXPECT_EQ(expected3, a3);
2200
2201 // Min ARRAY32.
2202 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x00, 0x00};
2203 error = Deserialize(&a0, &buffer);
2204 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2205
2206 // ARRAY32 with max ARRAY16 + 1. It's not practical to test max ARRAY32.
2207 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
2208 buffer.Append((1 << 16), 'x');
2209 std::array<std::uint8_t, (1 << 16)> a4, expected4;
2210 for (auto& element : expected4)
2211 element = 'x';
2212 error = Deserialize(&a4, &buffer);
2213 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2214 EXPECT_EQ(expected4, a4);
2215}
2216
2217TEST(DeserializationTest, ArrayWrapper) {
2218 Payload buffer;
2219 std::vector<std::uint8_t, DefaultInitializationAllocator<std::uint8_t>>
2220 result;
2221 std::vector<std::uint8_t, DefaultInitializationAllocator<std::uint8_t>>
2222 expected;
2223 ErrorType error;
2224
2225 result.reserve(0x10000);
2226 ArrayWrapper<std::uint8_t> wrapper(result.data(), result.capacity());
2227
2228 // Min FIXARRAY.
2229 buffer = {ENCODING_TYPE_FIXARRAY_MIN};
2230 error = Deserialize(&wrapper, &buffer);
2231 expected = {};
2232 result.resize(wrapper.size());
2233 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2234 EXPECT_EQ(expected, result);
2235
2236 // Max FIXARRAY.
2237 buffer = {ENCODING_TYPE_FIXARRAY_MAX};
2238 buffer.Append((1 << 4) - 1, 1);
2239 error = Deserialize(&wrapper, &buffer);
2240 expected = decltype(expected)((1 << 4) - 1, 1);
2241 result.resize(wrapper.size());
2242 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2243 EXPECT_EQ(expected, result);
2244
2245 // Min ARRAY16.
2246 buffer = {ENCODING_TYPE_ARRAY16, 0x00, 0x00};
2247 error = Deserialize(&wrapper, &buffer);
2248 expected = {};
2249 result.resize(wrapper.size());
2250 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2251 EXPECT_EQ(expected, result);
2252
2253 // Max ARRAY16.
2254 buffer = {ENCODING_TYPE_ARRAY16, 0xff, 0xff};
2255 buffer.Append(0xffff, 1);
2256 error = Deserialize(&wrapper, &buffer);
2257 expected = decltype(expected)(0xffff, 1);
2258 result.resize(wrapper.size());
2259 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2260 EXPECT_EQ(expected, result);
2261
2262 // Min ARRAY32.
2263 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x00, 0x00};
2264 error = Deserialize(&wrapper, &buffer);
2265 expected = {};
2266 result.resize(wrapper.size());
2267 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2268 EXPECT_EQ(expected, result);
2269
2270 // ARRAY32 with max ARRAY16 + 1. It's not practical to test max ARRAY32.
2271 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x01, 0x00};
2272 buffer.Append(0x10000, 1);
2273 error = Deserialize(&wrapper, &buffer);
2274 expected = decltype(expected)(0x10000, 1);
2275 result.resize(wrapper.size());
2276 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2277 EXPECT_EQ(expected, result);
2278}
2279
2280TEST(DeserializationTest, pair) {
2281 Payload buffer;
2282 ErrorType error;
2283
2284 std::pair<int, int> p1;
2285 buffer = {ENCODING_TYPE_FIXARRAY_MIN + 2, 1, 2};
2286 error = Deserialize(&p1, &buffer);
2287 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2288 EXPECT_EQ(std::make_pair(1, 2), p1);
2289}
2290
2291TEST(DeserializationTest, tuple) {
2292 Payload buffer;
2293 ErrorType error;
2294
2295 // Min FIXARRAY.
2296 std::tuple<> t1;
2297 buffer = {ENCODING_TYPE_FIXARRAY_MIN};
2298 error = Deserialize(&t1, &buffer);
2299 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2300 EXPECT_EQ(std::make_tuple(), t1); // Superfluous.
2301
2302 // Max FIXARRAY.
2303 auto t2 = GetNTuple<15, int>(0);
2304 buffer = {ENCODING_TYPE_FIXARRAY_MAX};
2305 buffer.Append((1 << 4) - 1, 1);
2306 error = Deserialize(&t2, &buffer);
2307 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2308 EXPECT_EQ((GetNTuple<15, int>(1)), t2);
2309
2310 // Min ARRAY16.
2311 // Using t1 above.
2312 buffer = {ENCODING_TYPE_ARRAY16, 0x00, 0x00};
2313 error = Deserialize(&t1, &buffer);
2314 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2315 EXPECT_EQ(std::make_tuple(), t1);
2316
2317 // ARRAY16 at Max FIXARRAY + 1
2318 auto t3 = GetNTuple<(1 << 4), int>(0);
2319 buffer = {ENCODING_TYPE_ARRAY16, 0x10, 0x00};
2320 buffer.Append((1 << 4), 1);
2321 error = Deserialize(&t3, &buffer);
2322 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2323 EXPECT_EQ((GetNTuple<(1 << 4), int>(1)), t3);
2324
2325 // Min ARRAY32.
2326 // Using t1 from above.
2327 buffer = {ENCODING_TYPE_ARRAY32, 0x00, 0x00, 0x00, 0x00};
2328 error = Deserialize(&t1, &buffer);
2329 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2330 EXPECT_EQ(std::make_tuple(), t1);
2331
2332 // ARRAY32 at Max FIXARRAY + 1
2333 auto t4 = GetNTuple<(1 << 4), int>(0);
2334 buffer = {ENCODING_TYPE_ARRAY32, 0x10, 0x00, 0x00, 0x00};
2335 buffer.Append((1 << 4), 1);
2336 error = Deserialize(&t4, &buffer);
2337 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2338 EXPECT_EQ((GetNTuple<(1 << 4), int>(1)), t4);
2339
2340 // Template instantiation depth is an issue for tuples with large numbers of
2341 // elements. As these are not expected in practice, the limits of ARRAY16
2342 // and ARRAY32 are not tested.
2343}
2344
2345TEST(DeserializationTest, Serializable) {
2346 Payload buffer;
2347 ErrorType error;
2348
2349 buffer = decltype(buffer)(
2350 {ENCODING_TYPE_FIXARRAY_MIN + 4, 10, ENCODING_TYPE_FLOAT32,
2351 kZeroFloatBytes[0], kZeroFloatBytes[1], kZeroFloatBytes[2],
2352 kZeroFloatBytes[3], ENCODING_TYPE_FIXSTR_MIN + 5, '1', '2', '3', '4',
2353 '5', ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1});
2354 TestType t1;
2355 error = Deserialize(&t1, &buffer);
2356 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2357 EXPECT_EQ(TestType(10, 0.f, "12345", TestType::Foo::kBar), t1);
2358
2359 buffer =
2360 decltype(buffer)({ENCODING_TYPE_FIXARRAY_MIN + 1, ENCODING_TYPE_FIXEXT2,
2361 ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 0xff, 0xff});
2362 TestTemplateType<LocalHandle> tt;
2363 error = Deserialize(&tt, &buffer);
2364 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2365 EXPECT_EQ(TestTemplateType<LocalHandle>(LocalHandle(-1)), tt);
2366}
2367
2368TEST(DeserializationTest, Variant) {
2369 Payload buffer;
2370 ErrorType error;
2371
2372 Variant<int, bool, float> v;
2373
2374 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1, ENCODING_TYPE_NEGATIVE_FIXINT_MAX,
2375 ENCODING_TYPE_NIL};
2376 error = Deserialize(&v, &buffer);
2377 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2378 EXPECT_TRUE(v.empty());
2379
2380 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1, ENCODING_TYPE_POSITIVE_FIXINT_MIN + 0,
2381 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 10};
2382 error = Deserialize(&v, &buffer);
2383 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2384 ASSERT_TRUE(v.is<int>());
2385 EXPECT_EQ(10, std::get<int>(v));
2386
2387 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1, ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1,
2388 ENCODING_TYPE_TRUE};
2389 error = Deserialize(&v, &buffer);
2390 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2391 ASSERT_TRUE(v.is<bool>());
2392 EXPECT_EQ(true, std::get<bool>(v));
2393
2394 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1, ENCODING_TYPE_POSITIVE_FIXINT_MIN + 1,
2395 ENCODING_TYPE_FALSE};
2396 error = Deserialize(&v, &buffer);
2397 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2398 ASSERT_TRUE(v.is<bool>());
2399 EXPECT_EQ(false, std::get<bool>(v));
2400
2401 buffer = {ENCODING_TYPE_FIXMAP_MIN + 1,
2402 ENCODING_TYPE_POSITIVE_FIXINT_MIN + 2,
2403 ENCODING_TYPE_FLOAT32,
2404 kOneFloatBytes[0],
2405 kOneFloatBytes[1],
2406 kOneFloatBytes[2],
2407 kOneFloatBytes[3]};
2408 error = Deserialize(&v, &buffer);
2409 EXPECT_EQ(ErrorCode::NO_ERROR, error);
2410 ASSERT_TRUE(v.is<float>());
2411 EXPECT_FLOAT_EQ(1.0, std::get<float>(v));
2412
2413 // TODO(eieio): Add more deserialization tests for Variant.
2414}
2415
2416TEST(DeserializationTest, ErrorType) {
2417 Payload buffer;
2418 ErrorType error;
2419
2420 std::uint8_t u8;
2421 buffer = {ENCODING_TYPE_STR8};
2422 error = Deserialize(&u8, &buffer);
2423 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2424 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
2425 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2426
2427 std::uint16_t u16;
2428 buffer = {ENCODING_TYPE_STR8};
2429 error = Deserialize(&u16, &buffer);
2430 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2431 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
2432 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2433
2434 std::uint32_t u32;
2435 buffer = {ENCODING_TYPE_STR8};
2436 error = Deserialize(&u32, &buffer);
2437 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2438 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
2439 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2440
2441 std::uint64_t u64;
2442 buffer = {ENCODING_TYPE_STR8};
2443 error = Deserialize(&u64, &buffer);
2444 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2445 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
2446 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2447
2448 std::int8_t i8;
2449 buffer = {ENCODING_TYPE_STR8};
2450 error = Deserialize(&i8, &buffer);
2451 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2452 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
2453 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2454
2455 std::int16_t i16;
2456 buffer = {ENCODING_TYPE_STR8};
2457 error = Deserialize(&i16, &buffer);
2458 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2459 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
2460 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2461
2462 std::int32_t i32;
2463 buffer = {ENCODING_TYPE_STR8};
2464 error = Deserialize(&i32, &buffer);
2465 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2466 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
2467 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2468
2469 std::int64_t i64;
2470 buffer = {ENCODING_TYPE_STR8};
2471 error = Deserialize(&i64, &buffer);
2472 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2473 EXPECT_EQ(ENCODING_CLASS_INT, error.encoding_class());
2474 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2475
2476 std::string s;
2477 buffer = {ENCODING_TYPE_POSITIVE_FIXINT};
2478 error = Deserialize(&s, &buffer);
2479 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2480 EXPECT_EQ(ENCODING_CLASS_STRING, error.encoding_class());
2481 EXPECT_EQ(ENCODING_TYPE_POSITIVE_FIXINT, error.encoding_type());
2482
2483 std::vector<std::uint8_t> v;
2484 buffer = {ENCODING_TYPE_POSITIVE_FIXINT};
2485 error = Deserialize(&v, &buffer);
2486 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2487 EXPECT_EQ(ENCODING_CLASS_ARRAY, error.encoding_class());
2488 EXPECT_EQ(ENCODING_TYPE_POSITIVE_FIXINT, error.encoding_type());
2489
2490 buffer = {ENCODING_TYPE_FIXARRAY_MIN + 1, ENCODING_TYPE_STR8};
2491 error = Deserialize(&v, &buffer);
2492 EXPECT_EQ(ErrorCode::UNEXPECTED_ENCODING, error);
2493 EXPECT_EQ(ENCODING_CLASS_UINT, error.encoding_class());
2494 EXPECT_EQ(ENCODING_TYPE_STR8, error.encoding_type());
2495
2496 buffer = {ENCODING_TYPE_FIXARRAY_MIN + 2, 0, 1};
2497 std::tuple<int> t;
2498 error = Deserialize(&t, &buffer);
2499 EXPECT_EQ(ErrorCode::UNEXPECTED_TYPE_SIZE, error);
2500
2501 buffer = {ENCODING_TYPE_FIXARRAY_MIN + 3, 0, 1, 2};
2502 std::pair<int, int> p;
2503 error = Deserialize(&p, &buffer);
2504 EXPECT_EQ(ErrorCode::UNEXPECTED_TYPE_SIZE, error);
2505}