1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gtest/gtest.h>
18
19 #include <forward_list>
20 #include <memory>
21
22 #define PACKET_TESTING
23
24 #include "packet/bit_inserter.h"
25 #include "packet/parser/test/big_endian_test_packets.h"
26 #include "packet/parser/test/six_bytes.h"
27 #include "packet/parser/test/test_packets.h"
28 #include "packet/raw_builder.h"
29
30 using ::bluetooth::packet::BitInserter;
31 using ::bluetooth::packet::kLittleEndian;
32 using ::bluetooth::packet::RawBuilder;
33 using ::bluetooth::packet::parser::test::SixBytes;
34 using std::vector;
35
36 namespace {
37 vector<uint8_t> child_two_two_three = {
38 0x20 /* Reserved : 4, FourBits::TWO */,
39 0x03 /* FourBits::THREE, Reserved : 4 */,
40 };
41 vector<uint8_t> child = {
42 0x12 /* fixed */,
43 0x02 /* Size of the payload */,
44 0xa1 /* First byte of the payload */,
45 0xa2,
46 0xb1 /* footer */,
47 };
48 vector<uint8_t> child_with_six_bytes = {
49 0x34 /* TwoBytes */,
50 0x12,
51 0xa1 /* First byte of the six_bytes */,
52 0xa2,
53 0xa3,
54 0xa4,
55 0xa5,
56 0xa6,
57 0xb1 /* Second six_bytes*/,
58 0xb2,
59 0xb3,
60 0xb4,
61 0xb5,
62 0xb6,
63 };
64
65 } // namespace
66
67 namespace bluetooth {
68 namespace packet {
69 namespace parser {
70 using namespace test;
71
TEST(GeneratedPacketTest,testChildTwoTwoThree)72 TEST(GeneratedPacketTest, testChildTwoTwoThree) {
73 auto packet = ChildTwoTwoThreeBuilder::Create();
74
75 ASSERT_EQ(child_two_two_three.size(), packet->size());
76
77 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
78 BitInserter it(*packet_bytes);
79 packet->Serialize(it);
80
81 ASSERT_EQ(packet_bytes->size(), child_two_two_three.size());
82 for (size_t i = 0; i < child_two_two_three.size(); i++) {
83 ASSERT_EQ(packet_bytes->at(i), child_two_two_three[i]);
84 }
85
86 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
87 ParentView wrong_view = ParentView::Create(packet_bytes_view);
88 ASSERT_FALSE(wrong_view.IsValid());
89
90 ParentTwoView parent_view = ParentTwoView::Create(packet_bytes_view);
91 ASSERT_TRUE(parent_view.IsValid());
92 ASSERT_EQ(FourBits::TWO, parent_view.GetFourBits());
93
94 ChildTwoTwoView child_view = ChildTwoTwoView::Create(parent_view);
95 ASSERT_TRUE(child_view.IsValid());
96 ASSERT_EQ(FourBits::THREE, child_view.GetMoreBits());
97
98 ChildTwoTwoThreeView grandchild_view = ChildTwoTwoThreeView::Create(child_view);
99 ASSERT_TRUE(grandchild_view.IsValid());
100 }
101
TEST(GeneratedPacketTest,testChild)102 TEST(GeneratedPacketTest, testChild) {
103 uint16_t field_name = 0xa2a1;
104 uint8_t footer = 0xb1;
105 auto packet = ChildBuilder::Create(field_name, footer);
106
107 ASSERT_EQ(child.size(), packet->size());
108
109 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
110 BitInserter it(*packet_bytes);
111 packet->Serialize(it);
112
113 ASSERT_EQ(packet_bytes->size(), child.size());
114 for (size_t i = 0; i < child.size(); i++) {
115 ASSERT_EQ(packet_bytes->at(i), child[i]);
116 }
117
118 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
119 ParentView parent_view = ParentView::Create(packet_bytes_view);
120 ASSERT_TRUE(parent_view.IsValid());
121 auto payload = parent_view.GetPayload();
122
123 ASSERT_EQ(child[1 /* skip fixed field */], payload.size());
124 for (size_t i = 0; i < payload.size(); i++) {
125 ASSERT_EQ(child[i + 2 /* fixed & size */], payload[i]);
126 }
127
128 ChildView child_view = ChildView::Create(parent_view);
129 ASSERT_TRUE(child_view.IsValid());
130
131 ASSERT_EQ(field_name, child_view.GetFieldName());
132 }
133
TEST(GeneratedPacketTest,testValidateWayTooSmall)134 TEST(GeneratedPacketTest, testValidateWayTooSmall) {
135 std::vector<uint8_t> too_small_bytes = {0x34};
136 auto too_small =
137 std::make_shared<std::vector<uint8_t>>(too_small_bytes.begin(), too_small_bytes.end());
138
139 ParentWithSixBytesView invalid_parent =
140 ParentWithSixBytesView::Create(PacketView<kLittleEndian>(too_small));
141 ASSERT_FALSE(invalid_parent.IsValid());
142 ChildWithSixBytesView invalid = ChildWithSixBytesView::Create(
143 ParentWithSixBytesView::Create(PacketView<kLittleEndian>(too_small)));
144 ASSERT_FALSE(invalid.IsValid());
145 }
146
TEST(GeneratedPacketTest,testValidateTooSmall)147 TEST(GeneratedPacketTest, testValidateTooSmall) {
148 std::vector<uint8_t> too_small_bytes = {0x34, 0x12, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x11};
149 auto too_small =
150 std::make_shared<std::vector<uint8_t>>(too_small_bytes.begin(), too_small_bytes.end());
151
152 ParentWithSixBytesView valid_parent =
153 ParentWithSixBytesView::Create(PacketView<kLittleEndian>(too_small));
154 ASSERT_TRUE(valid_parent.IsValid());
155 ChildWithSixBytesView invalid = ChildWithSixBytesView::Create(
156 ParentWithSixBytesView::Create(PacketView<kLittleEndian>(too_small)));
157 ASSERT_FALSE(invalid.IsValid());
158 }
159
TEST(GeneratedPacketTest,testValidateJustRight)160 TEST(GeneratedPacketTest, testValidateJustRight) {
161 std::vector<uint8_t> just_right_bytes = {0x34, 0x12, 0x01, 0x02, 0x03, 0x04, 0x05,
162 0x06, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
163 auto just_right =
164 std::make_shared<std::vector<uint8_t>>(just_right_bytes.begin(), just_right_bytes.end());
165
166 ChildWithSixBytesView valid = ChildWithSixBytesView::Create(
167 ParentWithSixBytesView::Create(PacketView<kLittleEndian>(just_right)));
168 ASSERT_TRUE(valid.IsValid());
169 }
170
TEST(GeneratedPacketTest,testValidateTooBig)171 TEST(GeneratedPacketTest, testValidateTooBig) {
172 std::vector<uint8_t> too_big_bytes = {0x34, 0x12, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
173 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x20};
174 auto too_big = std::make_shared<std::vector<uint8_t>>(too_big_bytes.begin(), too_big_bytes.end());
175
176 ChildWithSixBytesView lenient = ChildWithSixBytesView::Create(
177 ParentWithSixBytesView::Create(PacketView<kLittleEndian>(too_big)));
178 ASSERT_TRUE(lenient.IsValid());
179 }
180
TEST(GeneratedPacketTest,testValidateDeath)181 TEST(GeneratedPacketTest, testValidateDeath) {
182 auto packet = ChildTwoTwoThreeBuilder::Create();
183
184 ASSERT_EQ(child_two_two_three.size(), packet->size());
185
186 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
187 BitInserter it(*packet_bytes);
188 packet->Serialize(it);
189
190 ASSERT_EQ(packet_bytes->size(), child_two_two_three.size());
191 for (size_t i = 0; i < child_two_two_three.size(); i++) {
192 ASSERT_EQ(packet_bytes->at(i), child_two_two_three[i]);
193 }
194
195 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
196 ParentView wrong_view = ParentView::Create(packet_bytes_view);
197 ASSERT_DEATH(wrong_view.GetPayload(), "validated");
198 }
199
TEST(GeneratedPacketTest,testValidatedParentDeath)200 TEST(GeneratedPacketTest, testValidatedParentDeath) {
201 uint16_t field_name = 0xa2a1;
202 uint8_t footer = 0xb1;
203 auto packet = ChildBuilder::Create(field_name, footer);
204
205 ASSERT_EQ(child.size(), packet->size());
206
207 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
208 BitInserter it(*packet_bytes);
209 packet->Serialize(it);
210
211 ASSERT_EQ(packet_bytes->size(), child.size());
212 for (size_t i = 0; i < child.size(); i++) {
213 ASSERT_EQ(packet_bytes->at(i), child[i]);
214 }
215
216 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
217 ParentView parent_view = ParentView::Create(packet_bytes_view);
218 ASSERT_TRUE(parent_view.IsValid());
219 auto payload = parent_view.GetPayload();
220
221 ASSERT_EQ(child[1 /* skip fixed field */], payload.size());
222 for (size_t i = 0; i < payload.size(); i++) {
223 ASSERT_EQ(child[i + 2 /* fixed & size */], payload[i]);
224 }
225
226 ChildView child_view = ChildView::Create(parent_view);
227 ASSERT_DEATH(child_view.GetFieldName(), "validated");
228 }
229
230 vector<uint8_t> middle_four_bits = {
231 0x95, // low_two = ONE, next_four = FIVE, straddle = TEN
232 0x8a, // straddle = TEN, four_more = TWO, high_two = TWO
233 };
234
TEST(GeneratedPacketTest,testMiddleFourBitsPacket)235 TEST(GeneratedPacketTest, testMiddleFourBitsPacket) {
236 TwoBits low_two = TwoBits::ONE;
237 FourBits next_four = FourBits::FIVE;
238 FourBits straddle = FourBits::TEN;
239 FourBits four_more = FourBits::TWO;
240 TwoBits high_two = TwoBits::TWO;
241
242 auto packet = MiddleFourBitsBuilder::Create(low_two, next_four, straddle, four_more, high_two);
243
244 ASSERT_EQ(middle_four_bits.size(), packet->size());
245
246 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
247 BitInserter it(*packet_bytes);
248 packet->Serialize(it);
249
250 ASSERT_EQ(packet_bytes->size(), middle_four_bits.size());
251 for (size_t i = 0; i < middle_four_bits.size(); i++) {
252 ASSERT_EQ(packet_bytes->at(i), middle_four_bits[i]);
253 }
254
255 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
256 MiddleFourBitsView view = MiddleFourBitsView::Create(packet_bytes_view);
257 ASSERT_TRUE(view.IsValid());
258 ASSERT_EQ(low_two, view.GetLowTwo());
259 ASSERT_EQ(next_four, view.GetNextFour());
260 ASSERT_EQ(straddle, view.GetStraddle());
261 ASSERT_EQ(four_more, view.GetFourMore());
262 ASSERT_EQ(high_two, view.GetHighTwo());
263 }
264
TEST(GeneratedPacketTest,testChildWithSixBytes)265 TEST(GeneratedPacketTest, testChildWithSixBytes) {
266 SixBytes six_bytes_a{{0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6}};
267 SixBytes six_bytes_b{{0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6}};
268 auto packet = ChildWithSixBytesBuilder::Create(six_bytes_a, six_bytes_b);
269
270 ASSERT_EQ(child_with_six_bytes.size(), packet->size());
271
272 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
273 BitInserter it(*packet_bytes);
274 packet->Serialize(it);
275
276 ASSERT_EQ(packet_bytes->size(), child_with_six_bytes.size());
277 for (size_t i = 0; i < child_with_six_bytes.size(); i++) {
278 ASSERT_EQ(packet_bytes->at(i), child_with_six_bytes[i]);
279 }
280
281 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
282 ParentWithSixBytesView parent_view = ParentWithSixBytesView::Create(packet_bytes_view);
283 ASSERT_TRUE(parent_view.IsValid());
284 ASSERT_EQ(six_bytes_a, parent_view.GetSixBytes());
285
286 ChildWithSixBytesView child_view = ChildWithSixBytesView::Create(parent_view);
287 ASSERT_TRUE(child_view.IsValid());
288
289 ASSERT_EQ(six_bytes_a, child_view.GetSixBytes());
290 ASSERT_EQ(six_bytes_a, ((ParentWithSixBytesView)child_view).GetSixBytes());
291 ASSERT_EQ(six_bytes_b, child_view.GetChildSixBytes());
292 }
293
294 namespace {
295 vector<uint8_t> parent_with_sum = {
296 0x11 /* TwoBytes */,
297 0x12,
298 0x21 /* Sum Bytes */,
299 0x22,
300 0x43 /* Sum, excluding TwoBytes */,
301 0x00,
302 };
303
304 } // namespace
305
TEST(GeneratedPacketTest,testParentWithSum)306 TEST(GeneratedPacketTest, testParentWithSum) {
307 uint16_t two_bytes = 0x1211;
308 uint16_t sum_bytes = 0x2221;
309 auto packet = ParentWithSumBuilder::Create(two_bytes, sum_bytes,
310 std::make_unique<packet::RawBuilder>());
311
312 ASSERT_EQ(parent_with_sum.size(), packet->size());
313
314 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
315 BitInserter it(*packet_bytes);
316 packet->Serialize(it);
317
318 ASSERT_EQ(packet_bytes->size(), parent_with_sum.size());
319 for (size_t i = 0; i < parent_with_sum.size(); i++) {
320 ASSERT_EQ(packet_bytes->at(i), parent_with_sum[i]);
321 }
322
323 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
324 ParentWithSumView parent_view = ParentWithSumView::Create(packet_bytes_view);
325 ASSERT_TRUE(parent_view.IsValid());
326 ASSERT_EQ(two_bytes, parent_view.GetTwoBytes());
327
328 // Corrupt checksum
329 packet_bytes->back()++;
330 PacketView<kLittleEndian> corrupted_bytes_view(packet_bytes);
331 ParentWithSumView corrupted_view = ParentWithSumView::Create(corrupted_bytes_view);
332 ASSERT_FALSE(corrupted_view.IsValid());
333 }
334
335 namespace {
336 vector<uint8_t> child_with_nested_sum = {
337 0x11 /* TwoBytes */,
338 0x12,
339 0x21 /* Sum Bytes */,
340 0x22,
341 0x31 /* More Bytes */,
342 0x32,
343 0x33,
344 0x34,
345 0xca /* Nested Sum */,
346 0x00,
347 0xd7 /* Sum, excluding TwoBytes */,
348 0x01,
349 };
350
351 } // namespace
352
TEST(GeneratedPacketTest,testChildWithNestedSum)353 TEST(GeneratedPacketTest, testChildWithNestedSum) {
354 uint16_t two_bytes = 0x1211;
355 uint16_t sum_bytes = 0x2221;
356 uint32_t more_bytes = 0x34333231;
357 auto packet = ChildWithNestedSumBuilder::Create(two_bytes, sum_bytes, more_bytes);
358
359 ASSERT_EQ(child_with_nested_sum.size(), packet->size());
360
361 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
362 BitInserter it(*packet_bytes);
363 packet->Serialize(it);
364
365 ASSERT_EQ(packet_bytes->size(), child_with_nested_sum.size());
366 for (size_t i = 0; i < child_with_nested_sum.size(); i++) {
367 ASSERT_EQ(packet_bytes->at(i), child_with_nested_sum[i]);
368 }
369
370 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
371 ParentWithSumView parent_view = ParentWithSumView::Create(packet_bytes_view);
372 ASSERT_TRUE(parent_view.IsValid());
373 ASSERT_EQ(two_bytes, parent_view.GetTwoBytes());
374
375 ChildWithNestedSumView child_view = ChildWithNestedSumView::Create(parent_view);
376 ASSERT_TRUE(child_view.IsValid());
377
378 ASSERT_EQ(more_bytes, child_view.GetMoreBytes());
379 }
380
TEST(GeneratedPacketTest,testSizedWithSumBadSize)381 TEST(GeneratedPacketTest, testSizedWithSumBadSize) {
382 vector<uint8_t> size_too_big{0x01, 0x02, 0x23, 0x11, 0x22, 0x33, 0x66, 0x00};
383
384 auto shared_bytes = std::make_shared<std::vector<uint8_t>>(size_too_big);
385 PacketView<kLittleEndian> packet_bytes_view(shared_bytes);
386
387 auto sws = SizedWithSumView::Create(packet_bytes_view);
388 ASSERT_FALSE(sws.IsValid());
389 }
390
391 namespace {
392 vector<uint8_t> parent_size_modifier = {
393 0x02 /* Size */,
394 0x11 /* TwoBytes */,
395 0x12,
396 };
397
398 } // namespace
399
TEST(GeneratedPacketTest,testParentSizeModifier)400 TEST(GeneratedPacketTest, testParentSizeModifier) {
401 uint16_t two_bytes = 0x1211;
402 auto packet = ParentSizeModifierBuilder::Create(std::make_unique<RawBuilder>(), two_bytes);
403
404 ASSERT_EQ(parent_size_modifier.size(), packet->size());
405
406 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
407 BitInserter it(*packet_bytes);
408 packet->Serialize(it);
409
410 ASSERT_EQ(parent_size_modifier.size(), packet_bytes->size());
411 for (size_t i = 0; i < parent_size_modifier.size(); i++) {
412 ASSERT_EQ(parent_size_modifier[i], packet_bytes->at(i));
413 }
414
415 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
416 ParentSizeModifierView parent_view = ParentSizeModifierView::Create(packet_bytes_view);
417 ASSERT_TRUE(parent_view.IsValid());
418 ASSERT_EQ(two_bytes, parent_view.GetTwoBytes());
419 }
420
421 namespace {
422 vector<uint8_t> child_size_modifier = {
423 0x06 /* PayloadSize (TwoBytes + MoreBytes)*/,
424 0x31 /* MoreBytes */,
425 0x32,
426 0x33,
427 0x34,
428 0x11 /* TwoBytes = 0x1211 */,
429 0x12,
430 };
431
432 } // namespace
433
TEST(GeneratedPacketTest,testChildSizeModifier)434 TEST(GeneratedPacketTest, testChildSizeModifier) {
435 uint16_t two_bytes = 0x1211;
436 uint32_t more_bytes = 0x34333231;
437 auto packet = ChildSizeModifierBuilder::Create(more_bytes);
438
439 ASSERT_EQ(child_size_modifier.size(), packet->size());
440
441 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
442 BitInserter it(*packet_bytes);
443 packet->Serialize(it);
444
445 ASSERT_EQ(child_size_modifier.size(), packet_bytes->size());
446 for (size_t i = 0; i < child_size_modifier.size(); i++) {
447 ASSERT_EQ(child_size_modifier[i], packet_bytes->at(i));
448 }
449
450 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
451 ParentSizeModifierView parent_view = ParentSizeModifierView::Create(packet_bytes_view);
452 ASSERT_TRUE(parent_view.IsValid());
453 ASSERT_EQ(two_bytes, parent_view.GetTwoBytes());
454
455 ChildSizeModifierView child_view = ChildSizeModifierView::Create(parent_view);
456 ASSERT_TRUE(child_view.IsValid());
457
458 ASSERT_EQ(more_bytes, child_view.GetMoreBytes());
459 }
460
461 namespace {
462 vector<uint8_t> fixed_array_enum{
463 0x01, // ONE
464 0x00,
465 0x02, // TWO
466 0x00,
467 0x01, // ONE_TWO
468 0x02,
469 0x02, // TWO_THREE
470 0x03,
471 0xff, // FFFF
472 0xff,
473 };
474 }
475
TEST(GeneratedPacketTest,testFixedArrayEnum)476 TEST(GeneratedPacketTest, testFixedArrayEnum) {
477 std::array<ForArrays, 5> fixed_array{{ForArrays::ONE, ForArrays::TWO, ForArrays::ONE_TWO,
478 ForArrays::TWO_THREE, ForArrays::FFFF}};
479 auto packet = FixedArrayEnumBuilder::Create(fixed_array);
480 ASSERT_EQ(fixed_array_enum.size(), packet->size());
481
482 // Verify that the packet is independent from the array.
483 std::array<ForArrays, 5> copy_array(fixed_array);
484 fixed_array[1] = ForArrays::ONE;
485
486 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
487 BitInserter it(*packet_bytes);
488 packet->Serialize(it);
489
490 ASSERT_EQ(fixed_array_enum.size(), packet_bytes->size());
491 for (size_t i = 0; i < fixed_array_enum.size(); i++) {
492 ASSERT_EQ(fixed_array_enum[i], packet_bytes->at(i));
493 }
494
495 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
496 auto view = FixedArrayEnumView::Create(packet_bytes_view);
497 ASSERT_TRUE(view.IsValid());
498 auto array = view.GetEnumArray();
499 ASSERT_EQ(copy_array.size(), array.size());
500 for (size_t i = 0; i < copy_array.size(); i++) {
501 ASSERT_EQ(array[i], copy_array[i]);
502 }
503 }
504
505 namespace {
506 vector<uint8_t> sized_array_enum{
507 0x0a, // _size_
508 0x00,
509 0x01, // ONE
510 0x00,
511 0x02, // TWO
512 0x00,
513 0x01, // ONE_TWO
514 0x02,
515 0x02, // TWO_THREE
516 0x03,
517 0xff, // FFFF
518 0xff,
519 };
520 }
521
TEST(GeneratedPacketTest,testSizedArrayEnum)522 TEST(GeneratedPacketTest, testSizedArrayEnum) {
523 std::vector<ForArrays> sized_array{{ForArrays::ONE, ForArrays::TWO, ForArrays::ONE_TWO,
524 ForArrays::TWO_THREE, ForArrays::FFFF}};
525 auto packet = SizedArrayEnumBuilder::Create(sized_array);
526 ASSERT_EQ(sized_array_enum.size(), packet->size());
527
528 // Copy the original vector and modify it to make sure the packet is independent.
529 std::vector<ForArrays> copy_array(sized_array);
530 sized_array[1] = ForArrays::ONE;
531
532 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
533 BitInserter it(*packet_bytes);
534 packet->Serialize(it);
535
536 ASSERT_EQ(sized_array_enum.size(), packet_bytes->size());
537 for (size_t i = 0; i < sized_array_enum.size(); i++) {
538 ASSERT_EQ(sized_array_enum[i], packet_bytes->at(i));
539 }
540
541 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
542 auto view = SizedArrayEnumView::Create(packet_bytes_view);
543 ASSERT_TRUE(view.IsValid());
544 auto array = view.GetEnumArray();
545 ASSERT_EQ(copy_array.size(), array.size());
546 for (size_t i = 0; i < copy_array.size(); i++) {
547 ASSERT_EQ(array[i], copy_array[i]);
548 }
549 }
550
551 namespace {
552 vector<uint8_t> count_array_enum{
553 0x03, // _count_
554 0x01, // ONE
555 0x00,
556 0x02, // TWO_THREE
557 0x03,
558 0xff, // FFFF
559 0xff,
560 };
561 }
562
TEST(GeneratedPacketTest,testCountArrayEnum)563 TEST(GeneratedPacketTest, testCountArrayEnum) {
564 std::vector<ForArrays> count_array{{ForArrays::ONE, ForArrays::TWO_THREE, ForArrays::FFFF}};
565 auto packet = CountArrayEnumBuilder::Create(count_array);
566 ASSERT_EQ(count_array_enum.size(), packet->size());
567
568 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
569 BitInserter it(*packet_bytes);
570 packet->Serialize(it);
571
572 ASSERT_EQ(count_array_enum.size(), packet_bytes->size());
573 for (size_t i = 0; i < count_array_enum.size(); i++) {
574 ASSERT_EQ(count_array_enum[i], packet_bytes->at(i));
575 }
576
577 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
578 auto view = CountArrayEnumView::Create(packet_bytes_view);
579 ASSERT_TRUE(view.IsValid());
580 auto array = view.GetEnumArray();
581 ASSERT_EQ(count_array.size(), array.size());
582 for (size_t i = 0; i < count_array.size(); i++) {
583 ASSERT_EQ(array[i], count_array[i]);
584 }
585 }
586
TEST(GeneratedPacketTest,testFixedSizeByteArray)587 TEST(GeneratedPacketTest, testFixedSizeByteArray) {
588 constexpr std::size_t byte_array_size = 32;
589 std::array<uint8_t, byte_array_size> byte_array;
590 for (uint8_t i = 0; i < byte_array_size; i++) {
591 byte_array[i] = i;
592 }
593
594 constexpr int word_array_size = 8;
595 std::array<uint32_t, word_array_size> word_array;
596 for (uint32_t i = 0; i < word_array_size; i++) {
597 word_array[i] = i;
598 }
599
600 auto packet = PacketWithFixedArraysOfBytesBuilder::Create(byte_array, word_array);
601 ASSERT_EQ((size_t)(2 * (256 / 8)), packet->size());
602
603 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
604 BitInserter it(*packet_bytes);
605 packet->Serialize(it);
606
607 ASSERT_EQ(byte_array_size + word_array_size * sizeof(uint32_t), packet_bytes->size());
608
609 for (size_t i = 0; i < byte_array_size; i++) {
610 ASSERT_EQ(byte_array[i], packet_bytes->at(i));
611 }
612
613 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
614 auto view = PacketWithFixedArraysOfBytesView::Create(packet_bytes_view);
615 ASSERT_TRUE(view.IsValid());
616 auto array = view.GetFixed256bitInBytes();
617 ASSERT_EQ(byte_array.size(), array.size());
618 for (size_t i = 0; i < array.size(); i++) {
619 ASSERT_EQ(array[i], byte_array[i]);
620 }
621
622 auto decoded_word_array = view.GetFixed256bitInWords();
623 ASSERT_EQ(word_array.size(), decoded_word_array.size());
624 for (size_t i = 0; i < decoded_word_array.size(); i++) {
625 ASSERT_EQ(word_array[i], decoded_word_array[i]);
626 }
627 }
628
629 vector<uint8_t> one_variable{
630 0x03, 'o', 'n', 'e', // "one"
631 };
632
TEST(GeneratedPacketTest,testOneVariableField)633 TEST(GeneratedPacketTest, testOneVariableField) {
634 Variable variable_one{"one"};
635
636 auto packet = OneVariableBuilder::Create(variable_one);
637 ASSERT_EQ(one_variable.size(), packet->size());
638
639 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
640 BitInserter it(*packet_bytes);
641 packet->Serialize(it);
642
643 ASSERT_EQ(one_variable.size(), packet_bytes->size());
644 for (size_t i = 0; i < one_variable.size(); i++) {
645 ASSERT_EQ(one_variable[i], packet_bytes->at(i));
646 }
647
648 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
649 auto view = OneVariableView::Create(packet_bytes_view);
650 ASSERT_TRUE(view.IsValid());
651 auto one = view.GetOne();
652 ASSERT_EQ(one->data, variable_one.data);
653 }
654
655 vector<uint8_t> fou_variable{
656 0x04, 'f', 'o', 'u', // too short
657 };
658
TEST(GeneratedPacketTest,testOneVariableFieldTooShort)659 TEST(GeneratedPacketTest, testOneVariableFieldTooShort) {
660 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
661 std::make_shared<std::vector<uint8_t>>(fou_variable);
662 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
663 auto view = OneVariableView::Create(packet_bytes_view);
664 ASSERT_TRUE(view.IsValid());
665 auto one = view.GetOne();
666 ASSERT_EQ(one, nullptr);
667 }
668
669 vector<uint8_t> sized_array_variable{
670 0x0e, // _size_
671 0x03, 'o', 'n', 'e', // "one"
672 0x03, 't', 'w', 'o', // "two"
673 0x05, 't', 'h', 'r', 'e', 'e', // "three"
674 };
675
TEST(GeneratedPacketTest,testSizedArrayVariableLength)676 TEST(GeneratedPacketTest, testSizedArrayVariableLength) {
677 std::vector<Variable> sized_array;
678 sized_array.emplace_back("one");
679 sized_array.emplace_back("two");
680 sized_array.emplace_back("three");
681
682 auto packet = SizedArrayVariableBuilder::Create(sized_array);
683 ASSERT_EQ(sized_array_variable.size(), packet->size());
684
685 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
686 BitInserter it(*packet_bytes);
687 packet->Serialize(it);
688
689 ASSERT_EQ(sized_array_variable.size(), packet_bytes->size());
690 for (size_t i = 0; i < sized_array_variable.size(); i++) {
691 ASSERT_EQ(sized_array_variable[i], packet_bytes->at(i));
692 }
693
694 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
695 auto view = SizedArrayVariableView::Create(packet_bytes_view);
696 ASSERT_TRUE(view.IsValid());
697 auto array = view.GetVariableArray();
698 ASSERT_EQ(sized_array.size(), array.size());
699 for (size_t i = 0; i < sized_array.size(); i++) {
700 ASSERT_EQ(array[i].data, sized_array[i].data);
701 }
702 }
703
704 vector<uint8_t> sized_array_variable_too_short{
705 0x0e, // _size_
706 0x03, 'o', 'n', 'e', // "one"
707 0x03, 't', 'w', 'o', // "two"
708 0x06, 't', 'h', 'r', 'e', 'e', // "three" needs another letter to be length 6
709 };
710
TEST(GeneratedPacketTest,testSizedArrayVariableLengthLastBad)711 TEST(GeneratedPacketTest, testSizedArrayVariableLengthLastBad) {
712 std::vector<Variable> sized_array;
713 sized_array.emplace_back("one");
714 sized_array.emplace_back("two");
715
716 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
717 std::make_shared<std::vector<uint8_t>>(sized_array_variable_too_short);
718
719 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
720 auto view = SizedArrayVariableView::Create(packet_bytes_view);
721 ASSERT_TRUE(view.IsValid());
722 auto array = view.GetVariableArray();
723 ASSERT_EQ(sized_array.size(), array.size());
724 for (size_t i = 0; i < sized_array.size(); i++) {
725 ASSERT_EQ(array[i].data, sized_array[i].data);
726 }
727 }
728
729 vector<uint8_t> sized_array_variable_first_too_short{
730 0x0e, // _size_
731 0x02, 'o', 'n', 'e', // "on"
732 0x03, 't', 'w', 'o', // "two"
733 0x05, 't', 'h', 'r', 'e', 'e', // "three"
734 };
735
TEST(GeneratedPacketTest,testSizedArrayVariableLengthFirstBad)736 TEST(GeneratedPacketTest, testSizedArrayVariableLengthFirstBad) {
737 std::vector<Variable> sized_array;
738 sized_array.emplace_back("on");
739
740 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
741 std::make_shared<std::vector<uint8_t>>(sized_array_variable_first_too_short);
742
743 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
744 auto view = SizedArrayVariableView::Create(packet_bytes_view);
745 ASSERT_TRUE(view.IsValid());
746 auto array = view.GetVariableArray();
747 ASSERT_EQ(sized_array.size(), array.size());
748 for (size_t i = 0; i < sized_array.size(); i++) {
749 ASSERT_EQ(array[i].data, sized_array[i].data);
750 }
751 }
752
753 vector<uint8_t> fixed_array_variable{
754 0x03, 'o', 'n', 'e', // "one"
755 0x03, 't', 'w', 'o', // "two"
756 0x05, 't', 'h', 'r', 'e', 'e', // "three"
757 0x04, 'f', 'o', 'u', 'r', // "four"
758 0x04, 'f', 'i', 'v', 'e', // "five"
759 };
760
TEST(GeneratedPacketTest,testFixedArrayVariableLength)761 TEST(GeneratedPacketTest, testFixedArrayVariableLength) {
762 std::array<Variable, 5> fixed_array{std::string("one"), std::string("two"), std::string("three"),
763 std::string("four"), std::string("five")};
764
765 auto packet = FixedArrayVariableBuilder::Create(fixed_array);
766 ASSERT_EQ(fixed_array_variable.size(), packet->size());
767
768 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
769 BitInserter it(*packet_bytes);
770 packet->Serialize(it);
771
772 ASSERT_EQ(fixed_array_variable.size(), packet_bytes->size());
773 for (size_t i = 0; i < fixed_array_variable.size(); i++) {
774 ASSERT_EQ(fixed_array_variable[i], packet_bytes->at(i));
775 }
776
777 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
778 auto view = FixedArrayVariableView::Create(packet_bytes_view);
779 ASSERT_TRUE(view.IsValid());
780 auto array = view.GetVariableArray();
781 ASSERT_EQ(fixed_array.size(), array.size());
782 for (size_t i = 0; i < fixed_array.size(); i++) {
783 ASSERT_EQ(array[i].data, fixed_array[i].data);
784 }
785 }
786
787 vector<uint8_t> fixed_array_variable_too_short{
788 0x03, 'o', 'n', 'e', // "one"
789 0x03, 't', 'w', 'o', // "two"
790 0x05, 't', 'h', 'r', 'e', 'e', // "three"
791 0x04, 'f', 'o', 'u', 'r', // "four"
792 0x05, 'f', 'i', 'v', 'e', // "five"
793 };
794
TEST(GeneratedPacketTest,testFixedArrayVariableLengthTooShort)795 TEST(GeneratedPacketTest, testFixedArrayVariableLengthTooShort) {
796 std::array<Variable, 5> fixed_array{std::string("one"), std::string("two"), std::string("three"),
797 std::string("four")};
798
799 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
800 std::make_shared<std::vector<uint8_t>>(fixed_array_variable_too_short);
801
802 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
803 auto view = FixedArrayVariableView::Create(packet_bytes_view);
804 ASSERT_TRUE(view.IsValid());
805 auto array = view.GetVariableArray();
806 ASSERT_EQ(fixed_array.size(), array.size());
807 for (size_t i = 0; i < fixed_array.size(); i++) {
808 ASSERT_EQ(array[i].data, fixed_array[i].data);
809 }
810 }
811
812 vector<uint8_t> count_array_variable{
813 0x04, // _count_
814 0x03, 'o', 'n', 'e', // "one"
815 0x03, 't', 'w', 'o', // "two"
816 0x05, 't', 'h', 'r', 'e', 'e', // "three"
817 0x04, 'f', 'o', 'u', 'r', // "four"
818 };
819
TEST(GeneratedPacketTest,testCountArrayVariableLength)820 TEST(GeneratedPacketTest, testCountArrayVariableLength) {
821 std::vector<Variable> count_array;
822 count_array.emplace_back("one");
823 count_array.emplace_back("two");
824 count_array.emplace_back("three");
825 count_array.emplace_back("four");
826
827 auto packet = CountArrayVariableBuilder::Create(count_array);
828 ASSERT_EQ(count_array_variable.size(), packet->size());
829
830 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
831 BitInserter it(*packet_bytes);
832 packet->Serialize(it);
833
834 ASSERT_EQ(count_array_variable.size(), packet_bytes->size());
835 for (size_t i = 0; i < count_array_variable.size(); i++) {
836 ASSERT_EQ(count_array_variable[i], packet_bytes->at(i));
837 }
838
839 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
840 auto view = CountArrayVariableView::Create(packet_bytes_view);
841 ASSERT_TRUE(view.IsValid());
842 auto array = view.GetVariableArray();
843 ASSERT_EQ(count_array.size(), array.size());
844 for (size_t i = 0; i < count_array.size(); i++) {
845 ASSERT_EQ(array[i].data, count_array[i].data);
846 }
847 }
848
849 vector<uint8_t> count_array_variable_extra{
850 0x04, // _count_
851 0x03, 'o', 'n', 'e', // "one"
852 0x03, 't', 'w', 'o', // "two"
853 0x05, 't', 'h', 'r', 'e', 'e', // "three"
854 0x04, 'f', 'o', 'u', 'r', // "four"
855 0x04, 'x', 't', 'r', 'a', // "xtra"
856 };
857
TEST(GeneratedPacketTest,testCountArrayVariableLengthExtraData)858 TEST(GeneratedPacketTest, testCountArrayVariableLengthExtraData) {
859 std::vector<Variable> count_array;
860 count_array.emplace_back("one");
861 count_array.emplace_back("two");
862 count_array.emplace_back("three");
863 count_array.emplace_back("four");
864
865 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
866 std::make_shared<std::vector<uint8_t>>(count_array_variable_extra);
867
868 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
869 auto view = CountArrayVariableView::Create(packet_bytes_view);
870 ASSERT_TRUE(view.IsValid());
871 auto array = view.GetVariableArray();
872 ASSERT_EQ(count_array.size(), array.size());
873 for (size_t i = 0; i < count_array.size(); i++) {
874 ASSERT_EQ(array[i].data, count_array[i].data);
875 }
876 }
877
878 vector<uint8_t> count_array_variable_too_few{
879 0x04, // _count_
880 0x03, 'o', 'n', 'e', // "one"
881 0x03, 't', 'w', 'o', // "two"
882 0x05, 't', 'h', 'r', 'e', 'e', // "three"
883 };
884
TEST(GeneratedPacketTest,testCountArrayVariableLengthMissingData)885 TEST(GeneratedPacketTest, testCountArrayVariableLengthMissingData) {
886 std::vector<Variable> count_array;
887 count_array.emplace_back("one");
888 count_array.emplace_back("two");
889 count_array.emplace_back("three");
890
891 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
892 std::make_shared<std::vector<uint8_t>>(count_array_variable_too_few);
893
894 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
895 auto view = CountArrayVariableView::Create(packet_bytes_view);
896 ASSERT_TRUE(view.IsValid());
897 auto array = view.GetVariableArray();
898 ASSERT_EQ(count_array.size(), array.size());
899 for (size_t i = 0; i < count_array.size(); i++) {
900 ASSERT_EQ(array[i].data, count_array[i].data);
901 }
902 }
903
904 vector<uint8_t> one_struct{
905 0x01, 0x02, 0x03, // id = 0x01, count = 0x0302
906 };
907
TEST(GeneratedPacketTest,testOneStruct)908 TEST(GeneratedPacketTest, testOneStruct) {
909 TwoRelatedNumbers trn;
910 trn.id_ = 1;
911 trn.count_ = 0x0302;
912
913 auto packet = OneStructBuilder::Create(trn);
914 ASSERT_EQ(one_struct.size(), packet->size());
915
916 // Copy the original struct, then modify it to verify independence from the packet.
917 TwoRelatedNumbers copy_trn(trn);
918 trn.id_ = 2;
919
920 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
921 BitInserter it(*packet_bytes);
922 packet->Serialize(it);
923
924 ASSERT_EQ(one_struct.size(), packet_bytes->size());
925 for (size_t i = 0; i < one_struct.size(); i++) {
926 ASSERT_EQ(one_struct[i], packet_bytes->at(i));
927 }
928
929 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
930 auto view = OneStructView::Create(packet_bytes_view);
931 ASSERT_TRUE(view.IsValid());
932 auto one = view.GetOne();
933 ASSERT_EQ(one.id_, copy_trn.id_);
934 ASSERT_EQ(one.count_, copy_trn.count_);
935 }
936
937 vector<uint8_t> two_structs{
938 0x01, 0x01, 0x02, // id, id * 0x0201
939 0x02, 0x02, 0x04,
940 };
941
TEST(GeneratedPacketTest,testTwoStructs)942 TEST(GeneratedPacketTest, testTwoStructs) {
943 std::vector<TwoRelatedNumbers> count_array;
944 for (uint8_t i = 1; i < 3; i++) {
945 TwoRelatedNumbers trn;
946 trn.id_ = i;
947 trn.count_ = 0x0201 * i;
948 count_array.push_back(trn);
949 }
950
951 auto packet = TwoStructsBuilder::Create(count_array[0], count_array[1]);
952 ASSERT_EQ(two_structs.size(), packet->size());
953
954 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
955 BitInserter it(*packet_bytes);
956 packet->Serialize(it);
957
958 ASSERT_EQ(two_structs.size(), packet_bytes->size());
959 for (size_t i = 0; i < two_structs.size(); i++) {
960 ASSERT_EQ(two_structs[i], packet_bytes->at(i));
961 }
962
963 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
964 auto view = TwoStructsView::Create(packet_bytes_view);
965 ASSERT_TRUE(view.IsValid());
966 auto one = view.GetOne();
967 ASSERT_EQ(one.id_, count_array[0].id_);
968 ASSERT_EQ(one.count_, count_array[0].count_);
969 auto two = view.GetTwo();
970 ASSERT_EQ(two.id_, count_array[1].id_);
971 ASSERT_EQ(two.count_, count_array[1].count_);
972 }
973
974 vector<uint8_t> array_or_vector_of_struct{
975 0x04, // _count_
976 0x01, 0x01, 0x02, // id, id * 0x0201
977 0x02, 0x02, 0x04, 0x03, 0x03, 0x06, 0x04, 0x04, 0x08,
978 };
979
TEST(GeneratedPacketTest,testVectorOfStruct)980 TEST(GeneratedPacketTest, testVectorOfStruct) {
981 std::vector<TwoRelatedNumbers> count_array;
982 for (uint8_t i = 1; i < 5; i++) {
983 TwoRelatedNumbers trn;
984 trn.id_ = i;
985 trn.count_ = 0x0201 * i;
986 count_array.push_back(trn);
987 }
988
989 // Make a copy
990 std::vector<TwoRelatedNumbers> copy_array(count_array);
991
992 auto packet = VectorOfStructBuilder::Create(count_array);
993
994 // Change the original vector to make sure a copy was made.
995 count_array[0].id_ = count_array[0].id_ + 1;
996
997 ASSERT_EQ(array_or_vector_of_struct.size(), packet->size());
998
999 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1000 BitInserter it(*packet_bytes);
1001 packet->Serialize(it);
1002
1003 ASSERT_EQ(array_or_vector_of_struct.size(), packet_bytes->size());
1004 for (size_t i = 0; i < array_or_vector_of_struct.size(); i++) {
1005 ASSERT_EQ(array_or_vector_of_struct[i], packet_bytes->at(i));
1006 }
1007
1008 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1009 auto view = VectorOfStructView::Create(packet_bytes_view);
1010 ASSERT_TRUE(view.IsValid());
1011 auto array = view.GetArray();
1012 ASSERT_EQ(copy_array.size(), array.size());
1013 for (size_t i = 0; i < copy_array.size(); i++) {
1014 ASSERT_EQ(array[i].id_, copy_array[i].id_);
1015 ASSERT_EQ(array[i].count_, copy_array[i].count_);
1016 }
1017 }
1018
TEST(GeneratedPacketTest,testArrayOfStruct)1019 TEST(GeneratedPacketTest, testArrayOfStruct) {
1020 std::array<TwoRelatedNumbers, 4> count_array;
1021 for (uint8_t i = 1; i < 5; i++) {
1022 TwoRelatedNumbers trn;
1023 trn.id_ = i;
1024 trn.count_ = 0x0201 * i;
1025 count_array[i - 1] = trn;
1026 }
1027
1028 // Make a copy
1029 std::array<TwoRelatedNumbers, 4> copy_array(count_array);
1030
1031 auto packet = ArrayOfStructBuilder::Create(4, count_array);
1032
1033 // Change the original vector to make sure a copy was made.
1034 count_array[0].id_ = count_array[0].id_ + 1;
1035
1036 ASSERT_EQ(array_or_vector_of_struct.size(), packet->size());
1037
1038 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1039 BitInserter it(*packet_bytes);
1040 packet->Serialize(it);
1041
1042 ASSERT_EQ(array_or_vector_of_struct.size(), packet_bytes->size());
1043 for (size_t i = 0; i < array_or_vector_of_struct.size(); i++) {
1044 ASSERT_EQ(array_or_vector_of_struct[i], packet_bytes->at(i));
1045 }
1046
1047 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1048 auto view = ArrayOfStructView::Create(packet_bytes_view);
1049 ASSERT_TRUE(view.IsValid());
1050 auto array = view.GetArray();
1051 ASSERT_EQ(copy_array.size(), array.size());
1052 for (size_t i = 0; i < copy_array.size(); i++) {
1053 ASSERT_EQ(array[i].id_, copy_array[i].id_);
1054 ASSERT_EQ(array[i].count_, copy_array[i].count_);
1055 }
1056 }
1057
1058 vector<uint8_t> one_fixed_types_struct{
1059 0x05, // four_bits = FIVE, reserved
1060 0xf3, // _fixed_
1061 0x0d, // id = 0x0d
1062 0x01, 0x02, 0x03, // array = { 1, 2, 3}
1063 0x06, 0x01, // example_checksum
1064 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, // six_bytes
1065 };
1066
TEST(GeneratedPacketTest,testOneFixedTypesStruct)1067 TEST(GeneratedPacketTest, testOneFixedTypesStruct) {
1068 StructWithFixedTypes swf;
1069 swf.four_bits_ = FourBits::FIVE;
1070 swf.id_ = 0x0d;
1071 swf.array_ = {{0x01, 0x02, 0x03}};
1072 swf.six_bytes_ = SixBytes{{0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6}};
1073
1074 auto packet = OneFixedTypesStructBuilder::Create(swf);
1075 ASSERT_EQ(one_fixed_types_struct.size(), packet->size());
1076
1077 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1078 BitInserter it(*packet_bytes);
1079 packet->Serialize(it);
1080
1081 ASSERT_EQ(one_fixed_types_struct.size(), packet_bytes->size());
1082 for (size_t i = 0; i < one_fixed_types_struct.size(); i++) {
1083 ASSERT_EQ(one_fixed_types_struct[i], packet_bytes->at(i));
1084 }
1085
1086 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1087 auto view = OneFixedTypesStructView::Create(packet_bytes_view);
1088 ASSERT_TRUE(view.IsValid());
1089 auto one = view.GetOne();
1090 ASSERT_EQ(one.four_bits_, swf.four_bits_);
1091 ASSERT_EQ(one.id_, swf.id_);
1092 ASSERT_EQ(one.array_, swf.array_);
1093 ASSERT_EQ(one.six_bytes_, swf.six_bytes_);
1094 }
1095
1096 vector<uint8_t> array_of_struct_and_another{
1097 0x03, // _count_
1098 0x01, 0x01, 0x02, // id, id * 0x0201
1099 0x02, 0x02, 0x04, // 2
1100 0x03, 0x03, 0x06, // 3
1101 0x04, 0x04, 0x08, // Another
1102 };
1103
TEST(GeneratedPacketTest,testArrayOfStructAndAnother)1104 TEST(GeneratedPacketTest, testArrayOfStructAndAnother) {
1105 std::vector<TwoRelatedNumbers> count_array;
1106 for (uint8_t i = 1; i < 4; i++) {
1107 TwoRelatedNumbers trn;
1108 trn.id_ = i;
1109 trn.count_ = 0x0201 * i;
1110 count_array.push_back(trn);
1111 }
1112 TwoRelatedNumbers another;
1113 another.id_ = 4;
1114 another.count_ = 0x0201 * 4;
1115
1116 auto packet = ArrayOfStructAndAnotherBuilder::Create(count_array, another);
1117 ASSERT_EQ(array_or_vector_of_struct.size(), packet->size());
1118
1119 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1120 BitInserter it(*packet_bytes);
1121 packet->Serialize(it);
1122
1123 ASSERT_EQ(array_of_struct_and_another.size(), packet_bytes->size());
1124 for (size_t i = 0; i < array_of_struct_and_another.size(); i++) {
1125 ASSERT_EQ(array_of_struct_and_another[i], packet_bytes->at(i));
1126 }
1127
1128 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1129 auto view = ArrayOfStructAndAnotherView::Create(packet_bytes_view);
1130 ASSERT_TRUE(view.IsValid());
1131 auto array = view.GetArray();
1132 ASSERT_EQ(count_array.size(), array.size());
1133 for (size_t i = 0; i < count_array.size(); i++) {
1134 ASSERT_EQ(array[i].id_, count_array[i].id_);
1135 ASSERT_EQ(array[i].count_, count_array[i].count_);
1136 }
1137 auto nother = view.GetAnother();
1138 ASSERT_EQ(nother.id_, another.id_);
1139 ASSERT_EQ(nother.count_, another.count_);
1140 }
1141
1142 DEFINE_AND_INSTANTIATE_OneArrayOfStructAndAnotherStructReflectionTest(array_of_struct_and_another);
1143
TEST(GeneratedPacketTest,testOneArrayOfStructAndAnotherStruct)1144 TEST(GeneratedPacketTest, testOneArrayOfStructAndAnotherStruct) {
1145 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
1146 std::make_shared<std::vector<uint8_t>>(array_of_struct_and_another);
1147
1148 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1149 auto view = OneArrayOfStructAndAnotherStructView::Create(packet_bytes_view);
1150 ASSERT_TRUE(view.IsValid());
1151 auto one = view.GetOne();
1152 ASSERT_EQ(one.array_.size(), 3ul);
1153 ASSERT_EQ(one.another_.id_, 4);
1154 ASSERT_EQ(one.another_.count_, 0x0804);
1155 }
1156
1157 vector<uint8_t> sized_array_of_struct_and_another{
1158 0x09, // _size_
1159 0x01, 0x01, 0x02, // id, id * 0x0201
1160 0x02, 0x02, 0x04, // 2
1161 0x03, 0x03, 0x06, // 3
1162 0x04, 0x04, 0x08, // Another
1163 };
1164
1165 DEFINE_AND_INSTANTIATE_OneSizedArrayOfStructAndAnotherStructReflectionTest(
1166 sized_array_of_struct_and_another);
1167
1168 vector<uint8_t> bit_field_group_packet{
1169 // seven_bits_ = 0x77, straddle_ = 0x5, five_bits_ = 0x15
1170 0xf7, // 0x77 | (0x5 & 0x1) << 7
1171 0xaa, // 0x15 << 3 | (0x5 >> 1)
1172 };
1173
TEST(GeneratedPacketTest,testBitFieldGroupPacket)1174 TEST(GeneratedPacketTest, testBitFieldGroupPacket) {
1175 uint8_t seven_bits = 0x77;
1176 uint8_t straddle = 0x5;
1177 uint8_t five_bits = 0x15;
1178
1179 auto packet = BitFieldGroupPacketBuilder::Create(seven_bits, straddle, five_bits);
1180 ASSERT_EQ(bit_field_group_packet.size(), packet->size());
1181
1182 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1183 BitInserter it(*packet_bytes);
1184 packet->Serialize(it);
1185
1186 ASSERT_EQ(bit_field_group_packet.size(), packet_bytes->size());
1187 for (size_t i = 0; i < bit_field_group_packet.size(); i++) {
1188 ASSERT_EQ(bit_field_group_packet[i], packet_bytes->at(i));
1189 }
1190
1191 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1192 auto view = BitFieldGroupPacketView::Create(packet_bytes_view);
1193 ASSERT_TRUE(view.IsValid());
1194 ASSERT_EQ(seven_bits, view.GetSevenBits());
1195 ASSERT_EQ(straddle, view.GetStraddle());
1196 ASSERT_EQ(five_bits, view.GetFiveBits());
1197 }
1198
1199 vector<uint8_t> bit_field_packet{
1200 // seven_bits_ = 0x77, straddle_ = 0x5, five_bits_ = 0x15
1201 0xf7, // 0x77 | (0x5 & 0x1) << 7
1202 0xaa, // 0x15 << 3 | (0x5 >> 1)
1203 };
1204
TEST(GeneratedPacketTest,testBitFieldPacket)1205 TEST(GeneratedPacketTest, testBitFieldPacket) {
1206 BitField bit_field;
1207 bit_field.seven_bits_ = 0x77;
1208 bit_field.straddle_ = 0x5;
1209 bit_field.five_bits_ = 0x15;
1210
1211 auto packet = BitFieldPacketBuilder::Create(bit_field);
1212 ASSERT_EQ(bit_field_packet.size(), packet->size());
1213
1214 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1215 BitInserter it(*packet_bytes);
1216 packet->Serialize(it);
1217
1218 ASSERT_EQ(bit_field_packet.size(), packet_bytes->size());
1219 for (size_t i = 0; i < bit_field_packet.size(); i++) {
1220 ASSERT_EQ(bit_field_packet[i], packet_bytes->at(i));
1221 }
1222
1223 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1224 auto view = BitFieldPacketView::Create(packet_bytes_view);
1225 ASSERT_TRUE(view.IsValid());
1226 BitField bf = view.GetBitField();
1227 ASSERT_EQ(bf.seven_bits_, bit_field.seven_bits_);
1228 ASSERT_EQ(bf.straddle_, bit_field.straddle_);
1229 ASSERT_EQ(bf.five_bits_, bit_field.five_bits_);
1230 }
1231
1232 vector<uint8_t> bit_field_group_after_unsized_array_packet{
1233 0x01, 0x02, 0x03, 0x04, // byte array
1234 // seven_bits_ = 0x77, straddle_ = 0x5, five_bits_ = 0x15
1235 0xf7, // 0x77 | (0x5 & 0x1) << 7
1236 0xaa, // 0x15 << 3 | (0x5 >> 1)
1237 };
1238
TEST(GeneratedPacketTest,testBitFieldGroupAfterUnsizedArrayPacket)1239 TEST(GeneratedPacketTest, testBitFieldGroupAfterUnsizedArrayPacket) {
1240 std::vector<uint8_t> count_array;
1241 for (uint8_t i = 1; i < 5; i++) {
1242 count_array.push_back(i);
1243 }
1244 uint8_t seven_bits = 0x77;
1245 uint8_t straddle = 0x5;
1246 uint8_t five_bits = 0x15;
1247
1248 auto packet = BitFieldGroupAfterUnsizedArrayPacketBuilder::Create(count_array, seven_bits,
1249 straddle, five_bits);
1250 ASSERT_EQ(bit_field_group_after_unsized_array_packet.size(), packet->size());
1251
1252 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1253 BitInserter it(*packet_bytes);
1254 packet->Serialize(it);
1255
1256 ASSERT_EQ(bit_field_group_after_unsized_array_packet.size(), packet_bytes->size());
1257 for (size_t i = 0; i < bit_field_group_after_unsized_array_packet.size(); i++) {
1258 ASSERT_EQ(bit_field_group_after_unsized_array_packet[i], packet_bytes->at(i));
1259 }
1260
1261 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1262 auto payload_view = BitFieldGroupAfterPayloadPacketView::Create(packet_bytes_view);
1263 ASSERT_TRUE(payload_view.IsValid());
1264 EXPECT_EQ(seven_bits, payload_view.GetSevenBits());
1265 EXPECT_EQ(straddle, payload_view.GetStraddle());
1266 EXPECT_EQ(five_bits, payload_view.GetFiveBits());
1267
1268 auto view = BitFieldGroupAfterUnsizedArrayPacketView::Create(payload_view);
1269 ASSERT_TRUE(view.IsValid());
1270 auto array = view.GetArray();
1271 ASSERT_EQ(count_array.size(), array.size());
1272 for (size_t i = 0; i < count_array.size(); i++) {
1273 ASSERT_EQ(array[i], count_array[i]);
1274 }
1275 ASSERT_EQ(seven_bits, view.GetSevenBits());
1276 ASSERT_EQ(straddle, view.GetStraddle());
1277 ASSERT_EQ(five_bits, view.GetFiveBits());
1278 }
1279
1280 vector<uint8_t> bit_field_after_unsized_array_packet{
1281 0x01, 0x02, 0x03, 0x04, // byte array
1282 // seven_bits_ = 0x77, straddle_ = 0x5, five_bits_ = 0x15
1283 0xf7, // 0x77 | (0x5 & 0x1) << 7
1284 0xaa, // 0x15 << 3 | (0x5 >> 1)
1285 };
1286
TEST(GeneratedPacketTest,testBitFieldAfterUnsizedArrayPacket)1287 TEST(GeneratedPacketTest, testBitFieldAfterUnsizedArrayPacket) {
1288 std::vector<uint8_t> count_array;
1289 for (uint8_t i = 1; i < 5; i++) {
1290 count_array.push_back(i);
1291 }
1292 BitField bit_field;
1293 bit_field.seven_bits_ = 0x77;
1294 bit_field.straddle_ = 0x5;
1295 bit_field.five_bits_ = 0x15;
1296
1297 auto packet = BitFieldAfterUnsizedArrayPacketBuilder::Create(count_array, bit_field);
1298 ASSERT_EQ(bit_field_after_unsized_array_packet.size(), packet->size());
1299
1300 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1301 BitInserter it(*packet_bytes);
1302 packet->Serialize(it);
1303
1304 ASSERT_EQ(bit_field_after_unsized_array_packet.size(), packet_bytes->size());
1305 for (size_t i = 0; i < bit_field_after_unsized_array_packet.size(); i++) {
1306 ASSERT_EQ(bit_field_after_unsized_array_packet[i], packet_bytes->at(i));
1307 }
1308
1309 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1310 auto payload_view = BitFieldAfterPayloadPacketView::Create(packet_bytes_view);
1311 ASSERT_TRUE(payload_view.IsValid());
1312 BitField parent_bf = payload_view.GetBitField();
1313 ASSERT_EQ(parent_bf.seven_bits_, bit_field.seven_bits_);
1314 ASSERT_EQ(parent_bf.straddle_, bit_field.straddle_);
1315 ASSERT_EQ(parent_bf.five_bits_, bit_field.five_bits_);
1316
1317 auto view = BitFieldAfterUnsizedArrayPacketView::Create(payload_view);
1318 ASSERT_TRUE(view.IsValid());
1319 auto array = view.GetArray();
1320 ASSERT_EQ(count_array.size(), array.size());
1321 for (size_t i = 0; i < count_array.size(); i++) {
1322 ASSERT_EQ(array[i], count_array[i]);
1323 }
1324 BitField bf = view.GetBitField();
1325 ASSERT_EQ(bf.seven_bits_, bit_field.seven_bits_);
1326 ASSERT_EQ(bf.straddle_, bit_field.straddle_);
1327 ASSERT_EQ(bf.five_bits_, bit_field.five_bits_);
1328 }
1329
1330 vector<uint8_t> bit_field_array_packet{
1331 0x06, // _size_(array)
1332 // seven_bits_ = 0x77, straddle_ = 0x5, five_bits_ = 0x15
1333 0xf7, // 0x77 | (0x5 & 0x1) << 7
1334 0xaa, // 0x15 << 3 | (0x5 >> 1)
1335
1336 // seven_bits_ = 0x78, straddle_ = 0x6, five_bits_ = 0x16
1337 0x78, // 0x78 | (0x6 & 0x1) << 7
1338 0xb3, // 0x16 << 3 | (0x6 >> 1)
1339
1340 // seven_bits_ = 0x79, straddle_ = 0x7, five_bits_ = 0x17
1341 0xf9, // 0x79 | (0x7 & 0x1) << 7
1342 0xbb, // 0x17 << 3 | (0x7 >> 1)
1343 };
1344
TEST(GeneratedPacketTest,testBitFieldArrayPacket)1345 TEST(GeneratedPacketTest, testBitFieldArrayPacket) {
1346 std::vector<BitField> count_array;
1347 for (size_t i = 0; i < 3; i++) {
1348 BitField bf;
1349 bf.seven_bits_ = 0x77 + i;
1350 bf.straddle_ = 0x5 + i;
1351 bf.five_bits_ = 0x15 + i;
1352 count_array.push_back(bf);
1353 }
1354
1355 auto packet = BitFieldArrayPacketBuilder::Create(count_array);
1356 ASSERT_EQ(bit_field_array_packet.size(), packet->size());
1357
1358 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1359 BitInserter it(*packet_bytes);
1360 packet->Serialize(it);
1361
1362 ASSERT_EQ(bit_field_array_packet.size(), packet_bytes->size());
1363 for (size_t i = 0; i < bit_field_array_packet.size(); i++) {
1364 ASSERT_EQ(bit_field_array_packet[i], packet_bytes->at(i));
1365 }
1366
1367 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1368 auto view = BitFieldArrayPacketView::Create(packet_bytes_view);
1369 ASSERT_TRUE(view.IsValid());
1370 auto array = view.GetArray();
1371 ASSERT_EQ(count_array.size(), array.size());
1372 for (size_t i = 0; i < count_array.size(); i++) {
1373 ASSERT_EQ(array[i].seven_bits_, count_array[i].seven_bits_);
1374 ASSERT_EQ(array[i].straddle_, count_array[i].straddle_);
1375 ASSERT_EQ(array[i].five_bits_, count_array[i].five_bits_);
1376 }
1377 }
1378
TEST(GeneratedPacketTest,testNewBitFieldArrayPacket)1379 TEST(GeneratedPacketTest, testNewBitFieldArrayPacket) {
1380 PacketView<kLittleEndian> packet_bytes_view(
1381 std::make_shared<std::vector<uint8_t>>(bit_field_array_packet));
1382 auto view = BitFieldArrayPacketView::Create(packet_bytes_view);
1383 ASSERT_TRUE(view.IsValid());
1384
1385 auto packet = BitFieldArrayPacketBuilder::Create(view.GetArray());
1386 ASSERT_EQ(bit_field_array_packet.size(), packet->size());
1387
1388 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1389 BitInserter it(*packet_bytes);
1390 packet->Serialize(it);
1391
1392 ASSERT_EQ(*packet_bytes, bit_field_array_packet);
1393 }
1394
1395 std::vector<uint8_t> child_two_two_two_ = {0x20, 0x02};
1396 std::vector<uint8_t> child_two_two_three_ = {0x20, 0x03};
1397 std::vector<uint8_t> child_two_two_four_ = {0x20, 0x04};
1398
1399 DEFINE_AND_INSTANTIATE_ParentTwoReflectionTest(child_two_two_two_, child_two_two_three_,
1400 child_two_two_four_);
1401
1402 DEFINE_AND_INSTANTIATE_ChildTwoTwoReflectionTest(child_two_two_two_, child_two_two_three_,
1403 child_two_two_four_);
1404
1405 DEFINE_AND_INSTANTIATE_ChildTwoTwoThreeReflectionTest(child_two_two_three_);
1406
1407 std::vector<uint8_t> one_versionless_struct_packet = {0x01};
1408 std::vector<uint8_t> one_versioned_struct_packet = {0x02, 0x03 /* version */, 0x04, 0x05, 0x06};
1409 std::vector<uint8_t> one_version_one_struct_packet = {0x03, 0x01 /* version */, 0x02};
1410 std::vector<uint8_t> one_version_two_struct_packet = {0x03, 0x02 /* version */, 0x03, 0x04};
1411 DEFINE_AND_INSTANTIATE_OneVersionlessStructPacketReflectionTest(one_versionless_struct_packet,
1412 one_versioned_struct_packet,
1413 one_version_one_struct_packet,
1414 one_version_two_struct_packet);
1415 DEFINE_AND_INSTANTIATE_OneVersionedStructPacketReflectionTest(one_versioned_struct_packet,
1416 one_version_one_struct_packet,
1417 one_version_two_struct_packet);
1418 DEFINE_AND_INSTANTIATE_OneVersionOneStructPacketReflectionTest(one_version_one_struct_packet);
1419 DEFINE_AND_INSTANTIATE_OneVersionTwoStructPacketReflectionTest(one_version_two_struct_packet);
1420
1421 vector<uint8_t> one_struct_be{
1422 0x01, 0x02, 0x03, // id = 0x01, count = 0x0203
1423 };
1424
TEST(GeneratedPacketTest,testOneStructBe)1425 TEST(GeneratedPacketTest, testOneStructBe) {
1426 TwoRelatedNumbersBe trn;
1427 trn.id_ = 1;
1428 trn.count_ = 0x0203;
1429
1430 auto packet = OneStructBeBuilder::Create(trn);
1431 ASSERT_EQ(one_struct_be.size(), packet->size());
1432
1433 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1434 BitInserter it(*packet_bytes);
1435 packet->Serialize(it);
1436
1437 ASSERT_EQ(one_struct_be.size(), packet_bytes->size());
1438 for (size_t i = 0; i < one_struct_be.size(); i++) {
1439 ASSERT_EQ(one_struct_be[i], packet_bytes->at(i));
1440 }
1441
1442 PacketView<!kLittleEndian> packet_bytes_view(packet_bytes);
1443 auto view = OneStructBeView::Create(packet_bytes_view);
1444 ASSERT_TRUE(view.IsValid());
1445 auto one = view.GetOne();
1446 ASSERT_EQ(one.id_, trn.id_);
1447 ASSERT_EQ(one.count_, trn.count_);
1448 }
1449
1450 vector<uint8_t> two_structs_be{
1451 0x01, 0x01, 0x02, // id, id * 0x0102
1452 0x02, 0x02, 0x04,
1453 };
1454
TEST(GeneratedPacketTest,testTwoStructsBe)1455 TEST(GeneratedPacketTest, testTwoStructsBe) {
1456 std::vector<TwoRelatedNumbersBe> count_array;
1457 for (uint8_t i = 1; i < 3; i++) {
1458 TwoRelatedNumbersBe trn;
1459 trn.id_ = i;
1460 trn.count_ = 0x0102 * i;
1461 count_array.push_back(trn);
1462 }
1463
1464 auto packet = TwoStructsBeBuilder::Create(count_array[0], count_array[1]);
1465 ASSERT_EQ(two_structs_be.size(), packet->size());
1466
1467 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1468 BitInserter it(*packet_bytes);
1469 packet->Serialize(it);
1470
1471 ASSERT_EQ(two_structs_be.size(), packet_bytes->size());
1472 for (size_t i = 0; i < two_structs_be.size(); i++) {
1473 ASSERT_EQ(two_structs_be[i], packet_bytes->at(i));
1474 }
1475
1476 PacketView<!kLittleEndian> packet_bytes_view(packet_bytes);
1477 auto view = TwoStructsBeView::Create(packet_bytes_view);
1478 ASSERT_TRUE(view.IsValid());
1479 auto one = view.GetOne();
1480 ASSERT_EQ(one.id_, count_array[0].id_);
1481 ASSERT_EQ(one.count_, count_array[0].count_);
1482 auto two = view.GetTwo();
1483 ASSERT_EQ(two.id_, count_array[1].id_);
1484 ASSERT_EQ(two.count_, count_array[1].count_);
1485 }
1486
1487 vector<uint8_t> array_of_struct_be{
1488 0x04, // _count_
1489 0x01, 0x01, 0x02, // id, id * 0x0102
1490 0x02, 0x02, 0x04, 0x03, 0x03, 0x06, 0x04, 0x04, 0x08,
1491 };
1492
TEST(GeneratedPacketTest,testArrayOfStructBe)1493 TEST(GeneratedPacketTest, testArrayOfStructBe) {
1494 std::vector<TwoRelatedNumbersBe> count_array;
1495 for (uint8_t i = 1; i < 5; i++) {
1496 TwoRelatedNumbersBe trn;
1497 trn.id_ = i;
1498 trn.count_ = 0x0102 * i;
1499 count_array.push_back(trn);
1500 }
1501
1502 auto packet = ArrayOfStructBeBuilder::Create(count_array);
1503
1504 ASSERT_EQ(array_of_struct_be.size(), packet->size());
1505
1506 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1507 BitInserter it(*packet_bytes);
1508 packet->Serialize(it);
1509
1510 ASSERT_EQ(array_of_struct_be.size(), packet_bytes->size());
1511 for (size_t i = 0; i < array_of_struct_be.size(); i++) {
1512 ASSERT_EQ(array_of_struct_be[i], packet_bytes->at(i));
1513 }
1514
1515 PacketView<!kLittleEndian> packet_bytes_view(packet_bytes);
1516 auto view = ArrayOfStructBeView::Create(packet_bytes_view);
1517 ASSERT_TRUE(view.IsValid());
1518 auto array = view.GetArray();
1519 ASSERT_EQ(count_array.size(), array.size());
1520 for (size_t i = 0; i < count_array.size(); i++) {
1521 ASSERT_EQ(array[i].id_, count_array[i].id_);
1522 ASSERT_EQ(array[i].count_, count_array[i].count_);
1523 }
1524 }
1525
1526 vector<uint8_t> one_four_byte_struct{
1527 0x04, // struct_type_ = FourByte
1528 0xd1, 0xd2, 0xd3, 0xd4, // four_bytes_
1529 };
1530
TEST(GeneratedPacketTest,testOneFourByteStruct)1531 TEST(GeneratedPacketTest, testOneFourByteStruct) {
1532 FourByteStruct four_byte_struct(0xd4d3d2d1);
1533
1534 auto packet = OneFourByteStructBuilder::Create(four_byte_struct);
1535 ASSERT_EQ(one_four_byte_struct.size(), packet->size());
1536
1537 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1538 BitInserter it(*packet_bytes);
1539 packet->Serialize(it);
1540
1541 ASSERT_EQ(one_four_byte_struct.size(), packet_bytes->size());
1542 for (size_t i = 0; i < one_four_byte_struct.size(); i++) {
1543 ASSERT_EQ(one_four_byte_struct[i], packet_bytes->at(i));
1544 }
1545
1546 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1547 auto view = OneFourByteStructView::Create(packet_bytes_view);
1548 ASSERT_TRUE(view.IsValid());
1549 ASSERT_EQ(StructType::FOUR_BYTE, view.GetOneStruct().struct_type_);
1550 ASSERT_EQ(four_byte_struct.four_bytes_, view.GetOneStruct().four_bytes_);
1551 }
1552
1553 vector<uint8_t> generic_struct_two{
1554 0x02, // struct_type_ = TwoByte
1555 0x01, 0x02, // two_bytes_
1556 };
1557
TEST(GeneratedPacketTest,testOneGenericStructTwo)1558 TEST(GeneratedPacketTest, testOneGenericStructTwo) {
1559 TwoByteStruct two_byte_struct(0x0201);
1560 std::unique_ptr<TwoByteStruct> two_byte_struct_ptr =
1561 std::make_unique<TwoByteStruct>(two_byte_struct);
1562
1563 auto packet = OneGenericStructBuilder::Create(std::move(two_byte_struct_ptr));
1564 ASSERT_EQ(generic_struct_two.size(), packet->size());
1565
1566 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1567 BitInserter it(*packet_bytes);
1568 packet->Serialize(it);
1569
1570 ASSERT_EQ(generic_struct_two.size(), packet_bytes->size());
1571 for (size_t i = 0; i < generic_struct_two.size(); i++) {
1572 ASSERT_EQ(generic_struct_two[i], packet_bytes->at(i));
1573 }
1574
1575 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1576 auto view = OneGenericStructView::Create(packet_bytes_view);
1577 ASSERT_TRUE(view.IsValid());
1578 auto base_struct = view.GetBaseStruct();
1579 ASSERT_NE(nullptr, base_struct);
1580 ASSERT_TRUE(TwoByteStruct::IsInstance(*base_struct));
1581 TwoByteStruct* two_byte = static_cast<TwoByteStruct*>(base_struct.get());
1582 ASSERT_NE(nullptr, two_byte);
1583 ASSERT_TRUE(TwoByteStruct::IsInstance(*two_byte));
1584 ASSERT_EQ(two_byte_struct.two_bytes_, 0x0201);
1585 uint16_t val = two_byte->two_bytes_;
1586 ASSERT_EQ(val, 0x0201);
1587 ASSERT_EQ(two_byte_struct.two_bytes_, ((TwoByteStruct*)base_struct.get())->two_bytes_);
1588 }
1589
1590 vector<uint8_t> generic_struct_four{
1591 0x04, // struct_type_ = FourByte
1592 0x01, 0x02, 0x03, 0x04, // four_bytes_
1593 };
1594
TEST(GeneratedPacketTest,testOneGenericStructFour)1595 TEST(GeneratedPacketTest, testOneGenericStructFour) {
1596 FourByteStruct four_byte_struct(0x04030201);
1597 std::unique_ptr<FourByteStruct> four_byte_struct_p =
1598 std::make_unique<FourByteStruct>(four_byte_struct);
1599 ASSERT_EQ(four_byte_struct.four_bytes_, four_byte_struct_p->four_bytes_);
1600
1601 auto packet = OneGenericStructBuilder::Create(std::move(four_byte_struct_p));
1602 ASSERT_EQ(generic_struct_four.size(), packet->size());
1603
1604 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1605 BitInserter it(*packet_bytes);
1606 packet->Serialize(it);
1607
1608 ASSERT_EQ(generic_struct_four.size(), packet_bytes->size());
1609 for (size_t i = 0; i < generic_struct_four.size(); i++) {
1610 ASSERT_EQ(generic_struct_four[i], packet_bytes->at(i));
1611 }
1612
1613 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1614 auto view = OneGenericStructView::Create(packet_bytes_view);
1615 ASSERT_TRUE(view.IsValid());
1616 auto base_struct = view.GetBaseStruct();
1617 ASSERT_NE(nullptr, base_struct);
1618 ASSERT_EQ(StructType::FOUR_BYTE, base_struct->struct_type_);
1619 ASSERT_EQ(four_byte_struct.four_bytes_, ((FourByteStruct*)base_struct.get())->four_bytes_);
1620 }
1621
1622 vector<uint8_t> one_struct_array{
1623 0x04, // struct_type_ = FourByte
1624 0xa1, 0xa2, 0xa3, 0xa4, // four_bytes_
1625 0x04, // struct_type_ = FourByte
1626 0xb2, 0xb2, 0xb3, 0xb4, // four_bytes_
1627 0x02, // struct_type_ = TwoByte
1628 0xc3, 0xc2, // two_bytes_
1629 0x04, // struct_type_ = TwoByte
1630 0xd4, 0xd2, 0xd3, 0xd4, // four_bytes_
1631 };
1632
TEST(GeneratedPacketTest,testOneGenericStructArray)1633 TEST(GeneratedPacketTest, testOneGenericStructArray) {
1634 std::vector<std::unique_ptr<UnusedParentStruct>> parent_vector;
1635 std::unique_ptr<FourByteStruct> fbs;
1636 std::unique_ptr<TwoByteStruct> tbs;
1637 fbs = std::make_unique<FourByteStruct>(0xa4a3a2a1);
1638 parent_vector.push_back(std::move(fbs));
1639 fbs = std::make_unique<FourByteStruct>(0xb4b3b2b2);
1640 parent_vector.push_back(std::move(fbs));
1641 tbs = std::make_unique<TwoByteStruct>(0xc2c3);
1642 parent_vector.push_back(std::move(tbs));
1643 fbs = std::make_unique<FourByteStruct>(0xd4d3d2d4);
1644 parent_vector.push_back(std::move(fbs));
1645
1646 std::vector<std::unique_ptr<UnusedParentStruct>> vector_copy;
1647 for (auto& s : parent_vector) {
1648 if (s->struct_type_ == StructType::TWO_BYTE) {
1649 vector_copy.push_back(std::make_unique<TwoByteStruct>(*(TwoByteStruct*)s.get()));
1650 }
1651 if (s->struct_type_ == StructType::FOUR_BYTE) {
1652 vector_copy.push_back(std::make_unique<FourByteStruct>(*(FourByteStruct*)s.get()));
1653 }
1654 }
1655
1656 auto packet = OneGenericStructArrayBuilder::Create(std::move(parent_vector));
1657 ASSERT_EQ(one_struct_array.size(), packet->size());
1658
1659 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1660 BitInserter it(*packet_bytes);
1661 packet->Serialize(it);
1662
1663 ASSERT_EQ(one_struct_array.size(), packet_bytes->size());
1664 for (size_t i = 0; i < one_struct_array.size(); i++) {
1665 ASSERT_EQ(one_struct_array[i], packet_bytes->at(i));
1666 }
1667
1668 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1669 auto view = OneGenericStructArrayView::Create(packet_bytes_view);
1670 ASSERT_TRUE(view.IsValid());
1671 auto an_array = view.GetAnArray();
1672 ASSERT_EQ(vector_copy.size(), an_array.size());
1673 for (size_t i = 0; i < vector_copy.size(); i++) {
1674 ASSERT_NE(nullptr, an_array[i]);
1675 ASSERT_EQ(vector_copy[i]->struct_type_, an_array[i]->struct_type_);
1676 if (vector_copy[i]->struct_type_ == StructType::FOUR_BYTE) {
1677 ASSERT_EQ(FourByteStruct::Specialize(vector_copy[i].get())->four_bytes_,
1678 FourByteStruct::Specialize(an_array[i].get())->four_bytes_);
1679 } else {
1680 ASSERT_EQ(TwoByteStruct::Specialize(vector_copy[i].get())->two_bytes_,
1681 TwoByteStruct::Specialize(an_array[i].get())->two_bytes_);
1682 }
1683 }
1684 }
1685
TEST(GeneratedPacketTest,testOneGenericStructFourArray)1686 TEST(GeneratedPacketTest, testOneGenericStructFourArray) {
1687 std::array<std::unique_ptr<UnusedParentStruct>, 4> parent_vector;
1688 std::unique_ptr<FourByteStruct> fbs;
1689 std::unique_ptr<TwoByteStruct> tbs;
1690 fbs = std::make_unique<FourByteStruct>(0xa4a3a2a1);
1691 parent_vector[0] = std::move(fbs);
1692 fbs = std::make_unique<FourByteStruct>(0xb4b3b2b2);
1693 parent_vector[1] = std::move(fbs);
1694 tbs = std::make_unique<TwoByteStruct>(0xc2c3);
1695 parent_vector[2] = std::move(tbs);
1696 fbs = std::make_unique<FourByteStruct>(0xd4d3d2d4);
1697 parent_vector[3] = std::move(fbs);
1698
1699 std::array<std::unique_ptr<UnusedParentStruct>, 4> vector_copy;
1700 size_t index = 0;
1701 for (auto& s : parent_vector) {
1702 if (s->struct_type_ == StructType::TWO_BYTE) {
1703 vector_copy[index] = std::make_unique<TwoByteStruct>(*(TwoByteStruct*)s.get());
1704 }
1705 if (s->struct_type_ == StructType::FOUR_BYTE) {
1706 vector_copy[index] = std::make_unique<FourByteStruct>(*(FourByteStruct*)s.get());
1707 }
1708 index++;
1709 }
1710
1711 auto packet = OneGenericStructFourArrayBuilder::Create(std::move(parent_vector));
1712 ASSERT_EQ(one_struct_array.size(), packet->size());
1713
1714 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1715 BitInserter it(*packet_bytes);
1716 packet->Serialize(it);
1717
1718 ASSERT_EQ(one_struct_array.size(), packet_bytes->size());
1719 for (size_t i = 0; i < one_struct_array.size(); i++) {
1720 ASSERT_EQ(one_struct_array[i], packet_bytes->at(i));
1721 }
1722
1723 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1724 auto view = OneGenericStructFourArrayView::Create(packet_bytes_view);
1725 ASSERT_TRUE(view.IsValid());
1726 auto an_array = view.GetAnArray();
1727 ASSERT_EQ(vector_copy.size(), an_array.size());
1728 for (size_t i = 0; i < vector_copy.size(); i++) {
1729 ASSERT_NE(nullptr, an_array[i]);
1730 ASSERT_EQ(vector_copy[i]->struct_type_, an_array[i]->struct_type_);
1731 if (vector_copy[i]->struct_type_ == StructType::FOUR_BYTE) {
1732 ASSERT_EQ(FourByteStruct::Specialize(vector_copy[i].get())->four_bytes_,
1733 FourByteStruct::Specialize(an_array[i].get())->four_bytes_);
1734 } else {
1735 ASSERT_EQ(TwoByteStruct::Specialize(vector_copy[i].get())->two_bytes_,
1736 TwoByteStruct::Specialize(an_array[i].get())->two_bytes_);
1737 }
1738 }
1739 }
1740
1741 vector<uint8_t> one_struct_array_after_fixed{
1742 0x01, 0x02, // two_bytes = 0x0201
1743 0x04, // struct_type_ = FourByte
1744 0xa1, 0xa2, 0xa3, 0xa4, // four_bytes_
1745 0x04, // struct_type_ = FourByte
1746 0xb2, 0xb2, 0xb3, 0xb4, // four_bytes_
1747 0x02, // struct_type_ = TwoByte
1748 0xc3, 0xc2, // two_bytes_
1749 0x04, // struct_type_ = TwoByte
1750 0xd4, 0xd2, 0xd3, 0xd4, // four_bytes_
1751 };
1752
1753 DEFINE_AND_INSTANTIATE_OneGenericStructArrayAfterFixedReflectionTest(one_struct_array_after_fixed);
1754
1755 vector<uint8_t> one_length_type_value_struct{
1756 // _size_(value):16 type value
1757 0x04, 0x00, 0x01, 'o', 'n', 'e', // ONE
1758 0x04, 0x00, 0x02, 't', 'w', 'o', // TWO
1759 0x06, 0x00, 0x03, 't', 'h', 'r', 'e', 'e', // THREE
1760 };
1761
1762 DEFINE_AND_INSTANTIATE_OneLengthTypeValueStructReflectionTest(one_length_type_value_struct);
1763
TEST(GeneratedPacketTest,testOneLengthTypeValueStruct)1764 TEST(GeneratedPacketTest, testOneLengthTypeValueStruct) {
1765 std::shared_ptr<std::vector<uint8_t>> packet_bytes =
1766 std::make_shared<std::vector<uint8_t>>(one_length_type_value_struct);
1767
1768 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1769 auto view = OneLengthTypeValueStructView::Create(packet_bytes_view);
1770 ASSERT_TRUE(view.IsValid());
1771 auto one = view.GetOneArray();
1772 size_t entry_id = 0;
1773 for (const auto& entry : one) {
1774 switch (entry_id++) {
1775 case 0:
1776 ASSERT_EQ(entry.type_, DataType::ONE);
1777 ASSERT_EQ(entry.value_, std::vector<uint8_t>({'o', 'n', 'e'}));
1778 break;
1779 case 1:
1780 ASSERT_EQ(entry.type_, DataType::TWO);
1781 ASSERT_EQ(entry.value_, std::vector<uint8_t>({'t', 'w', 'o'}));
1782 break;
1783 case 2:
1784 ASSERT_EQ(entry.type_, DataType::THREE);
1785 ASSERT_EQ(entry.value_, std::vector<uint8_t>({'t', 'h', 'r', 'e', 'e'}));
1786 break;
1787 default:
1788 ASSERT_EQ(entry.type_, DataType::UNUSED);
1789 }
1790 }
1791 }
1792
1793 vector<uint8_t> one_length_type_value_struct_padded_10{
1794 0x20, // _size_(payload),
1795 0x14, // valid bytes
1796 0x04, 0x00, 0x01, 'o', 'n', 'e', // ONE
1797 0x04, 0x00, 0x02, 't', 'w', 'o', // TWO
1798 0x06, 0x00, 0x03, 't', 'h', 'r', 'e', 'e', // THREE
1799 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // padding to 30
1800 0x20, // after padding
1801 };
1802
1803 vector<uint8_t> one_length_type_value_struct_padded_18{
1804 0x20, // _size_(payload),
1805 0x0C, // valid bytes
1806 0x04, 0x00, 0x01, 'o', 'n', 'e', // ONE
1807 0x04, 0x00, 0x02, 't', 'w', 'o', // TWO
1808 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // padding to 20
1809 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // padding to 30
1810 0x20, // after padding
1811 };
1812
1813 // TODO: Revisit LTV parsing. Right now, the padding bytes are parsed
1814 // DEFINE_AND_INSTANTIATE_OneLengthTypeValueStructPaddedReflectionTest(one_length_type_value_struct_padded_10,
1815 // one_length_type_value_struct_padded_18);
1816
TEST(GeneratedPacketTest,testOneLengthTypeValueStructPaddedGeneration)1817 TEST(GeneratedPacketTest, testOneLengthTypeValueStructPaddedGeneration) {
1818 std::vector<LengthTypeValueStruct> ltv_vector;
1819 LengthTypeValueStruct ltv;
1820 ltv.type_ = DataType::ONE;
1821 ltv.value_ = {
1822 'o',
1823 'n',
1824 'e',
1825 };
1826 ltv_vector.push_back(ltv);
1827 ltv.type_ = DataType::TWO;
1828 ltv.value_ = {
1829 't',
1830 'w',
1831 'o',
1832 };
1833 ltv_vector.push_back(ltv);
1834 uint8_t after_padding = 0x20;
1835
1836 auto packet = OneLengthTypeValueStructPaddedBuilder::Create(12, ltv_vector, after_padding);
1837 ASSERT_EQ(one_length_type_value_struct_padded_18.size(), packet->size());
1838
1839 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1840 BitInserter it(*packet_bytes);
1841 packet->Serialize(it);
1842
1843 ASSERT_EQ(one_length_type_value_struct_padded_18.size(), packet_bytes->size());
1844 for (size_t i = 0; i < one_length_type_value_struct_padded_18.size(); i++) {
1845 ASSERT_EQ(one_length_type_value_struct_padded_18[i], packet_bytes->at(i));
1846 }
1847
1848 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1849 auto view =
1850 OneLengthTypeValueStructPaddedView::Create(SizedParentView::Create(packet_bytes_view));
1851 ASSERT_TRUE(view.IsValid());
1852 auto an_array = view.GetOneArray();
1853 // TODO: Revisit LTV parsing. Right now, the padding bytes are parsed
1854 ASSERT_LE(ltv_vector.size(), an_array.size());
1855 for (size_t i = 0; i < ltv_vector.size(); i++) {
1856 ASSERT_EQ(ltv_vector[i].type_, an_array[i].type_);
1857 ASSERT_EQ(ltv_vector[i].value_, an_array[i].value_);
1858 }
1859 ASSERT_EQ(after_padding, view.GetAfterPadding());
1860 }
1861
1862 vector<uint8_t> byte_sized{
1863 0x11, // 1
1864 0x21, 0x22, // 2
1865 0x31, 0x32, 0x33, // 3
1866 0x41, 0x42, 0x43, 0x44, // 4
1867 0x51, 0x52, 0x53, 0x54, 0x55, // 5
1868 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, // 6
1869 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, // 7
1870 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, // 8
1871 };
1872
TEST(GeneratedPacketTest,testByteSizedFields)1873 TEST(GeneratedPacketTest, testByteSizedFields) {
1874 uint64_t array[9]{
1875 0xbadbadbad,
1876 0x11, // 1
1877 0x2221, // 2
1878 0x333231, // 3
1879 0x44434241, // 4
1880 0x5554535251, // 5
1881 0x666564636261, // 6
1882 0x77767574737271, // 7
1883 0x8887868584838281, // 8
1884 };
1885 auto packet = ByteSizedFieldsBuilder::Create(array[1], array[2], array[3], array[4], array[5],
1886 array[6], array[7], array[8]);
1887 ASSERT_EQ(byte_sized.size(), packet->size());
1888
1889 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1890 BitInserter it(*packet_bytes);
1891 packet->Serialize(it);
1892
1893 ASSERT_EQ(byte_sized.size(), packet_bytes->size());
1894 for (size_t i = 0; i < byte_sized.size(); i++) {
1895 ASSERT_EQ(byte_sized[i], packet_bytes->at(i));
1896 }
1897
1898 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1899 auto view = ByteSizedFieldsView::Create(packet_bytes_view);
1900 ASSERT_TRUE(view.IsValid());
1901 ASSERT_EQ(array[1], view.GetOne());
1902 ASSERT_EQ(array[2], view.GetTwo());
1903 ASSERT_EQ(array[3], view.GetThree());
1904 ASSERT_EQ(array[4], view.GetFour());
1905 ASSERT_EQ(array[5], view.GetFive());
1906 ASSERT_EQ(array[6], view.GetSix());
1907 ASSERT_EQ(array[7], view.GetSeven());
1908 ASSERT_EQ(array[8], view.GetEight());
1909 }
1910
1911 DEFINE_AND_INSTANTIATE_ByteSizedFieldsReflectionTest(byte_sized);
1912
TEST(GeneratedPacketTest,testOneGenericStructArrayNoZeroEmpty)1913 TEST(GeneratedPacketTest, testOneGenericStructArrayNoZeroEmpty) {
1914 auto too_few_bytes = std::make_shared<std::vector<uint8_t>>(0);
1915 auto view = OneGenericStructArrayNoZeroView::Create(PacketView<kLittleEndian>(too_few_bytes));
1916 for (size_t i = 0; i < 10; i++) {
1917 if (view.IsValid()) {
1918 view.GetAnArray().size();
1919 }
1920 too_few_bytes->push_back(0);
1921 view = OneGenericStructArrayNoZeroView::Create(PacketView<kLittleEndian>(too_few_bytes));
1922 }
1923
1924 std::vector<uint8_t> a_two_byte_struct = {
1925 static_cast<uint8_t>(StructTypeNoZero::TWO_BYTE),
1926 0x01,
1927 0x02,
1928 };
1929 too_few_bytes = std::make_shared<std::vector<uint8_t>>(a_two_byte_struct);
1930 view = OneGenericStructArrayNoZeroView::Create(PacketView<kLittleEndian>(too_few_bytes));
1931 ASSERT_TRUE(view.IsValid());
1932 ASSERT_EQ(1ul, view.GetAnArray().size());
1933 }
1934
TEST(GeneratedPacketTest,testToStringOutput)1935 TEST(GeneratedPacketTest, testToStringOutput) {
1936 std::vector<TwoRelatedNumbersBe> count_array;
1937 for (uint8_t i = 1; i < 5; i++) {
1938 TwoRelatedNumbersBe trn;
1939 trn.id_ = i;
1940 trn.count_ = 0x0102 * i;
1941 count_array.push_back(trn);
1942 }
1943
1944 auto packet = ArrayOfStructBeBuilder::Create(count_array);
1945
1946 ASSERT_EQ(array_of_struct_be.size(), packet->size());
1947
1948 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1949 BitInserter it(*packet_bytes);
1950 packet->Serialize(it);
1951
1952 ASSERT_EQ(array_of_struct_be.size(), packet_bytes->size());
1953 for (size_t i = 0; i < array_of_struct_be.size(); i++) {
1954 ASSERT_EQ(array_of_struct_be[i], packet_bytes->at(i));
1955 }
1956
1957 PacketView<!kLittleEndian> packet_bytes_view(packet_bytes);
1958 auto view = ArrayOfStructBeView::Create(packet_bytes_view);
1959 ASSERT_TRUE(view.IsValid());
1960
1961 ASSERT_EQ(
1962 "ArrayOfStructBe { array_count = 0x4, array = VECTOR[TwoRelatedNumbersBe { id = 0x1, "
1963 "count = 0x102 }, "
1964 "TwoRelatedNumbersBe { id = 0x2, count = 0x204 }, TwoRelatedNumbersBe { id = 0x3, count "
1965 "= 0x306 }, "
1966 "TwoRelatedNumbersBe { id = 0x4, count = 0x408 }] }",
1967 view.ToString());
1968 }
1969
TEST(GeneratedPacketTest,testEnumText)1970 TEST(GeneratedPacketTest, testEnumText) {
1971 EXPECT_EQ("FIVE(0x5)", FourBitsText(FourBits::FIVE));
1972 EXPECT_EQ("THREE(0x3)", TwoBitsText(TwoBits::THREE));
1973 EXPECT_EQ("FOUR_BYTE(0x04)", StructTypeText(StructType::FOUR_BYTE));
1974 EXPECT_EQ("TWO_THREE(0x0302)", ForArraysText(ForArrays::TWO_THREE));
1975 }
1976
TEST(GeneratedPacketTest,testToStringOneFixedTypesStruct)1977 TEST(GeneratedPacketTest, testToStringOneFixedTypesStruct) {
1978 StructWithFixedTypes swf;
1979 swf.four_bits_ = FourBits::FIVE;
1980 swf.id_ = 0x0d;
1981 swf.array_ = {{0x01, 0x02, 0x03}};
1982 swf.six_bytes_ = SixBytes{{0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6}};
1983
1984 auto packet = OneFixedTypesStructBuilder::Create(swf);
1985 ASSERT_EQ(one_fixed_types_struct.size(), packet->size());
1986
1987 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
1988 BitInserter it(*packet_bytes);
1989 packet->Serialize(it);
1990
1991 ASSERT_EQ(one_fixed_types_struct.size(), packet_bytes->size());
1992 for (size_t i = 0; i < one_fixed_types_struct.size(); i++) {
1993 ASSERT_EQ(one_fixed_types_struct[i], packet_bytes->at(i));
1994 }
1995
1996 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
1997 auto view = OneFixedTypesStructView::Create(packet_bytes_view);
1998 ASSERT_TRUE(view.IsValid());
1999
2000 ASSERT_EQ(
2001 "OneFixedTypesStruct { one = StructWithFixedTypes { four_bits = FIVE(0x5), id = 0xd, "
2002 "array = ARRAY[0x1, 0x2, 0x3], example_checksum = CHECKSUM, six_bytes = SixBytes } }",
2003 view.ToString());
2004 }
2005
TEST(GeneratedPacketTest,testCreateOptional)2006 TEST(GeneratedPacketTest, testCreateOptional) {
2007 auto packet = ChildTwoTwoThreeBuilder::Create();
2008
2009 ASSERT_EQ(child_two_two_three.size(), packet->size());
2010
2011 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
2012 BitInserter it(*packet_bytes);
2013 packet->Serialize(it);
2014
2015 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
2016 auto wrong_view = ParentView::CreateOptional(packet_bytes_view);
2017 ASSERT_FALSE(wrong_view.has_value());
2018
2019 auto parent_view = ParentTwoView::CreateOptional(packet_bytes_view);
2020 ASSERT_EQ(FourBits::TWO, parent_view->GetFourBits());
2021
2022 auto child_view = ChildTwoTwoView::CreateOptional(*parent_view);
2023 ASSERT_EQ(FourBits::THREE, child_view->GetMoreBits());
2024
2025 auto grandchild_view = ChildTwoTwoThreeView::CreateOptional(*child_view);
2026 ASSERT_TRUE(grandchild_view.has_value());
2027 }
2028
TEST(GeneratedPacketTest,testStructWithShadowedNames)2029 TEST(GeneratedPacketTest, testStructWithShadowedNames) {
2030 uint32_t four_bytes = 0x01020304;
2031 StructType struct_type = StructType::TWO_BYTE;
2032 auto ebs = AtLeastFourByteStruct(four_bytes, struct_type);
2033
2034 ASSERT_EQ(ebs.four_bytes_, four_bytes);
2035 ASSERT_EQ(ebs.struct_type_, struct_type);
2036 }
2037
TEST(GeneratedPacketTest,testArrays)2038 TEST(GeneratedPacketTest, testArrays) {
2039 std::vector<uint8_t> bytes({1, 2, 3});
2040 std::vector<uint16_t> sixteens({0x0111, 0x0212, 0x0313});
2041 std::vector<uint32_t> thirtytwos({0x01112131, 0x02122232, 0x03132333});
2042 auto packet = ArraysBuilder::Create(bytes, sixteens, thirtytwos);
2043
2044 std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
2045 BitInserter it(*packet_bytes);
2046 packet->Serialize(it);
2047
2048 PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
2049 auto view = ArraysView::Create(packet_bytes_view);
2050 ASSERT_TRUE(view.IsValid());
2051
2052 auto bytes_from_packet = view.GetBytes();
2053 ASSERT_EQ(bytes.size(), bytes_from_packet.size());
2054 for (size_t i = 0; i < bytes.size(); i++) {
2055 ASSERT_EQ(bytes[i], bytes_from_packet[i]);
2056 }
2057
2058 auto sixteens_from_packet = view.GetSixteens();
2059 ASSERT_EQ(sixteens.size(), sixteens_from_packet.size());
2060 for (size_t i = 0; i < sixteens.size(); i++) {
2061 ASSERT_EQ(sixteens[i], sixteens_from_packet[i]);
2062 }
2063
2064 auto thirtytwos_from_packet = view.GetThirtytwos();
2065 ASSERT_EQ(thirtytwos.size(), thirtytwos_from_packet.size());
2066 for (size_t i = 0; i < thirtytwos.size(); i++) {
2067 ASSERT_EQ(thirtytwos[i], thirtytwos_from_packet[i]);
2068 }
2069 }
2070 } // namespace parser
2071 } // namespace packet
2072 } // namespace bluetooth
2073