1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <algorithm>
18 #include <fstream>
19 #include <iostream>
20 #include "directory_ex.h"
21 #include "parcel.h"
22 #include "refbase.h"
23 #include "securec.h"
24 using namespace testing::ext;
25 using namespace std;
26
27 namespace OHOS {
28 namespace {
29 const int MAX_PARCEL_SIZE = 1000;
30 char g_data[MAX_PARCEL_SIZE];
31 class UtilsParcelTest : public testing::Test {
32 public:
33 static constexpr size_t DEFAULT_CPACITY = 204800; // 200K
34 static constexpr size_t CAPACITY_THRESHOLD = 4096; // 4k
35 static void TearDownTestCase(void);
36 };
37
TearDownTestCase(void)38 void UtilsParcelTest::TearDownTestCase(void)
39 {
40 for (int i = 0; i < MAX_PARCEL_SIZE; i++) {
41 g_data[i] = 0;
42 }
43 }
44
45 /*-------------------------------base data------------------------------------*/
46
47 struct TestData {
48 bool booltest;
49 int8_t int8test;
50 int16_t int16test;
51 int32_t int32test;
52 uint8_t uint8test;
53 uint16_t uint16test;
54 uint32_t uint32test;
55 };
56
WriteTestData(Parcel & parcel,const struct TestData & data)57 void WriteTestData(Parcel &parcel, const struct TestData &data)
58 {
59 bool result = false;
60
61 result = parcel.WriteBool(data.booltest);
62 EXPECT_EQ(result, true);
63
64 result = parcel.WriteInt8(data.int8test);
65 EXPECT_EQ(result, true);
66
67 result = parcel.WriteInt16(data.int16test);
68 EXPECT_EQ(result, true);
69
70 result = parcel.WriteInt32(data.int32test);
71 EXPECT_EQ(result, true);
72
73 result = parcel.WriteUint8(data.uint8test);
74 EXPECT_EQ(result, true);
75
76 result = parcel.WriteUint16(data.uint16test);
77 EXPECT_EQ(result, true);
78
79 result = parcel.WriteUint32(data.uint32test);
80 EXPECT_EQ(result, true);
81 }
82
WriteUnalignedTestData(Parcel & parcel,const struct TestData & data)83 void WriteUnalignedTestData(Parcel &parcel, const struct TestData &data)
84 {
85 bool result = false;
86
87 result = parcel.WriteBoolUnaligned(data.booltest);
88 EXPECT_EQ(result, true);
89
90 result = parcel.WriteInt8Unaligned(data.int8test);
91 EXPECT_EQ(result, true);
92
93 result = parcel.WriteInt16Unaligned(data.int16test);
94 EXPECT_EQ(result, true);
95
96 result = parcel.WriteUint8Unaligned(data.uint8test);
97 EXPECT_EQ(result, true);
98
99 result = parcel.WriteUint16Unaligned(data.uint16test);
100 EXPECT_EQ(result, true);
101 }
102
ReadTestData(Parcel & parcel,const struct TestData & data)103 void ReadTestData(Parcel &parcel, const struct TestData &data)
104 {
105 bool readbool = parcel.ReadBool();
106 EXPECT_EQ(readbool, data.booltest);
107
108 int8_t readint8 = parcel.ReadInt8();
109 EXPECT_EQ(readint8, data.int8test);
110
111 int16_t readint16 = parcel.ReadInt16();
112 EXPECT_EQ(readint16, data.int16test);
113
114 int32_t readint32 = parcel.ReadInt32();
115 EXPECT_EQ(readint32, data.int32test);
116
117 uint8_t readuint8 = parcel.ReadUint8();
118 EXPECT_EQ(readuint8, data.uint8test);
119
120 uint16_t readuint16 = parcel.ReadUint16();
121 EXPECT_EQ(readuint16, data.uint16test);
122
123 uint32_t readuint32 = parcel.ReadUint32();
124 EXPECT_EQ(readuint32, data.uint32test);
125 }
126
ReadUnalignedTestData(Parcel & parcel,const struct TestData & data)127 void ReadUnalignedTestData(Parcel &parcel, const struct TestData &data)
128 {
129 bool readbool = parcel.ReadBoolUnaligned();
130 EXPECT_EQ(readbool, data.booltest);
131
132 int8_t readint8;
133 EXPECT_TRUE(parcel.ReadInt8Unaligned(readint8));
134 EXPECT_EQ(readint8, data.int8test);
135
136 int16_t readint16;
137 EXPECT_TRUE(parcel.ReadInt16Unaligned(readint16));
138 EXPECT_EQ(readint16, data.int16test);
139
140 uint8_t readuint8;
141 EXPECT_TRUE(parcel.ReadUint8Unaligned(readuint8));
142 EXPECT_EQ(readuint8, data.uint8test);
143
144 uint16_t readuint16;
145 EXPECT_TRUE(parcel.ReadUint16Unaligned(readuint16));
146 EXPECT_EQ(readuint16, data.uint16test);
147 }
148
ReadTestDataWithTarget(Parcel & parcel,const struct TestData & data)149 void ReadTestDataWithTarget(Parcel &parcel, const struct TestData &data)
150 {
151 bool result = false;
152 bool boolVal = true;
153 result = parcel.ReadBool(boolVal);
154 EXPECT_EQ(result, true);
155 EXPECT_EQ(boolVal, data.booltest);
156
157 int8_t int8Val;
158 result = parcel.ReadInt8(int8Val);
159 EXPECT_EQ(result, true);
160 EXPECT_EQ(int8Val, data.int8test);
161
162 int16_t int16Val;
163 result = parcel.ReadInt16(int16Val);
164 EXPECT_EQ(result, true);
165 EXPECT_EQ(int16Val, data.int16test);
166
167 int32_t int32Val;
168 result = parcel.ReadInt32(int32Val);
169 EXPECT_EQ(result, true);
170 EXPECT_EQ(int32Val, data.int32test);
171
172 uint8_t uint8Val;
173 result = parcel.ReadUint8(uint8Val);
174 EXPECT_EQ(result, true);
175 EXPECT_EQ(uint8Val, data.uint8test);
176
177 uint16_t uint16Val;
178 result = parcel.ReadUint16(uint16Val);
179 EXPECT_EQ(result, true);
180 EXPECT_EQ(uint16Val, data.uint16test);
181
182 uint32_t uint32Val;
183 result = parcel.ReadUint32(uint32Val);
184 EXPECT_EQ(result, true);
185 EXPECT_EQ(uint32Val, data.uint32test);
186 }
187
188 /**
189 * Here to simulate the scenario of ipc sending data, the buffer will be released when the Parcel object is destructed.
190 */
SendData(void * & buffer,size_t size,const uint8_t * data)191 bool SendData(void *&buffer, size_t size, const uint8_t *data)
192 {
193 if (size <= 0) {
194 return false;
195 }
196 buffer = malloc(size);
197 if (buffer == nullptr) {
198 return false;
199 }
200 if (memcpy_s(buffer, size, data, size) != EOK) {
201 return false;
202 }
203 return true;
204 }
205
206 /**
207 * @tc.name: test_parcel_001
208 * @tc.desc: test parcel CheckOffsets, WriteRemoteObject, RewindRead and
209 * RewindWrite failed.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(UtilsParcelTest, test_parcel_001, TestSize.Level0)
213 {
214 Parcel parcel;
215 bool result = parcel.CheckOffsets();
216 EXPECT_EQ(result, false);
217 result = parcel.WriteRemoteObject(nullptr);
218 EXPECT_EQ(result, false);
219 result = parcel.RewindRead(parcel.GetDataSize() + 1);
220 EXPECT_EQ(result, false);
221 result = parcel.RewindWrite(parcel.GetDataSize() + 1);
222 EXPECT_EQ(result, false);
223 }
224
225 /**
226 * @tc.name: test_parcel_readvec_001
227 * @tc.desc: test parcel read vector failed with invlalid input.
228 * @tc.type: FUNC
229 */
230 HWTEST_F(UtilsParcelTest, test_parcel_readvec_001, TestSize.Level0)
231 {
232 Parcel parcel;
233
234 bool result = parcel.ReadBoolVector(nullptr);
235 EXPECT_EQ(result, false);
236
237 result = parcel.ReadInt8Vector(nullptr);
238 EXPECT_EQ(result, false);
239
240 result = parcel.ReadInt16Vector(nullptr);
241 EXPECT_EQ(result, false);
242
243 result = parcel.ReadInt32Vector(nullptr);
244 EXPECT_EQ(result, false);
245
246 result = parcel.ReadInt64Vector(nullptr);
247 EXPECT_EQ(result, false);
248
249 result = parcel.ReadUInt8Vector(nullptr);
250 EXPECT_EQ(result, false);
251
252 result = parcel.ReadUInt16Vector(nullptr);
253 EXPECT_EQ(result, false);
254
255 result = parcel.ReadUInt32Vector(nullptr);
256 EXPECT_EQ(result, false);
257
258 result = parcel.ReadUInt64Vector(nullptr);
259 EXPECT_EQ(result, false);
260
261 result = parcel.ReadFloatVector(nullptr);
262 EXPECT_EQ(result, false);
263
264 result = parcel.ReadDoubleVector(nullptr);
265 EXPECT_EQ(result, false);
266
267 result = parcel.ReadStringVector(nullptr);
268 EXPECT_EQ(result, false);
269
270 result = parcel.ReadString16Vector(nullptr);
271 EXPECT_EQ(result, false);
272 }
273
274 /**
275 * @tc.name: test_parcel_readvec_002
276 * @tc.desc: test parcel read vector failed with invlalid vector length -1.
277 * @tc.type: FUNC
278 */
279 HWTEST_F(UtilsParcelTest, test_parcel_readvec_002, TestSize.Level0)
280 {
281 Parcel parcel1;
282 parcel1.WriteInt32(-1);
283 std::vector<bool> val1;
284 bool x1 = true;
285 val1.push_back(x1);
286 bool result = parcel1.ReadBoolVector(&val1);
287 EXPECT_EQ(result, false);
288
289 Parcel parcel2;
290 parcel2.WriteInt32(-1);
291 std::vector<int8_t> val2;
292 int8_t x2 = 1;
293 val2.push_back(x2);
294 result = parcel2.ReadInt8Vector(&val2);
295 EXPECT_EQ(result, false);
296
297 Parcel parcel3;
298 parcel3.WriteInt32(-1);
299 std::vector<int16_t> val3;
300 int16_t x3 = 1;
301 val3.push_back(x3);
302 result = parcel3.ReadInt16Vector(&val3);
303 EXPECT_EQ(result, false);
304
305 Parcel parcel4;
306 parcel4.WriteInt32(-1);
307 std::vector<int32_t> val4;
308 int32_t x4 = 1;
309 val4.push_back(x4);
310 result = parcel4.ReadInt32Vector(&val4);
311 EXPECT_EQ(result, false);
312
313 Parcel parcel5;
314 parcel5.WriteInt32(-1);
315 std::vector<int64_t> val5;
316 int64_t x5 = 1;
317 val5.push_back(x5);
318 result = parcel5.ReadInt64Vector(&val5);
319 EXPECT_EQ(result, false);
320
321 Parcel parcel6;
322 parcel6.WriteInt32(-1);
323 std::vector<uint8_t> val6;
324 uint8_t x6 = 1;
325 val6.push_back(x6);
326 result = parcel6.ReadUInt8Vector(&val6);
327 EXPECT_EQ(result, false);
328
329 Parcel parcel7;
330 parcel7.WriteInt32(-1);
331 std::vector<uint16_t> val7;
332 uint16_t x7 = 1;
333 val7.push_back(x7);
334 result = parcel7.ReadUInt16Vector(&val7);
335 EXPECT_EQ(result, false);
336
337 Parcel parcel8;
338 parcel8.WriteInt32(-1);
339 std::vector<uint32_t> val8;
340 uint32_t x8 = 1;
341 val8.push_back(x8);
342 result = parcel8.ReadUInt32Vector(&val8);
343 EXPECT_EQ(result, false);
344
345 Parcel parcel9;
346 parcel9.WriteInt32(-1);
347 std::vector<uint64_t> val9;
348 uint64_t x9 = 1;
349 val9.push_back(x9);
350 result = parcel9.ReadUInt64Vector(&val9);
351 EXPECT_EQ(result, false);
352
353 Parcel parcel10;
354 parcel10.WriteInt32(-1);
355 std::vector<float> val10;
356 float x10 = 1;
357 val10.push_back(x10);
358 result = parcel10.ReadFloatVector(&val10);
359 EXPECT_EQ(result, false);
360
361 Parcel parcel11;
362 parcel11.WriteInt32(-1);
363 std::vector<double> val11;
364 double x11 = 1;
365 val11.push_back(x11);
366 result = parcel11.ReadDoubleVector(&val11);
367 EXPECT_EQ(result, false);
368
369 Parcel parcel12;
370 parcel12.WriteInt32(-1);
371 std::vector<std::string> val12;
372 std::string x12 = "test";
373 val12.push_back(x12);
374 result = parcel12.ReadStringVector(&val12);
375 EXPECT_EQ(result, false);
376
377 Parcel parcel13;
378 parcel13.WriteInt32(-1);
379 std::vector<std::u16string> val13;
380 std::u16string x13 = u"test";
381 val13.push_back(x13);
382 result = parcel13.ReadString16Vector(&val13);
383 EXPECT_EQ(result, false);
384 }
385
386 /**
387 * @tc.name: test_parcel_readvec_003
388 * @tc.desc: test parcel read vector failed with invlalid vector length
389 * std::vector::max_size().
390 * @tc.type: FUNC
391 */
392 HWTEST_F(UtilsParcelTest, test_parcel_readvec_003, TestSize.Level0)
393 {
394 Parcel parcel1;
395 std::vector<bool> val1;
396 bool x1 = true;
397 val1.push_back(x1);
398 parcel1.WriteInt32(val1.max_size());
399 bool result = parcel1.ReadBoolVector(&val1);
400 EXPECT_EQ(result, false);
401
402 Parcel parcel2;
403 std::vector<int8_t> val2;
404 int8_t x2 = 1;
405 val2.push_back(x2);
406 parcel2.WriteInt32(val2.max_size());
407 result = parcel2.ReadInt8Vector(&val2);
408 EXPECT_EQ(result, false);
409
410 Parcel parcel3;
411 std::vector<int16_t> val3;
412 int16_t x3 = 1;
413 val3.push_back(x3);
414 parcel3.WriteInt32(val3.max_size());
415 result = parcel3.ReadInt16Vector(&val3);
416 EXPECT_EQ(result, false);
417
418 Parcel parcel4;
419 std::vector<int32_t> val4;
420 int32_t x4 = 1;
421 val4.push_back(x4);
422 parcel4.WriteInt32(val4.max_size());
423 result = parcel4.ReadInt32Vector(&val4);
424 EXPECT_EQ(result, false);
425
426 Parcel parcel5;
427 std::vector<int64_t> val5;
428 int64_t x5 = 1;
429 val5.push_back(x5);
430 parcel5.WriteInt32(val5.max_size());
431 result = parcel5.ReadInt64Vector(&val5);
432 EXPECT_EQ(result, false);
433
434 Parcel parcel6;
435 std::vector<uint8_t> val6;
436 uint8_t x6 = 1;
437 val6.push_back(x6);
438 parcel6.WriteInt32(val6.max_size());
439 result = parcel6.ReadUInt8Vector(&val6);
440 EXPECT_EQ(result, false);
441
442 Parcel parcel7;
443 std::vector<uint16_t> val7;
444 uint16_t x7 = 1;
445 val7.push_back(x7);
446 parcel7.WriteInt32(val7.max_size());
447 result = parcel7.ReadUInt16Vector(&val7);
448 EXPECT_EQ(result, false);
449
450 Parcel parcel8;
451 std::vector<uint32_t> val8;
452 uint32_t x8 = 1;
453 val8.push_back(x8);
454 parcel8.WriteInt32(val8.max_size());
455 result = parcel8.ReadUInt32Vector(&val8);
456 EXPECT_EQ(result, false);
457
458 Parcel parcel9;
459 std::vector<uint64_t> val9;
460 uint64_t x9 = 1;
461 val9.push_back(x9);
462 parcel9.WriteInt32(val9.max_size());
463 result = parcel9.ReadUInt64Vector(&val9);
464 EXPECT_EQ(result, false);
465
466 Parcel parcel10;
467 std::vector<float> val10;
468 float x10 = 1;
469 val10.push_back(x10);
470 parcel10.WriteInt32(val10.max_size());
471 result = parcel10.ReadFloatVector(&val10);
472 EXPECT_EQ(result, false);
473
474 Parcel parcel11;
475 std::vector<double> val11;
476 double x11 = 1;
477 val11.push_back(x11);
478 parcel11.WriteInt32(val11.max_size());
479 result = parcel11.ReadDoubleVector(&val11);
480 EXPECT_EQ(result, false);
481
482 Parcel parcel12;
483 std::vector<std::string> val12;
484 std::string x12 = "test";
485 val12.push_back(x12);
486 parcel12.WriteInt32(val12.max_size());
487 result = parcel12.ReadStringVector(&val12);
488 EXPECT_EQ(result, false);
489
490 Parcel parcel13;
491 std::vector<std::u16string> val13;
492 std::u16string x13 = u"test";
493 val13.push_back(x13);
494 parcel13.WriteInt32(val13.max_size());
495 result = parcel13.ReadString16Vector(&val13);
496 EXPECT_EQ(result, false);
497 }
498
499 /**
500 * @tc.name: test_parcel_writevec_001
501 * @tc.desc: test parcel write vector failed with writting data out of the
502 * maximum capacity.
503 * @tc.type: FUNC
504 */
505 HWTEST_F(UtilsParcelTest, test_parcel_writevec_001, TestSize.Level0)
506 {
507 size_t cap = DEFAULT_CPACITY;
508
509 Parcel parcel(nullptr);
510 std::vector<bool> val1;
511 bool x1 = true;
512 for (int i = 0; i < cap / sizeof(bool); i++) {
513 val1.push_back(x1);
514 }
515 bool result = parcel.WriteBoolVector(val1);
516 EXPECT_EQ(result, false);
517
518 parcel.FlushBuffer();
519 std::vector<int8_t> val2;
520 int8_t x2 = 1;
521 for (int i = 0; i < cap / sizeof(int8_t); i++) {
522 val2.push_back(x2);
523 }
524 result = parcel.WriteInt8Vector(val2);
525 EXPECT_EQ(result, false);
526
527 parcel.FlushBuffer();
528 std::vector<int16_t> val3;
529 int16_t x3 = 1;
530 for (int i = 0; i < cap / sizeof(int16_t); i++) {
531 val3.push_back(x3);
532 }
533 result = parcel.WriteInt16Vector(val3);
534 EXPECT_EQ(result, false);
535
536 parcel.FlushBuffer();
537 std::vector<int32_t> val4;
538 int32_t x4 = 1;
539 for (int i = 0; i < cap / sizeof(int32_t); i++) {
540 val4.push_back(x4);
541 }
542 result = parcel.WriteInt32Vector(val4);
543 EXPECT_EQ(result, false);
544
545 parcel.FlushBuffer();
546 std::vector<int64_t> val5;
547 int64_t x5 = 1;
548 for (int i = 0; i < cap / sizeof(int64_t); i++) {
549 val5.push_back(x5);
550 }
551 result = parcel.WriteInt64Vector(val5);
552 EXPECT_EQ(result, false);
553
554 parcel.FlushBuffer();
555 std::vector<uint8_t> val6;
556 uint8_t x6 = 1;
557 for (int i = 0; i < cap / sizeof(uint8_t); i++) {
558 val6.push_back(x6);
559 }
560 result = parcel.WriteUInt8Vector(val6);
561 EXPECT_EQ(result, false);
562
563 parcel.FlushBuffer();
564 std::vector<uint16_t> val7;
565 uint16_t x7 = 1;
566 for (int i = 0; i < cap / sizeof(uint16_t); i++) {
567 val7.push_back(x7);
568 }
569 result = parcel.WriteUInt16Vector(val7);
570 EXPECT_EQ(result, false);
571
572 parcel.FlushBuffer();
573 std::vector<uint32_t> val8;
574 uint32_t x8 = 1;
575 for (int i = 0; i < cap / sizeof(uint32_t); i++) {
576 val8.push_back(x8);
577 }
578 result = parcel.WriteUInt32Vector(val8);
579 EXPECT_EQ(result, false);
580
581 parcel.FlushBuffer();
582 std::vector<uint64_t> val9;
583 uint64_t x9 = 1;
584 for (int i = 0; i < cap / sizeof(uint64_t); i++) {
585 val9.push_back(x9);
586 }
587 result = parcel.WriteUInt64Vector(val9);
588 EXPECT_EQ(result, false);
589
590 parcel.FlushBuffer();
591 std::vector<float> val10;
592 float x10 = 1;
593 for (int i = 0; i < cap / sizeof(float); i++) {
594 val10.push_back(x10);
595 }
596 result = parcel.WriteFloatVector(val10);
597 EXPECT_EQ(result, false);
598
599 parcel.FlushBuffer();
600 std::vector<double> val11;
601 double x11 = 1;
602 for (int i = 0; i < cap / sizeof(double); i++) {
603 val11.push_back(x11);
604 }
605 result = parcel.WriteDoubleVector(val11);
606 EXPECT_EQ(result, false);
607
608 parcel.FlushBuffer();
609 std::vector<std::string> val12;
610 std::string x12((cap / sizeof(char)), 't');
611 val12.push_back(x12);
612 result = parcel.WriteStringVector(val12);
613 EXPECT_EQ(result, false);
614
615 parcel.FlushBuffer();
616 std::vector<std::u16string> val13;
617 std::u16string x13((cap / sizeof(char16_t)), u't');
618 val13.push_back(x13);
619 result = parcel.WriteString16Vector(val13);
620 EXPECT_EQ(result, false);
621 }
622
623 /**
624 * @tc.name: test_parcel_SetMaxCapacity_001
625 * @tc.desc: test parcel primary type read write.
626 * @tc.type: FUNC
627 */
628 HWTEST_F(UtilsParcelTest, test_parcel_SetMaxCapacity_001, TestSize.Level0)
629 {
630 size_t cap = DEFAULT_CPACITY;
631 Parcel parcel(nullptr);
632 EXPECT_TRUE(parcel.SetMaxCapacity(cap + 1));
633 EXPECT_FALSE(parcel.SetMaxCapacity(cap - 1));
634 }
635
636 /**
637 * @tc.name: test_parcel_SetAllocator_001
638 * @tc.desc: test setting allocator to parcels with and without existed allocator.
639 * @tc.type: FUNC
640 */
641 HWTEST_F(UtilsParcelTest, test_parcel_SetAllocator_001, TestSize.Level0)
642 {
643 Allocator* alloc = new DefaultAllocator();
644 Parcel parcel(alloc);
645 EXPECT_FALSE(parcel.SetAllocator(alloc));
646 EXPECT_FALSE(parcel.SetAllocator(nullptr));
647
648 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
649
650 WriteTestData(parcel, data);
651 parcel.SetAllocator(new DefaultAllocator());
652 ReadTestData(parcel, data);
653 }
654
655 /**
656 * @tc.name: test_parcel_write_001
657 * @tc.desc: test parcel write failed.
658 * @tc.type: FUNC
659 */
660 HWTEST_F(UtilsParcelTest, test_parcel_write_001, TestSize.Level0)
661 {
662 Parcel parcel1;
663 parcel1.WriteBool(true);
664 Parcel parcel2;
665 void *buffer = nullptr;
666 size_t size = parcel1.GetDataSize();
667 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
668 ASSERT_FALSE(false);
669 }
670 parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
671
672 string str8write;
673 bool result = parcel2.WriteString(str8write);
674 EXPECT_EQ(result, false);
675
676 u16string str16Write;
677 result = parcel2.WriteString16(str16Write);
678 EXPECT_EQ(result, false);
679
680 result = parcel2.WriteBool(false);
681 EXPECT_EQ(result, false);
682
683 result = parcel2.WriteBoolUnaligned(false);
684 EXPECT_EQ(result, false);
685
686 result = parcel2.WriteInt8(false);
687 EXPECT_EQ(result, false);
688
689 result = parcel2.WriteInt8Unaligned(false);
690 EXPECT_EQ(result, false);
691
692 result = parcel2.WriteInt32(false);
693 EXPECT_EQ(result, false);
694
695 result = parcel2.WriteInt64(false);
696 EXPECT_EQ(result, false);
697
698 result = parcel2.WriteUint8(false);
699 EXPECT_EQ(result, false);
700
701 result = parcel2.WriteUint16(false);
702 EXPECT_EQ(result, false);
703
704 result = parcel2.WriteUint8Unaligned(false);
705 EXPECT_EQ(result, false);
706
707 result = parcel2.WriteUint16Unaligned(false);
708 EXPECT_EQ(result, false);
709
710 result = parcel2.WriteUint32(false);
711 EXPECT_EQ(result, false);
712
713 result = parcel2.WriteUint64(false);
714 EXPECT_EQ(result, false);
715
716 result = parcel2.WriteFloat(false);
717 EXPECT_EQ(result, false);
718
719 result = parcel2.WriteDouble(false);
720 EXPECT_EQ(result, false);
721
722 result = parcel2.WritePointer(false);
723 EXPECT_EQ(result, false);
724 }
725
726 /**
727 * @tc.name: test_parcel_WriteAndRead_001
728 * @tc.desc: test parcel primary type read write.
729 * @tc.type: FUNC
730 */
731 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_001, TestSize.Level0)
732 {
733 Parcel parcel(nullptr);
734 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
735 WriteTestData(parcel, data);
736 ReadTestData(parcel, data);
737
738 WriteUnalignedTestData(parcel, data);
739 ReadUnalignedTestData(parcel, data);
740 }
741
742 /**
743 * @tc.name: test_parcel_WriteAndRead_002
744 * @tc.desc: test parcel primary type read write.
745 * @tc.type: FUNC
746 */
747 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_002, TestSize.Level0)
748 {
749 Parcel parcel1(nullptr);
750 Parcel parcel2(nullptr);
751 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
752 WriteTestData(parcel1, data);
753 WriteUnalignedTestData(parcel1, data);
754
755 void *buffer = nullptr;
756 size_t size = parcel1.GetDataSize();
757 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
758 ASSERT_FALSE(false);
759 }
760
761 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
762 EXPECT_EQ(result, true);
763
764 ReadTestData(parcel2, data);
765 ReadUnalignedTestData(parcel2, data);
766 }
767
768 /**
769 * @tc.name: test_parcel_WriteAndRead_003
770 * @tc.desc: test parcel primary type read write.
771 * @tc.type: FUNC
772 */
773 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_003, TestSize.Level0)
774 {
775 Parcel parcel1(nullptr);
776 Parcel parcel2(nullptr);
777 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
778 WriteTestData(parcel1, data);
779
780 void *buffer = nullptr;
781 size_t size = parcel1.GetDataSize();
782 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
783 ASSERT_FALSE(false);
784 }
785
786 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
787 EXPECT_EQ(result, true);
788
789 ReadTestDataWithTarget(parcel2, data);
790 }
791
792 /**
793 * @tc.name: test_parcel_WriteAndRead_004
794 * @tc.desc: test parcel primary type read write.
795 * @tc.type: FUNC
796 */
797 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_004, TestSize.Level0)
798 {
799 Parcel parcel1(nullptr);
800
801 int64_t int64test = -0x1234567887654321;
802 bool result = parcel1.WriteInt64(int64test);
803 EXPECT_EQ(result, true);
804
805 uint64_t uint64test = 0x1234567887654321;
806 result = parcel1.WriteUint64(uint64test);
807 EXPECT_EQ(result, true);
808
809 int64_t readint64 = parcel1.ReadInt64();
810 EXPECT_EQ(readint64, int64test);
811
812 uint64_t readuint64 = parcel1.ReadUint64();
813 EXPECT_EQ(readuint64, uint64test);
814
815 Parcel parcel2(nullptr);
816
817 void *buffer = nullptr;
818 size_t size = parcel1.GetDataSize();
819 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
820 ASSERT_FALSE(false);
821 }
822
823 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
824
825 readint64 = parcel2.ReadInt64();
826 EXPECT_EQ(readint64, int64test);
827
828 readuint64 = parcel2.ReadUint64();
829 EXPECT_EQ(readuint64, uint64test);
830 }
831
832 /**
833 * @tc.name: test_parcel_WriteAndRead_String_001
834 * @tc.desc: test parcel string read write.
835 * @tc.type: FUNC
836 */
837 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_001, TestSize.Level0)
838 {
839 Parcel parcel1(nullptr);
840
841 string strWrite = "test";
842 bool result = parcel1.WriteString(strWrite);
843 EXPECT_EQ(result, true);
844
845 string strWrite1 =
846 "test for write string padded**********************************************************##################";
847 result = parcel1.WriteString(strWrite1);
848 EXPECT_EQ(result, true);
849
850 string strWrite2 =
851 "test for write string padded**********************************************************##################";
852 result = parcel1.WriteString(strWrite2);
853 EXPECT_EQ(result, true);
854
855 string strRead = parcel1.ReadString();
856 string strRead1 = parcel1.ReadString();
857 string strRead2 = parcel1.ReadString();
858 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
859 EXPECT_EQ(0, strcmp(strRead1.c_str(), strWrite1.c_str()));
860 EXPECT_EQ(0, strcmp(strRead2.c_str(), strWrite2.c_str()));
861
862 Parcel parcel2(nullptr);
863
864 void *buffer = nullptr;
865 size_t size = parcel1.GetDataSize();
866 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
867 ASSERT_FALSE(false);
868 }
869
870 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
871
872 strRead = parcel2.ReadString();
873 strRead1 = parcel2.ReadString();
874 strRead2 = parcel2.ReadString();
875 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
876 EXPECT_EQ(0, strcmp(strRead1.c_str(), strWrite1.c_str()));
877 EXPECT_EQ(0, strcmp(strRead2.c_str(), strWrite2.c_str()));
878 }
879
880 /**
881 * @tc.name: test_parcel_WriteAndRead_String_002
882 * @tc.desc: test parcel string read write.
883 * @tc.type: FUNC
884 */
885 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_002, TestSize.Level0)
886 {
887 Parcel parcel1(nullptr);
888
889 u16string str16Write = u"12345";
890 bool result = parcel1.WriteString16(str16Write);
891 EXPECT_EQ(result, true);
892
893 u16string str16Write2 = u"12345 test for write16string padded*********";
894 result = parcel1.WriteString16(str16Write2);
895 EXPECT_EQ(result, true);
896
897 u16string str16Read = parcel1.ReadString16();
898 u16string str16Read2 = parcel1.ReadString16();
899 EXPECT_EQ(0, str16Read.compare(str16Write));
900 EXPECT_EQ(0, str16Read2.compare(str16Write2));
901
902 Parcel parcel2(nullptr);
903
904 void *buffer = nullptr;
905 size_t size = parcel1.GetDataSize();
906 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
907 ASSERT_FALSE(false);
908 }
909
910 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
911
912 str16Read = parcel2.ReadString16();
913 str16Read2 = parcel2.ReadString16();
914 EXPECT_EQ(0, str16Read.compare(str16Write));
915 EXPECT_EQ(0, str16Read2.compare(str16Write2));
916 }
917
918 /**
919 * @tc.name: test_parcel_WriteAndRead_String_003
920 * @tc.desc: test parcel CString read write.
921 * @tc.type: FUNC
922 */
923 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_003, TestSize.Level0)
924 {
925 Parcel parcel(nullptr);
926 string test1 = "12345";
927 string test2 = "23456";
928 string test3 = "34567";
929 string test4 = "45678";
930 bool result = parcel.WriteCString(nullptr);
931 EXPECT_FALSE(result);
932 result = parcel.WriteCString(test1.c_str());
933 EXPECT_TRUE(result);
934 result = parcel.WriteCString(test2.c_str());
935 EXPECT_TRUE(result);
936 result = parcel.WriteCString(test3.c_str());
937 EXPECT_TRUE(result);
938 result = parcel.WriteCString(test4.c_str());
939 EXPECT_TRUE(result);
940
941 EXPECT_EQ(0, strcmp(test1.c_str(), parcel.ReadCString()));
942 EXPECT_EQ(0, strcmp(test2.c_str(), parcel.ReadCString()));
943 EXPECT_EQ(0, strcmp(test3.c_str(), parcel.ReadCString()));
944 EXPECT_EQ(0, strcmp(test4.c_str(), parcel.ReadCString()));
945 }
946
947 /**
948 * @tc.name: test_parcel_WriteAndRead_String004
949 * @tc.desc: test parcel CString read write.
950 * @tc.type: FUNC
951 */
952 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String004, TestSize.Level0)
953 {
954 Parcel parcel1(nullptr);
955 bool result = false;
956
957 // write from Java, read from C++
958 result = parcel1.WriteString16WithLength(nullptr, 0);
959 EXPECT_EQ(result, true);
960
961 u16string str16write = u"12345";
962 char16_t *value1 = str16write.data();
963 result = parcel1.WriteString16WithLength(value1, str16write.length());
964 EXPECT_EQ(result, true);
965
966 u16string str16write2 = u"12345 test for write16string padded*********";
967 char16_t *value2 = str16write2.data();
968 result = parcel1.WriteString16WithLength(value2, str16write2.length());
969 EXPECT_EQ(result, true);
970
971 u16string str16readNull = parcel1.ReadString16();
972 u16string str16read1 = parcel1.ReadString16();
973 u16string str16read2 = parcel1.ReadString16();
974 EXPECT_EQ(0, str16readNull.compare(std::u16string()));
975 EXPECT_EQ(0, str16read1.compare(str16write));
976 EXPECT_EQ(0, str16read2.compare(str16write2));
977
978 // write from C++, read from Java
979 result = parcel1.WriteString16(str16write);
980 EXPECT_EQ(result, true);
981
982 result = parcel1.WriteString16(str16write2);
983 EXPECT_EQ(result, true);
984
985 int32_t readLength1 = 0;
986 u16string str16read3 = parcel1.ReadString16WithLength(readLength1);
987 EXPECT_EQ(readLength1, static_cast<int32_t>(str16write.length()));
988
989 int32_t readLength2 = 0;
990 u16string str16read4 = parcel1.ReadString16WithLength(readLength2);
991 EXPECT_EQ(readLength2, static_cast<int32_t>(str16write2.length()));
992
993 EXPECT_EQ(0, str16read3.compare(str16write));
994 EXPECT_EQ(0, str16read4.compare(str16write2));
995 }
996
997 /**
998 * @tc.name: test_parcel_WriteAndRead_String005
999 * @tc.desc: test parcel CString read write.
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String005, TestSize.Level0)
1003 {
1004 Parcel parcel1(nullptr);
1005 bool result = false;
1006
1007 // write from Java, read from C++
1008 result = parcel1.WriteString8WithLength(nullptr, 0);
1009 EXPECT_EQ(result, true);
1010
1011 string str8write = "12345";
1012 char *value1 = str8write.data();
1013 result = parcel1.WriteString8WithLength(value1, str8write.length());
1014 EXPECT_EQ(result, true);
1015
1016 string str8write2 = "12345 test for write16string padded*********";
1017 char *value2 = str8write2.data();
1018 result = parcel1.WriteString8WithLength(value2, str8write2.length());
1019 EXPECT_EQ(result, true);
1020
1021 string str8readNull = parcel1.ReadString();
1022 string str8read1 = parcel1.ReadString();
1023 string str8read2 = parcel1.ReadString();
1024 EXPECT_EQ(0, str8readNull.compare(std::string()));
1025 EXPECT_EQ(0, str8read1.compare(str8write));
1026 EXPECT_EQ(0, str8read2.compare(str8write2));
1027
1028 // write from C++, read from Java
1029 result = parcel1.WriteString(str8write);
1030 EXPECT_EQ(result, true);
1031
1032 result = parcel1.WriteString(str8write2);
1033 EXPECT_EQ(result, true);
1034
1035 int32_t readLength1 = 0;
1036 string str8read3 = parcel1.ReadString8WithLength(readLength1);
1037 EXPECT_EQ(readLength1, static_cast<int32_t>(str8write.length()));
1038
1039 int32_t readLength2 = 0;
1040 string str8read4 = parcel1.ReadString8WithLength(readLength2);
1041 EXPECT_EQ(readLength2, static_cast<int32_t>(str8write2.length()));
1042
1043 EXPECT_EQ(0, str8read3.compare(str8write));
1044 EXPECT_EQ(0, str8read4.compare(str8write2));
1045 }
1046
1047 /**
1048 * @tc.name: test_parcel_WriteAndRead_Float_001
1049 * @tc.desc: test parcel float types read write.
1050 * @tc.type: FUNC
1051 */
1052 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_Float_001, TestSize.Level0)
1053 {
1054 Parcel parcel1(nullptr);
1055
1056 float floatwrite = 12.345678f;
1057 bool result = parcel1.WriteFloat(floatwrite);
1058 EXPECT_EQ(result, true);
1059
1060 double doublewrite = 1345.7653;
1061 result = parcel1.WriteDouble(doublewrite);
1062 EXPECT_EQ(result, true);
1063
1064 float floatread;
1065 result = parcel1.ReadFloat(floatread);
1066 EXPECT_EQ(result, true);
1067 EXPECT_EQ(floatwrite, floatread);
1068
1069 double doubleread;
1070 doubleread = parcel1.ReadDouble();
1071 EXPECT_EQ(doublewrite, doubleread);
1072
1073 Parcel parcel2(nullptr);
1074
1075 void *buffer = nullptr;
1076 size_t size = parcel1.GetDataSize();
1077 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1078 ASSERT_FALSE(false);
1079 }
1080
1081 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1082 result = parcel2.ReadFloat(floatread);
1083 EXPECT_EQ(result, true);
1084 EXPECT_EQ(floatwrite, floatread);
1085
1086 doubleread = parcel2.ReadDouble();
1087 EXPECT_EQ(doublewrite, doubleread);
1088 }
1089
1090 /**
1091 * @tc.name: test_parcel_WriteAndRead_String_005
1092 * @tc.desc: test parcel String type read write.
1093 * @tc.type: FUNC
1094 */
1095 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_005, TestSize.Level0)
1096 {
1097 Parcel parcel1(nullptr);
1098
1099 string strwrite = "test";
1100 bool result = parcel1.WriteString(strwrite);
1101 EXPECT_EQ(result, true);
1102
1103 string strwrite1 =
1104 "test for write string padded**********************************************************##################";
1105 result = parcel1.WriteString(strwrite1);
1106 EXPECT_EQ(result, true);
1107
1108 string strwrite2 =
1109 "test for write string padded**********************************************************##################";
1110 result = parcel1.WriteString(strwrite2);
1111 EXPECT_EQ(result, true);
1112
1113 string strread;
1114 string strread1;
1115 string strread2;
1116 result = parcel1.ReadString(strread);
1117 EXPECT_EQ(result, true);
1118 result = parcel1.ReadString(strread1);
1119 EXPECT_EQ(result, true);
1120 result = parcel1.ReadString(strread2);
1121 EXPECT_EQ(result, true);
1122 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
1123 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
1124 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
1125
1126 Parcel parcel2(nullptr);
1127
1128 void *buffer = nullptr;
1129 size_t size = parcel1.GetDataSize();
1130 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1131 ASSERT_FALSE(false);
1132 }
1133
1134 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1135 EXPECT_EQ(result, true);
1136
1137 result = parcel2.ReadString(strread);
1138 EXPECT_EQ(result, true);
1139 result = parcel2.ReadString(strread1);
1140 EXPECT_EQ(result, true);
1141 result = parcel2.ReadString(strread2);
1142 EXPECT_EQ(result, true);
1143 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
1144 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
1145 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
1146 }
1147
1148 struct Padded {
1149 char title;
1150 int32_t handle;
1151 uint64_t cookie;
1152 };
1153
1154 struct Unpadded {
1155 char tip;
1156 };
1157
ValidatePadded(const struct Padded & left,const struct Padded & right)1158 void ValidatePadded(const struct Padded &left, const struct Padded &right)
1159 {
1160 EXPECT_EQ(left.title, right.title);
1161 EXPECT_EQ(left.handle, right.handle);
1162 EXPECT_EQ(left.cookie, right.cookie);
1163 }
1164
ValidateUnpadded(const struct Unpadded & left,const struct Unpadded & right)1165 void ValidateUnpadded(const struct Unpadded &left, const struct Unpadded &right)
1166 {
1167 EXPECT_EQ(left.tip, right.tip);
1168 }
1169
1170 /**
1171 * @tc.name: test_CalcNewCapacity_001
1172 * @tc.desc: test kinds of input to CalcNewCapacity.
1173 * @tc.type: FUNC
1174 */
1175 HWTEST_F(UtilsParcelTest, test_CalcNewCapacity_001, TestSize.Level0)
1176 {
1177 Parcel parcel;
1178
1179 size_t newMaxCapacity;
1180 size_t minNewCapacity = CAPACITY_THRESHOLD;
1181 const string strLenThreshd = string(minNewCapacity, 't');
1182 bool ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strLenThreshd.data()), minNewCapacity);
1183 EXPECT_EQ(true, ret); // calculated capacity = CAPACITY_THRESHOLD
1184
1185 newMaxCapacity = CAPACITY_THRESHOLD - 1;
1186 minNewCapacity = newMaxCapacity;
1187 const string strLessThreshd = string(minNewCapacity, 'l');
1188 parcel.SetMaxCapacity(newMaxCapacity);
1189 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strLessThreshd.data()), minNewCapacity);
1190 EXPECT_EQ(true, ret); // calculated capacity = newMaxCapacity
1191
1192 newMaxCapacity = -1; // minNewCapacity = CAPACITY_THRESHOLD - 1
1193 const string strNoMaxCap = string(minNewCapacity, 'n');
1194 parcel.SetMaxCapacity(newMaxCapacity);
1195 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strNoMaxCap.data()), minNewCapacity);
1196 EXPECT_EQ(ret, true); // calculated capacity = CAPACITY_THRESHOLD
1197
1198 minNewCapacity = CAPACITY_THRESHOLD + 1; // newMaxCapacity = -1
1199 const string strExtThreshd = string(minNewCapacity, 'e');
1200 parcel.SetMaxCapacity(newMaxCapacity);
1201 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strExtThreshd.data()), minNewCapacity);
1202 EXPECT_EQ(ret, true); // calculated capacity = 2 * CAPACITY_THRESHOLD
1203
1204 newMaxCapacity = CAPACITY_THRESHOLD; // minNewCapacity = CAPACITY_THRESHOLD + 1
1205 const string strCapThreshd = string(minNewCapacity, 'e');
1206 parcel.SetMaxCapacity(newMaxCapacity);
1207 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strCapThreshd.data()), minNewCapacity);
1208 EXPECT_EQ(ret, true); // calculated capacity = CAPACITY_THRESHOLD
1209 }
1210
1211 /**
1212 * @tc.name: test_SetDataCapacity_001
1213 * @tc.desc: test kinds of input to SetDataCapacity.
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(UtilsParcelTest, test_SetDataCapacity_001, TestSize.Level0)
1217 {
1218 Parcel parcel;
1219 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
1220
1221 WriteTestData(parcel, data);
1222 bool result = parcel.SetDataCapacity(0);
1223 EXPECT_FALSE(result);
1224 }
1225
1226 /**
1227 * @tc.name: test_SetDataSize_001
1228 * @tc.desc: test kinds of input to SetDataSize.
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(UtilsParcelTest, test_SetDataSize_001, TestSize.Level0)
1232 {
1233 Parcel parcel;
1234
1235 bool result = parcel.SetDataCapacity(sizeof(bool));
1236 EXPECT_TRUE(result);
1237 result = parcel.WriteBool(true);
1238 EXPECT_TRUE(result);
1239 result = parcel.SetDataSize(DEFAULT_CPACITY + 1);
1240 EXPECT_FALSE(result);
1241 }
1242
1243 /**
1244 * @tc.name: test_parcel_Data_Structure_001
1245 * @tc.desc: test parcel struct data related function.
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_001, TestSize.Level0)
1249 {
1250 Parcel parcel(nullptr);
1251
1252 const struct Padded pad = { 'p', 0x34567890, -0x2345678998765432 };
1253 const struct Unpadded unpad = { 'u' };
1254
1255 bool result = parcel.WriteBuffer(static_cast<const void *>(&pad), sizeof(struct Padded));
1256 EXPECT_EQ(true, result);
1257 const struct Padded *padRead = reinterpret_cast<const struct Padded *>(parcel.ReadBuffer(sizeof(struct Padded)));
1258 ValidatePadded(*padRead, pad);
1259 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1260
1261 result = parcel.WriteBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded));
1262 const struct Unpadded *unpadRead =
1263 reinterpret_cast<const struct Unpadded *>(parcel.ReadBuffer(sizeof(struct Unpadded)));
1264 ValidateUnpadded(*unpadRead, unpad);
1265 EXPECT_NE(parcel.GetWritePosition(), parcel.GetReadPosition());
1266
1267 parcel.RewindRead(0);
1268 parcel.RewindWrite(0);
1269 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1270
1271 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&pad), sizeof(struct Padded));
1272 EXPECT_EQ(true, result);
1273 const struct Padded *padReadNew =
1274 reinterpret_cast<const struct Padded *>(parcel.ReadUnpadBuffer(sizeof(struct Padded)));
1275 ValidatePadded(*padReadNew, pad);
1276 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1277
1278 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded));
1279 EXPECT_EQ(true, result);
1280 const struct Unpadded *unpadReadNew =
1281 reinterpret_cast<const struct Unpadded *>(parcel.ReadUnpadBuffer(sizeof(struct Unpadded)));
1282 ValidateUnpadded(*unpadReadNew, unpad);
1283 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1284 }
1285
1286 /**
1287 * @tc.name: test_parcel_Data_Structure_002
1288 * @tc.desc: test invalid input to WriteBuffer and WriteBufferAddTerminator.
1289 * @tc.type: FUNC
1290 */
1291 HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_002, TestSize.Level0)
1292 {
1293 Parcel parcel(nullptr);
1294
1295 const string str = "test invalid input";
1296 const string strOverflow = "test write with SIZE_MAX bytes";
1297 const string strWriteFail = string((DEFAULT_CPACITY + 1) / sizeof(char), 'f');
1298 const string strWriteTermFail = string((DEFAULT_CPACITY - 2) / sizeof(char), 't');
1299
1300 bool result = parcel.WriteBuffer(nullptr, sizeof(string));
1301 EXPECT_EQ(false, result);
1302 result = parcel.WriteBufferAddTerminator(nullptr, sizeof(string), sizeof(char));
1303 EXPECT_EQ(false, result);
1304
1305 result = parcel.WriteBuffer(static_cast<const void *>(str.data()), 0);
1306 EXPECT_EQ(false, result);
1307 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(str.data()), 0, sizeof(char));
1308 EXPECT_EQ(false, result);
1309
1310 result = parcel.WriteBuffer(static_cast<const void *>(strWriteFail.data()), strWriteFail.length());
1311 EXPECT_EQ(false, result);
1312 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(strWriteFail.data()),
1313 strWriteFail.length(), sizeof(char));
1314 EXPECT_EQ(false, result);
1315
1316 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(str.data()), str.length(), sizeof(char));
1317 EXPECT_EQ(true, result);
1318
1319 Parcel recvParcel(nullptr);
1320 void *buffer = nullptr;
1321 size_t size = parcel.GetDataSize();
1322 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel.GetData()))) {
1323 ASSERT_FALSE(false);
1324 }
1325 result = recvParcel.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel.GetDataSize());
1326 EXPECT_EQ(result, true);
1327 result = recvParcel.WriteBufferAddTerminator(static_cast<const void *>(&str), str.length() + 1, sizeof(char));
1328 EXPECT_EQ(result, false);
1329 }
1330
1331 struct VectorTestData {
1332 vector<bool> booltest = { false, false, true, false, true };
1333 vector<int8_t> int8test = { 0x01, 0x10, -0x20, 0x30, 0x40 };
1334 vector<int16_t> int16test = { 0x1234, -0x2345, 0x3456, -0x4567, 0x5678 };
1335 vector<int32_t> int32test = { 0x12345678, -0x23456789, 0x34567890, -0x45678901 };
1336 vector<int64_t> int64test = { 0x1234567887654321, -0x2345678998765432 };
1337 vector<uint8_t> uint8test = { 0x01, 0x10, 0x20, 0x30, 0x40 };
1338 vector<uint16_t> uint16test = { 0x1234, 0x2345, 0x3456, 0x4567, 0x5678 };
1339 vector<uint32_t> uint32test = { 0x12345678, 0x23456789, 0x34567890, 0x45678901 };
1340 vector<uint64_t> uint64test = { 0x1234567887654321, 0x2345678998765432 };
1341 };
1342
WriteVectorTestData(Parcel & parcel,const VectorTestData & data)1343 void WriteVectorTestData(Parcel &parcel, const VectorTestData &data)
1344 {
1345 bool result = parcel.WriteBoolVector(data.booltest);
1346 EXPECT_EQ(result, true);
1347 result = parcel.WriteInt8Vector(data.int8test);
1348 EXPECT_EQ(result, true);
1349 result = parcel.WriteInt16Vector(data.int16test);
1350 EXPECT_EQ(result, true);
1351 result = parcel.WriteInt32Vector(data.int32test);
1352 EXPECT_EQ(result, true);
1353 result = parcel.WriteInt64Vector(data.int64test);
1354 EXPECT_EQ(result, true);
1355 result = parcel.WriteUInt8Vector(data.uint8test);
1356 EXPECT_EQ(result, true);
1357 result = parcel.WriteUInt16Vector(data.uint16test);
1358 EXPECT_EQ(result, true);
1359 result = parcel.WriteUInt32Vector(data.uint32test);
1360 EXPECT_EQ(result, true);
1361 result = parcel.WriteUInt64Vector(data.uint64test);
1362 EXPECT_EQ(result, true);
1363 }
1364
ReadVectorTestData(Parcel & parcel,const VectorTestData & data)1365 void ReadVectorTestData(Parcel &parcel, const VectorTestData &data)
1366 {
1367 vector<bool> boolread;
1368 vector<int8_t> int8read;
1369 vector<int16_t> int16read;
1370 vector<int32_t> int32read;
1371 vector<int64_t> int64read;
1372
1373 vector<uint8_t> uint8read;
1374 vector<uint16_t> uint16read;
1375 vector<uint32_t> uint32read;
1376 vector<uint64_t> uint64read;
1377
1378 bool result = parcel.ReadBoolVector(&boolread);
1379 EXPECT_EQ(result, true);
1380 for (size_t i = 0; i < data.booltest.size(); i++) {
1381 EXPECT_EQ(data.booltest[i], boolread[i]);
1382 }
1383
1384 result = parcel.ReadInt8Vector(&int8read);
1385 EXPECT_EQ(result, true);
1386 for (size_t i = 0; i < data.int8test.size(); i++) {
1387 EXPECT_EQ(data.int8test[i], int8read[i]);
1388 }
1389
1390 result = parcel.ReadInt16Vector(&int16read);
1391 EXPECT_EQ(result, true);
1392 for (size_t i = 0; i < data.int16test.size(); i++) {
1393 EXPECT_EQ(data.int16test[i], int16read[i]);
1394 }
1395
1396 result = parcel.ReadInt32Vector(&int32read);
1397 EXPECT_EQ(result, true);
1398 for (size_t i = 0; i < data.int32test.size(); i++) {
1399 EXPECT_EQ(data.int32test[i], int32read[i]);
1400 }
1401
1402 result = parcel.ReadInt64Vector(&int64read);
1403 EXPECT_EQ(result, true);
1404 for (size_t i = 0; i < data.int64test.size(); i++) {
1405 EXPECT_EQ(data.int64test[i], int64read[i]);
1406 }
1407
1408 result = parcel.ReadUInt8Vector(&uint8read);
1409 EXPECT_EQ(result, true);
1410 for (size_t i = 0; i < data.uint8test.size(); i++) {
1411 EXPECT_EQ(data.uint8test[i], uint8read[i]);
1412 }
1413
1414 result = parcel.ReadUInt16Vector(&uint16read);
1415 EXPECT_EQ(result, true);
1416 for (size_t i = 0; i < data.uint16test.size(); i++) {
1417 EXPECT_EQ(data.uint16test[i], uint16read[i]);
1418 }
1419
1420 result = parcel.ReadUInt32Vector(&uint32read);
1421 EXPECT_EQ(result, true);
1422 for (size_t i = 0; i < data.uint32test.size(); i++) {
1423 EXPECT_EQ(data.uint32test[i], uint32read[i]);
1424 }
1425
1426 result = parcel.ReadUInt64Vector(&uint64read);
1427 EXPECT_EQ(result, true);
1428 for (size_t i = 0; i < data.uint64test.size(); i++) {
1429 EXPECT_EQ(data.uint64test[i], uint64read[i]);
1430 }
1431 }
1432
1433 /**
1434 * @tc.name: test_parcel_WriteAndReadVector_001
1435 * @tc.desc: test vector parcel read and write.
1436 * @tc.type: FUNC
1437 */
1438 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_001, TestSize.Level0)
1439 {
1440 Parcel parcel(nullptr);
1441 struct VectorTestData data;
1442
1443 WriteVectorTestData(parcel, data);
1444 ReadVectorTestData(parcel, data);
1445 }
1446
1447 /**
1448 * @tc.name: test_parcel_WriteAndReadVector_002
1449 * @tc.desc: test vector parcel read and write.
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_002, TestSize.Level0)
1453 {
1454 Parcel parcel1(nullptr);
1455 struct VectorTestData data;
1456 WriteVectorTestData(parcel1, data);
1457
1458 Parcel parcel2(nullptr);
1459
1460 void *buffer = nullptr;
1461 size_t size = parcel1.GetDataSize();
1462 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1463 ASSERT_FALSE(false);
1464 }
1465
1466 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1467 EXPECT_EQ(result, true);
1468 ReadVectorTestData(parcel2, data);
1469 }
1470
1471 /**
1472 * @tc.name: test_parcel_WriteAndReadVector_003
1473 * @tc.desc: test vector parcel read and write.
1474 * @tc.type: FUNC
1475 */
1476 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_003, TestSize.Level0)
1477 {
1478 Parcel parcel1(nullptr);
1479 Parcel parcel2(nullptr);
1480
1481 vector<string> stringtest{ "test", "test for", "test for write", "test for write vector" };
1482 vector<u16string> string16test{ u"test", u"test for", u"test for write", u"test for write vector" };
1483
1484 bool result = parcel1.WriteStringVector(stringtest);
1485 EXPECT_EQ(result, true);
1486 result = parcel1.WriteString16Vector(string16test);
1487 EXPECT_EQ(result, true);
1488
1489 vector<string> stringread;
1490 result = parcel1.ReadStringVector(&stringread);
1491 EXPECT_EQ(result, true);
1492 for (size_t i = 0; i < stringtest.size(); i++) {
1493 EXPECT_EQ(stringtest[i], stringread[i]);
1494 }
1495
1496 vector<u16string> u16stringread;
1497 result = parcel1.ReadString16Vector(&u16stringread);
1498 EXPECT_EQ(result, true);
1499 for (size_t i = 0; i < string16test.size(); i++) {
1500 EXPECT_EQ(0, string16test[i].compare(u16stringread[i]));
1501 }
1502
1503 void *buffer = nullptr;
1504 size_t size = parcel1.GetDataSize();
1505 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1506 ASSERT_FALSE(false);
1507 }
1508
1509 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1510 result = parcel2.ReadStringVector(&stringread);
1511 EXPECT_EQ(result, true);
1512 for (size_t i = 0; i < stringtest.size(); i++) {
1513 EXPECT_EQ(stringtest[i], stringread[i]);
1514 }
1515
1516 result = parcel2.ReadString16Vector(&u16stringread);
1517 EXPECT_EQ(result, true);
1518 for (size_t i = 0; i < string16test.size(); i++) {
1519 EXPECT_EQ(0, string16test[i].compare(u16stringread[i]));
1520 }
1521 }
1522
1523 /**
1524 * @tc.name: test_parcel_WriteAndReadVector_004
1525 * @tc.desc: test vector parcel read and write.
1526 * @tc.type: FUNC
1527 */
1528 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_004, TestSize.Level0)
1529 {
1530 Parcel parcel1(nullptr);
1531 Parcel parcel2(nullptr);
1532
1533 vector<float> floattest{ 11221.132313, 11221.45678 };
1534 vector<double> doubletest{ 1122.132313, 1122.45678 };
1535
1536 bool result = parcel1.WriteFloatVector(floattest);
1537 EXPECT_EQ(result, true);
1538
1539 result = parcel1.WriteDoubleVector(doubletest);
1540 EXPECT_EQ(result, true);
1541
1542 vector<float> floatread;
1543 vector<double> doubleread;
1544
1545 result = parcel1.ReadFloatVector(&floatread);
1546 EXPECT_EQ(result, true);
1547 for (size_t i = 0; i < floattest.size(); i++) {
1548 EXPECT_EQ(floattest[i], floatread[i]);
1549 }
1550
1551 result = parcel1.ReadDoubleVector(&doubleread);
1552 EXPECT_EQ(result, true);
1553 for (size_t i = 0; i < doubletest.size(); i++) {
1554 EXPECT_EQ(doubletest[i], doubleread[i]);
1555 }
1556 }
1557
CallWriteVector(Parcel & parcel,const std::vector<bool> & vectorTest)1558 bool CallWriteVector(Parcel &parcel, const std::vector<bool> &vectorTest)
1559 {
1560 return parcel.WriteBoolVector(vectorTest);
1561 }
1562
CallWriteVector(Parcel & parcel,const std::vector<int8_t> & vectorTest)1563 bool CallWriteVector(Parcel &parcel, const std::vector<int8_t> &vectorTest)
1564 {
1565 return parcel.WriteInt8Vector(vectorTest);
1566 }
1567
CallWriteVector(Parcel & parcel,const std::vector<int16_t> & vectorTest)1568 bool CallWriteVector(Parcel &parcel, const std::vector<int16_t> &vectorTest)
1569 {
1570 return parcel.WriteInt16Vector(vectorTest);
1571 }
1572
CallWriteVector(Parcel & parcel,const std::vector<int32_t> & vectorTest)1573 bool CallWriteVector(Parcel &parcel, const std::vector<int32_t> &vectorTest)
1574 {
1575 return parcel.WriteInt32Vector(vectorTest);
1576 }
1577
CallWriteVector(Parcel & parcel,const std::vector<int64_t> & vectorTest)1578 bool CallWriteVector(Parcel &parcel, const std::vector<int64_t> &vectorTest)
1579 {
1580 return parcel.WriteInt64Vector(vectorTest);
1581 }
1582
CallWriteVector(Parcel & parcel,const std::vector<uint8_t> & vectorTest)1583 bool CallWriteVector(Parcel &parcel, const std::vector<uint8_t> &vectorTest)
1584 {
1585 return parcel.WriteUInt8Vector(vectorTest);
1586 }
1587
CallWriteVector(Parcel & parcel,const std::vector<uint16_t> & vectorTest)1588 bool CallWriteVector(Parcel &parcel, const std::vector<uint16_t> &vectorTest)
1589 {
1590 return parcel.WriteUInt16Vector(vectorTest);
1591 }
1592
CallWriteVector(Parcel & parcel,const std::vector<uint32_t> & vectorTest)1593 bool CallWriteVector(Parcel &parcel, const std::vector<uint32_t> &vectorTest)
1594 {
1595 return parcel.WriteUInt32Vector(vectorTest);
1596 }
1597
CallWriteVector(Parcel & parcel,const std::vector<uint64_t> & vectorTest)1598 bool CallWriteVector(Parcel &parcel, const std::vector<uint64_t> &vectorTest)
1599 {
1600 return parcel.WriteUInt64Vector(vectorTest);
1601 }
1602
CallWriteVector(Parcel & parcel,const std::vector<float> & vectorTest)1603 bool CallWriteVector(Parcel &parcel, const std::vector<float> &vectorTest)
1604 {
1605 return parcel.WriteFloatVector(vectorTest);
1606 }
1607
CallWriteVector(Parcel & parcel,const std::vector<double> & vectorTest)1608 bool CallWriteVector(Parcel &parcel, const std::vector<double> &vectorTest)
1609 {
1610 return parcel.WriteDoubleVector(vectorTest);
1611 }
1612
CallWriteVector(Parcel & parcel,const std::vector<std::string> & vectorTest)1613 bool CallWriteVector(Parcel &parcel, const std::vector<std::string> &vectorTest)
1614 {
1615 return parcel.WriteStringVector(vectorTest);
1616 }
1617
CallWriteVector(Parcel & parcel,const std::vector<std::u16string> & vectorTest)1618 bool CallWriteVector(Parcel &parcel, const std::vector<std::u16string> &vectorTest)
1619 {
1620 return parcel.WriteString16Vector(vectorTest);
1621 }
1622
1623 template <typename T>
ParcelWriteVector(const std::vector<T> & vectorTest)1624 void ParcelWriteVector(const std::vector<T> &vectorTest)
1625 {
1626 Parcel parcel1(nullptr);
1627 Parcel parcel2(nullptr);
1628 bool result = CallWriteVector(parcel1, vectorTest);
1629 EXPECT_EQ(result, true);
1630
1631 void *buffer = nullptr;
1632 size_t size = parcel1.GetDataSize();
1633 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1634 ASSERT_FALSE(false);
1635 }
1636 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1637 EXPECT_EQ(result, true);
1638
1639 result = CallWriteVector(parcel2, vectorTest);
1640 EXPECT_EQ(result, false);
1641 }
1642
1643 /**
1644 * @tc.name: test_parcel_WriteAndReadVector_005
1645 * @tc.desc: test vector parcel write failed.
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_005, TestSize.Level0)
1649 {
1650 vector<bool> boolVectorTest { true, false };
1651 vector<int8_t> int8VectorTest { 1, 0 };
1652 vector<int16_t> int16VectorTest { 1, 0 };
1653 vector<int32_t> int32VectorTest { 1, 0 };
1654 vector<int64_t> int64VectorTest { 1, 0 };
1655 vector<uint8_t> uint8VectorTest { 1, 0 };
1656 vector<uint16_t> uint16VectorTest { 1, 0 };
1657 vector<uint32_t> uint32VectorTest { 1, 0 };
1658 vector<uint64_t> uint64VectorTest { 1, 0 };
1659 vector<float> floatVectorTest { 1.1, 0 };
1660 vector<double> doubleVectorTest { 1.1, 0 };
1661 vector<std::string> stringVectorTest { "true", "false" };
1662 vector<std::u16string> string16VectorTest { u"true", u"false" };
1663
1664 ParcelWriteVector(boolVectorTest);
1665 ParcelWriteVector(int8VectorTest);
1666 ParcelWriteVector(int16VectorTest);
1667 ParcelWriteVector(int32VectorTest);
1668 ParcelWriteVector(int64VectorTest);
1669 ParcelWriteVector(uint8VectorTest);
1670 ParcelWriteVector(uint16VectorTest);
1671 ParcelWriteVector(uint32VectorTest);
1672 ParcelWriteVector(uint64VectorTest);
1673 ParcelWriteVector(floatVectorTest);
1674 ParcelWriteVector(doubleVectorTest);
1675 ParcelWriteVector(stringVectorTest);
1676 ParcelWriteVector(string16VectorTest);
1677 }
1678
1679 class TestParcelable : public virtual Parcelable {
1680 public:
1681 TestParcelable() = default;
1682 ~TestParcelable() = default;
1683
1684 bool Marshalling(Parcel &parcel) const override;
1685 static TestParcelable *Unmarshalling(Parcel &parcel);
1686
1687 public:
1688 int32_t int32Write_ = -0x12345678;
1689 int32_t int32Read_;
1690 };
1691
Marshalling(Parcel & parcel) const1692 bool TestParcelable::Marshalling(Parcel &parcel) const
1693 {
1694 bool result = parcel.WriteInt32(this->int32Write_);
1695 return result;
1696 }
1697
Unmarshalling(Parcel & parcel)1698 TestParcelable *TestParcelable::Unmarshalling(Parcel &parcel)
1699 {
1700 auto *read = new TestParcelable();
1701 read->int32Read_ = parcel.ReadInt32();
1702 return read;
1703 }
1704
1705 /**
1706 * @tc.name: test_parcel_parcelable_001
1707 * @tc.desc: test parcel read and write parcelable obj.
1708 * @tc.type: FUNC
1709 */
1710 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_001, TestSize.Level0)
1711 {
1712 Parcel parcel(nullptr);
1713 sptr<TestParcelable> parcelableWrite = new TestParcelable();
1714 bool result = false;
1715
1716 result = parcel.WriteParcelable(parcelableWrite);
1717 EXPECT_EQ(true, result);
1718 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
1719
1720 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
1721 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_);
1722 EXPECT_EQ(parcel.GetReadPosition(), parcel.GetDataSize());
1723 }
1724
1725 /**
1726 * @tc.name: test_parcel_parcelable_002
1727 * @tc.desc: test parcel read and write parcelable obj.
1728 * @tc.type: FUNC
1729 */
1730 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_002, TestSize.Level0)
1731 {
1732 Parcel parcel(nullptr);
1733
1734 bool result = parcel.WriteParcelable(nullptr);
1735 EXPECT_EQ(true, result);
1736
1737 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
1738 EXPECT_EQ(nullptr, parcelableRead);
1739 }
1740
1741 /**
1742 * @tc.name: test_parcel_parcelable_003
1743 * @tc.desc: test parcel read and write parcelable obj.
1744 * @tc.type: FUNC
1745 */
1746 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_003, TestSize.Level0)
1747 {
1748 Parcel parcel(nullptr);
1749 sptr<TestParcelable> parcelableWriteNull;
1750 bool result = parcel.WriteStrongParcelable(parcelableWriteNull);
1751 EXPECT_EQ(true, result);
1752
1753 sptr<TestParcelable> parcelableWrite = new TestParcelable();
1754
1755 bool test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1756 EXPECT_EQ(false, test);
1757 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC);
1758 EXPECT_EQ(false, test);
1759 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC);
1760 EXPECT_EQ(false, test);
1761
1762 result = parcel.WriteStrongParcelable(parcelableWrite);
1763 EXPECT_EQ(true, result);
1764
1765 sptr<TestParcelable> parcelableReadNull = parcel.ReadParcelable<TestParcelable>();
1766 EXPECT_EQ(nullptr, parcelableReadNull);
1767
1768 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
1769 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_);
1770
1771 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1772 EXPECT_EQ(true, test);
1773 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC);
1774 EXPECT_EQ(false, test);
1775 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC);
1776 EXPECT_EQ(false, test);
1777
1778 parcelableWrite->ClearBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1779 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1780 EXPECT_EQ(false, test);
1781 }
1782
1783 /**
1784 * @tc.name: test_SetMaxCapacity_001
1785 * @tc.desc: test parcel capacity function.
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_001, TestSize.Level0)
1789 {
1790 Parcel parcel(nullptr);
1791 char test[48] = {0};
1792 bool ret = parcel.WriteBuffer(test, 48);
1793 EXPECT_EQ(true, ret);
1794 // because default maxCap is 200 * 1024, so reset it more
1795 parcel.SetMaxCapacity(201 * 1024);
1796 // test write data over max capacity: 205780 + 48 > 201 * 1024
1797 char test2[205780] = {0};
1798 ret = parcel.WriteBuffer(test2, 205780);
1799 EXPECT_EQ(false, ret);
1800 }
1801
1802 /**
1803 * @tc.name: test_SetMaxCapacity_002
1804 * @tc.desc: test parcel capacity function.
1805 * @tc.type: FUNC
1806 */
1807 HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_002, TestSize.Level0)
1808 {
1809 Parcel parcel(nullptr);
1810 char test[48] = {0};
1811 bool ret = parcel.WriteInt32(5767168);
1812 EXPECT_EQ(true, ret);
1813 ret = parcel.WriteBuffer(test, 48);
1814 EXPECT_EQ(true, ret);
1815 vector<std::u16string> val;
1816 ret = parcel.ReadString16Vector(&val);
1817 EXPECT_EQ(false, ret);
1818 }
1819 } // namespace
1820 } // namespace OHOS