1 /*
2  * Copyright (c) 2022 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 <memory>
18 #include <string>
19 
20 #include "bundle_used_record_parcel.h"
21 #include "parcel.h"
22 #include "parcel_utils.h"
23 #include "perm_active_response_parcel.h"
24 #include "permission_used_record_parcel.h"
25 #include "permission_used_request_parcel.h"
26 #include "permission_used_result_parcel.h"
27 #include "used_record_detail_parcel.h"
28 
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Security {
33 namespace AccessToken {
34 namespace {
35 UsedRecordDetail g_accessRecord1 = {
36     .status = 0,
37     .lockScreenStatus = 1,
38     .timestamp = 0L,
39     .accessDuration = 0L,
40     .count = 0,
41 };
42 
43 UsedRecordDetail g_accessRecord2 = {
44     .status = 1,
45     .lockScreenStatus = 1,
46     .timestamp = 1L,
47     .accessDuration = 1L,
48     .count = 0,
49 };
50 
51 UsedRecordDetail g_rejectRecord1 = {
52     .status = 2,
53     .lockScreenStatus = 2,
54     .timestamp = 2L,
55     .accessDuration = 2L,
56     .count = 0,
57 };
58 
59 UsedRecordDetail g_rejectRecord2 = {
60     .status = 3,
61     .lockScreenStatus = 2,
62     .timestamp = 3L,
63     .accessDuration = 3L,
64     .count = 0,
65 };
66 
67 PermissionUsedRecord g_permissionRecord1 = {
68     .permissionName = "ohos.permission.CAMERA",
69     .accessCount = 2,
70     .rejectCount = 2,
71     .lastAccessTime = 0L,
72     .lastRejectTime = 0L,
73     .lastAccessDuration = 0L,
74 };
75 
76 PermissionUsedRecord g_permissionRecord2 = {
77     .permissionName = "ohos.permission.LOCATION",
78     .accessCount = 2,
79     .rejectCount = 2,
80     .lastAccessTime = 1L,
81     .lastRejectTime = 1L,
82     .lastAccessDuration = 1L,
83 };
84 
85 BundleUsedRecord g_bundleUsedRecord1 = {
86     .tokenId = 100,
87     .isRemote = false,
88     .deviceId = "you guess",
89     .bundleName = "com.ohos.test",
90 };
91 
92 BundleUsedRecord g_bundleUsedRecord2 = {
93     .tokenId = 101,
94     .isRemote = false,
95     .deviceId = "i want to know too",
96     .bundleName = "com.ohos.permissionmanager",
97 };
98 }
99 
100 class PrivacyParcelTest : public testing::Test  {
101 public:
102     static void SetUpTestCase();
103     static void TearDownTestCase();
104 
105     void SetUp();
106     void TearDown();
107 };
108 
SetUpTestCase()109 void PrivacyParcelTest::SetUpTestCase() {}
TearDownTestCase()110 void PrivacyParcelTest::TearDownTestCase() {}
SetUp()111 void PrivacyParcelTest::SetUp() {}
TearDown()112 void PrivacyParcelTest::TearDown() {}
113 
114 /**
115  * @tc.name: BundleUsedRecordParcel001
116  * @tc.desc: Verify the CreateHapTokenInfo add one hap token function.
117  * @tc.type: FUNC
118  * @tc.require: issueI5RUCC
119  */
120 HWTEST_F(PrivacyParcelTest, BundleUsedRecordParcel001, TestSize.Level1)
121 {
122     BundleUsedRecordParcel bundleUsedRecordParcel;
123 
124     bundleUsedRecordParcel.bundleRecord = {
125         .tokenId = 100,
126         .isRemote = false,
127         .deviceId = "device",
128         .bundleName = "com.ohos.permissionmanager",
129     };
130 
131     g_permissionRecord1.accessRecords.emplace_back(g_accessRecord1);
132     g_permissionRecord1.accessRecords.emplace_back(g_accessRecord2);
133     g_permissionRecord2.rejectRecords.emplace_back(g_rejectRecord1);
134     g_permissionRecord2.rejectRecords.emplace_back(g_rejectRecord2);
135 
136     bundleUsedRecordParcel.bundleRecord.permissionRecords.emplace_back(g_permissionRecord1);
137     bundleUsedRecordParcel.bundleRecord.permissionRecords.emplace_back(g_permissionRecord2);
138 
139     Parcel parcel;
140     EXPECT_EQ(true, bundleUsedRecordParcel.Marshalling(parcel));
141 
142     std::shared_ptr<BundleUsedRecordParcel> readedData(BundleUsedRecordParcel::Unmarshalling(parcel));
143     EXPECT_EQ(true, readedData != nullptr);
144 
145     EXPECT_EQ(bundleUsedRecordParcel.bundleRecord.tokenId, readedData->bundleRecord.tokenId);
146     EXPECT_EQ(bundleUsedRecordParcel.bundleRecord.isRemote, readedData->bundleRecord.isRemote);
147     EXPECT_EQ(bundleUsedRecordParcel.bundleRecord.deviceId, readedData->bundleRecord.deviceId);
148     EXPECT_EQ(bundleUsedRecordParcel.bundleRecord.bundleName, readedData->bundleRecord.bundleName);
149 }
150 
151 /**
152  * @tc.name: ActiveChangeResponseParcel001
153  * @tc.desc: Verify ActiveChangeResponseParcel Marshalling and Unmarshalling function.
154  * @tc.type: FUNC
155  * @tc.require: issueI5RRLJ
156  */
157 HWTEST_F(PrivacyParcelTest, ActiveChangeResponseParcel001, TestSize.Level1)
158 {
159     ActiveChangeResponseParcel activeChangeResponseParcel;
160 
161     activeChangeResponseParcel.changeResponse = {
162         .tokenID = 100,
163         .permissionName = "ohos.permission.CAMERA",
164         .deviceId = "device",
165         .type = PERM_INACTIVE,
166     };
167 
168     Parcel parcel;
169     EXPECT_EQ(true, activeChangeResponseParcel.Marshalling(parcel));
170 
171     std::shared_ptr<ActiveChangeResponseParcel> readedData(ActiveChangeResponseParcel::Unmarshalling(parcel));
172     EXPECT_EQ(true, readedData != nullptr);
173 
174     EXPECT_EQ(activeChangeResponseParcel.changeResponse.tokenID, readedData->changeResponse.tokenID);
175     EXPECT_EQ(activeChangeResponseParcel.changeResponse.permissionName, readedData->changeResponse.permissionName);
176     EXPECT_EQ(activeChangeResponseParcel.changeResponse.deviceId, readedData->changeResponse.deviceId);
177     EXPECT_EQ(activeChangeResponseParcel.changeResponse.type, readedData->changeResponse.type);
178 }
179 
180 /**
181  * @tc.name: PermissionUsedRecordParcel001
182  * @tc.desc: Verify the PermissionUsedRecordParcel Marshalling and Unmarshalling function.
183  * @tc.type: FUNC
184  * @tc.require: issueI5RUCC
185  */
186 HWTEST_F(PrivacyParcelTest, PermissionUsedRecordParcel001, TestSize.Level1)
187 {
188     PermissionUsedRecordParcel permissionUsedRecordParcel;
189 
190     permissionUsedRecordParcel.permissionRecord = {
191         .permissionName = "ohos.permission.CAMERA",
192         .accessCount = 2,
193         .rejectCount = 2,
194         .lastAccessTime = 0L,
195         .lastRejectTime = 0L,
196         .lastAccessDuration = 0L,
197     };
198     permissionUsedRecordParcel.permissionRecord.accessRecords.emplace_back(g_accessRecord1);
199     permissionUsedRecordParcel.permissionRecord.accessRecords.emplace_back(g_accessRecord2);
200     permissionUsedRecordParcel.permissionRecord.rejectRecords.emplace_back(g_rejectRecord1);
201     permissionUsedRecordParcel.permissionRecord.rejectRecords.emplace_back(g_rejectRecord2);
202 
203     Parcel parcel;
204     EXPECT_EQ(true, permissionUsedRecordParcel.Marshalling(parcel));
205 
206     std::shared_ptr<PermissionUsedRecordParcel> readedData(PermissionUsedRecordParcel::Unmarshalling(parcel));
207     EXPECT_EQ(true, readedData != nullptr);
208 
209     EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.permissionName, readedData->permissionRecord.permissionName);
210     EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessCount, readedData->permissionRecord.accessCount);
211     EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectCount, readedData->permissionRecord.rejectCount);
212     EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.lastAccessTime, readedData->permissionRecord.lastAccessTime);
213     EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.lastRejectTime, readedData->permissionRecord.lastRejectTime);
214     EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.lastAccessDuration,
215         readedData->permissionRecord.lastAccessDuration);
216 
217     for (uint32_t i = 0; i < permissionUsedRecordParcel.permissionRecord.accessRecords.size(); i++) {
218         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].status,
219             readedData->permissionRecord.accessRecords[i].status);
220         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].lockScreenStatus,
221             readedData->permissionRecord.accessRecords[i].lockScreenStatus);
222         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].timestamp,
223             readedData->permissionRecord.accessRecords[i].timestamp);
224         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].accessDuration,
225             readedData->permissionRecord.accessRecords[i].accessDuration);
226         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].count,
227             readedData->permissionRecord.accessRecords[i].count);
228     }
229 
230     for (uint32_t i = 0; i < permissionUsedRecordParcel.permissionRecord.rejectRecords.size(); i++) {
231         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].status,
232             readedData->permissionRecord.rejectRecords[i].status);
233         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].lockScreenStatus,
234             readedData->permissionRecord.rejectRecords[i].lockScreenStatus);
235         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].timestamp,
236             readedData->permissionRecord.rejectRecords[i].timestamp);
237         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].accessDuration,
238             readedData->permissionRecord.rejectRecords[i].accessDuration);
239         EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].count,
240             readedData->permissionRecord.rejectRecords[i].count);
241     }
242 }
243 
244 /**
245  * @tc.name: PermissionUsedRequestParcel001
246  * @tc.desc: Verify the PermissionUsedRequestParcel Marshalling and Unmarshalling function.
247  * @tc.type: FUNC
248  * @tc.require: issueI5RUP1
249  */
250 HWTEST_F(PrivacyParcelTest, PermissionUsedRequestParcel001, TestSize.Level1)
251 {
252     PermissionUsedRequestParcel permissionUsedRequestParcel;
253 
254     permissionUsedRequestParcel.request = {
255         .tokenId = 100,
256         .isRemote = false,
257         .deviceId = "you guess",
258         .bundleName = "com.ohos.permissionmanager",
259         .beginTimeMillis = 0L,
260         .endTimeMillis = 0L,
261         .flag = FLAG_PERMISSION_USAGE_SUMMARY,
262     };
263     permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA");
264     permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.LOCATION");
265 
266     Parcel parcel;
267     EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel));
268 
269     std::shared_ptr<PermissionUsedRequestParcel> readedData(PermissionUsedRequestParcel::Unmarshalling(parcel));
270     EXPECT_EQ(true, readedData != nullptr);
271 
272     EXPECT_EQ(permissionUsedRequestParcel.request.tokenId, readedData->request.tokenId);
273     EXPECT_EQ(permissionUsedRequestParcel.request.isRemote, readedData->request.isRemote);
274     EXPECT_EQ(permissionUsedRequestParcel.request.deviceId, readedData->request.deviceId);
275     EXPECT_EQ(permissionUsedRequestParcel.request.bundleName, readedData->request.bundleName);
276     EXPECT_EQ(permissionUsedRequestParcel.request.beginTimeMillis, readedData->request.beginTimeMillis);
277     EXPECT_EQ(permissionUsedRequestParcel.request.endTimeMillis, readedData->request.endTimeMillis);
278     EXPECT_EQ(permissionUsedRequestParcel.request.flag, readedData->request.flag);
279 
280     for (uint32_t i = 0; i < permissionUsedRequestParcel.request.permissionList.size(); i++) {
281         EXPECT_EQ(permissionUsedRequestParcel.request.permissionList[i], readedData->request.permissionList[i]);
282     }
283 }
284 
285 /**
286  * @tc.name: PermissionUsedResultParcel001
287  * @tc.desc: Verify the PermissionUsedResultParcel Marshalling and Unmarshalling function.
288  * @tc.type: FUNC
289  * @tc.require: issueI5RWP4
290  */
291 HWTEST_F(PrivacyParcelTest, PermissionUsedResultParcel001, TestSize.Level1)
292 {
293     PermissionUsedResultParcel permissionUsedResultParcel;
294 
295     permissionUsedResultParcel.result = {
296         .beginTimeMillis = 0L,
297         .endTimeMillis = 0L,
298     };
299 
300     g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord1);
301     g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord2);
302     g_bundleUsedRecord2.permissionRecords.emplace_back(g_permissionRecord1);
303     g_bundleUsedRecord2.permissionRecords.emplace_back(g_permissionRecord2);
304 
305     permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1);
306     permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord2);
307 
308     Parcel parcel;
309     EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel));
310 
311     std::shared_ptr<PermissionUsedResultParcel> readedData(PermissionUsedResultParcel::Unmarshalling(parcel));
312     EXPECT_EQ(true, readedData != nullptr);
313 
314     EXPECT_EQ(permissionUsedResultParcel.result.beginTimeMillis, readedData->result.beginTimeMillis);
315     EXPECT_EQ(permissionUsedResultParcel.result.endTimeMillis, readedData->result.endTimeMillis);
316 }
317 
318 /**
319  * @tc.name: UsedRecordDetailParcel001
320  * @tc.desc: Verify the UsedRecordDetailParcel Marshalling and Unmarshalling function.
321  * @tc.type: FUNC
322  * @tc.require: issueI5RWP4
323  */
324 HWTEST_F(PrivacyParcelTest, UsedRecordDetailParcel001, TestSize.Level1)
325 {
326     UsedRecordDetailParcel usedRecordDetailParcel;
327 
328     usedRecordDetailParcel.detail = {
329         .status = 0,
330         .timestamp = 0L,
331         .accessDuration = 0L,
332         .count = 0,
333     };
334 
335     Parcel parcel;
336     EXPECT_EQ(true, usedRecordDetailParcel.Marshalling(parcel));
337 
338     std::shared_ptr<UsedRecordDetailParcel> readedData(UsedRecordDetailParcel::Unmarshalling(parcel));
339     EXPECT_EQ(true, readedData != nullptr);
340 
341     EXPECT_EQ(usedRecordDetailParcel.detail.status, readedData->detail.status);
342     EXPECT_EQ(usedRecordDetailParcel.detail.lockScreenStatus, readedData->detail.lockScreenStatus);
343     EXPECT_EQ(usedRecordDetailParcel.detail.timestamp, readedData->detail.timestamp);
344     EXPECT_EQ(usedRecordDetailParcel.detail.accessDuration, readedData->detail.accessDuration);
345     EXPECT_EQ(usedRecordDetailParcel.detail.count, readedData->detail.count);
346 }
347 
BundleUsedRecordData(Parcel & out,uint32_t size)348 void BundleUsedRecordData(Parcel& out, uint32_t size)
349 {
350     EXPECT_EQ(true, out.WriteUint32(100)); // 100: tokenid
351     EXPECT_EQ(true, out.WriteBool(false));
352     EXPECT_EQ(true, out.WriteString("device"));
353     EXPECT_EQ(true, out.WriteString("bundleName"));
354 
355     EXPECT_EQ(true, out.WriteUint32(size));
356 
357     g_permissionRecord1.accessRecords.emplace_back(g_accessRecord1);
358 
359     for (uint32_t i = 0; i < size; i++) {
360         PermissionUsedRecordParcel permRecordParcel;
361         permRecordParcel.permissionRecord = g_permissionRecord1;
362         out.WriteParcelable(&permRecordParcel);
363     }
364 }
365 
366 /**
367  * @tc.name: BundleUsedRecordParcel002
368  * @tc.desc: Test BundleUsedRecordParcel Marshalling/Unmarshalling.
369  * @tc.type: FUNC
370  * @tc.require: issueI5QKZF
371  */
372 HWTEST_F(PrivacyParcelTest, BundleUsedRecordParcel002, TestSize.Level1)
373 {
374     Parcel parcel;
375     BundleUsedRecordData(parcel, MAX_RECORD_SIZE);
376     std::shared_ptr<BundleUsedRecordParcel> readedData(BundleUsedRecordParcel::Unmarshalling(parcel));
377     EXPECT_EQ(true, readedData != nullptr);
378 
379     Parcel parcel1;
380     BundleUsedRecordData(parcel1, MAX_RECORD_SIZE + 1);
381     std::shared_ptr<BundleUsedRecordParcel> readedData1(BundleUsedRecordParcel::Unmarshalling(parcel1));
382     EXPECT_EQ(true, readedData1 == nullptr);
383 }
384 
DataMarshalling(Parcel & out,uint32_t accessSize,uint32_t rejectSize)385 void DataMarshalling(Parcel& out, uint32_t accessSize, uint32_t rejectSize)
386 {
387     UsedRecordDetail detailIns = {0, 0, 0L, 0L, 0};
388     EXPECT_EQ(true, out.WriteString("permissionName"));
389     EXPECT_EQ(true, out.WriteInt32(1));
390     EXPECT_EQ(true, out.WriteInt32(1));
391     EXPECT_EQ(true, out.WriteInt64(0L));
392     EXPECT_EQ(true, out.WriteInt64(0L));
393     EXPECT_EQ(true, out.WriteInt64(0L));
394 
395     EXPECT_EQ(true, out.WriteUint32(accessSize));
396     for (uint32_t i = 0; i < accessSize; i++) {
397         UsedRecordDetailParcel detailParcel;
398         detailParcel.detail = detailIns;
399         EXPECT_EQ(true, out.WriteParcelable(&detailParcel));
400     }
401 
402     EXPECT_EQ(true, out.WriteUint32(rejectSize));
403     for (uint32_t i = 0; i < rejectSize; i++) {
404         UsedRecordDetailParcel detailParcel;
405         detailParcel.detail = detailIns;
406         EXPECT_EQ(true, out.WriteParcelable(&detailParcel));
407     }
408 }
409 
410 /**
411  * @tc.name: PermissionUsedRecordParcel002
412  * @tc.desc: Test PermissionUsedRecordParcel Marshalling/Unmarshalling.
413  * @tc.type: FUNC
414  * @tc.require: issueI5QKZF
415  */
416 HWTEST_F(PrivacyParcelTest, PermissionUsedRecordParcel002, TestSize.Level1)
417 {
418     Parcel parcel;
419     DataMarshalling(parcel, MAX_ACCESS_RECORD_SIZE / 2, MAX_ACCESS_RECORD_SIZE / 2);
420     std::shared_ptr<PermissionUsedRecordParcel> readedData(PermissionUsedRecordParcel::Unmarshalling(parcel));
421     EXPECT_EQ(true, readedData != nullptr);
422 
423     Parcel parcel1;
424     DataMarshalling(parcel1, MAX_ACCESS_RECORD_SIZE / 2, MAX_ACCESS_RECORD_SIZE / 2 + 1);
425     std::shared_ptr<PermissionUsedRecordParcel> readedData1(PermissionUsedRecordParcel::Unmarshalling(parcel1));
426     EXPECT_EQ(true, readedData1 == nullptr);
427 
428     Parcel parcel2;
429     DataMarshalling(parcel2, MAX_ACCESS_RECORD_SIZE / 2 + 1, MAX_ACCESS_RECORD_SIZE / 2);
430     std::shared_ptr<PermissionUsedRecordParcel> readedData2(PermissionUsedRecordParcel::Unmarshalling(parcel2));
431     EXPECT_EQ(true, readedData2 == nullptr);
432 }
433 
434 /**
435  * @tc.name: PermissionUsedRequestParcel002
436  * @tc.desc: Verify the PermissionUsedRequestParcel Marshalling and Unmarshalling function.
437  * @tc.type: FUNC
438  * @tc.require: issueI5RUP1
439  */
440 HWTEST_F(PrivacyParcelTest, PermissionUsedRequestParcel002, TestSize.Level1)
441 {
442     PermissionUsedRequestParcel permissionUsedRequestParcel;
443 
444     permissionUsedRequestParcel.request = {
445         .tokenId = 100,
446         .isRemote = false,
447         .deviceId = "deviceId",
448         .bundleName = "com.ohos.permissionmanager",
449         .beginTimeMillis = 0L,
450         .endTimeMillis = 0L,
451         .flag = FLAG_PERMISSION_USAGE_SUMMARY,
452     };
453     for (uint32_t i = 0; i < MAX_PERMLIST_SIZE; i++) {
454         permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA");
455     }
456 
457     Parcel parcel;
458     EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel));
459     std::shared_ptr<PermissionUsedRequestParcel> readedData(PermissionUsedRequestParcel::Unmarshalling(parcel));
460     EXPECT_NE(readedData, nullptr);
461 
462     permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA");
463     Parcel parcel1;
464     EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel1));
465     std::shared_ptr<PermissionUsedRequestParcel> readedData1(PermissionUsedRequestParcel::Unmarshalling(parcel1));
466     EXPECT_EQ(readedData1, nullptr);
467 }
468 
469 /**
470  * @tc.name: PermissionUsedResultParcel002
471  * @tc.desc: Verify the PermissionUsedResultParcel Marshalling and Unmarshalling function.
472  * @tc.type: FUNC
473  * @tc.require: issueI5RWP4
474  */
475 HWTEST_F(PrivacyParcelTest, PermissionUsedResultParcel002, TestSize.Level1)
476 {
477     PermissionUsedResultParcel permissionUsedResultParcel;
478 
479     permissionUsedResultParcel.result = {
480         .beginTimeMillis = 0L,
481         .endTimeMillis = 0L,
482     };
483 
484     g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord1);
485     g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord2);
486 
487     for (uint32_t i = 0; i < 1024; i++) {
488         permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1);
489     }
490 
491     Parcel parcel;
492     EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel));
493     auto* resultParcel = new (std::nothrow) PermissionUsedResultParcel();
494     ASSERT_NE(resultParcel, nullptr);
495     EXPECT_EQ(true, parcel.ReadInt64(resultParcel->result.beginTimeMillis));
496     EXPECT_EQ(true, parcel.ReadInt64(resultParcel->result.endTimeMillis));
497     uint32_t bundResponseSize = 0;
498     EXPECT_EQ(true, parcel.ReadUint32(bundResponseSize));
499     EXPECT_EQ(true, bundResponseSize <= MAX_RECORD_SIZE);
500     EXPECT_EQ(true, resultParcel != nullptr);
501     delete resultParcel;
502     permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1);
503 
504     Parcel parcel1;
505     EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel1));
506     auto* resultParcel2 = new (std::nothrow) PermissionUsedResultParcel();
507     ASSERT_NE(resultParcel2, nullptr);
508     EXPECT_EQ(true, parcel1.ReadInt64(resultParcel2->result.beginTimeMillis));
509     EXPECT_EQ(true, parcel1.ReadInt64(resultParcel2->result.endTimeMillis));
510     uint32_t bundResponseSize1 = 0;
511     EXPECT_EQ(true, parcel1.ReadUint32(bundResponseSize1));
512     GTEST_LOG_(INFO) << "bundResponseSize1 :" << bundResponseSize1;
513     EXPECT_EQ(true, bundResponseSize1 > MAX_RECORD_SIZE);
514     delete resultParcel2;
515 
516     Parcel parcel2;
517     EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel2));
518     std::shared_ptr<PermissionUsedResultParcel> readedData1(PermissionUsedResultParcel::Unmarshalling(parcel2));
519     EXPECT_EQ(readedData1, nullptr);
520 }
521 } // namespace AccessToken
522 } // namespace Security
523 } // namespace OHOS
524