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