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
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace std;
28
29 const int MAX_PARCEL_SIZE = 1000;
30 char g_data[MAX_PARCEL_SIZE];
31 class UtilsParcelTest : public testing::Test {
32 public:
33 static void TearDownTestCase(void);
34 };
35
TearDownTestCase(void)36 void UtilsParcelTest::TearDownTestCase(void)
37 {
38 for (int i = 0; i < MAX_PARCEL_SIZE; i++) {
39 g_data[i] = 0;
40 }
41 }
42
43 /*-------------------------------base data------------------------------------*/
44
45 struct TestData {
46 bool booltest;
47 int8_t int8test;
48 int16_t int16test;
49 int32_t int32test;
50 uint8_t uint8test;
51 uint16_t uint16test;
52 uint32_t uint32test;
53 };
54
WriteTestData(Parcel & parcel,const struct TestData & data)55 void WriteTestData(Parcel &parcel, const struct TestData &data)
56 {
57 bool result = false;
58
59 result = parcel.WriteBool(data.booltest);
60 EXPECT_EQ(result, true);
61
62 result = parcel.WriteInt8(data.int8test);
63 EXPECT_EQ(result, true);
64
65 result = parcel.WriteInt16(data.int16test);
66 EXPECT_EQ(result, true);
67
68 result = parcel.WriteInt32(data.int32test);
69 EXPECT_EQ(result, true);
70
71 result = parcel.WriteUint8(data.uint8test);
72 EXPECT_EQ(result, true);
73
74 result = parcel.WriteUint16(data.uint16test);
75 EXPECT_EQ(result, true);
76
77 result = parcel.WriteUint32(data.uint32test);
78 EXPECT_EQ(result, true);
79 }
80
81 /**
82 * Here to simulate the scenario of ipc sending data, the buffer will be released when the Parcel object is destructed.
83 */
SendData(void * & buffer,size_t size,const uint8_t * data)84 bool SendData(void *&buffer, size_t size, const uint8_t *data)
85 {
86 if (size <= 0) {
87 return false;
88 }
89 buffer = malloc(size);
90 if (buffer == nullptr) {
91 return false;
92 }
93 if (memcpy_s(buffer, size, data, size) != EOK) {
94 return false;
95 }
96 return true;
97 }
98
99 /**
100 * @tc.name: test_parcel_WriteAndRead_001
101 * @tc.desc: test parcel primary type read write.
102 * @tc.type: FUNC
103 */
104 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_001, TestSize.Level0)
105 {
106 Parcel parcel(nullptr);
107 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
108 WriteTestData(parcel, data);
109
110 bool readbool = parcel.ReadBool();
111 EXPECT_EQ(readbool, data.booltest);
112
113 int8_t readint8 = parcel.ReadInt8();
114 EXPECT_EQ(readint8, data.int8test);
115
116 int16_t readint16 = parcel.ReadInt16();
117 EXPECT_EQ(readint16, data.int16test);
118
119 int32_t readint32 = parcel.ReadInt32();
120 EXPECT_EQ(readint32, data.int32test);
121
122 uint8_t readuint8 = parcel.ReadUint8();
123 EXPECT_EQ(readuint8, data.uint8test);
124
125 uint16_t readuint16 = parcel.ReadUint16();
126 EXPECT_EQ(readuint16, data.uint16test);
127
128 uint32_t readuint32 = parcel.ReadUint32();
129 EXPECT_EQ(readuint32, data.uint32test);
130 }
131
132 /**
133 * @tc.name: test_parcel_WriteAndRead_002
134 * @tc.desc: test parcel primary type read write.
135 * @tc.type: FUNC
136 */
137 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_002, TestSize.Level0)
138 {
139 Parcel parcel1(nullptr);
140 Parcel parcel2(nullptr);
141 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
142 WriteTestData(parcel1, data);
143
144 void *buffer = nullptr;
145 size_t size = parcel1.GetDataSize();
146 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
147 ASSERT_FALSE(false);
148 }
149
150 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
151 EXPECT_EQ(result, true);
152
153 bool readbool = parcel2.ReadBool();
154 EXPECT_EQ(readbool, data.booltest);
155
156 int8_t readint8 = parcel2.ReadInt8();
157 EXPECT_EQ(readint8, data.int8test);
158
159 int16_t readint16 = parcel2.ReadInt16();
160 EXPECT_EQ(readint16, data.int16test);
161
162 int32_t readint32 = parcel2.ReadInt32();
163 EXPECT_EQ(readint32, data.int32test);
164
165 uint8_t readuint8 = parcel2.ReadUint8();
166 EXPECT_EQ(readuint8, data.uint8test);
167
168 uint16_t readuint16 = parcel2.ReadUint16();
169 EXPECT_EQ(readuint16, data.uint16test);
170
171 uint32_t readuint32 = parcel2.ReadUint32();
172 EXPECT_EQ(readuint32, data.uint32test);
173 }
174
175 /**
176 * @tc.name: test_parcel_WriteAndRead_003
177 * @tc.desc: test parcel primary type read write.
178 * @tc.type: FUNC
179 */
180 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_003, TestSize.Level0)
181 {
182 Parcel parcel1(nullptr);
183 Parcel parcel2(nullptr);
184 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
185 WriteTestData(parcel1, data);
186
187 void *buffer = nullptr;
188 size_t size = parcel1.GetDataSize();
189 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
190 ASSERT_FALSE(false);
191 }
192
193 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
194 EXPECT_EQ(result, true);
195
196 bool boolVal = true;
197 result = parcel2.ReadBool(boolVal);
198 EXPECT_EQ(result, true);
199 EXPECT_EQ(boolVal, data.booltest);
200
201 int8_t int8Val;
202 result = parcel2.ReadInt8(int8Val);
203 EXPECT_EQ(result, true);
204 EXPECT_EQ(int8Val, data.int8test);
205
206 int16_t int16Val;
207 result = parcel2.ReadInt16(int16Val);
208 EXPECT_EQ(result, true);
209 EXPECT_EQ(int16Val, data.int16test);
210
211 int32_t int32Val;
212 result = parcel2.ReadInt32(int32Val);
213 EXPECT_EQ(result, true);
214 EXPECT_EQ(int32Val, data.int32test);
215
216 uint8_t uint8Val;
217 result = parcel2.ReadUint8(uint8Val);
218 EXPECT_EQ(result, true);
219 EXPECT_EQ(uint8Val, data.uint8test);
220
221 uint16_t uint16Val;
222 result = parcel2.ReadUint16(uint16Val);
223 EXPECT_EQ(result, true);
224 EXPECT_EQ(uint16Val, data.uint16test);
225
226 uint32_t uint32Val;
227 result = parcel2.ReadUint32(uint32Val);
228 EXPECT_EQ(result, true);
229 EXPECT_EQ(uint32Val, data.uint32test);
230 }
231
232 /**
233 * @tc.name: test_parcel_WriteAndRead_004
234 * @tc.desc: test parcel primary type read write.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_004, TestSize.Level0)
238 {
239 Parcel parcel1(nullptr);
240 bool result;
241
242 int64_t int64test = -0x1234567887654321;
243 result = parcel1.WriteInt64(int64test);
244 EXPECT_EQ(result, true);
245
246 uint64_t uint64test = 0x1234567887654321;
247 result = parcel1.WriteUint64(uint64test);
248 EXPECT_EQ(result, true);
249
250 int64_t readint64 = parcel1.ReadInt64();
251 EXPECT_EQ(readint64, int64test);
252
253 uint64_t readuint64 = parcel1.ReadUint64();
254 EXPECT_EQ(readuint64, uint64test);
255
256 Parcel parcel2(nullptr);
257
258 void *buffer = nullptr;
259 size_t size = parcel1.GetDataSize();
260 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
261 ASSERT_FALSE(false);
262 }
263
264 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
265
266 readint64 = parcel2.ReadInt64();
267 EXPECT_EQ(readint64, int64test);
268
269 readuint64 = parcel2.ReadUint64();
270 EXPECT_EQ(readuint64, uint64test);
271 }
272
273 /**
274 * @tc.name: test_parcel_WriteAndRead_String_001
275 * @tc.desc: test parcel string read write.
276 * @tc.type: FUNC
277 */
278 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_001, TestSize.Level0)
279 {
280 Parcel parcel1(nullptr);
281 bool result;
282
283 string strwrite = "test";
284 result = parcel1.WriteString(strwrite);
285 EXPECT_EQ(result, true);
286
287 string strwrite1 =
288 "test for write string padded**********************************************************##################";
289 result = parcel1.WriteString(strwrite1);
290 EXPECT_EQ(result, true);
291
292 string strwrite2 =
293 "test for write string padded**********************************************************##################";
294 result = parcel1.WriteString(strwrite2);
295 EXPECT_EQ(result, true);
296
297 string strread = parcel1.ReadString();
298 string strread1 = parcel1.ReadString();
299 string strread2 = parcel1.ReadString();
300 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
301 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
302 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
303
304 Parcel parcel2(nullptr);
305
306 void *buffer = nullptr;
307 size_t size = parcel1.GetDataSize();
308 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
309 ASSERT_FALSE(false);
310 }
311
312 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
313
314 strread = parcel2.ReadString();
315 strread1 = parcel2.ReadString();
316 strread2 = parcel2.ReadString();
317 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
318 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
319 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
320 }
321
322 /**
323 * @tc.name: test_parcel_WriteAndRead_String_002
324 * @tc.desc: test parcel string read write.
325 * @tc.type: FUNC
326 */
327 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_002, TestSize.Level0)
328 {
329 Parcel parcel1(nullptr);
330
331 u16string str16write = u"12345";
332 bool result = parcel1.WriteString16(str16write);
333 EXPECT_EQ(result, true);
334
335 u16string str16write2 = u"12345 test for write16string padded*********";
336 result = parcel1.WriteString16(str16write2);
337 EXPECT_EQ(result, true);
338
339 u16string str16read = parcel1.ReadString16();
340 u16string str16read2 = parcel1.ReadString16();
341 EXPECT_EQ(0, str16read.compare(str16write));
342 EXPECT_EQ(0, str16read2.compare(str16write2));
343
344 Parcel parcel2(nullptr);
345
346 void *buffer = nullptr;
347 size_t size = parcel1.GetDataSize();
348 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
349 ASSERT_FALSE(false);
350 }
351
352 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
353
354 str16read = parcel2.ReadString16();
355 str16read2 = parcel2.ReadString16();
356 EXPECT_EQ(0, str16read.compare(str16write));
357 EXPECT_EQ(0, str16read2.compare(str16write2));
358 }
359
360 /**
361 * @tc.name: test_parcel_WriteAndRead_String_003
362 * @tc.desc: test parcel CString read write.
363 * @tc.type: FUNC
364 */
365 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_003, TestSize.Level0)
366 {
367 Parcel parcel(nullptr);
368 string test1 = "12345";
369 string test2 = "23456";
370 string test3 = "34567";
371 string test4 = "45678";
372 parcel.WriteCString(test1.c_str());
373 parcel.WriteCString(test2.c_str());
374 parcel.WriteCString(test3.c_str());
375 parcel.WriteCString(test4.c_str());
376
377 EXPECT_EQ(0, strcmp(test1.c_str(), parcel.ReadCString()));
378 EXPECT_EQ(0, strcmp(test2.c_str(), parcel.ReadCString()));
379 EXPECT_EQ(0, strcmp(test3.c_str(), parcel.ReadCString()));
380 EXPECT_EQ(0, strcmp(test4.c_str(), parcel.ReadCString()));
381 }
382
383 /**
384 * @tc.name: test_parcel_WriteAndRead_String004
385 * @tc.desc: test parcel CString read write.
386 * @tc.type: FUNC
387 */
388 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String004, TestSize.Level0)
389 {
390 Parcel parcel1(nullptr);
391 bool result = false;
392
393 // write from Java, read from C++
394 result = parcel1.WriteString16WithLength(nullptr, 0);
395 EXPECT_EQ(result, true);
396
397 u16string str16write = u"12345";
398 char16_t *value1 = str16write.data();
399 result = parcel1.WriteString16WithLength(value1, str16write.length());
400 EXPECT_EQ(result, true);
401
402 u16string str16write2 = u"12345 test for write16string padded*********";
403 char16_t *value2 = str16write2.data();
404 result = parcel1.WriteString16WithLength(value2, str16write2.length());
405 EXPECT_EQ(result, true);
406
407 u16string str16readNull = parcel1.ReadString16();
408 u16string str16read1 = parcel1.ReadString16();
409 u16string str16read2 = parcel1.ReadString16();
410 EXPECT_EQ(0, str16readNull.compare(std::u16string()));
411 EXPECT_EQ(0, str16read1.compare(str16write));
412 EXPECT_EQ(0, str16read2.compare(str16write2));
413
414 // write from C++, read from Java
415 result = parcel1.WriteString16(str16write);
416 EXPECT_EQ(result, true);
417
418 result = parcel1.WriteString16(str16write2);
419 EXPECT_EQ(result, true);
420
421 int32_t readLength1 = 0;
422 u16string str16read3 = parcel1.ReadString16WithLength(readLength1);
423 EXPECT_EQ(readLength1, static_cast<int32_t>(str16write.length()));
424
425 int32_t readLength2 = 0;
426 u16string str16read4 = parcel1.ReadString16WithLength(readLength2);
427 EXPECT_EQ(readLength2, static_cast<int32_t>(str16write2.length()));
428
429 EXPECT_EQ(0, str16read3.compare(str16write));
430 EXPECT_EQ(0, str16read4.compare(str16write2));
431 }
432
433 /**
434 * @tc.name: test_parcel_WriteAndRead_Float_001
435 * @tc.desc: test parcel float types read write.
436 * @tc.type: FUNC
437 */
438 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_Float_001, TestSize.Level0)
439 {
440 Parcel parcel1(nullptr);
441 bool result;
442
443 float floatwrite = 12.345678f;
444 result = parcel1.WriteFloat(floatwrite);
445 EXPECT_EQ(result, true);
446
447 double doublewrite = 1345.7653;
448 result = parcel1.WriteDouble(doublewrite);
449 EXPECT_EQ(result, true);
450
451 float floatread;
452 result = parcel1.ReadFloat(floatread);
453 EXPECT_EQ(result, true);
454 EXPECT_EQ(floatwrite, floatread);
455
456 double doubleread;
457 doubleread = parcel1.ReadDouble();
458 EXPECT_EQ(doublewrite, doubleread);
459
460 Parcel parcel2(nullptr);
461
462 void *buffer = nullptr;
463 size_t size = parcel1.GetDataSize();
464 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
465 ASSERT_FALSE(false);
466 }
467
468 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
469 result = parcel2.ReadFloat(floatread);
470 EXPECT_EQ(result, true);
471 EXPECT_EQ(floatwrite, floatread);
472
473 doubleread = parcel2.ReadDouble();
474 EXPECT_EQ(doublewrite, doubleread);
475 }
476
477 /**
478 * @tc.name: test_parcel_WriteAndRead_String_005
479 * @tc.desc: test parcel String type read write.
480 * @tc.type: FUNC
481 */
482 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_005, TestSize.Level0)
483 {
484 Parcel parcel1(nullptr);
485 bool result;
486
487 string strwrite = "test";
488 result = parcel1.WriteString(strwrite);
489 EXPECT_EQ(result, true);
490
491 string strwrite1 =
492 "test for write string padded**********************************************************##################";
493 result = parcel1.WriteString(strwrite1);
494 EXPECT_EQ(result, true);
495
496 string strwrite2 =
497 "test for write string padded**********************************************************##################";
498 result = parcel1.WriteString(strwrite2);
499 EXPECT_EQ(result, true);
500
501 string strread;
502 string strread1;
503 string strread2;
504 result = parcel1.ReadString(strread);
505 EXPECT_EQ(result, true);
506 result = parcel1.ReadString(strread1);
507 EXPECT_EQ(result, true);
508 result = parcel1.ReadString(strread2);
509 EXPECT_EQ(result, true);
510 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
511 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
512 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
513
514 Parcel parcel2(nullptr);
515
516 void *buffer = nullptr;
517 size_t size = parcel1.GetDataSize();
518 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
519 ASSERT_FALSE(false);
520 }
521
522 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
523 EXPECT_EQ(result, true);
524
525 result = parcel2.ReadString(strread);
526 EXPECT_EQ(result, true);
527 result = parcel2.ReadString(strread1);
528 EXPECT_EQ(result, true);
529 result = parcel2.ReadString(strread2);
530 EXPECT_EQ(result, true);
531 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str()));
532 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str()));
533 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str()));
534 }
535
536 struct Padded {
537 char title;
538 int32_t handle;
539 uint64_t cookie;
540 };
541
542 struct Unpadded {
543 char tip;
544 };
545
ValidatePadded(const struct Padded & left,const struct Padded & right)546 void ValidatePadded(const struct Padded &left, const struct Padded &right)
547 {
548 EXPECT_EQ(left.title, right.title);
549 EXPECT_EQ(left.handle, right.handle);
550 EXPECT_EQ(left.cookie, right.cookie);
551 }
552
ValidateUnpadded(const struct Unpadded & left,const struct Unpadded & right)553 void ValidateUnpadded(const struct Unpadded &left, const struct Unpadded &right)
554 {
555 EXPECT_EQ(left.tip, right.tip);
556 }
557
558 /**
559 * @tc.name: test_parcel_Data_Structure_001
560 * @tc.desc: test parcel struct data related function.
561 * @tc.type: FUNC
562 */
563 HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_001, TestSize.Level0)
564 {
565 Parcel parcel(nullptr);
566 bool result;
567
568 const struct Padded pad = { 'p', 0x34567890, -0x2345678998765432 };
569 const struct Unpadded unpad = { 'u' };
570
571 result = parcel.WriteBuffer(static_cast<const void *>(&pad), sizeof(struct Padded));
572 EXPECT_EQ(true, result);
573 const struct Padded *padRead = reinterpret_cast<const struct Padded *>(parcel.ReadBuffer(sizeof(struct Padded)));
574 ValidatePadded(*padRead, pad);
575 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
576
577 result = parcel.WriteBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded));
578 const struct Unpadded *unpadRead =
579 reinterpret_cast<const struct Unpadded *>(parcel.ReadBuffer(sizeof(struct Unpadded)));
580 ValidateUnpadded(*unpadRead, unpad);
581 EXPECT_NE(parcel.GetWritePosition(), parcel.GetReadPosition());
582
583 parcel.RewindRead(0);
584 parcel.RewindWrite(0);
585 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
586
587 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&pad), sizeof(struct Padded));
588 EXPECT_EQ(true, result);
589 const struct Padded *padReadNew =
590 reinterpret_cast<const struct Padded *>(parcel.ReadUnpadBuffer(sizeof(struct Padded)));
591 ValidatePadded(*padReadNew, pad);
592 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
593
594 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded));
595 EXPECT_EQ(true, result);
596 const struct Unpadded *unpadReadNew =
597 reinterpret_cast<const struct Unpadded *>(parcel.ReadUnpadBuffer(sizeof(struct Unpadded)));
598 ValidateUnpadded(*unpadReadNew, unpad);
599 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition());
600 }
601
602 struct VectorTestData {
603 vector<bool> booltest = { false, false, true, false, true };
604 vector<int8_t> int8test = { 0x01, 0x10, -0x20, 0x30, 0x40 };
605 vector<int16_t> int16test = { 0x1234, -0x2345, 0x3456, -0x4567, 0x5678 };
606 vector<int32_t> int32test = { 0x12345678, -0x23456789, 0x34567890, -0x45678901 };
607 vector<int64_t> int64test = { 0x1234567887654321, -0x2345678998765432 };
608 vector<uint8_t> uint8test = { 0x01, 0x10, 0x20, 0x30, 0x40 };
609 vector<uint16_t> uint16test = { 0x1234, 0x2345, 0x3456, 0x4567, 0x5678 };
610 vector<uint32_t> uint32test = { 0x12345678, 0x23456789, 0x34567890, 0x45678901 };
611 vector<uint64_t> uint64test = { 0x1234567887654321, 0x2345678998765432 };
612 };
613
WriteVectorTestData(Parcel & parcel,const VectorTestData & data)614 void WriteVectorTestData(Parcel &parcel, const VectorTestData &data)
615 {
616 bool result = parcel.WriteBoolVector(data.booltest);
617 EXPECT_EQ(result, true);
618 result = parcel.WriteInt8Vector(data.int8test);
619 EXPECT_EQ(result, true);
620 result = parcel.WriteInt16Vector(data.int16test);
621 EXPECT_EQ(result, true);
622 result = parcel.WriteInt32Vector(data.int32test);
623 EXPECT_EQ(result, true);
624 result = parcel.WriteInt64Vector(data.int64test);
625 EXPECT_EQ(result, true);
626 result = parcel.WriteUInt8Vector(data.uint8test);
627 EXPECT_EQ(result, true);
628 result = parcel.WriteUInt16Vector(data.uint16test);
629 EXPECT_EQ(result, true);
630 result = parcel.WriteUInt32Vector(data.uint32test);
631 EXPECT_EQ(result, true);
632 result = parcel.WriteUInt64Vector(data.uint64test);
633 EXPECT_EQ(result, true);
634 }
635
ReadVectorTestData(Parcel & parcel,const VectorTestData & data)636 void ReadVectorTestData(Parcel &parcel, const VectorTestData &data)
637 {
638 vector<bool> boolread;
639 vector<int8_t> int8read;
640 vector<int16_t> int16read;
641 vector<int32_t> int32read;
642 vector<int64_t> int64read;
643
644 vector<uint8_t> uint8read;
645 vector<uint16_t> uint16read;
646 vector<uint32_t> uint32read;
647 vector<uint64_t> uint64read;
648
649 bool result = parcel.ReadBoolVector(&boolread);
650 EXPECT_EQ(result, true);
651 for (size_t i = 0; i < data.booltest.size(); i++) {
652 EXPECT_EQ(data.booltest[i], boolread[i]);
653 }
654
655 result = parcel.ReadInt8Vector(&int8read);
656 EXPECT_EQ(result, true);
657 for (size_t i = 0; i < data.int8test.size(); i++) {
658 EXPECT_EQ(data.int8test[i], int8read[i]);
659 }
660
661 result = parcel.ReadInt16Vector(&int16read);
662 EXPECT_EQ(result, true);
663 for (size_t i = 0; i < data.int16test.size(); i++) {
664 EXPECT_EQ(data.int16test[i], int16read[i]);
665 }
666
667 result = parcel.ReadInt32Vector(&int32read);
668 EXPECT_EQ(result, true);
669 for (size_t i = 0; i < data.int32test.size(); i++) {
670 EXPECT_EQ(data.int32test[i], int32read[i]);
671 }
672
673 result = parcel.ReadInt64Vector(&int64read);
674 EXPECT_EQ(result, true);
675 for (size_t i = 0; i < data.int64test.size(); i++) {
676 EXPECT_EQ(data.int64test[i], int64read[i]);
677 }
678
679 result = parcel.ReadUInt8Vector(&uint8read);
680 EXPECT_EQ(result, true);
681 for (size_t i = 0; i < data.uint8test.size(); i++) {
682 EXPECT_EQ(data.uint8test[i], uint8read[i]);
683 }
684
685 result = parcel.ReadUInt16Vector(&uint16read);
686 EXPECT_EQ(result, true);
687 for (size_t i = 0; i < data.uint16test.size(); i++) {
688 EXPECT_EQ(data.uint16test[i], uint16read[i]);
689 }
690
691 result = parcel.ReadUInt32Vector(&uint32read);
692 EXPECT_EQ(result, true);
693 for (size_t i = 0; i < data.uint32test.size(); i++) {
694 EXPECT_EQ(data.uint32test[i], uint32read[i]);
695 }
696
697 result = parcel.ReadUInt64Vector(&uint64read);
698 EXPECT_EQ(result, true);
699 for (size_t i = 0; i < data.uint64test.size(); i++) {
700 EXPECT_EQ(data.uint64test[i], uint64read[i]);
701 }
702 }
703
704 /**
705 * @tc.name: test_parcel_WriteAndReadVector_001
706 * @tc.desc: test vector parcel read and write.
707 * @tc.type: FUNC
708 */
709 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_001, TestSize.Level0)
710 {
711 Parcel parcel(nullptr);
712 struct VectorTestData data;
713
714 WriteVectorTestData(parcel, data);
715 ReadVectorTestData(parcel, data);
716 }
717
718 /**
719 * @tc.name: test_parcel_WriteAndReadVector_002
720 * @tc.desc: test vector parcel read and write.
721 * @tc.type: FUNC
722 */
723 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_002, TestSize.Level0)
724 {
725 Parcel parcel1(nullptr);
726 struct VectorTestData data;
727 WriteVectorTestData(parcel1, data);
728
729 Parcel parcel2(nullptr);
730
731 void *buffer = nullptr;
732 size_t size = parcel1.GetDataSize();
733 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
734 ASSERT_FALSE(false);
735 }
736
737 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
738 EXPECT_EQ(result, true);
739 ReadVectorTestData(parcel2, data);
740 }
741
742 /**
743 * @tc.name: test_parcel_WriteAndReadVector_003
744 * @tc.desc: test vector parcel read and write.
745 * @tc.type: FUNC
746 */
747 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_003, TestSize.Level0)
748 {
749 Parcel parcel1(nullptr);
750 Parcel parcel2(nullptr);
751 bool result;
752 vector<string> stringtest{ "test", "test for", "test for write", "test for write vector" };
753 vector<u16string> string16test{ u"test", u"test for", u"test for write", u"test for write vector" };
754
755 result = parcel1.WriteStringVector(stringtest);
756 EXPECT_EQ(result, true);
757 result = parcel1.WriteString16Vector(string16test);
758 EXPECT_EQ(result, true);
759
760 vector<string> stringread;
761 result = parcel1.ReadStringVector(&stringread);
762 EXPECT_EQ(result, true);
763 for (size_t i = 0; i < stringtest.size(); i++) {
764 EXPECT_EQ(stringtest[i], stringread[i]);
765 }
766
767 vector<u16string> u16stringread;
768 result = parcel1.ReadString16Vector(&u16stringread);
769 EXPECT_EQ(result, true);
770 for (size_t i = 0; i < string16test.size(); i++) {
771 EXPECT_EQ(0, string16test[i].compare(u16stringread[i]));
772 }
773
774 void *buffer = nullptr;
775 size_t size = parcel1.GetDataSize();
776 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) {
777 ASSERT_FALSE(false);
778 }
779
780 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize());
781 result = parcel2.ReadStringVector(&stringread);
782 EXPECT_EQ(result, true);
783 for (size_t i = 0; i < stringtest.size(); i++) {
784 EXPECT_EQ(stringtest[i], stringread[i]);
785 }
786
787 result = parcel2.ReadString16Vector(&u16stringread);
788 EXPECT_EQ(result, true);
789 for (size_t i = 0; i < string16test.size(); i++) {
790 EXPECT_EQ(0, string16test[i].compare(u16stringread[i]));
791 }
792 }
793
794 /**
795 * @tc.name: test_parcel_WriteAndReadVector_004
796 * @tc.desc: test vector parcel read and write.
797 * @tc.type: FUNC
798 */
799 HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_004, TestSize.Level0)
800 {
801 Parcel parcel1(nullptr);
802 Parcel parcel2(nullptr);
803 bool result;
804 vector<float> floattest{ 11221.132313, 11221.45678 };
805 vector<double> doubletest{ 1122.132313, 1122.45678 };
806
807 result = parcel1.WriteFloatVector(floattest);
808 EXPECT_EQ(result, true);
809 result = parcel1.WriteDoubleVector(doubletest);
810 EXPECT_EQ(result, true);
811
812 vector<float> floatread;
813 vector<double> doubleread;
814
815 result = parcel1.ReadFloatVector(&floatread);
816 EXPECT_EQ(result, true);
817 for (size_t i = 0; i < floattest.size(); i++) {
818 EXPECT_EQ(floattest[i], floatread[i]);
819 }
820
821 result = parcel1.ReadDoubleVector(&doubleread);
822 EXPECT_EQ(result, true);
823 for (size_t i = 0; i < doubletest.size(); i++) {
824 EXPECT_EQ(doubletest[i], doubleread[i]);
825 }
826 }
827
828 class TestParcelable : public virtual Parcelable {
829 public:
830 TestParcelable() = default;
831 ~TestParcelable() = default;
832
833 bool Marshalling(Parcel &parcel) const override;
834 static TestParcelable *Unmarshalling(Parcel &parcel);
835
836 public:
837 int32_t int32Write_ = -0x12345678;
838 int32_t int32Read_;
839 };
840
Marshalling(Parcel & parcel) const841 bool TestParcelable::Marshalling(Parcel &parcel) const
842 {
843 bool result = parcel.WriteInt32(this->int32Write_);
844 return result;
845 }
846
Unmarshalling(Parcel & parcel)847 TestParcelable *TestParcelable::Unmarshalling(Parcel &parcel)
848 {
849 auto *read = new TestParcelable();
850 read->int32Read_ = parcel.ReadInt32();
851 return read;
852 }
853
854 /**
855 * @tc.name: test_parcel_parcelable_001
856 * @tc.desc: test parcel read and write parcelable obj.
857 * @tc.type: FUNC
858 */
859 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_001, TestSize.Level0)
860 {
861 Parcel parcel(nullptr);
862 sptr<TestParcelable> parcelableWrite = new TestParcelable();
863 bool result = false;
864
865 result = parcel.WriteParcelable(parcelableWrite);
866 EXPECT_EQ(true, result);
867 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
868
869 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
870 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_);
871 EXPECT_EQ(parcel.GetReadPosition(), parcel.GetDataSize());
872 }
873
874 /**
875 * @tc.name: test_parcel_parcelable_002
876 * @tc.desc: test parcel read and write parcelable obj.
877 * @tc.type: FUNC
878 */
879 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_002, TestSize.Level0)
880 {
881 Parcel parcel(nullptr);
882
883 bool result = parcel.WriteParcelable(nullptr);
884 EXPECT_EQ(true, result);
885
886 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
887 EXPECT_EQ(nullptr, parcelableRead);
888 }
889
890 /**
891 * @tc.name: test_parcel_parcelable_003
892 * @tc.desc: test parcel read and write parcelable obj.
893 * @tc.type: FUNC
894 */
895 HWTEST_F(UtilsParcelTest, test_parcel_parcelable_003, TestSize.Level0)
896 {
897 Parcel parcel(nullptr);
898 sptr<TestParcelable> parcelableWriteNull;
899 bool result = parcel.WriteStrongParcelable(parcelableWriteNull);
900 EXPECT_EQ(true, result);
901
902 sptr<TestParcelable> parcelableWrite = new TestParcelable();
903
904 bool test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
905 EXPECT_EQ(false, test);
906 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC);
907 EXPECT_EQ(false, test);
908 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC);
909 EXPECT_EQ(false, test);
910
911 result = parcel.WriteStrongParcelable(parcelableWrite);
912 EXPECT_EQ(true, result);
913
914 sptr<TestParcelable> parcelableReadNull = parcel.ReadParcelable<TestParcelable>();
915 EXPECT_EQ(nullptr, parcelableReadNull);
916
917 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>();
918 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_);
919
920 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
921 EXPECT_EQ(true, test);
922 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC);
923 EXPECT_EQ(false, test);
924 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC);
925 EXPECT_EQ(false, test);
926
927 parcelableWrite->ClearBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
928 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT);
929 EXPECT_EQ(false, test);
930 }
931
932 /**
933 * @tc.name: test_SetMaxCapacity_001
934 * @tc.desc: test parcel capacity function.
935 * @tc.type: FUNC
936 */
937 HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_001, TestSize.Level0)
938 {
939 Parcel parcel(nullptr);
940 char test[48] = {0};
941 bool ret;
942 ret = parcel.WriteBuffer(test, 48);
943 EXPECT_EQ(true, ret);
944 // because default maxCap is 200 * 1024, so reset it more
945 parcel.SetMaxCapacity(201 * 1024);
946 // test write data over max capacity: 205780 + 48 > 201 * 1024
947 char test2[205780] = {0};
948 ret = parcel.WriteBuffer(test2, 205780);
949 EXPECT_EQ(false, ret);
950 }
951
952 /**
953 * @tc.name: test_SetMaxCapacity_002
954 * @tc.desc: test parcel capacity function.
955 * @tc.type: FUNC
956 */
957 HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_002, TestSize.Level0)
958 {
959 Parcel parcel(nullptr);
960 char test[48] = {0};
961 bool ret;
962 ret = parcel.WriteInt32(5767168);
963 EXPECT_EQ(true, ret);
964 ret = parcel.WriteBuffer(test, 48);
965 EXPECT_EQ(true, ret);
966 vector<std::u16string> val;
967 ret = parcel.ReadString16Vector(&val);
968 EXPECT_EQ(false, ret);
969 }
970