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 .callingTokenID = 100,
163 .tokenID = 100,
164 .permissionName = "ohos.permission.CAMERA",
165 .deviceId = "device",
166 .type = PERM_INACTIVE,
167 .usedType = NORMAL_TYPE,
168 .pid = -1,
169 };
170
171 Parcel parcel;
172 EXPECT_EQ(true, activeChangeResponseParcel.Marshalling(parcel));
173
174 std::shared_ptr<ActiveChangeResponseParcel> readedData(ActiveChangeResponseParcel::Unmarshalling(parcel));
175 EXPECT_EQ(true, readedData != nullptr);
176
177 EXPECT_EQ(activeChangeResponseParcel.changeResponse.callingTokenID, readedData->changeResponse.callingTokenID);
178 EXPECT_EQ(activeChangeResponseParcel.changeResponse.tokenID, readedData->changeResponse.tokenID);
179 EXPECT_EQ(activeChangeResponseParcel.changeResponse.permissionName, readedData->changeResponse.permissionName);
180 EXPECT_EQ(activeChangeResponseParcel.changeResponse.deviceId, readedData->changeResponse.deviceId);
181 EXPECT_EQ(activeChangeResponseParcel.changeResponse.type, readedData->changeResponse.type);
182 EXPECT_EQ(activeChangeResponseParcel.changeResponse.usedType, readedData->changeResponse.usedType);
183 EXPECT_EQ(activeChangeResponseParcel.changeResponse.pid, readedData->changeResponse.pid);
184 }
185
186 /**
187 * @tc.name: PermissionUsedRecordParcel001
188 * @tc.desc: Verify the PermissionUsedRecordParcel Marshalling and Unmarshalling function.
189 * @tc.type: FUNC
190 * @tc.require: issueI5RUCC
191 */
192 HWTEST_F(PrivacyParcelTest, PermissionUsedRecordParcel001, TestSize.Level1)
193 {
194 PermissionUsedRecordParcel permissionUsedRecordParcel;
195
196 permissionUsedRecordParcel.permissionRecord = {
197 .permissionName = "ohos.permission.CAMERA",
198 .accessCount = 2,
199 .rejectCount = 2,
200 .lastAccessTime = 0L,
201 .lastRejectTime = 0L,
202 .lastAccessDuration = 0L,
203 };
204 permissionUsedRecordParcel.permissionRecord.accessRecords.emplace_back(g_accessRecord1);
205 permissionUsedRecordParcel.permissionRecord.accessRecords.emplace_back(g_accessRecord2);
206 permissionUsedRecordParcel.permissionRecord.rejectRecords.emplace_back(g_rejectRecord1);
207 permissionUsedRecordParcel.permissionRecord.rejectRecords.emplace_back(g_rejectRecord2);
208
209 Parcel parcel;
210 EXPECT_EQ(true, permissionUsedRecordParcel.Marshalling(parcel));
211
212 std::shared_ptr<PermissionUsedRecordParcel> readedData(PermissionUsedRecordParcel::Unmarshalling(parcel));
213 EXPECT_EQ(true, readedData != nullptr);
214
215 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.permissionName, readedData->permissionRecord.permissionName);
216 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessCount, readedData->permissionRecord.accessCount);
217 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectCount, readedData->permissionRecord.rejectCount);
218 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.lastAccessTime, readedData->permissionRecord.lastAccessTime);
219 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.lastRejectTime, readedData->permissionRecord.lastRejectTime);
220 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.lastAccessDuration,
221 readedData->permissionRecord.lastAccessDuration);
222
223 for (uint32_t i = 0; i < permissionUsedRecordParcel.permissionRecord.accessRecords.size(); i++) {
224 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].status,
225 readedData->permissionRecord.accessRecords[i].status);
226 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].lockScreenStatus,
227 readedData->permissionRecord.accessRecords[i].lockScreenStatus);
228 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].timestamp,
229 readedData->permissionRecord.accessRecords[i].timestamp);
230 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].accessDuration,
231 readedData->permissionRecord.accessRecords[i].accessDuration);
232 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.accessRecords[i].count,
233 readedData->permissionRecord.accessRecords[i].count);
234 }
235
236 for (uint32_t i = 0; i < permissionUsedRecordParcel.permissionRecord.rejectRecords.size(); i++) {
237 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].status,
238 readedData->permissionRecord.rejectRecords[i].status);
239 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].lockScreenStatus,
240 readedData->permissionRecord.rejectRecords[i].lockScreenStatus);
241 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].timestamp,
242 readedData->permissionRecord.rejectRecords[i].timestamp);
243 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].accessDuration,
244 readedData->permissionRecord.rejectRecords[i].accessDuration);
245 EXPECT_EQ(permissionUsedRecordParcel.permissionRecord.rejectRecords[i].count,
246 readedData->permissionRecord.rejectRecords[i].count);
247 }
248 }
249
250 /**
251 * @tc.name: PermissionUsedRequestParcel001
252 * @tc.desc: Verify the PermissionUsedRequestParcel Marshalling and Unmarshalling function.
253 * @tc.type: FUNC
254 * @tc.require: issueI5RUP1
255 */
256 HWTEST_F(PrivacyParcelTest, PermissionUsedRequestParcel001, TestSize.Level1)
257 {
258 PermissionUsedRequestParcel permissionUsedRequestParcel;
259
260 permissionUsedRequestParcel.request = {
261 .tokenId = 100,
262 .isRemote = false,
263 .deviceId = "you guess",
264 .bundleName = "com.ohos.permissionmanager",
265 .beginTimeMillis = 0L,
266 .endTimeMillis = 0L,
267 .flag = FLAG_PERMISSION_USAGE_SUMMARY,
268 };
269 permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA");
270 permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.LOCATION");
271
272 Parcel parcel;
273 EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel));
274
275 std::shared_ptr<PermissionUsedRequestParcel> readedData(PermissionUsedRequestParcel::Unmarshalling(parcel));
276 EXPECT_EQ(true, readedData != nullptr);
277
278 EXPECT_EQ(permissionUsedRequestParcel.request.tokenId, readedData->request.tokenId);
279 EXPECT_EQ(permissionUsedRequestParcel.request.isRemote, readedData->request.isRemote);
280 EXPECT_EQ(permissionUsedRequestParcel.request.deviceId, readedData->request.deviceId);
281 EXPECT_EQ(permissionUsedRequestParcel.request.bundleName, readedData->request.bundleName);
282 EXPECT_EQ(permissionUsedRequestParcel.request.beginTimeMillis, readedData->request.beginTimeMillis);
283 EXPECT_EQ(permissionUsedRequestParcel.request.endTimeMillis, readedData->request.endTimeMillis);
284 EXPECT_EQ(permissionUsedRequestParcel.request.flag, readedData->request.flag);
285
286 for (uint32_t i = 0; i < permissionUsedRequestParcel.request.permissionList.size(); i++) {
287 EXPECT_EQ(permissionUsedRequestParcel.request.permissionList[i], readedData->request.permissionList[i]);
288 }
289 }
290
291 /**
292 * @tc.name: PermissionUsedResultParcel001
293 * @tc.desc: Verify the PermissionUsedResultParcel Marshalling and Unmarshalling function.
294 * @tc.type: FUNC
295 * @tc.require: issueI5RWP4
296 */
297 HWTEST_F(PrivacyParcelTest, PermissionUsedResultParcel001, TestSize.Level1)
298 {
299 PermissionUsedResultParcel permissionUsedResultParcel;
300
301 permissionUsedResultParcel.result = {
302 .beginTimeMillis = 0L,
303 .endTimeMillis = 0L,
304 };
305
306 g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord1);
307 g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord2);
308 g_bundleUsedRecord2.permissionRecords.emplace_back(g_permissionRecord1);
309 g_bundleUsedRecord2.permissionRecords.emplace_back(g_permissionRecord2);
310
311 permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1);
312 permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord2);
313
314 Parcel parcel;
315 EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel));
316
317 std::shared_ptr<PermissionUsedResultParcel> readedData(PermissionUsedResultParcel::Unmarshalling(parcel));
318 EXPECT_EQ(true, readedData != nullptr);
319
320 EXPECT_EQ(permissionUsedResultParcel.result.beginTimeMillis, readedData->result.beginTimeMillis);
321 EXPECT_EQ(permissionUsedResultParcel.result.endTimeMillis, readedData->result.endTimeMillis);
322 }
323
324 /**
325 * @tc.name: UsedRecordDetailParcel001
326 * @tc.desc: Verify the UsedRecordDetailParcel Marshalling and Unmarshalling function.
327 * @tc.type: FUNC
328 * @tc.require: issueI5RWP4
329 */
330 HWTEST_F(PrivacyParcelTest, UsedRecordDetailParcel001, TestSize.Level1)
331 {
332 UsedRecordDetailParcel usedRecordDetailParcel;
333
334 usedRecordDetailParcel.detail = {
335 .status = 0,
336 .timestamp = 0L,
337 .accessDuration = 0L,
338 .count = 0,
339 };
340
341 Parcel parcel;
342 EXPECT_EQ(true, usedRecordDetailParcel.Marshalling(parcel));
343
344 std::shared_ptr<UsedRecordDetailParcel> readedData(UsedRecordDetailParcel::Unmarshalling(parcel));
345 EXPECT_EQ(true, readedData != nullptr);
346
347 EXPECT_EQ(usedRecordDetailParcel.detail.status, readedData->detail.status);
348 EXPECT_EQ(usedRecordDetailParcel.detail.lockScreenStatus, readedData->detail.lockScreenStatus);
349 EXPECT_EQ(usedRecordDetailParcel.detail.timestamp, readedData->detail.timestamp);
350 EXPECT_EQ(usedRecordDetailParcel.detail.accessDuration, readedData->detail.accessDuration);
351 EXPECT_EQ(usedRecordDetailParcel.detail.count, readedData->detail.count);
352 }
353
BundleUsedRecordData(Parcel & out,uint32_t size)354 void BundleUsedRecordData(Parcel& out, uint32_t size)
355 {
356 EXPECT_EQ(true, out.WriteUint32(100)); // 100: tokenid
357 EXPECT_EQ(true, out.WriteBool(false));
358 EXPECT_EQ(true, out.WriteString("device"));
359 EXPECT_EQ(true, out.WriteString("bundleName"));
360
361 EXPECT_EQ(true, out.WriteUint32(size));
362
363 g_permissionRecord1.accessRecords.emplace_back(g_accessRecord1);
364
365 for (uint32_t i = 0; i < size; i++) {
366 PermissionUsedRecordParcel permRecordParcel;
367 permRecordParcel.permissionRecord = g_permissionRecord1;
368 out.WriteParcelable(&permRecordParcel);
369 }
370 }
371
372 /**
373 * @tc.name: BundleUsedRecordParcel002
374 * @tc.desc: Test BundleUsedRecordParcel Marshalling/Unmarshalling.
375 * @tc.type: FUNC
376 * @tc.require: issueI5QKZF
377 */
378 HWTEST_F(PrivacyParcelTest, BundleUsedRecordParcel002, TestSize.Level1)
379 {
380 Parcel parcel;
381 BundleUsedRecordData(parcel, MAX_RECORD_SIZE);
382 std::shared_ptr<BundleUsedRecordParcel> readedData(BundleUsedRecordParcel::Unmarshalling(parcel));
383 EXPECT_EQ(true, readedData != nullptr);
384
385 Parcel parcel1;
386 BundleUsedRecordData(parcel1, MAX_RECORD_SIZE + 1);
387 std::shared_ptr<BundleUsedRecordParcel> readedData1(BundleUsedRecordParcel::Unmarshalling(parcel1));
388 EXPECT_EQ(true, readedData1 == nullptr);
389 }
390
DataMarshalling(Parcel & out,uint32_t accessSize,uint32_t rejectSize)391 void DataMarshalling(Parcel& out, uint32_t accessSize, uint32_t rejectSize)
392 {
393 UsedRecordDetail detailIns = {0, 0, 0L, 0L, 0};
394 EXPECT_EQ(true, out.WriteString("permissionName"));
395 EXPECT_EQ(true, out.WriteInt32(1));
396 EXPECT_EQ(true, out.WriteInt32(0));
397 EXPECT_EQ(true, out.WriteInt32(1));
398 EXPECT_EQ(true, out.WriteInt64(0L));
399 EXPECT_EQ(true, out.WriteInt64(0L));
400 EXPECT_EQ(true, out.WriteInt64(0L));
401
402 EXPECT_EQ(true, out.WriteUint32(accessSize));
403 for (uint32_t i = 0; i < accessSize; i++) {
404 UsedRecordDetailParcel detailParcel;
405 detailParcel.detail = detailIns;
406 EXPECT_EQ(true, out.WriteParcelable(&detailParcel));
407 }
408
409 EXPECT_EQ(true, out.WriteUint32(rejectSize));
410 for (uint32_t i = 0; i < rejectSize; i++) {
411 UsedRecordDetailParcel detailParcel;
412 detailParcel.detail = detailIns;
413 EXPECT_EQ(true, out.WriteParcelable(&detailParcel));
414 }
415 }
416
417 /**
418 * @tc.name: PermissionUsedRecordParcel002
419 * @tc.desc: Test PermissionUsedRecordParcel Marshalling/Unmarshalling.
420 * @tc.type: FUNC
421 * @tc.require: issueI5QKZF
422 */
423 HWTEST_F(PrivacyParcelTest, PermissionUsedRecordParcel002, TestSize.Level1)
424 {
425 Parcel parcel;
426 DataMarshalling(parcel, MAX_ACCESS_RECORD_SIZE / 2, MAX_ACCESS_RECORD_SIZE / 2);
427 std::shared_ptr<PermissionUsedRecordParcel> readedData(PermissionUsedRecordParcel::Unmarshalling(parcel));
428 EXPECT_EQ(true, readedData != nullptr);
429
430 Parcel parcel1;
431 DataMarshalling(parcel1, MAX_ACCESS_RECORD_SIZE / 2, MAX_ACCESS_RECORD_SIZE / 2 + 1);
432 std::shared_ptr<PermissionUsedRecordParcel> readedData1(PermissionUsedRecordParcel::Unmarshalling(parcel1));
433 EXPECT_EQ(true, readedData1 == nullptr);
434
435 Parcel parcel2;
436 DataMarshalling(parcel2, MAX_ACCESS_RECORD_SIZE / 2 + 1, MAX_ACCESS_RECORD_SIZE / 2);
437 std::shared_ptr<PermissionUsedRecordParcel> readedData2(PermissionUsedRecordParcel::Unmarshalling(parcel2));
438 EXPECT_EQ(true, readedData2 == nullptr);
439 }
440
441 /**
442 * @tc.name: PermissionUsedRequestParcel002
443 * @tc.desc: Verify the PermissionUsedRequestParcel Marshalling and Unmarshalling function.
444 * @tc.type: FUNC
445 * @tc.require: issueI5RUP1
446 */
447 HWTEST_F(PrivacyParcelTest, PermissionUsedRequestParcel002, TestSize.Level1)
448 {
449 PermissionUsedRequestParcel permissionUsedRequestParcel;
450
451 permissionUsedRequestParcel.request = {
452 .tokenId = 100,
453 .isRemote = false,
454 .deviceId = "deviceId",
455 .bundleName = "com.ohos.permissionmanager",
456 .beginTimeMillis = 0L,
457 .endTimeMillis = 0L,
458 .flag = FLAG_PERMISSION_USAGE_SUMMARY,
459 };
460 for (uint32_t i = 0; i < MAX_PERMLIST_SIZE; i++) {
461 permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA");
462 }
463
464 Parcel parcel;
465 EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel));
466 std::shared_ptr<PermissionUsedRequestParcel> readedData(PermissionUsedRequestParcel::Unmarshalling(parcel));
467 EXPECT_NE(readedData, nullptr);
468
469 permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA");
470 Parcel parcel1;
471 EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel1));
472 std::shared_ptr<PermissionUsedRequestParcel> readedData1(PermissionUsedRequestParcel::Unmarshalling(parcel1));
473 EXPECT_EQ(readedData1, nullptr);
474 }
475
476 /**
477 * @tc.name: PermissionUsedResultParcel002
478 * @tc.desc: Verify the PermissionUsedResultParcel Marshalling and Unmarshalling function.
479 * @tc.type: FUNC
480 * @tc.require: issueI5RWP4
481 */
482 HWTEST_F(PrivacyParcelTest, PermissionUsedResultParcel002, TestSize.Level1)
483 {
484 PermissionUsedResultParcel permissionUsedResultParcel;
485
486 permissionUsedResultParcel.result = {
487 .beginTimeMillis = 0L,
488 .endTimeMillis = 0L,
489 };
490
491 g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord1);
492 g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord2);
493
494 for (uint32_t i = 0; i < 1024; i++) {
495 permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1);
496 }
497
498 Parcel parcel;
499 EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel));
500 auto* resultParcel = new (std::nothrow) PermissionUsedResultParcel();
501 ASSERT_NE(resultParcel, nullptr);
502 EXPECT_EQ(true, parcel.ReadInt64(resultParcel->result.beginTimeMillis));
503 EXPECT_EQ(true, parcel.ReadInt64(resultParcel->result.endTimeMillis));
504 uint32_t bundResponseSize = 0;
505 EXPECT_EQ(true, parcel.ReadUint32(bundResponseSize));
506 EXPECT_EQ(true, bundResponseSize <= MAX_RECORD_SIZE);
507 EXPECT_EQ(true, resultParcel != nullptr);
508 delete resultParcel;
509 permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1);
510
511 Parcel parcel1;
512 EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel1));
513 auto* resultParcel2 = new (std::nothrow) PermissionUsedResultParcel();
514 ASSERT_NE(resultParcel2, nullptr);
515 EXPECT_EQ(true, parcel1.ReadInt64(resultParcel2->result.beginTimeMillis));
516 EXPECT_EQ(true, parcel1.ReadInt64(resultParcel2->result.endTimeMillis));
517 uint32_t bundResponseSize1 = 0;
518 EXPECT_EQ(true, parcel1.ReadUint32(bundResponseSize1));
519 GTEST_LOG_(INFO) << "bundResponseSize1 :" << bundResponseSize1;
520 EXPECT_EQ(true, bundResponseSize1 > MAX_RECORD_SIZE);
521 delete resultParcel2;
522
523 Parcel parcel2;
524 EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel2));
525 std::shared_ptr<PermissionUsedResultParcel> readedData1(PermissionUsedResultParcel::Unmarshalling(parcel2));
526 EXPECT_EQ(readedData1, nullptr);
527 }
528 } // namespace AccessToken
529 } // namespace Security
530 } // namespace OHOS
531