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 class RemoteObject : public virtual Parcelable {
46 public:
RemoteObject()47 RemoteObject() { asRemote_ = true; };
48 bool Marshalling(Parcel &parcel) const override;
49 static sptr<RemoteObject> Unmarshalling(Parcel &parcel);
50 };
51
Marshalling(Parcel & parcel) const52 bool RemoteObject::Marshalling(Parcel &parcel) const
53 {
54 parcel_flat_binder_object flat;
55 flat.hdr.type = 0xff;
56 flat.flags = 0x7f;
57 flat.binder = 0;
58 flat.handle = (uint32_t)(-1);
59 flat.cookie = reinterpret_cast<uintptr_t>(this);
60 bool status = parcel.WriteBuffer(&flat, sizeof(parcel_flat_binder_object));
61 if (!status) {
62 return false;
63 }
64 return true;
65 }
66
Unmarshalling(Parcel & parcel)67 sptr<RemoteObject> RemoteObject::Unmarshalling(Parcel &parcel)
68 {
69 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object), false);
70 if (buffer == nullptr) {
71 return nullptr;
72 }
73 sptr<RemoteObject> obj = new RemoteObject();
74 return obj;
75 }
76
77 /*-------------------------------base data------------------------------------*/
78
79 struct TestData {
80 bool booltest;
81 int8_t int8test;
82 int16_t int16test;
83 int32_t int32test;
84 uint8_t uint8test;
85 uint16_t uint16test;
86 uint32_t uint32test;
87 };
88
WriteTestData(Parcel & parcel,const struct TestData & data)89 void WriteTestData(Parcel &parcel, const struct TestData &data)
90 {
91 bool result = false;
92
93 result = parcel.WriteBool(data.booltest);
94 EXPECT_EQ(result, true);
95
96 result = parcel.WriteInt8(data.int8test);
97 EXPECT_EQ(result, true);
98
99 result = parcel.WriteInt16(data.int16test);
100 EXPECT_EQ(result, true);
101
102 result = parcel.WriteInt32(data.int32test);
103 EXPECT_EQ(result, true);
104
105 result = parcel.WriteUint8(data.uint8test);
106 EXPECT_EQ(result, true);
107
108 result = parcel.WriteUint16(data.uint16test);
109 EXPECT_EQ(result, true);
110
111 result = parcel.WriteUint32(data.uint32test);
112 EXPECT_EQ(result, true);
113 }
114
WriteUnalignedTestData(Parcel & parcel,const struct TestData & data)115 void WriteUnalignedTestData(Parcel &parcel, const struct TestData &data)
116 {
117 bool result = false;
118
119 result = parcel.WriteBoolUnaligned(data.booltest);
120 EXPECT_EQ(result, true);
121
122 result = parcel.WriteInt8Unaligned(data.int8test);
123 EXPECT_EQ(result, true);
124
125 result = parcel.WriteInt16Unaligned(data.int16test);
126 EXPECT_EQ(result, true);
127
128 result = parcel.WriteUint8Unaligned(data.uint8test);
129 EXPECT_EQ(result, true);
130
131 result = parcel.WriteUint16Unaligned(data.uint16test);
132 EXPECT_EQ(result, true);
133 }
134
ReadTestData(Parcel & parcel,const struct TestData & data)135 void ReadTestData(Parcel &parcel, const struct TestData &data)
136 {
137 bool readbool = parcel.ReadBool();
138 EXPECT_EQ(readbool, data.booltest);
139
140 int8_t readint8 = parcel.ReadInt8();
141 EXPECT_EQ(readint8, data.int8test);
142
143 int16_t readint16 = parcel.ReadInt16();
144 EXPECT_EQ(readint16, data.int16test);
145
146 int32_t readint32 = parcel.ReadInt32();
147 EXPECT_EQ(readint32, data.int32test);
148
149 uint8_t readuint8 = parcel.ReadUint8();
150 EXPECT_EQ(readuint8, data.uint8test);
151
152 uint16_t readuint16 = parcel.ReadUint16();
153 EXPECT_EQ(readuint16, data.uint16test);
154
155 uint32_t readuint32 = parcel.ReadUint32();
156 EXPECT_EQ(readuint32, data.uint32test);
157 }
158
ReadUnalignedTestData(Parcel & parcel,const struct TestData & data)159 void ReadUnalignedTestData(Parcel &parcel, const struct TestData &data)
160 {
161 bool readbool = parcel.ReadBoolUnaligned();
162 EXPECT_EQ(readbool, data.booltest);
163
164 int8_t readint8;
165 EXPECT_TRUE(parcel.ReadInt8Unaligned(readint8));
166 EXPECT_EQ(readint8, data.int8test);
167
168 int16_t readint16;
169 EXPECT_TRUE(parcel.ReadInt16Unaligned(readint16));
170 EXPECT_EQ(readint16, data.int16test);
171
172 uint8_t readuint8;
173 EXPECT_TRUE(parcel.ReadUint8Unaligned(readuint8));
174 EXPECT_EQ(readuint8, data.uint8test);
175
176 uint16_t readuint16;
177 EXPECT_TRUE(parcel.ReadUint16Unaligned(readuint16));
178 EXPECT_EQ(readuint16, data.uint16test);
179 }
180
ReadTestDataWithTarget(Parcel & parcel,const struct TestData & data)181 void ReadTestDataWithTarget(Parcel &parcel, const struct TestData &data)
182 {
183 bool result = false;
184 bool boolVal = true;
185 result = parcel.ReadBool(boolVal);
186 EXPECT_EQ(result, true);
187 EXPECT_EQ(boolVal, data.booltest);
188
189 int8_t int8Val;
190 result = parcel.ReadInt8(int8Val);
191 EXPECT_EQ(result, true);
192 EXPECT_EQ(int8Val, data.int8test);
193
194 int16_t int16Val;
195 result = parcel.ReadInt16(int16Val);
196 EXPECT_EQ(result, true);
197 EXPECT_EQ(int16Val, data.int16test);
198
199 int32_t int32Val;
200 result = parcel.ReadInt32(int32Val);
201 EXPECT_EQ(result, true);
202 EXPECT_EQ(int32Val, data.int32test);
203
204 uint8_t uint8Val;
205 result = parcel.ReadUint8(uint8Val);
206 EXPECT_EQ(result, true);
207 EXPECT_EQ(uint8Val, data.uint8test);
208
209 uint16_t uint16Val;
210 result = parcel.ReadUint16(uint16Val);
211 EXPECT_EQ(result, true);
212 EXPECT_EQ(uint16Val, data.uint16test);
213
214 uint32_t uint32Val;
215 result = parcel.ReadUint32(uint32Val);
216 EXPECT_EQ(result, true);
217 EXPECT_EQ(uint32Val, data.uint32test);
218 }
219
220 /**
221 * Here to simulate the scenario of ipc sending data, the buffer will be released when the Parcel object is destructed.
222 */
SendData(void * & buffer,size_t size,const uint8_t * data)223 bool SendData(void *&buffer, size_t size, const uint8_t *data)
224 {
225 if (size <= 0) {
226 return false;
227 }
228 buffer = malloc(size);
229 if (buffer == nullptr) {
230 return false;
231 }
232 if (memcpy_s(buffer, size, data, size) != EOK) {
233 return false;
234 }
235 return true;
236 }
237
238 /**
239 * @tc.name: test_parcel_001
240 * @tc.desc: test parcel CheckOffsets, WriteRemoteObject, RewindRead and
241 * RewindWrite failed.
242 * @tc.type: FUNC
243 */
244 HWTEST_F(UtilsParcelTest, test_parcel_001, TestSize.Level0)
245 {
246 Parcel parcel;
247 bool result = parcel.CheckOffsets();
248 EXPECT_EQ(result, false);
249 result = parcel.WriteRemoteObject(nullptr);
250 EXPECT_EQ(result, false);
251 result = parcel.RewindRead(parcel.GetDataSize() + 1);
252 EXPECT_EQ(result, false);
253 result = parcel.RewindWrite(parcel.GetDataSize() + 1);
254 EXPECT_EQ(result, false);
255 }
256
257 /**
258 * @tc.name: test_parcel_readvec_001
259 * @tc.desc: test parcel read vector failed with invlalid input.
260 * @tc.type: FUNC
261 */
262 HWTEST_F(UtilsParcelTest, test_parcel_readvec_001, TestSize.Level0)
263 {
264 Parcel parcel;
265
266 bool result = parcel.ReadBoolVector(nullptr);
267 EXPECT_EQ(result, false);
268
269 result = parcel.ReadInt8Vector(nullptr);
270 EXPECT_EQ(result, false);
271
272 result = parcel.ReadInt16Vector(nullptr);
273 EXPECT_EQ(result, false);
274
275 result = parcel.ReadInt32Vector(nullptr);
276 EXPECT_EQ(result, false);
277
278 result = parcel.ReadInt64Vector(nullptr);
279 EXPECT_EQ(result, false);
280
281 result = parcel.ReadUInt8Vector(nullptr);
282 EXPECT_EQ(result, false);
283
284 result = parcel.ReadUInt16Vector(nullptr);
285 EXPECT_EQ(result, false);
286
287 result = parcel.ReadUInt32Vector(nullptr);
288 EXPECT_EQ(result, false);
289
290 result = parcel.ReadUInt64Vector(nullptr);
291 EXPECT_EQ(result, false);
292
293 result = parcel.ReadFloatVector(nullptr);
294 EXPECT_EQ(result, false);
295
296 result = parcel.ReadDoubleVector(nullptr);
297 EXPECT_EQ(result, false);
298
299 result = parcel.ReadStringVector(nullptr);
300 EXPECT_EQ(result, false);
301
302 result = parcel.ReadString16Vector(nullptr);
303 EXPECT_EQ(result, false);
304 }
305
ReadvecTestTwoFunc01()306 static void ReadvecTestTwoFunc01()
307 {
308 Parcel parcel1;
309 parcel1.WriteInt32(-1);
310 std::vector<bool> val1;
311 bool x1 = true;
312 val1.push_back(x1);
313 bool result = parcel1.ReadBoolVector(&val1);
314 EXPECT_EQ(result, false);
315
316 Parcel parcel2;
317 parcel2.WriteInt32(-1);
318 std::vector<int8_t> val2;
319 int8_t x2 = 1;
320 val2.push_back(x2);
321 result = parcel2.ReadInt8Vector(&val2);
322 EXPECT_EQ(result, false);
323
324 Parcel parcel3;
325 parcel3.WriteInt32(-1);
326 std::vector<int16_t> val3;
327 int16_t x3 = 1;
328 val3.push_back(x3);
329 result = parcel3.ReadInt16Vector(&val3);
330 EXPECT_EQ(result, false);
331
332 Parcel parcel4;
333 parcel4.WriteInt32(-1);
334 std::vector<int32_t> val4;
335 int32_t x4 = 1;
336 val4.push_back(x4);
337 result = parcel4.ReadInt32Vector(&val4);
338 EXPECT_EQ(result, false);
339 }
340
ReadvecTestTwoFunc02()341 static void ReadvecTestTwoFunc02()
342 {
343 Parcel parcel1;
344 parcel1.WriteInt32(-1);
345 std::vector<int64_t> val1;
346 int64_t x1 = 1;
347 val1.push_back(x1);
348 bool result = parcel1.ReadInt64Vector(&val1);
349 EXPECT_EQ(result, false);
350
351 Parcel parcel2;
352 parcel2.WriteInt32(-1);
353 std::vector<uint8_t> val2;
354 uint8_t x2 = 1;
355 val2.push_back(x2);
356 result = parcel2.ReadUInt8Vector(&val2);
357 EXPECT_EQ(result, false);
358
359 Parcel parcel3;
360 parcel3.WriteInt32(-1);
361 std::vector<uint16_t> val3;
362 uint16_t x3 = 1;
363 val3.push_back(x3);
364 result = parcel3.ReadUInt16Vector(&val3);
365 EXPECT_EQ(result, false);
366
367 Parcel parcel4;
368 parcel4.WriteInt32(-1);
369 std::vector<uint32_t> val4;
370 uint32_t x4 = 1;
371 val4.push_back(x4);
372 result = parcel4.ReadUInt32Vector(&val4);
373 EXPECT_EQ(result, false);
374 }
375
ReadvecTestTwoFunc03()376 static void ReadvecTestTwoFunc03()
377 {
378 Parcel parcel1;
379 parcel1.WriteInt32(-1);
380 std::vector<uint64_t> val1;
381 uint64_t x1 = 1;
382 val1.push_back(x1);
383 bool result = parcel1.ReadUInt64Vector(&val1);
384 EXPECT_EQ(result, false);
385
386 Parcel parcel2;
387 parcel2.WriteInt32(-1);
388 std::vector<float> val2;
389 float x2 = 1;
390 val2.push_back(x2);
391 result = parcel2.ReadFloatVector(&val2);
392 EXPECT_EQ(result, false);
393
394 Parcel parcel3;
395 parcel3.WriteInt32(-1);
396 std::vector<double> val3;
397 double x3 = 1;
398 val3.push_back(x3);
399 result = parcel3.ReadDoubleVector(&val3);
400 EXPECT_EQ(result, false);
401
402 Parcel parcel4;
403 parcel4.WriteInt32(-1);
404 std::vector<std::string> val4;
405 std::string x4 = "test";
406 val4.push_back(x4);
407 result = parcel4.ReadStringVector(&val4);
408 EXPECT_EQ(result, false);
409
410 Parcel parcel5;
411 parcel5.WriteInt32(-1);
412 std::vector<std::u16string> val5;
413 std::u16string x5 = u"test";
414 val5.push_back(x5);
415 result = parcel5.ReadString16Vector(&val5);
416 EXPECT_EQ(result, false);
417 }
418
419 /**
420 * @tc.name: test_parcel_readvec_002
421 * @tc.desc: test parcel read vector failed with invlalid vector length -1.
422 * @tc.type: FUNC
423 */
424 HWTEST_F(UtilsParcelTest, test_parcel_readvec_002, TestSize.Level0)
425 {
426 ReadvecTestTwoFunc01();
427 ReadvecTestTwoFunc02();
428 ReadvecTestTwoFunc03();
429 }
430
ReadvecTestThreeFunc01()431 static void ReadvecTestThreeFunc01()
432 {
433 Parcel parcel1;
434 std::vector<bool> val1;
435 bool x1 = true;
436 val1.push_back(x1);
437 parcel1.WriteInt32(val1.max_size());
438 bool result = parcel1.ReadBoolVector(&val1);
439 EXPECT_EQ(result, false);
440
441 Parcel parcel2;
442 std::vector<int8_t> val2;
443 int8_t x2 = 1;
444 val2.push_back(x2);
445 parcel2.WriteInt32(val2.max_size());
446 result = parcel2.ReadInt8Vector(&val2);
447 EXPECT_EQ(result, false);
448
449 Parcel parcel3;
450 std::vector<int16_t> val3;
451 int16_t x3 = 1;
452 val3.push_back(x3);
453 parcel3.WriteInt32(val3.max_size());
454 result = parcel3.ReadInt16Vector(&val3);
455 EXPECT_EQ(result, false);
456
457 Parcel parcel4;
458 std::vector<int32_t> val4;
459 int32_t x4 = 1;
460 val4.push_back(x4);
461 parcel4.WriteInt32(val4.max_size());
462 result = parcel4.ReadInt32Vector(&val4);
463 EXPECT_EQ(result, false);
464 }
465
ReadvecTestThreeFunc02()466 static void ReadvecTestThreeFunc02()
467 {
468 Parcel parcel1;
469 std::vector<int64_t> val1;
470 int64_t x1 = 1;
471 val1.push_back(x1);
472 parcel1.WriteInt32(val1.max_size());
473 bool result = parcel1.ReadInt64Vector(&val1);
474 EXPECT_EQ(result, false);
475
476 Parcel parcel2;
477 std::vector<uint8_t> val2;
478 uint8_t x2 = 1;
479 val2.push_back(x2);
480 parcel2.WriteInt32(val2.max_size());
481 result = parcel2.ReadUInt8Vector(&val2);
482 EXPECT_EQ(result, false);
483
484 Parcel parcel3;
485 std::vector<uint16_t> val3;
486 uint16_t x3 = 1;
487 val3.push_back(x3);
488 parcel3.WriteInt32(val3.max_size());
489 result = parcel3.ReadUInt16Vector(&val3);
490 EXPECT_EQ(result, false);
491
492 Parcel parcel4;
493 std::vector<uint32_t> val4;
494 uint32_t x4 = 1;
495 val4.push_back(x4);
496 parcel4.WriteInt32(val4.max_size());
497 result = parcel4.ReadUInt32Vector(&val4);
498 EXPECT_EQ(result, false);
499 }
500
ReadvecTestThreeFunc03()501 static void ReadvecTestThreeFunc03()
502 {
503 Parcel parcel1;
504 std::vector<uint64_t> val1;
505 uint64_t x1 = 1;
506 val1.push_back(x1);
507 parcel1.WriteInt32(val1.max_size());
508 bool result = parcel1.ReadUInt64Vector(&val1);
509 EXPECT_EQ(result, false);
510
511 Parcel parcel2;
512 std::vector<float> val2;
513 float x2 = 1;
514 val2.push_back(x2);
515 parcel2.WriteInt32(val2.max_size());
516 result = parcel2.ReadFloatVector(&val2);
517 EXPECT_EQ(result, false);
518
519 Parcel parcel3;
520 std::vector<double> val3;
521 double x3 = 1;
522 val3.push_back(x3);
523 parcel3.WriteInt32(val3.max_size());
524 result = parcel3.ReadDoubleVector(&val3);
525 EXPECT_EQ(result, false);
526
527 Parcel parcel4;
528 std::vector<std::string> val4;
529 std::string x4 = "test";
530 val4.push_back(x4);
531 parcel4.WriteInt32(val4.max_size());
532 result = parcel4.ReadStringVector(&val4);
533 EXPECT_EQ(result, false);
534
535 Parcel parcel5;
536 std::vector<std::u16string> val5;
537 std::u16string x5 = u"test";
538 val5.push_back(x5);
539 parcel5.WriteInt32(val5.max_size());
540 result = parcel5.ReadString16Vector(&val5);
541 EXPECT_EQ(result, false);
542 }
543
544 /**
545 * @tc.name: test_parcel_readvec_003
546 * @tc.desc: test parcel read vector failed with invlalid vector length
547 * std::vector::max_size().
548 * @tc.type: FUNC
549 */
550 HWTEST_F(UtilsParcelTest, test_parcel_readvec_003, TestSize.Level0)
551 {
552 ReadvecTestThreeFunc01();
553 ReadvecTestThreeFunc02();
554 ReadvecTestThreeFunc03();
555 }
556
WritevecTestOneFunc01(const size_t cap)557 static void WritevecTestOneFunc01(const size_t cap)
558 {
559 Parcel parcel(nullptr);
560 std::vector<bool> val1;
561 bool x1 = true;
562 for (int i = 0; i < cap / sizeof(bool); i++) {
563 val1.push_back(x1);
564 }
565 bool result = parcel.WriteBoolVector(val1);
566 EXPECT_EQ(result, false);
567
568 parcel.FlushBuffer();
569 std::vector<int8_t> val2;
570 int8_t x2 = 1;
571 for (int i = 0; i < cap / sizeof(int8_t); i++) {
572 val2.push_back(x2);
573 }
574 result = parcel.WriteInt8Vector(val2);
575 EXPECT_EQ(result, false);
576
577 parcel.FlushBuffer();
578 std::vector<int16_t> val3;
579 int16_t x3 = 1;
580 for (int i = 0; i < cap / sizeof(int16_t); i++) {
581 val3.push_back(x3);
582 }
583 result = parcel.WriteInt16Vector(val3);
584 EXPECT_EQ(result, false);
585
586 parcel.FlushBuffer();
587 std::vector<int32_t> val4;
588 int32_t x4 = 1;
589 for (int i = 0; i < cap / sizeof(int32_t); i++) {
590 val4.push_back(x4);
591 }
592 result = parcel.WriteInt32Vector(val4);
593 EXPECT_EQ(result, false);
594 }
595
WritevecTestOneFunc02(const size_t cap)596 static void WritevecTestOneFunc02(const size_t cap)
597 {
598 Parcel parcel(nullptr);
599 std::vector<int64_t> val1;
600 int64_t x1 = 1;
601 for (int i = 0; i < cap / sizeof(int64_t); i++) {
602 val1.push_back(x1);
603 }
604 bool result = parcel.WriteInt64Vector(val1);
605 EXPECT_EQ(result, false);
606
607 parcel.FlushBuffer();
608 std::vector<uint8_t> val2;
609 uint8_t x2 = 1;
610 for (int i = 0; i < cap / sizeof(uint8_t); i++) {
611 val2.push_back(x2);
612 }
613 result = parcel.WriteUInt8Vector(val2);
614 EXPECT_EQ(result, false);
615
616 parcel.FlushBuffer();
617 std::vector<uint16_t> val3;
618 uint16_t x3 = 1;
619 for (int i = 0; i < cap / sizeof(uint16_t); i++) {
620 val3.push_back(x3);
621 }
622 result = parcel.WriteUInt16Vector(val3);
623 EXPECT_EQ(result, false);
624
625 parcel.FlushBuffer();
626 std::vector<uint32_t> val4;
627 uint32_t x4 = 1;
628 for (int i = 0; i < cap / sizeof(uint32_t); i++) {
629 val4.push_back(x4);
630 }
631 result = parcel.WriteUInt32Vector(val4);
632 EXPECT_EQ(result, false);
633 }
634
WritevecTestOneFunc03(const size_t cap)635 static void WritevecTestOneFunc03(const size_t cap)
636 {
637 Parcel parcel(nullptr);
638 std::vector<uint64_t> val1;
639 uint64_t x1 = 1;
640 for (int i = 0; i < cap / sizeof(uint64_t); i++) {
641 val1.push_back(x1);
642 }
643 bool result = parcel.WriteUInt64Vector(val1);
644 EXPECT_EQ(result, false);
645
646 parcel.FlushBuffer();
647 std::vector<float> val2;
648 float x2 = 1;
649 for (int i = 0; i < cap / sizeof(float); i++) {
650 val2.push_back(x2);
651 }
652 result = parcel.WriteFloatVector(val2);
653 EXPECT_EQ(result, false);
654
655 parcel.FlushBuffer();
656 std::vector<double> val3;
657 double x3 = 1;
658 for (int i = 0; i < cap / sizeof(double); i++) {
659 val3.push_back(x3);
660 }
661 result = parcel.WriteDoubleVector(val3);
662 EXPECT_EQ(result, false);
663
664 parcel.FlushBuffer();
665 std::vector<std::string> val4;
666 std::string x4((cap / sizeof(char)), 't');
667 val4.push_back(x4);
668 result = parcel.WriteStringVector(val4);
669 EXPECT_EQ(result, false);
670
671 parcel.FlushBuffer();
672 std::vector<std::u16string> val5;
673 std::u16string x5((cap / sizeof(char16_t)), u't');
674 val5.push_back(x5);
675 result = parcel.WriteString16Vector(val5);
676 EXPECT_EQ(result, false);
677 }
678
679 /**
680 * @tc.name: test_parcel_writevec_001
681 * @tc.desc: test parcel write vector failed with writting data out of the
682 * maximum capacity.
683 * @tc.type: FUNC
684 */
685 HWTEST_F(UtilsParcelTest, test_parcel_writevec_001, TestSize.Level0)
686 {
687 size_t cap = DEFAULT_CPACITY;
688
689 WritevecTestOneFunc01(cap);
690 WritevecTestOneFunc02(cap);
691 WritevecTestOneFunc03(cap);
692 }
693
694 /**
695 * @tc.name: test_parcel_SetMaxCapacity_001
696 * @tc.desc: test parcel primary type read write.
697 * @tc.type: FUNC
698 */
699 HWTEST_F(UtilsParcelTest, test_parcel_SetMaxCapacity_001, TestSize.Level0)
700 {
701 size_t cap = DEFAULT_CPACITY;
702 Parcel parcel(nullptr);
703 EXPECT_TRUE(parcel.SetMaxCapacity(cap + 1));
704 EXPECT_FALSE(parcel.SetMaxCapacity(cap - 1));
705 }
706
707 /**
708 * @tc.name: test_parcel_SetAllocator_001
709 * @tc.desc: test setting allocator to parcels with and without existed allocator.
710 * @tc.type: FUNC
711 */
712 HWTEST_F(UtilsParcelTest, test_parcel_SetAllocator_001, TestSize.Level0)
713 {
714 Allocator* alloc = new DefaultAllocator();
715 Parcel parcel(alloc);
716 EXPECT_FALSE(parcel.SetAllocator(alloc));
717 EXPECT_FALSE(parcel.SetAllocator(nullptr));
718
719 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
720
721 WriteTestData(parcel, data);
722 parcel.SetAllocator(new DefaultAllocator());
723 ReadTestData(parcel, data);
724 }
725
726 /**
727 * @tc.name: test_parcel_write_001
728 * @tc.desc: test parcel write failed.
729 * @tc.type: FUNC
730 */
731 HWTEST_F(UtilsParcelTest, test_parcel_write_001, TestSize.Level0)
732 {
733 Parcel parcel1;
734 parcel1.WriteBool(true);
735 Parcel parcel2;
736 void *buffer = nullptr;
737 size_t size = parcel1.GetDataSize();
738 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
739 ASSERT_FALSE(false);
740 }
741 parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
742
743 string str8write;
744 bool result = parcel2.WriteString(str8write);
745 EXPECT_EQ(result, false);
746
747 u16string str16Write;
748 result = parcel2.WriteString16(str16Write);
749 EXPECT_EQ(result, false);
750
751 result = parcel2.WriteBool(false);
752 EXPECT_EQ(result, false);
753
754 result = parcel2.WriteBoolUnaligned(false);
755 EXPECT_EQ(result, false);
756
757 result = parcel2.WriteInt8(false);
758 EXPECT_EQ(result, false);
759
760 result = parcel2.WriteInt8Unaligned(false);
761 EXPECT_EQ(result, false);
762
763 result = parcel2.WriteInt32(false);
764 EXPECT_EQ(result, false);
765
766 result = parcel2.WriteInt64(false);
767 EXPECT_EQ(result, false);
768
769 result = parcel2.WriteUint8(false);
770 EXPECT_EQ(result, false);
771
772 result = parcel2.WriteUint16(false);
773 EXPECT_EQ(result, false);
774
775 result = parcel2.WriteUint8Unaligned(false);
776 EXPECT_EQ(result, false);
777
778 result = parcel2.WriteUint16Unaligned(false);
779 EXPECT_EQ(result, false);
780
781 result = parcel2.WriteUint32(false);
782 EXPECT_EQ(result, false);
783
784 result = parcel2.WriteUint64(false);
785 EXPECT_EQ(result, false);
786
787 result = parcel2.WriteFloat(false);
788 EXPECT_EQ(result, false);
789
790 result = parcel2.WriteDouble(false);
791 EXPECT_EQ(result, false);
792
793 result = parcel2.WritePointer(false);
794 EXPECT_EQ(result, false);
795 }
796
797 /**
798 * @tc.name: test_parcel_WriteAndRead_001
799 * @tc.desc: test parcel primary type read write.
800 * @tc.type: FUNC
801 */
802 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_001, TestSize.Level0)
803 {
804 Parcel parcel(nullptr);
805 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
806 WriteTestData(parcel, data);
807 ReadTestData(parcel, data);
808
809 WriteUnalignedTestData(parcel, data);
810 ReadUnalignedTestData(parcel, data);
811 }
812
813 /**
814 * @tc.name: test_parcel_WriteAndRead_002
815 * @tc.desc: test parcel primary type read write.
816 * @tc.type: FUNC
817 */
818 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_002, TestSize.Level0)
819 {
820 Parcel parcel1(nullptr);
821 Parcel parcel2(nullptr);
822 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
823 WriteTestData(parcel1, data);
824 WriteUnalignedTestData(parcel1, data);
825
826 void *buffer = nullptr;
827 size_t size = parcel1.GetDataSize();
828 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
829 ASSERT_FALSE(false);
830 }
831
832 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
833 EXPECT_EQ(result, true);
834
835 ReadTestData(parcel2, data);
836 ReadUnalignedTestData(parcel2, data);
837 }
838
839 /**
840 * @tc.name: test_parcel_WriteAndRead_003
841 * @tc.desc: test parcel primary type read write.
842 * @tc.type: FUNC
843 */
844 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_003, TestSize.Level0)
845 {
846 Parcel parcel1(nullptr);
847 Parcel parcel2(nullptr);
848 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
849 WriteTestData(parcel1, data);
850
851 void *buffer = nullptr;
852 size_t size = parcel1.GetDataSize();
853 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
854 ASSERT_FALSE(false);
855 }
856
857 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
858 EXPECT_EQ(result, true);
859
860 ReadTestDataWithTarget(parcel2, data);
861 }
862
863 /**
864 * @tc.name: test_parcel_WriteAndRead_004
865 * @tc.desc: test parcel primary type read write.
866 * @tc.type: FUNC
867 */
868 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_004, TestSize.Level0)
869 {
870 Parcel parcel1(nullptr);
871
872 int64_t int64test = -0x1234567887654321;
873 bool result = parcel1.WriteInt64(int64test);
874 EXPECT_EQ(result, true);
875
876 uint64_t uint64test = 0x1234567887654321;
877 result = parcel1.WriteUint64(uint64test);
878 EXPECT_EQ(result, true);
879
880 int64_t readint64 = parcel1.ReadInt64();
881 EXPECT_EQ(readint64, int64test);
882
883 uint64_t readuint64 = parcel1.ReadUint64();
884 EXPECT_EQ(readuint64, uint64test);
885
886 Parcel parcel2(nullptr);
887
888 void *buffer = nullptr;
889 size_t size = parcel1.GetDataSize();
890 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
891 ASSERT_FALSE(false);
892 }
893
894 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
895
896 readint64 = parcel2.ReadInt64();
897 EXPECT_EQ(readint64, int64test);
898
899 readuint64 = parcel2.ReadUint64();
900 EXPECT_EQ(readuint64, uint64test);
901 }
902
903 /**
904 * @tc.name: test_parcel_WriteAndRead_String_001
905 * @tc.desc: test parcel string read write.
906 * @tc.type: FUNC
907 */
908 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_001, TestSize.Level0)
909 {
910 Parcel parcel1(nullptr);
911
912 string strWrite = "test";
913 bool result = parcel1.WriteString(strWrite);
914 EXPECT_EQ(result, true);
915
916 string strWrite1 =
917 "test for write string padded**********************************************************##################";
918 result = parcel1.WriteString(strWrite1);
919 EXPECT_EQ(result, true);
920
921 string strWrite2 =
922 "test for write string padded**********************************************************##################";
923 result = parcel1.WriteString(strWrite2);
924 EXPECT_EQ(result, true);
925
926 string strRead = parcel1.ReadString();
927 string strRead1 = parcel1.ReadString();
928 string strRead2 = parcel1.ReadString();
929 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
930 EXPECT_EQ(0, strcmp(strRead1.c_str(), strWrite1.c_str()));
931 EXPECT_EQ(0, strcmp(strRead2.c_str(), strWrite2.c_str()));
932
933 Parcel parcel2(nullptr);
934
935 void *buffer = nullptr;
936 size_t size = parcel1.GetDataSize();
937 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
938 ASSERT_FALSE(false);
939 }
940
941 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
942
943 strRead = parcel2.ReadString();
944 strRead1 = parcel2.ReadString();
945 strRead2 = parcel2.ReadString();
946 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
947 EXPECT_EQ(0, strcmp(strRead1.c_str(), strWrite1.c_str()));
948 EXPECT_EQ(0, strcmp(strRead2.c_str(), strWrite2.c_str()));
949 }
950
951 /**
952 * @tc.name: test_parcel_WriteAndRead_String_002
953 * @tc.desc: test parcel string read write.
954 * @tc.type: FUNC
955 */
956 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_002, TestSize.Level0)
957 {
958 Parcel parcel1(nullptr);
959
960 u16string str16Write = u"12345";
961 bool result = parcel1.WriteString16(str16Write);
962 EXPECT_EQ(result, true);
963
964 u16string str16Write2 = u"12345 test for write16string padded*********";
965 result = parcel1.WriteString16(str16Write2);
966 EXPECT_EQ(result, true);
967
968 u16string str16Read = parcel1.ReadString16();
969 u16string str16Read2 = parcel1.ReadString16();
970 EXPECT_EQ(0, str16Read.compare(str16Write));
971 EXPECT_EQ(0, str16Read2.compare(str16Write2));
972
973 Parcel parcel2(nullptr);
974
975 void *buffer = nullptr;
976 size_t size = parcel1.GetDataSize();
977 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
978 ASSERT_FALSE(false);
979 }
980
981 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
982
983 str16Read = parcel2.ReadString16();
984 str16Read2 = parcel2.ReadString16();
985 EXPECT_EQ(0, str16Read.compare(str16Write));
986 EXPECT_EQ(0, str16Read2.compare(str16Write2));
987 }
988
989 /**
990 * @tc.name: test_parcel_WriteAndRead_String_003
991 * @tc.desc: test parcel CString read write.
992 * @tc.type: FUNC
993 */
994 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_003, TestSize.Level0)
995 {
996 Parcel parcel(nullptr);
997 string test1 = "12345";
998 string test2 = "23456";
999 string test3 = "34567";
1000 string test4 = "45678";
1001 bool result = parcel.WriteCString(nullptr);
1002 EXPECT_FALSE(result);
1003 result = parcel.WriteCString(test1.c_str());
1004 EXPECT_TRUE(result);
1005 result = parcel.WriteCString(test2.c_str());
1006 EXPECT_TRUE(result);
1007 result = parcel.WriteCString(test3.c_str());
1008 EXPECT_TRUE(result);
1009 result = parcel.WriteCString(test4.c_str());
1010 EXPECT_TRUE(result);
1011
1012 EXPECT_EQ(0, strcmp(test1.c_str(), parcel.ReadCString()));
1013 EXPECT_EQ(0, strcmp(test2.c_str(), parcel.ReadCString()));
1014 EXPECT_EQ(0, strcmp(test3.c_str(), parcel.ReadCString()));
1015 EXPECT_EQ(0, strcmp(test4.c_str(), parcel.ReadCString()));
1016 }
1017
1018 /**
1019 * @tc.name: test_parcel_WriteAndRead_String004
1020 * @tc.desc: test parcel CString read write.
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String004, TestSize.Level0)
1024 {
1025 Parcel parcel1(nullptr);
1026 bool result = false;
1027
1028 // write from Java, read from C++
1029 result = parcel1.WriteString16WithLength(nullptr, 0);
1030 EXPECT_EQ(result, true);
1031
1032 u16string str16write = u"12345";
1033 char16_t *value1 = str16write.data();
1034 result = parcel1.WriteString16WithLength(value1, str16write.length());
1035 EXPECT_EQ(result, true);
1036
1037 u16string str16write2 = u"12345 test for write16string padded*********";
1038 char16_t *value2 = str16write2.data();
1039 result = parcel1.WriteString16WithLength(value2, str16write2.length());
1040 EXPECT_EQ(result, true);
1041
1042 u16string str16readNull = parcel1.ReadString16();
1043 u16string str16read1 = parcel1.ReadString16();
1044 u16string str16read2 = parcel1.ReadString16();
1045 EXPECT_EQ(0, str16readNull.compare(std::u16string()));
1046 EXPECT_EQ(0, str16read1.compare(str16write));
1047 EXPECT_EQ(0, str16read2.compare(str16write2));
1048
1049 // write from C++, read from Java
1050 result = parcel1.WriteString16(str16write);
1051 EXPECT_EQ(result, true);
1052
1053 result = parcel1.WriteString16(str16write2);
1054 EXPECT_EQ(result, true);
1055
1056 int32_t readLength1 = 0;
1057 u16string str16read3 = parcel1.ReadString16WithLength(readLength1);
1058 EXPECT_EQ(readLength1, static_cast<int32_t>(str16write.length()));
1059
1060 int32_t readLength2 = 0;
1061 u16string str16read4 = parcel1.ReadString16WithLength(readLength2);
1062 EXPECT_EQ(readLength2, static_cast<int32_t>(str16write2.length()));
1063
1064 EXPECT_EQ(0, str16read3.compare(str16write));
1065 EXPECT_EQ(0, str16read4.compare(str16write2));
1066 }
1067
1068 /**
1069 * @tc.name: test_parcel_WriteAndRead_String005
1070 * @tc.desc: test parcel CString read write.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String005, TestSize.Level0)
1074 {
1075 Parcel parcel1(nullptr);
1076 bool result = false;
1077
1078 // write from Java, read from C++
1079 result = parcel1.WriteString8WithLength(nullptr, 0);
1080 EXPECT_EQ(result, true);
1081
1082 string str8write = "12345";
1083 char *value1 = str8write.data();
1084 result = parcel1.WriteString8WithLength(value1, str8write.length());
1085 EXPECT_EQ(result, true);
1086
1087 string str8write2 = "12345 test for write16string padded*********";
1088 char *value2 = str8write2.data();
1089 result = parcel1.WriteString8WithLength(value2, str8write2.length());
1090 EXPECT_EQ(result, true);
1091
1092 string str8readNull = parcel1.ReadString();
1093 string str8read1 = parcel1.ReadString();
1094 string str8read2 = parcel1.ReadString();
1095 EXPECT_EQ(0, str8readNull.compare(std::string()));
1096 EXPECT_EQ(0, str8read1.compare(str8write));
1097 EXPECT_EQ(0, str8read2.compare(str8write2));
1098
1099 // write from C++, read from Java
1100 result = parcel1.WriteString(str8write);
1101 EXPECT_EQ(result, true);
1102
1103 result = parcel1.WriteString(str8write2);
1104 EXPECT_EQ(result, true);
1105
1106 int32_t readLength1 = 0;
1107 string str8read3 = parcel1.ReadString8WithLength(readLength1);
1108 EXPECT_EQ(readLength1, static_cast<int32_t>(str8write.length()));
1109
1110 int32_t readLength2 = 0;
1111 string str8read4 = parcel1.ReadString8WithLength(readLength2);
1112 EXPECT_EQ(readLength2, static_cast<int32_t>(str8write2.length()));
1113
1114 EXPECT_EQ(0, str8read3.compare(str8write));
1115 EXPECT_EQ(0, str8read4.compare(str8write2));
1116 }
1117
1118 /**
1119 * @tc.name: test_parcel_WriteAndRead_Float_001
1120 * @tc.desc: test parcel float types read write.
1121 * @tc.type: FUNC
1122 */
1123 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_Float_001, TestSize.Level0)
1124 {
1125 Parcel parcel1(nullptr);
1126
1127 float floatwrite = 12.345678f;
1128 bool result = parcel1.WriteFloat(floatwrite);
1129 EXPECT_EQ(result, true);
1130
1131 double doublewrite = 1345.7653;
1132 result = parcel1.WriteDouble(doublewrite);
1133 EXPECT_EQ(result, true);
1134
1135 float floatread;
1136 result = parcel1.ReadFloat(floatread);
1137 EXPECT_EQ(result, true);
1138 EXPECT_EQ(floatwrite, floatread);
1139
1140 double doubleread;
1141 doubleread = parcel1.ReadDouble();
1142 EXPECT_EQ(doublewrite, doubleread);
1143
1144 Parcel parcel2(nullptr);
1145
1146 void *buffer = nullptr;
1147 size_t size = parcel1.GetDataSize();
1148 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1149 ASSERT_FALSE(false);
1150 }
1151
1152 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1153 result = parcel2.ReadFloat(floatread);
1154 EXPECT_EQ(result, true);
1155 EXPECT_EQ(floatwrite, floatread);
1156
1157 doubleread = parcel2.ReadDouble();
1158 EXPECT_EQ(doublewrite, doubleread);
1159 }
1160
1161 /**
1162 * @tc.name: test_parcel_WriteAndRead_String_005
1163 * @tc.desc: test parcel String type read write.
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_005, TestSize.Level0)
1167 {
1168 Parcel parcel1(nullptr);
1169
1170 string strwrite = "test";
1171 bool result = parcel1.WriteString(strwrite);
1172 EXPECT_EQ(result, true);
1173
1174 string strwrite1 =
1175 "test for write string padded**********************************************************##################";
1176 result = parcel1.WriteString(strwrite1);
1177 EXPECT_EQ(result, true);
1178
1179 string strwrite2 =
1180 "test for write string padded**********************************************************##################";
1181 result = parcel1.WriteString(strwrite2);
1182 EXPECT_EQ(result, true);
1183
1184 string strread;
1185 string strread1;
1186 string strread2;
1187 result = parcel1.ReadString(strread);
1188 EXPECT_EQ(result, true);
1189 result = parcel1.ReadString(strread1);
1190 EXPECT_EQ(result, true);
1191 result = parcel1.ReadString(strread2);
1192 EXPECT_EQ(result, true);
1193 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
1194 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
1195 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
1196
1197 Parcel parcel2(nullptr);
1198
1199 void *buffer = nullptr;
1200 size_t size = parcel1.GetDataSize();
1201 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1202 ASSERT_FALSE(false);
1203 }
1204
1205 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1206 EXPECT_EQ(result, true);
1207
1208 result = parcel2.ReadString(strread);
1209 EXPECT_EQ(result, true);
1210 result = parcel2.ReadString(strread1);
1211 EXPECT_EQ(result, true);
1212 result = parcel2.ReadString(strread2);
1213 EXPECT_EQ(result, true);
1214 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
1215 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
1216 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
1217 }
1218
1219 struct Padded {
1220 char title;
1221 int32_t handle;
1222 uint64_t cookie;
1223 };
1224
1225 struct Unpadded {
1226 char tip;
1227 };
1228
ValidatePadded(const struct Padded & left,const struct Padded & right)1229 void ValidatePadded(const struct Padded &left, const struct Padded &right)
1230 {
1231 EXPECT_EQ(left.title, right.title);
1232 EXPECT_EQ(left.handle, right.handle);
1233 EXPECT_EQ(left.cookie, right.cookie);
1234 }
1235
ValidateUnpadded(const struct Unpadded & left,const struct Unpadded & right)1236 void ValidateUnpadded(const struct Unpadded &left, const struct Unpadded &right)
1237 {
1238 EXPECT_EQ(left.tip, right.tip);
1239 }
1240
1241 /**
1242 * @tc.name: test_CalcNewCapacity_001
1243 * @tc.desc: test kinds of input to CalcNewCapacity.
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(UtilsParcelTest, test_CalcNewCapacity_001, TestSize.Level0)
1247 {
1248 Parcel parcel;
1249
1250 size_t newMaxCapacity;
1251 size_t minNewCapacity = CAPACITY_THRESHOLD;
1252 const string strLenThreshd = string(minNewCapacity, 't');
1253 bool ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strLenThreshd.data()), minNewCapacity);
1254 EXPECT_EQ(true, ret); // calculated capacity = CAPACITY_THRESHOLD
1255
1256 newMaxCapacity = CAPACITY_THRESHOLD - 1;
1257 minNewCapacity = newMaxCapacity;
1258 const string strLessThreshd = string(minNewCapacity, 'l');
1259 parcel.SetMaxCapacity(newMaxCapacity);
1260 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strLessThreshd.data()), minNewCapacity);
1261 EXPECT_EQ(true, ret); // calculated capacity = newMaxCapacity
1262
1263 newMaxCapacity = -1; // minNewCapacity = CAPACITY_THRESHOLD - 1
1264 const string strNoMaxCap = string(minNewCapacity, 'n');
1265 parcel.SetMaxCapacity(newMaxCapacity);
1266 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strNoMaxCap.data()), minNewCapacity);
1267 EXPECT_EQ(ret, true); // calculated capacity = CAPACITY_THRESHOLD
1268
1269 minNewCapacity = CAPACITY_THRESHOLD + 1; // newMaxCapacity = -1
1270 const string strExtThreshd = string(minNewCapacity, 'e');
1271 parcel.SetMaxCapacity(newMaxCapacity);
1272 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strExtThreshd.data()), minNewCapacity);
1273 EXPECT_EQ(ret, true); // calculated capacity = 2 * CAPACITY_THRESHOLD
1274
1275 newMaxCapacity = CAPACITY_THRESHOLD; // minNewCapacity = CAPACITY_THRESHOLD + 1
1276 const string strCapThreshd = string(minNewCapacity, 'e');
1277 parcel.SetMaxCapacity(newMaxCapacity);
1278 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strCapThreshd.data()), minNewCapacity);
1279 EXPECT_EQ(ret, true); // calculated capacity = CAPACITY_THRESHOLD
1280 }
1281
1282 /**
1283 * @tc.name: test_SetDataCapacity_001
1284 * @tc.desc: test kinds of input to SetDataCapacity.
1285 * @tc.type: FUNC
1286 */
1287 HWTEST_F(UtilsParcelTest, test_SetDataCapacity_001, TestSize.Level0)
1288 {
1289 Parcel parcel;
1290 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
1291
1292 WriteTestData(parcel, data);
1293 bool result = parcel.SetDataCapacity(0);
1294 EXPECT_FALSE(result);
1295 }
1296
1297 /**
1298 * @tc.name: test_SetDataSize_001
1299 * @tc.desc: test kinds of input to SetDataSize.
1300 * @tc.type: FUNC
1301 */
1302 HWTEST_F(UtilsParcelTest, test_SetDataSize_001, TestSize.Level0)
1303 {
1304 Parcel parcel;
1305
1306 bool result = parcel.SetDataCapacity(sizeof(bool));
1307 EXPECT_TRUE(result);
1308 result = parcel.WriteBool(true);
1309 EXPECT_TRUE(result);
1310 result = parcel.SetDataSize(DEFAULT_CPACITY + 1);
1311 EXPECT_FALSE(result);
1312 }
1313
1314 /**
1315 * @tc.name: test_parcel_Data_Structure_001
1316 * @tc.desc: test parcel struct data related function.
1317 * @tc.type: FUNC
1318 */
1319 HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_001, TestSize.Level0)
1320 {
1321 Parcel parcel(nullptr);
1322
1323 const struct Padded pad = { 'p', 0x34567890, -0x2345678998765432 };
1324 const struct Unpadded unpad = { 'u' };
1325
1326 bool result = parcel.WriteBuffer(static_cast<const void *>(&pad), sizeof(struct Padded));
1327 EXPECT_EQ(true, result);
1328 const struct Padded *padRead = reinterpret_cast<const struct Padded *>(parcel.ReadBuffer(sizeof(struct Padded)));
1329 ValidatePadded(*padRead, pad);
1330 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1331
1332 result = parcel.WriteBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded));
1333 const struct Unpadded *unpadRead =
1334 reinterpret_cast<const struct Unpadded *>(parcel.ReadBuffer(sizeof(struct Unpadded)));
1335 ValidateUnpadded(*unpadRead, unpad);
1336 EXPECT_NE(parcel.GetWritePosition(), parcel.GetReadPosition());
1337
1338 parcel.RewindRead(0);
1339 parcel.RewindWrite(0);
1340 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1341
1342 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&pad), sizeof(struct Padded));
1343 EXPECT_EQ(true, result);
1344 const struct Padded *padReadNew =
1345 reinterpret_cast<const struct Padded *>(parcel.ReadUnpadBuffer(sizeof(struct Padded)));
1346 ValidatePadded(*padReadNew, pad);
1347 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1348
1349 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded));
1350 EXPECT_EQ(true, result);
1351 const struct Unpadded *unpadReadNew =
1352 reinterpret_cast<const struct Unpadded *>(parcel.ReadUnpadBuffer(sizeof(struct Unpadded)));
1353 ValidateUnpadded(*unpadReadNew, unpad);
1354 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
1355 }
1356
1357 /**
1358 * @tc.name: test_parcel_Data_Structure_002
1359 * @tc.desc: test invalid input to WriteBuffer and WriteBufferAddTerminator.
1360 * @tc.type: FUNC
1361 */
1362 HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_002, TestSize.Level0)
1363 {
1364 Parcel parcel(nullptr);
1365
1366 const string str = "test invalid input";
1367 const string strOverflow = "test write with SIZE_MAX bytes";
1368 const string strWriteFail = string((DEFAULT_CPACITY + 1) / sizeof(char), 'f');
1369 const string strWriteTermFail = string((DEFAULT_CPACITY - 2) / sizeof(char), 't');
1370
1371 bool result = parcel.WriteBuffer(nullptr, sizeof(string));
1372 EXPECT_EQ(false, result);
1373 result = parcel.WriteBufferAddTerminator(nullptr, sizeof(string), sizeof(char));
1374 EXPECT_EQ(false, result);
1375
1376 result = parcel.WriteBuffer(static_cast<const void *>(str.data()), 0);
1377 EXPECT_EQ(false, result);
1378 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(str.data()), 0, sizeof(char));
1379 EXPECT_EQ(false, result);
1380
1381 result = parcel.WriteBuffer(static_cast<const void *>(strWriteFail.data()), strWriteFail.length());
1382 EXPECT_EQ(false, result);
1383 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(strWriteFail.data()),
1384 strWriteFail.length(), sizeof(char));
1385 EXPECT_EQ(false, result);
1386
1387 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(str.data()), str.length(), sizeof(char));
1388 EXPECT_EQ(true, result);
1389
1390 Parcel recvParcel(nullptr);
1391 void *buffer = nullptr;
1392 size_t size = parcel.GetDataSize();
1393 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel.GetData()))) {
1394 ASSERT_FALSE(false);
1395 }
1396 result = recvParcel.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel.GetDataSize());
1397 EXPECT_EQ(result, true);
1398 result = recvParcel.WriteBufferAddTerminator(static_cast<const void *>(&str), str.length() + 1, sizeof(char));
1399 EXPECT_EQ(result, false);
1400 }
1401
1402 struct VectorTestData {
1403 vector<bool> booltest = { false, false, true, false, true };
1404 vector<int8_t> int8test = { 0x01, 0x10, -0x20, 0x30, 0x40 };
1405 vector<int16_t> int16test = { 0x1234, -0x2345, 0x3456, -0x4567, 0x5678 };
1406 vector<int32_t> int32test = { 0x12345678, -0x23456789, 0x34567890, -0x45678901 };
1407 vector<int64_t> int64test = { 0x1234567887654321, -0x2345678998765432 };
1408 vector<uint8_t> uint8test = { 0x01, 0x10, 0x20, 0x30, 0x40 };
1409 vector<uint16_t> uint16test = { 0x1234, 0x2345, 0x3456, 0x4567, 0x5678 };
1410 vector<uint32_t> uint32test = { 0x12345678, 0x23456789, 0x34567890, 0x45678901 };
1411 vector<uint64_t> uint64test = { 0x1234567887654321, 0x2345678998765432 };
1412 };
1413
WriteVectorTestData(Parcel & parcel,const VectorTestData & data)1414 void WriteVectorTestData(Parcel &parcel, const VectorTestData &data)
1415 {
1416 bool result = parcel.WriteBoolVector(data.booltest);
1417 EXPECT_EQ(result, true);
1418 result = parcel.WriteInt8Vector(data.int8test);
1419 EXPECT_EQ(result, true);
1420 result = parcel.WriteInt16Vector(data.int16test);
1421 EXPECT_EQ(result, true);
1422 result = parcel.WriteInt32Vector(data.int32test);
1423 EXPECT_EQ(result, true);
1424 result = parcel.WriteInt64Vector(data.int64test);
1425 EXPECT_EQ(result, true);
1426 result = parcel.WriteUInt8Vector(data.uint8test);
1427 EXPECT_EQ(result, true);
1428 result = parcel.WriteUInt16Vector(data.uint16test);
1429 EXPECT_EQ(result, true);
1430 result = parcel.WriteUInt32Vector(data.uint32test);
1431 EXPECT_EQ(result, true);
1432 result = parcel.WriteUInt64Vector(data.uint64test);
1433 EXPECT_EQ(result, true);
1434 }
1435
ReadVectorTestDataFunc01(Parcel & parcel,const VectorTestData & data)1436 void ReadVectorTestDataFunc01(Parcel &parcel, const VectorTestData &data)
1437 {
1438 vector<bool> boolread;
1439 vector<int8_t> int8read;
1440 vector<int16_t> int16read;
1441 vector<int32_t> int32read;
1442 vector<int64_t> int64read;
1443
1444 bool result = parcel.ReadBoolVector(&boolread);
1445 EXPECT_EQ(result, true);
1446 for (size_t i = 0; i < data.booltest.size(); i++) {
1447 EXPECT_EQ(data.booltest[i], boolread[i]);
1448 }
1449
1450 result = parcel.ReadInt8Vector(&int8read);
1451 EXPECT_EQ(result, true);
1452 for (size_t i = 0; i < data.int8test.size(); i++) {
1453 EXPECT_EQ(data.int8test[i], int8read[i]);
1454 }
1455
1456 result = parcel.ReadInt16Vector(&int16read);
1457 EXPECT_EQ(result, true);
1458 for (size_t i = 0; i < data.int16test.size(); i++) {
1459 EXPECT_EQ(data.int16test[i], int16read[i]);
1460 }
1461
1462 result = parcel.ReadInt32Vector(&int32read);
1463 EXPECT_EQ(result, true);
1464 for (size_t i = 0; i < data.int32test.size(); i++) {
1465 EXPECT_EQ(data.int32test[i], int32read[i]);
1466 }
1467
1468 result = parcel.ReadInt64Vector(&int64read);
1469 EXPECT_EQ(result, true);
1470 for (size_t i = 0; i < data.int64test.size(); i++) {
1471 EXPECT_EQ(data.int64test[i], int64read[i]);
1472 }
1473 }
1474
ReadVectorTestDataFunc02(Parcel & parcel,const VectorTestData & data)1475 void ReadVectorTestDataFunc02(Parcel &parcel, const VectorTestData &data)
1476 {
1477 vector<uint8_t> uint8read;
1478 vector<uint16_t> uint16read;
1479 vector<uint32_t> uint32read;
1480 vector<uint64_t> uint64read;
1481
1482 bool result = parcel.ReadUInt8Vector(&uint8read);
1483 EXPECT_EQ(result, true);
1484 for (size_t i = 0; i < data.uint8test.size(); i++) {
1485 EXPECT_EQ(data.uint8test[i], uint8read[i]);
1486 }
1487
1488 result = parcel.ReadUInt16Vector(&uint16read);
1489 EXPECT_EQ(result, true);
1490 for (size_t i = 0; i < data.uint16test.size(); i++) {
1491 EXPECT_EQ(data.uint16test[i], uint16read[i]);
1492 }
1493
1494 result = parcel.ReadUInt32Vector(&uint32read);
1495 EXPECT_EQ(result, true);
1496 for (size_t i = 0; i < data.uint32test.size(); i++) {
1497 EXPECT_EQ(data.uint32test[i], uint32read[i]);
1498 }
1499
1500 result = parcel.ReadUInt64Vector(&uint64read);
1501 EXPECT_EQ(result, true);
1502 for (size_t i = 0; i < data.uint64test.size(); i++) {
1503 EXPECT_EQ(data.uint64test[i], uint64read[i]);
1504 }
1505 }
1506
ReadVectorTestData(Parcel & parcel,const VectorTestData & data)1507 void ReadVectorTestData(Parcel &parcel, const VectorTestData &data)
1508 {
1509 ReadVectorTestDataFunc01(parcel, data);
1510 ReadVectorTestDataFunc02(parcel, data);
1511 }
1512
1513 /**
1514 * @tc.name: test_parcel_WriteAndReadVector_001
1515 * @tc.desc: test vector parcel read and write.
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_001, TestSize.Level0)
1519 {
1520 Parcel parcel(nullptr);
1521 struct VectorTestData data;
1522
1523 WriteVectorTestData(parcel, data);
1524 ReadVectorTestData(parcel, data);
1525 }
1526
1527 /**
1528 * @tc.name: test_parcel_WriteAndReadVector_002
1529 * @tc.desc: test vector parcel read and write.
1530 * @tc.type: FUNC
1531 */
1532 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_002, TestSize.Level0)
1533 {
1534 Parcel parcel1(nullptr);
1535 struct VectorTestData data;
1536 WriteVectorTestData(parcel1, data);
1537
1538 Parcel parcel2(nullptr);
1539
1540 void *buffer = nullptr;
1541 size_t size = parcel1.GetDataSize();
1542 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1543 ASSERT_FALSE(false);
1544 }
1545
1546 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1547 EXPECT_EQ(result, true);
1548 ReadVectorTestData(parcel2, data);
1549 }
1550
1551 /**
1552 * @tc.name: test_parcel_WriteAndReadVector_003
1553 * @tc.desc: test vector parcel read and write.
1554 * @tc.type: FUNC
1555 */
1556 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_003, TestSize.Level0)
1557 {
1558 Parcel parcel1(nullptr);
1559 Parcel parcel2(nullptr);
1560
1561 vector<string> stringtest{ "test", "test for", "test for write", "test for write vector" };
1562 vector<u16string> string16test{ u"test", u"test for", u"test for write", u"test for write vector" };
1563
1564 bool result = parcel1.WriteStringVector(stringtest);
1565 EXPECT_EQ(result, true);
1566 result = parcel1.WriteString16Vector(string16test);
1567 EXPECT_EQ(result, true);
1568
1569 vector<string> stringread;
1570 result = parcel1.ReadStringVector(&stringread);
1571 EXPECT_EQ(result, true);
1572 for (size_t i = 0; i < stringtest.size(); i++) {
1573 EXPECT_EQ(stringtest[i], stringread[i]);
1574 }
1575
1576 vector<u16string> u16stringread;
1577 result = parcel1.ReadString16Vector(&u16stringread);
1578 EXPECT_EQ(result, true);
1579 for (size_t i = 0; i < string16test.size(); i++) {
1580 EXPECT_EQ(0, string16test[i].compare(u16stringread[i]));
1581 }
1582
1583 void *buffer = nullptr;
1584 size_t size = parcel1.GetDataSize();
1585 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1586 ASSERT_FALSE(false);
1587 }
1588
1589 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1590 result = parcel2.ReadStringVector(&stringread);
1591 EXPECT_EQ(result, true);
1592 for (size_t i = 0; i < stringtest.size(); i++) {
1593 EXPECT_EQ(stringtest[i], stringread[i]);
1594 }
1595
1596 result = parcel2.ReadString16Vector(&u16stringread);
1597 EXPECT_EQ(result, true);
1598 for (size_t i = 0; i < string16test.size(); i++) {
1599 EXPECT_EQ(0, string16test[i].compare(u16stringread[i]));
1600 }
1601 }
1602
1603 /**
1604 * @tc.name: test_parcel_WriteAndReadVector_004
1605 * @tc.desc: test vector parcel read and write.
1606 * @tc.type: FUNC
1607 */
1608 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_004, TestSize.Level0)
1609 {
1610 Parcel parcel1(nullptr);
1611 Parcel parcel2(nullptr);
1612
1613 vector<float> floattest{ 11221.132313, 11221.45678 };
1614 vector<double> doubletest{ 1122.132313, 1122.45678 };
1615
1616 bool result = parcel1.WriteFloatVector(floattest);
1617 EXPECT_EQ(result, true);
1618
1619 result = parcel1.WriteDoubleVector(doubletest);
1620 EXPECT_EQ(result, true);
1621
1622 vector<float> floatread;
1623 vector<double> doubleread;
1624
1625 result = parcel1.ReadFloatVector(&floatread);
1626 EXPECT_EQ(result, true);
1627 for (size_t i = 0; i < floattest.size(); i++) {
1628 EXPECT_EQ(floattest[i], floatread[i]);
1629 }
1630
1631 result = parcel1.ReadDoubleVector(&doubleread);
1632 EXPECT_EQ(result, true);
1633 for (size_t i = 0; i < doubletest.size(); i++) {
1634 EXPECT_EQ(doubletest[i], doubleread[i]);
1635 }
1636 }
1637
CallWriteVector(Parcel & parcel,const std::vector<bool> & vectorTest)1638 bool CallWriteVector(Parcel &parcel, const std::vector<bool> &vectorTest)
1639 {
1640 return parcel.WriteBoolVector(vectorTest);
1641 }
1642
CallWriteVector(Parcel & parcel,const std::vector<int8_t> & vectorTest)1643 bool CallWriteVector(Parcel &parcel, const std::vector<int8_t> &vectorTest)
1644 {
1645 return parcel.WriteInt8Vector(vectorTest);
1646 }
1647
CallWriteVector(Parcel & parcel,const std::vector<int16_t> & vectorTest)1648 bool CallWriteVector(Parcel &parcel, const std::vector<int16_t> &vectorTest)
1649 {
1650 return parcel.WriteInt16Vector(vectorTest);
1651 }
1652
CallWriteVector(Parcel & parcel,const std::vector<int32_t> & vectorTest)1653 bool CallWriteVector(Parcel &parcel, const std::vector<int32_t> &vectorTest)
1654 {
1655 return parcel.WriteInt32Vector(vectorTest);
1656 }
1657
CallWriteVector(Parcel & parcel,const std::vector<int64_t> & vectorTest)1658 bool CallWriteVector(Parcel &parcel, const std::vector<int64_t> &vectorTest)
1659 {
1660 return parcel.WriteInt64Vector(vectorTest);
1661 }
1662
CallWriteVector(Parcel & parcel,const std::vector<uint8_t> & vectorTest)1663 bool CallWriteVector(Parcel &parcel, const std::vector<uint8_t> &vectorTest)
1664 {
1665 return parcel.WriteUInt8Vector(vectorTest);
1666 }
1667
CallWriteVector(Parcel & parcel,const std::vector<uint16_t> & vectorTest)1668 bool CallWriteVector(Parcel &parcel, const std::vector<uint16_t> &vectorTest)
1669 {
1670 return parcel.WriteUInt16Vector(vectorTest);
1671 }
1672
CallWriteVector(Parcel & parcel,const std::vector<uint32_t> & vectorTest)1673 bool CallWriteVector(Parcel &parcel, const std::vector<uint32_t> &vectorTest)
1674 {
1675 return parcel.WriteUInt32Vector(vectorTest);
1676 }
1677
CallWriteVector(Parcel & parcel,const std::vector<uint64_t> & vectorTest)1678 bool CallWriteVector(Parcel &parcel, const std::vector<uint64_t> &vectorTest)
1679 {
1680 return parcel.WriteUInt64Vector(vectorTest);
1681 }
1682
CallWriteVector(Parcel & parcel,const std::vector<float> & vectorTest)1683 bool CallWriteVector(Parcel &parcel, const std::vector<float> &vectorTest)
1684 {
1685 return parcel.WriteFloatVector(vectorTest);
1686 }
1687
CallWriteVector(Parcel & parcel,const std::vector<double> & vectorTest)1688 bool CallWriteVector(Parcel &parcel, const std::vector<double> &vectorTest)
1689 {
1690 return parcel.WriteDoubleVector(vectorTest);
1691 }
1692
CallWriteVector(Parcel & parcel,const std::vector<std::string> & vectorTest)1693 bool CallWriteVector(Parcel &parcel, const std::vector<std::string> &vectorTest)
1694 {
1695 return parcel.WriteStringVector(vectorTest);
1696 }
1697
CallWriteVector(Parcel & parcel,const std::vector<std::u16string> & vectorTest)1698 bool CallWriteVector(Parcel &parcel, const std::vector<std::u16string> &vectorTest)
1699 {
1700 return parcel.WriteString16Vector(vectorTest);
1701 }
1702
1703 template <typename T>
ParcelWriteVector(const std::vector<T> & vectorTest)1704 void ParcelWriteVector(const std::vector<T> &vectorTest)
1705 {
1706 Parcel parcel1(nullptr);
1707 Parcel parcel2(nullptr);
1708 bool result = CallWriteVector(parcel1, vectorTest);
1709 EXPECT_EQ(result, true);
1710
1711 void *buffer = nullptr;
1712 size_t size = parcel1.GetDataSize();
1713 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
1714 ASSERT_FALSE(false);
1715 }
1716 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
1717 EXPECT_EQ(result, true);
1718
1719 result = CallWriteVector(parcel2, vectorTest);
1720 EXPECT_EQ(result, false);
1721 }
1722
1723 /**
1724 * @tc.name: test_parcel_WriteAndReadVector_005
1725 * @tc.desc: test vector parcel write failed.
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_005, TestSize.Level0)
1729 {
1730 vector<bool> boolVectorTest { true, false };
1731 vector<int8_t> int8VectorTest { 1, 0 };
1732 vector<int16_t> int16VectorTest { 1, 0 };
1733 vector<int32_t> int32VectorTest { 1, 0 };
1734 vector<int64_t> int64VectorTest { 1, 0 };
1735 vector<uint8_t> uint8VectorTest { 1, 0 };
1736 vector<uint16_t> uint16VectorTest { 1, 0 };
1737 vector<uint32_t> uint32VectorTest { 1, 0 };
1738 vector<uint64_t> uint64VectorTest { 1, 0 };
1739 vector<float> floatVectorTest { 1.1, 0 };
1740 vector<double> doubleVectorTest { 1.1, 0 };
1741 vector<std::string> stringVectorTest { "true", "false" };
1742 vector<std::u16string> string16VectorTest { u"true", u"false" };
1743
1744 ParcelWriteVector(boolVectorTest);
1745 ParcelWriteVector(int8VectorTest);
1746 ParcelWriteVector(int16VectorTest);
1747 ParcelWriteVector(int32VectorTest);
1748 ParcelWriteVector(int64VectorTest);
1749 ParcelWriteVector(uint8VectorTest);
1750 ParcelWriteVector(uint16VectorTest);
1751 ParcelWriteVector(uint32VectorTest);
1752 ParcelWriteVector(uint64VectorTest);
1753 ParcelWriteVector(floatVectorTest);
1754 ParcelWriteVector(doubleVectorTest);
1755 ParcelWriteVector(stringVectorTest);
1756 ParcelWriteVector(string16VectorTest);
1757 }
1758
1759 class TestParcelable : public virtual Parcelable {
1760 public:
1761 TestParcelable() = default;
1762 ~TestParcelable() = default;
1763
1764 bool Marshalling(Parcel &parcel) const override;
1765 static TestParcelable *Unmarshalling(Parcel &parcel);
1766
1767 public:
1768 int32_t int32Write_ = -0x12345678;
1769 int32_t int32Read_;
1770 };
1771
Marshalling(Parcel & parcel) const1772 bool TestParcelable::Marshalling(Parcel &parcel) const
1773 {
1774 bool result = parcel.WriteInt32(this->int32Write_);
1775 return result;
1776 }
1777
Unmarshalling(Parcel & parcel)1778 TestParcelable *TestParcelable::Unmarshalling(Parcel &parcel)
1779 {
1780 auto *read = new TestParcelable();
1781 read->int32Read_ = parcel.ReadInt32();
1782 return read;
1783 }
1784
1785 /**
1786 * @tc.name: test_parcel_parcelable_001
1787 * @tc.desc: test parcel read and write parcelable obj.
1788 * @tc.type: FUNC
1789 */
1790 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_001, TestSize.Level0)
1791 {
1792 Parcel parcel(nullptr);
1793 sptr<TestParcelable> parcelableWrite = new TestParcelable();
1794 bool result = false;
1795
1796 result = parcel.WriteParcelable(parcelableWrite);
1797 EXPECT_EQ(true, result);
1798 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
1799
1800 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
1801 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_);
1802 EXPECT_EQ(parcel.GetReadPosition(), parcel.GetDataSize());
1803 }
1804
1805 /**
1806 * @tc.name: test_parcel_parcelable_002
1807 * @tc.desc: test parcel read and write parcelable obj.
1808 * @tc.type: FUNC
1809 */
1810 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_002, TestSize.Level0)
1811 {
1812 Parcel parcel(nullptr);
1813
1814 bool result = parcel.WriteParcelable(nullptr);
1815 EXPECT_EQ(true, result);
1816
1817 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
1818 EXPECT_EQ(nullptr, parcelableRead);
1819 }
1820
1821 /**
1822 * @tc.name: test_parcel_parcelable_003
1823 * @tc.desc: test parcel read and write parcelable obj.
1824 * @tc.type: FUNC
1825 */
1826 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_003, TestSize.Level0)
1827 {
1828 Parcel parcel(nullptr);
1829 sptr<TestParcelable> parcelableWriteNull;
1830 bool result = parcel.WriteStrongParcelable(parcelableWriteNull);
1831 EXPECT_EQ(true, result);
1832
1833 sptr<TestParcelable> parcelableWrite = new TestParcelable();
1834
1835 bool test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1836 EXPECT_EQ(false, test);
1837 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC);
1838 EXPECT_EQ(false, test);
1839 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC);
1840 EXPECT_EQ(false, test);
1841
1842 result = parcel.WriteStrongParcelable(parcelableWrite);
1843 EXPECT_EQ(true, result);
1844
1845 sptr<TestParcelable> parcelableReadNull = parcel.ReadParcelable<TestParcelable>();
1846 EXPECT_EQ(nullptr, parcelableReadNull);
1847
1848 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
1849 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_);
1850
1851 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1852 EXPECT_EQ(true, test);
1853 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC);
1854 EXPECT_EQ(false, test);
1855 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC);
1856 EXPECT_EQ(false, test);
1857
1858 parcelableWrite->ClearBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1859 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
1860 EXPECT_EQ(false, test);
1861 }
1862
1863 /**
1864 * @tc.name: test_SetMaxCapacity_001
1865 * @tc.desc: test parcel capacity function.
1866 * @tc.type: FUNC
1867 */
1868 HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_001, TestSize.Level0)
1869 {
1870 Parcel parcel(nullptr);
1871 char test[48] = {0};
1872 bool ret = parcel.WriteBuffer(test, 48);
1873 EXPECT_EQ(true, ret);
1874 // because default maxCap is 200 * 1024, so reset it more
1875 parcel.SetMaxCapacity(201 * 1024);
1876 // test write data over max capacity: 205780 + 48 > 201 * 1024
1877 char test2[205780] = {0};
1878 ret = parcel.WriteBuffer(test2, 205780);
1879 EXPECT_EQ(false, ret);
1880 }
1881
1882 /**
1883 * @tc.name: test_SetMaxCapacity_002
1884 * @tc.desc: test parcel capacity function.
1885 * @tc.type: FUNC
1886 */
1887 HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_002, TestSize.Level0)
1888 {
1889 Parcel parcel(nullptr);
1890 char test[48] = {0};
1891 bool ret = parcel.WriteInt32(5767168);
1892 EXPECT_EQ(true, ret);
1893 ret = parcel.WriteBuffer(test, 48);
1894 EXPECT_EQ(true, ret);
1895 vector<std::u16string> val;
1896 ret = parcel.ReadString16Vector(&val);
1897 EXPECT_EQ(false, ret);
1898 }
1899
1900 HWTEST_F(UtilsParcelTest, test_ValidateReadData_001, TestSize.Level0)
1901 {
1902 Parcel parcel(nullptr);
1903 parcel.WriteBool(true);
1904 string strWrite = "test";
1905 bool result = parcel.WriteString(strWrite);
1906 EXPECT_EQ(result, true);
1907
1908 RemoteObject obj1;
1909 result = parcel.WriteRemoteObject(&obj1);
1910 EXPECT_EQ(result, true);
1911 parcel.WriteInt32(5);
1912 RemoteObject obj2;
1913 result = parcel.WriteRemoteObject(&obj2);
1914 EXPECT_EQ(result, true);
1915 u16string str16Write = u"12345";
1916 result = parcel.WriteString16(str16Write);
1917 EXPECT_EQ(result, true);
1918
1919 bool readBool = parcel.ReadBool();
1920 EXPECT_EQ(readBool, true);
1921
1922 string strRead = parcel.ReadString();
1923 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
1924
1925 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>();
1926 EXPECT_EQ(true, readObj1.GetRefPtr() != nullptr);
1927
1928 int32_t readInt32 = parcel.ReadInt32();
1929 EXPECT_EQ(readInt32, 5);
1930
1931 sptr<RemoteObject> readObj2 = parcel.ReadObject<RemoteObject>();
1932 EXPECT_EQ(true, readObj2.GetRefPtr() != nullptr);
1933
1934 u16string str16Read = parcel.ReadString16();
1935 EXPECT_EQ(0, str16Read.compare(str16Write));
1936 }
1937
1938 HWTEST_F(UtilsParcelTest, test_ValidateReadData_002, TestSize.Level0)
1939 {
1940 Parcel parcel(nullptr);
1941 parcel.WriteBool(true);
1942 string strWrite = "test";
1943 bool result = parcel.WriteString(strWrite);
1944 EXPECT_EQ(result, true);
1945
1946 RemoteObject obj1;
1947 result = parcel.WriteRemoteObject(&obj1);
1948 EXPECT_EQ(result, true);
1949 parcel.WriteInt32(5);
1950 RemoteObject obj2;
1951 result = parcel.WriteRemoteObject(&obj2);
1952 EXPECT_EQ(result, true);
1953 u16string str16Write = u"12345";
1954 result = parcel.WriteString16(str16Write);
1955 EXPECT_EQ(result, true);
1956
1957 bool readBool = parcel.ReadBool();
1958 EXPECT_EQ(readBool, true);
1959
1960 string strRead = parcel.ReadString();
1961 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
1962
1963 int32_t readInt32 = parcel.ReadInt32();
1964 EXPECT_EQ(readInt32, 0);
1965
1966 u16string str16Read = parcel.ReadString16();
1967 EXPECT_EQ(0, str16Read.compare(std::u16string()));
1968
1969 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>();
1970 EXPECT_EQ(true, readObj1.GetRefPtr() == nullptr);
1971 }
1972
1973 HWTEST_F(UtilsParcelTest, test_RewindWrite_001, TestSize.Level0)
1974 {
1975 Parcel parcel(nullptr);
1976 parcel.WriteInt32(5);
1977 string strWrite = "test";
1978 parcel.WriteString(strWrite);
1979 RemoteObject obj1;
1980 parcel.WriteRemoteObject(&obj1);
1981 size_t pos = parcel.GetWritePosition();
1982 parcel.WriteInt32(5);
1983 RemoteObject obj2;
1984 parcel.WriteRemoteObject(&obj2);
1985 u16string str16Write = u"12345";
1986 parcel.WriteString16(str16Write);
1987
1988 bool result = parcel.RewindWrite(pos);
1989 EXPECT_EQ(result, true);
1990 parcel.WriteInt32(5);
1991 parcel.WriteInt32(5);
1992
1993 int32_t readint32 = parcel.ReadInt32();
1994 EXPECT_EQ(readint32, 5);
1995 string strRead = parcel.ReadString();
1996 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
1997 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>();
1998 EXPECT_EQ(true, readObj1.GetRefPtr() != nullptr);
1999 readint32 = parcel.ReadInt32();
2000 EXPECT_EQ(readint32, 5);
2001 sptr<RemoteObject> readObj2 = parcel.ReadObject<RemoteObject>();
2002 EXPECT_EQ(true, readObj2.GetRefPtr() == nullptr);
2003 readint32 = parcel.ReadInt32();
2004 EXPECT_EQ(readint32, 5);
2005 }
2006
2007 HWTEST_F(UtilsParcelTest, test_RewindWrite_002, TestSize.Level0)
2008 {
2009 Parcel parcel(nullptr);
2010 parcel.WriteInt32(5);
2011 string strWrite = "test";
2012 parcel.WriteString(strWrite);
2013 RemoteObject obj1;
2014 parcel.WriteRemoteObject(&obj1);
2015 parcel.WriteInt32(5);
2016 RemoteObject obj2;
2017 parcel.WriteRemoteObject(&obj2);
2018 size_t pos = parcel.GetWritePosition();
2019 u16string str16Write = u"12345";
2020 parcel.WriteString16(str16Write);
2021
2022 bool result = parcel.RewindWrite(pos);
2023 EXPECT_EQ(result, true);
2024
2025 int32_t readint32 = parcel.ReadInt32();
2026 EXPECT_EQ(readint32, 5);
2027 string strRead = parcel.ReadString();
2028 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str()));
2029 uint32_t readUint32 = parcel.ReadUint32();
2030 EXPECT_EQ(readUint32, 0);
2031 string strRead2 = parcel.ReadString();
2032 EXPECT_EQ(0, strRead2.compare(std::string()));
2033 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>();
2034 EXPECT_EQ(true, readObj1.GetRefPtr() == nullptr);
2035 double readDouble = parcel.ReadDouble();
2036 EXPECT_EQ(readDouble, 0);
2037 }
2038
2039 HWTEST_F(UtilsParcelTest, test_RewindWrite_003, TestSize.Level0)
2040 {
2041 Parcel parcel(nullptr);
2042 std::vector<int32_t> val{1, 2, 3, 4, 5};
2043 EXPECT_EQ(val.size(), 5);
2044 bool result = parcel.WriteInt32Vector(val);
2045 EXPECT_EQ(result, true);
2046 size_t pos = parcel.GetWritePosition() - sizeof(int32_t);
2047 result = parcel.RewindWrite(pos);
2048 EXPECT_EQ(result, true);
2049 RemoteObject obj;
2050 parcel.WriteRemoteObject(&obj);
2051
2052 std::vector<int32_t> int32Read;
2053 result = parcel.ReadInt32Vector(&int32Read);
2054 EXPECT_EQ(result, false);
2055 EXPECT_EQ(int32Read.size(), 5);
2056 EXPECT_EQ(int32Read[0], 1);
2057 EXPECT_EQ(int32Read[1], 2);
2058 EXPECT_EQ(int32Read[2], 3);
2059 EXPECT_EQ(int32Read[3], 4);
2060 EXPECT_EQ(int32Read[4], 0);
2061 }
2062
2063 HWTEST_F(UtilsParcelTest, test_VectorDataPadding_001, TestSize.Level0)
2064 {
2065 Parcel parcel1(nullptr);
2066 std::vector<bool> val1(121, true);
2067 bool result = parcel1.WriteBoolVector(val1);
2068 EXPECT_EQ(result, true);
2069
2070 int32_t targetVal = 123;
2071 parcel1.WriteInt32(targetVal);
2072
2073 std::vector<bool> val2;
2074 result = parcel1.ReadBoolVector(&val2);
2075 int32_t target = parcel1.ReadInt32();
2076 EXPECT_EQ(target, targetVal);
2077 }
2078
2079 HWTEST_F(UtilsParcelTest, test_VectorDataPadding_002, TestSize.Level0)
2080 {
2081 Parcel parcel1(nullptr);
2082 std::vector<bool> val1(15, true);
2083 bool result = parcel1.WriteBoolVector(val1);
2084 EXPECT_EQ(result, true);
2085
2086 std::vector<bool> val2(16, true);
2087 result = parcel1.WriteBoolVector(val2);
2088 EXPECT_EQ(result, true);
2089
2090 std::vector<bool> val3;
2091 result = parcel1.ReadBoolVector(&val3);
2092 for (int i = 0; i < val1.size(); i++) {
2093 EXPECT_EQ(val1[i], val3[i]);
2094 }
2095
2096 std::vector<bool> val4;
2097 result = parcel1.ReadBoolVector(&val4);
2098 for (int i = 0; i < val2.size(); i++) {
2099 EXPECT_EQ(val2[i], val4[i]);
2100 }
2101 parcel1.FlushBuffer();
2102
2103 result = parcel1.WriteBoolVector(val2);
2104 EXPECT_EQ(result, true);
2105 result = parcel1.WriteBoolVector(val1);
2106 EXPECT_EQ(result, true);
2107
2108 std::vector<bool> val5;
2109 result = parcel1.ReadBoolVector(&val5);
2110 for (int i = 0; i < val2.size(); i++) {
2111 EXPECT_EQ(val2[i], val5[i]);
2112 }
2113
2114 std::vector<bool> val6;
2115 result = parcel1.ReadBoolVector(&val6);
2116 for (int i = 0; i < val1.size(); i++) {
2117 EXPECT_EQ(val1[i], val6[i]);
2118 }
2119 }
2120
2121 HWTEST_F(UtilsParcelTest, test_VectorDataPadding_003, TestSize.Level0)
2122 {
2123 Parcel parcel1(nullptr);
2124 std::vector<bool> val1(17, true);
2125 bool result = parcel1.WriteBoolVector(val1);
2126 EXPECT_EQ(result, true);
2127
2128 std::vector<int16_t> val2(18, 1);
2129 result = parcel1.WriteInt16Vector(val2);
2130 EXPECT_EQ(result, true);
2131
2132 std::vector<bool> val3;
2133 result = parcel1.ReadBoolVector(&val3);
2134 for (int i = 0; i < val1.size(); i++) {
2135 EXPECT_EQ(val1[i], val3[i]);
2136 }
2137
2138 std::vector<int16_t> val4;
2139 result = parcel1.ReadInt16Vector(&val4);
2140 for (int i = 0; i < val2.size(); i++) {
2141 EXPECT_EQ(val2[i], val4[i]);
2142 }
2143 parcel1.FlushBuffer();
2144
2145 result = parcel1.WriteInt16Vector(val2);
2146 EXPECT_EQ(result, true);
2147 result = parcel1.WriteBoolVector(val1);
2148 EXPECT_EQ(result, true);
2149
2150 std::vector<int16_t> val5;
2151 result = parcel1.ReadInt16Vector(&val5);
2152 for (int i = 0; i < val2.size(); i++) {
2153 EXPECT_EQ(val2[i], val5[i]);
2154 }
2155
2156 std::vector<bool> val6;
2157 result = parcel1.ReadBoolVector(&val6);
2158 for (int i = 0; i < val1.size(); i++) {
2159 EXPECT_EQ(val1[i], val6[i]);
2160 }
2161 }
2162
2163 HWTEST_F(UtilsParcelTest, test_VectorDataPadding_004, TestSize.Level0)
2164 {
2165 Parcel parcel1(nullptr);
2166 std::vector<int16_t> val1(19, 1);
2167 bool result = parcel1.WriteInt16Vector(val1);
2168 EXPECT_EQ(result, true);
2169
2170 std::vector<int16_t> val2(20, 1);
2171 result = parcel1.WriteInt16Vector(val2);
2172 EXPECT_EQ(result, true);
2173
2174 std::vector<int16_t> val3;
2175 result = parcel1.ReadInt16Vector(&val3);
2176 for (int i = 0; i < val1.size(); i++) {
2177 EXPECT_EQ(val1[i], val3[i]);
2178 }
2179
2180 std::vector<int16_t> val4;
2181 result = parcel1.ReadInt16Vector(&val4);
2182 for (int i = 0; i < val2.size(); i++) {
2183 EXPECT_EQ(val2[i], val4[i]);
2184 }
2185 parcel1.FlushBuffer();
2186
2187 result = parcel1.WriteInt16Vector(val2);
2188 EXPECT_EQ(result, true);
2189 result = parcel1.WriteInt16Vector(val1);
2190 EXPECT_EQ(result, true);
2191
2192 std::vector<int16_t> val5;
2193 result = parcel1.ReadInt16Vector(&val5);
2194 for (int i = 0; i < val2.size(); i++) {
2195 EXPECT_EQ(val2[i], val5[i]);
2196 }
2197
2198 std::vector<int16_t> val6;
2199 result = parcel1.ReadInt16Vector(&val6);
2200 for (int i = 0; i < val1.size(); i++) {
2201 EXPECT_EQ(val1[i], val6[i]);
2202 }
2203 }
2204
2205 #ifdef __aarch64__
2206 HWTEST_F(UtilsParcelTest, test_WriteStringDataLength_001, TestSize.Level0)
2207 {
2208 Parcel parcel1(nullptr);
2209
2210 std::string veryLongString(static_cast<size_t>(INT32_MAX) + 1, '#');
2211 bool result = parcel1.WriteCString(veryLongString.c_str());
2212 EXPECT_EQ(result, false);
2213 parcel1.FlushBuffer();
2214
2215 result = parcel1.WriteString(veryLongString);
2216 EXPECT_EQ(result, false);
2217 parcel1.FlushBuffer();
2218
2219 std::u16string veryLongStringU16(static_cast<size_t>(INT32_MAX) / 2, '#');
2220 result = parcel1.WriteString16(veryLongStringU16);
2221 EXPECT_EQ(result, false);
2222 parcel1.FlushBuffer();
2223
2224 result = parcel1.WriteString16WithLength(veryLongStringU16.c_str(), static_cast<size_t>(INT32_MAX) / 2);
2225 EXPECT_EQ(result, false);
2226 parcel1.FlushBuffer();
2227
2228 result = parcel1.WriteString8WithLength(veryLongString.c_str(), static_cast<size_t>(INT32_MAX) + 1);
2229 EXPECT_EQ(result, false);
2230 parcel1.FlushBuffer();
2231
2232 result = parcel1.WriteCString(veryLongString.substr(0, DEFAULT_CPACITY - 1).c_str());
2233 EXPECT_EQ(result, true);
2234 parcel1.FlushBuffer();
2235
2236 result = parcel1.WriteString(veryLongString.substr(0, DEFAULT_CPACITY - 5));
2237 EXPECT_EQ(result, true);
2238 parcel1.FlushBuffer();
2239
2240 result = parcel1.WriteString16(veryLongStringU16.substr(0, (DEFAULT_CPACITY - 4) / 2 - 1));
2241 EXPECT_EQ(result, true);
2242 parcel1.FlushBuffer();
2243
2244 result = parcel1.WriteString16WithLength(veryLongStringU16.c_str(), (DEFAULT_CPACITY - 4) / 2 - 1);
2245 EXPECT_EQ(result, true);
2246 parcel1.FlushBuffer();
2247
2248 result = parcel1.WriteString8WithLength(veryLongString.c_str(), DEFAULT_CPACITY - 5);
2249 EXPECT_EQ(result, true);
2250 parcel1.FlushBuffer();
2251 }
2252 #endif
2253 } // namespace
2254 } // namespace OHOS
2255