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 "access_token.h"
21 #include "atm_tools_param_info_parcel.h"
22 #include "hap_info_parcel.h"
23 #include "hap_policy_parcel.h"
24 #include "hap_token_info_parcel.h"
25 #include "hap_token_info_for_sync_parcel.h"
26 #include "native_token_info_for_sync_parcel.h"
27 #include "native_token_info_parcel.h"
28 #include "parcel.h"
29 #include "parcel_utils.h"
30 #include "permission_grant_info_parcel.h"
31 #include "permission_state_change_scope_parcel.h"
32 #include "permission_state_change_info_parcel.h"
33 #include "permission_state_full.h"
34 #include "permission_state_full_parcel.h"
35 
36 using namespace testing::ext;
37 
38 namespace OHOS {
39 namespace Security {
40 namespace AccessToken {
41 namespace {
42 static constexpr int32_t DEFAULT_API_VERSION = 8;
43 static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA";
44 static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA";
45 static constexpr AccessTokenID TEST_TOKEN_ID = 10002;
46 static constexpr int32_t TEST_PERMSTATE_CHANGE_TYPE = 10001;
47 
48 PermissionDef g_permDefAlpha = {
49     .permissionName = TEST_PERMISSION_NAME_ALPHA,
50     .bundleName = "accesstoken_test",
51     .grantMode = 1,
52     .availableLevel = APL_NORMAL,
53     .label = "label",
54     .labelId = 1,
55     .description = "annoying",
56     .descriptionId = 1
57 };
58 PermissionDef g_permDefBeta = {
59     .permissionName = TEST_PERMISSION_NAME_BETA,
60     .bundleName = "accesstoken_test",
61     .grantMode = 1,
62     .availableLevel = APL_NORMAL,
63     .label = "label",
64     .labelId = 1,
65     .description = "so trouble",
66     .descriptionId = 1
67 };
68 
69 PermissionStateFull g_permStatAlpha = {
70     .permissionName = TEST_PERMISSION_NAME_ALPHA,
71     .isGeneral = true,
72     .resDeviceID = {"device"},
73     .grantStatus = {PermissionState::PERMISSION_DENIED},
74     .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
75 };
76 PermissionStateFull g_permStatBeta = {
77     .permissionName = TEST_PERMISSION_NAME_BETA,
78     .isGeneral = true,
79     .resDeviceID = {"device"},
80     .grantStatus = {PermissionState::PERMISSION_GRANTED},
81     .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
82 };
83 }
84 class AccessTokenParcelTest : public testing::Test  {
85 public:
86     static void SetUpTestCase(void);
87     static void TearDownTestCase(void);
88     void SetUp();
89     void TearDown();
90 };
91 
SetUpTestCase(void)92 void AccessTokenParcelTest::SetUpTestCase(void) {}
TearDownTestCase(void)93 void AccessTokenParcelTest::TearDownTestCase(void) {}
SetUp(void)94 void AccessTokenParcelTest::SetUp(void) {}
TearDown(void)95 void AccessTokenParcelTest::TearDown(void) {}
96 
97 /**
98  * @tc.name: HapInfoParcel001
99  * @tc.desc: Test HapInfo Marshalling/Unmarshalling.
100  * @tc.type: FUNC
101  * @tc.require: issueI5QKZF
102  */
103 HWTEST_F(AccessTokenParcelTest, HapInfoParcel001, TestSize.Level1)
104 {
105     HapInfoParcel hapinfoParcel;
106     hapinfoParcel.hapInfoParameter = {
107         .userID = 1,
108         .bundleName = "accesstoken_test",
109         .instIndex = 0,
110         .appIDDesc = "testtesttesttest",
111         .apiVersion = DEFAULT_API_VERSION,
112         .isSystemApp = false,
113     };
114 
115     Parcel parcel;
116     EXPECT_EQ(true, hapinfoParcel.Marshalling(parcel));
117 
118     std::shared_ptr<HapInfoParcel> readedData(HapInfoParcel::Unmarshalling(parcel));
119     EXPECT_NE(nullptr, readedData);
120 
121     EXPECT_EQ(hapinfoParcel.hapInfoParameter.userID, readedData->hapInfoParameter.userID);
122     EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.bundleName == readedData->hapInfoParameter.bundleName);
123     EXPECT_EQ(hapinfoParcel.hapInfoParameter.instIndex, readedData->hapInfoParameter.instIndex);
124     EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.appIDDesc == readedData->hapInfoParameter.appIDDesc);
125     EXPECT_EQ(hapinfoParcel.hapInfoParameter.apiVersion, readedData->hapInfoParameter.apiVersion);
126     EXPECT_EQ(hapinfoParcel.hapInfoParameter.isSystemApp, readedData->hapInfoParameter.isSystemApp);
127 }
128 
129 /**
130  * @tc.name: HapPolicyParcel001
131  * @tc.desc: Test HapPolicy Marshalling/Unmarshalling.
132  * @tc.type: FUNC
133  * @tc.require: issueI5QKZF
134  */
135 HWTEST_F(AccessTokenParcelTest, HapPolicyParcel001, TestSize.Level1)
136 {
137     HapPolicyParcel hapPolicyParcel;
138 
139     hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
140     hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
141     hapPolicyParcel.hapPolicyParameter.permList.emplace_back(g_permDefAlpha);
142     hapPolicyParcel.hapPolicyParameter.permList.emplace_back(g_permDefBeta);
143     hapPolicyParcel.hapPolicyParameter.permStateList.emplace_back(g_permStatAlpha);
144     hapPolicyParcel.hapPolicyParameter.permStateList.emplace_back(g_permStatBeta);
145 
146     Parcel parcel;
147     EXPECT_EQ(true, hapPolicyParcel.Marshalling(parcel));
148 
149     std::shared_ptr<HapPolicyParcel> readedData(HapPolicyParcel::Unmarshalling(parcel));
150     EXPECT_NE(nullptr, readedData);
151 
152     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.apl, readedData->hapPolicyParameter.apl);
153     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.domain, readedData->hapPolicyParameter.domain);
154     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList.size(), readedData->hapPolicyParameter.permList.size());
155     EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList.size(),
156         readedData->hapPolicyParameter.permStateList.size());
157 
158     for (uint32_t i = 0; i < hapPolicyParcel.hapPolicyParameter.permList.size(); i++) {
159         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].permissionName,
160             readedData->hapPolicyParameter.permList[i].permissionName);
161         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].bundleName,
162             readedData->hapPolicyParameter.permList[i].bundleName);
163         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].grantMode,
164             readedData->hapPolicyParameter.permList[i].grantMode);
165         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].availableLevel,
166             readedData->hapPolicyParameter.permList[i].availableLevel);
167         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].label,
168             readedData->hapPolicyParameter.permList[i].label);
169         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].labelId,
170             readedData->hapPolicyParameter.permList[i].labelId);
171         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].description,
172             readedData->hapPolicyParameter.permList[i].description);
173         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permList[i].descriptionId,
174             readedData->hapPolicyParameter.permList[i].descriptionId);
175     }
176 
177     for (uint32_t i = 0; i < hapPolicyParcel.hapPolicyParameter.permStateList.size(); i++) {
178         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].permissionName,
179             readedData->hapPolicyParameter.permStateList[i].permissionName);
180         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].isGeneral,
181             readedData->hapPolicyParameter.permStateList[i].isGeneral);
182         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].resDeviceID,
183             readedData->hapPolicyParameter.permStateList[i].resDeviceID);
184         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].grantStatus,
185             readedData->hapPolicyParameter.permStateList[i].grantStatus);
186         EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].grantFlags,
187             readedData->hapPolicyParameter.permStateList[i].grantFlags);
188     }
189 }
190 
191 /**
192  * @tc.name: PermissionStateChangeInfoParcel001
193  * @tc.desc: Test PermissionStateChangeInfo Marshalling/Unmarshalling.
194  * @tc.type: FUNC
195  * @tc.require: issueI5QKZF
196  */
197 HWTEST_F(AccessTokenParcelTest, PermissionStateChangeInfoParcel001, TestSize.Level1)
198 {
199     PermissionStateChangeInfoParcel permissionStateParcel;
200     permissionStateParcel.changeInfo.permStateChangeType = TEST_PERMSTATE_CHANGE_TYPE;
201     permissionStateParcel.changeInfo.tokenID = TEST_TOKEN_ID;
202     permissionStateParcel.changeInfo.permissionName = TEST_PERMISSION_NAME_ALPHA;
203 
204     Parcel parcel;
205     EXPECT_EQ(true, permissionStateParcel.Marshalling(parcel));
206 
207     std::shared_ptr<PermissionStateChangeInfoParcel> readedData(PermissionStateChangeInfoParcel::Unmarshalling(parcel));
208     EXPECT_NE(nullptr, readedData);
209     EXPECT_EQ(permissionStateParcel.changeInfo.permStateChangeType, readedData->changeInfo.permStateChangeType);
210     EXPECT_EQ(permissionStateParcel.changeInfo.tokenID, readedData->changeInfo.tokenID);
211     EXPECT_EQ(permissionStateParcel.changeInfo.permissionName, readedData->changeInfo.permissionName);
212 }
213 
214 /**
215  * @tc.name: PermStateChangeScopeParcel001
216  * @tc.desc: Test PermStateChangeScope Marshalling/Unmarshalling.
217  * @tc.type: FUNC
218  * @tc.require: issueI5QKZF
219  */
220 HWTEST_F(AccessTokenParcelTest, PermStateChangeScopeParcel001, TestSize.Level1)
221 {
222     PermStateChangeScopeParcel permStateChangeScopeParcel;
223     permStateChangeScopeParcel.scope.tokenIDs.emplace_back(TEST_TOKEN_ID);
224     permStateChangeScopeParcel.scope.permList.emplace_back(TEST_PERMISSION_NAME_ALPHA);
225 
226     Parcel parcel;
227     EXPECT_EQ(true, permStateChangeScopeParcel.Marshalling(parcel));
228 
229     std::shared_ptr<PermStateChangeScopeParcel> readedData(PermStateChangeScopeParcel::Unmarshalling(parcel));
230     EXPECT_NE(nullptr, readedData);
231 
232     EXPECT_EQ(true,  permStateChangeScopeParcel.scope.tokenIDs.size() == readedData->scope.tokenIDs.size());
233     EXPECT_EQ(true,  permStateChangeScopeParcel.scope.permList.size() == readedData->scope.permList.size());
234 
235     for (uint32_t i = 0; i < readedData->scope.tokenIDs.size(); i++) {
236         EXPECT_EQ(permStateChangeScopeParcel.scope.tokenIDs[i], readedData->scope.tokenIDs[i]);
237     }
238     for (uint32_t i = 0; i < readedData->scope.permList.size(); i++) {
239         EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList[i] == readedData->scope.permList[i]);
240     }
241 }
242 
243 /**
244  * @tc.name: HapTokenInfoForSyncParcel001
245  * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
246  * @tc.type: FUNC
247  * @tc.require: issueI5QKZF
248  */
249 HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel001, TestSize.Level1)
250 {
251     HapTokenInfoForSyncParcel hapTokenInfoSync;
252 
253     HapTokenInfo hapTokenInfo;
254     hapTokenInfo.apl = ATokenAplEnum::APL_NORMAL;
255     hapTokenInfo.ver = 0;
256     hapTokenInfo.userID = 2;
257     hapTokenInfo.bundleName = "bundle1";
258     hapTokenInfo.apiVersion = 8;
259     hapTokenInfo.instIndex = 0;
260     hapTokenInfo.dlpType = 0;
261     hapTokenInfo.appID = "test1";
262     hapTokenInfo.deviceID = "0";
263     hapTokenInfo.tokenID = 0x53100000;
264     hapTokenInfo.tokenAttr = 0;
265     hapTokenInfoSync.hapTokenInfoForSyncParams.baseInfo = hapTokenInfo;
266     hapTokenInfoSync.hapTokenInfoForSyncParams.permStateList.emplace_back(g_permStatBeta);
267 
268     Parcel parcel;
269     EXPECT_EQ(true, hapTokenInfoSync.Marshalling(parcel));
270     std::shared_ptr<HapTokenInfoForSyncParcel> readedData(HapTokenInfoForSyncParcel::Unmarshalling(parcel));
271     EXPECT_NE(nullptr, readedData);
272 }
273 
WriteParcelable(Parcel & out,const Parcelable & baseInfoParcel,uint32_t size)274 static void WriteParcelable(
275     Parcel& out, const Parcelable& baseInfoParcel, uint32_t size)
276 {
277     out.WriteParcelable(&baseInfoParcel);
278     std::vector<PermissionStateFull> permStateList;
279     for (uint32_t i = 0; i < size; i++) {
280         permStateList.emplace_back(g_permStatBeta);
281     }
282     uint32_t permStateListSize = permStateList.size();
283     out.WriteUint32(permStateListSize);
284     for (uint32_t i = 0; i < permStateListSize; i++) {
285         PermissionStateFullParcel permStateParcel;
286         permStateParcel.permStatFull = permStateList[i];
287         out.WriteParcelable(&permStateParcel);
288     }
289 
290     out.WriteParcelable(&baseInfoParcel);
291     permStateList.emplace_back(g_permStatBeta);
292 
293     permStateListSize = permStateList.size();
294     out.WriteUint32(permStateListSize);
295     for (uint32_t i = 0; i < permStateListSize; i++) {
296         PermissionStateFullParcel permStateParcel;
297         permStateParcel.permStatFull = permStateList[i];
298         out.WriteParcelable(&permStateParcel);
299     }
300 }
301 
302 /**
303  * @tc.name: HapTokenInfoForSyncParcel002
304  * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
305  * @tc.type: FUNC
306  * @tc.require: issueI5QKZF
307  */
308 HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel002, TestSize.Level1)
309 {
310     HapTokenInfoForSyncParcel hapTokenInfoSync;
311 
312     HapTokenInfo hapTokenInfo;
313     hapTokenInfo.apl = ATokenAplEnum::APL_NORMAL;
314     hapTokenInfo.ver = 0;
315     hapTokenInfo.userID = 2;
316     hapTokenInfo.bundleName = "bundle2";
317     hapTokenInfo.apiVersion = 8;
318     hapTokenInfo.instIndex = 0;
319     hapTokenInfo.dlpType = 0;
320     hapTokenInfo.appID = "test2";
321     hapTokenInfo.deviceID = "0";
322     hapTokenInfo.tokenID = 0x53100000;
323     hapTokenInfo.tokenAttr = 0;
324 
325     Parcel out;
326     HapTokenInfoParcel baseInfoParcel;
327     baseInfoParcel.hapTokenInfoParams = hapTokenInfo;
328     WriteParcelable(out, baseInfoParcel, MAX_PERMLIST_SIZE);
329 
330     std::shared_ptr<HapTokenInfoForSyncParcel> readedData(HapTokenInfoForSyncParcel::Unmarshalling(out));
331     EXPECT_NE(nullptr, readedData);
332 
333     Parcel out1;
334     WriteParcelable(out, baseInfoParcel, MAX_PERMLIST_SIZE + 1);
335     std::shared_ptr<HapTokenInfoForSyncParcel> readedData1(HapTokenInfoForSyncParcel::Unmarshalling(out1));
336     EXPECT_EQ(true, readedData1 == nullptr);
337 }
338 
339 /**
340  * @tc.name: NativeTokenInfoForSyncParcel001
341  * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
342  * @tc.type: FUNC
343  * @tc.require: issueI5QKZF
344  */
345 HWTEST_F(AccessTokenParcelTest, NativeTokenInfoForSyncParcel001, TestSize.Level1)
346 {
347     NativeTokenInfoForSyncParcel nativeTokenInfoSync;
348 
349     NativeTokenInfo baseInfo;
350     baseInfo.apl = APL_NORMAL,
351     baseInfo.ver = 1,
352     baseInfo.processName = "native_token_test1",
353     baseInfo.tokenID = 0x28100000, // 0x28100000 tokenid
354     baseInfo.tokenAttr = 0,
355     baseInfo.dcap =  {"AT_CAP", "ST_CAP"};
356     baseInfo.nativeAcls = {"ohos.permission.LOCATION"};
357 
358     Parcel out;
359     NativeTokenInfoParcel baseInfoParcel;
360     baseInfoParcel.nativeTokenInfoParams = baseInfo;
361     WriteParcelable(out, baseInfoParcel, MAX_PERMLIST_SIZE);
362 
363     std::shared_ptr<NativeTokenInfoForSyncParcel> readedData(NativeTokenInfoForSyncParcel::Unmarshalling(out));
364     EXPECT_NE(nullptr, readedData);
365 
366     Parcel outInvalid;
367     WriteParcelable(outInvalid, baseInfoParcel, MAX_PERMLIST_SIZE + 1);
368     std::shared_ptr<NativeTokenInfoForSyncParcel> readedData1(NativeTokenInfoForSyncParcel::Unmarshalling(outInvalid));
369     EXPECT_EQ(true, readedData1 == nullptr);
370 }
371 
372 /**
373  * @tc.name: NativeTokenInfoForSyncParcel002
374  * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
375  * @tc.type: FUNC
376  * @tc.require: issueI5QKZF
377  */
378 HWTEST_F(AccessTokenParcelTest, NativeTokenInfoForSyncParcel002, TestSize.Level1)
379 {
380     NativeTokenInfoForSyncParcel nativeTokenInfoSync;
381 
382     NativeTokenInfo baseInfo;
383     baseInfo.apl = APL_NORMAL,
384     baseInfo.ver = 1,
385     baseInfo.processName = "native_token_test2",
386     baseInfo.tokenID = 0x28100000, // 0x28100000 tokenid
387     baseInfo.tokenAttr = 0,
388     baseInfo.dcap =  {"AT_CAP", "ST_CAP"};
389     baseInfo.nativeAcls = {"ohos.permission.LOCATION"};
390 
391     nativeTokenInfoSync.nativeTokenInfoForSyncParams.baseInfo = baseInfo;
392     nativeTokenInfoSync.nativeTokenInfoForSyncParams.permStateList.emplace_back(g_permStatBeta);
393 
394     Parcel parcel;
395     EXPECT_EQ(true, nativeTokenInfoSync.Marshalling(parcel));
396     std::shared_ptr<NativeTokenInfoForSyncParcel> readedData(NativeTokenInfoForSyncParcel::Unmarshalling(parcel));
397     EXPECT_NE(nullptr, readedData);
398 }
399 
PutData(Parcel & out,uint32_t deviceSize,uint32_t statusSize,uint32_t flagSize)400 static void PutData(Parcel& out, uint32_t deviceSize, uint32_t statusSize, uint32_t flagSize)
401 {
402     out.WriteString("ohos.permission.LOCATION");
403     out.WriteBool(true);
404     out.WriteUint32(deviceSize);
405     for (uint32_t i = 0; i < deviceSize; i++) {
406         out.WriteString("deviceName");
407     }
408     out.WriteUint32(statusSize);
409     for (uint32_t i = 0; i < statusSize; i++) {
410         out.WriteInt32(0);
411     }
412     out.WriteUint32(flagSize);
413     for (uint32_t i = 0; i < flagSize; i++) {
414         out.WriteInt32(0);
415     }
416 }
417 
418 /**
419  * @tc.name: PermissionStateFullParcel001
420  * @tc.desc: Test permissionStateFullParcel Marshalling/Unmarshalling.
421  * @tc.type: FUNC
422  * @tc.require: issueI5QKZF
423  */
424 HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel001, TestSize.Level1)
425 {
426     Parcel out;
427     PutData(out, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE + 1);
428     std::shared_ptr<PermissionStateFullParcel> readedData(PermissionStateFullParcel::Unmarshalling(out));
429     EXPECT_EQ(nullptr, readedData);
430 
431     Parcel out1;
432     PutData(out1, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1);
433     std::shared_ptr<PermissionStateFullParcel> readedData1(PermissionStateFullParcel::Unmarshalling(out1));
434     EXPECT_EQ(readedData1, nullptr);
435 
436     Parcel out2;
437     PutData(out2, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1);
438     std::shared_ptr<PermissionStateFullParcel> readedData2(PermissionStateFullParcel::Unmarshalling(out2));
439     EXPECT_EQ(readedData2, nullptr);
440 
441     Parcel out3;
442     PutData(out3, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE);
443     std::shared_ptr<PermissionStateFullParcel> readedData3(PermissionStateFullParcel::Unmarshalling(out3));
444     EXPECT_NE(readedData3, nullptr);
445 }
446 
447 /**
448  * @tc.name: PermissionStateFullParcel002
449  * @tc.desc: Test permissionStateFullParcel Marshalling/Unmarshalling.
450  * @tc.type: FUNC
451  * @tc.require: issueI5QKZF
452  */
453 HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel002, TestSize.Level1)
454 {
455     PermissionStateFullParcel permissionStateFullParcel;
456     permissionStateFullParcel.permStatFull.permissionName = "permissionName";
457     permissionStateFullParcel.permStatFull.isGeneral = false;
458     permissionStateFullParcel.permStatFull.resDeviceID = {"device"};
459     permissionStateFullParcel.permStatFull.grantStatus = {1};
460     permissionStateFullParcel.permStatFull.grantFlags = {0};
461     Parcel parcel;
462     EXPECT_EQ(true, permissionStateFullParcel.Marshalling(parcel));
463 
464     std::shared_ptr<PermissionStateFullParcel> readedData(PermissionStateFullParcel::Unmarshalling(parcel));
465     EXPECT_NE(nullptr, readedData);
466 }
467 
468 
PutNativeTokenInfoData(Parcel & out,uint32_t dcapSize,uint32_t aclSize)469 static void PutNativeTokenInfoData(Parcel& out, uint32_t dcapSize, uint32_t aclSize)
470 {
471     EXPECT_EQ(true, out.WriteInt32(APL_NORMAL));
472     EXPECT_EQ(true, out.WriteUint8(1));
473     EXPECT_EQ(true, out.WriteString("native_token_test0"));
474     EXPECT_EQ(true, out.WriteUint32(0x28100000)); // 0x28100000 tokenid
475     EXPECT_EQ(true, out.WriteUint32(0));
476 
477     EXPECT_EQ(true, out.WriteUint32(dcapSize));
478     for (uint32_t i = 0; i < dcapSize; i++) {
479         EXPECT_EQ(true, out.WriteString("dcapItem"));
480     }
481     EXPECT_EQ(true, out.WriteUint32(aclSize));
482     for (uint32_t i = 0; i < aclSize; i++) {
483         EXPECT_EQ(true, out.WriteString("ohos.permission.LOCATION"));
484     }
485 }
486 
487 /**
488  * @tc.name: NativeTokenInfoParcel001
489  * @tc.desc: Test NativeTokenInfoParcel Marshalling/Unmarshalling.
490  * @tc.type: FUNC
491  * @tc.require: issueI5QKZF
492  */
493 HWTEST_F(AccessTokenParcelTest, NativeTokenInfoParcel001, TestSize.Level1)
494 {
495     Parcel out;
496     PutNativeTokenInfoData(out, MAX_DCAP_SIZE, MAX_ACL_SIZE);
497     std::shared_ptr<NativeTokenInfoParcel> readedData(NativeTokenInfoParcel::Unmarshalling(out));
498     EXPECT_NE(nullptr, readedData);
499 
500     Parcel out1;
501     PutNativeTokenInfoData(out1, MAX_DCAP_SIZE, MAX_ACL_SIZE + 1);
502     std::shared_ptr<NativeTokenInfoParcel> readedData1(NativeTokenInfoParcel::Unmarshalling(out1));
503     EXPECT_EQ(readedData1, nullptr);
504 
505     Parcel out2;
506     PutNativeTokenInfoData(out2, MAX_DCAP_SIZE + 1, MAX_ACL_SIZE + 1);
507     std::shared_ptr<NativeTokenInfoParcel> readedData2(NativeTokenInfoParcel::Unmarshalling(out2));
508     EXPECT_EQ(readedData2, nullptr);
509 }
510 
511 /**
512  * @tc.name: NativeTokenInfoParcel002
513  * @tc.desc: Test NativeTokenInfoParcel Marshalling/Unmarshalling.
514  * @tc.type: FUNC
515  * @tc.require: issueI5QKZF
516  */
517 HWTEST_F(AccessTokenParcelTest, NativeTokenInfoParcel002, TestSize.Level1)
518 {
519     NativeTokenInfoParcel nativeTokenInfoParcel;
520     nativeTokenInfoParcel.nativeTokenInfoParams.apl = APL_NORMAL;
521     nativeTokenInfoParcel.nativeTokenInfoParams.ver = 0;
522     nativeTokenInfoParcel.nativeTokenInfoParams.processName = "processName";
523     nativeTokenInfoParcel.nativeTokenInfoParams.dcap = {"AT_CAP"};
524     nativeTokenInfoParcel.nativeTokenInfoParams.tokenID = 12; // 12 : tokenid
525     nativeTokenInfoParcel.nativeTokenInfoParams.tokenAttr = 0;
526     nativeTokenInfoParcel.nativeTokenInfoParams.nativeAcls = {};
527 
528     Parcel parcel;
529     EXPECT_EQ(true, nativeTokenInfoParcel.Marshalling(parcel));
530     std::shared_ptr<NativeTokenInfoParcel> readedData(NativeTokenInfoParcel::Unmarshalling(parcel));
531     EXPECT_NE(nullptr, readedData);
532 }
533 
534 /*
535  * @tc.name: NativeTokenInfoParcel003
536  * @tc.desc: NativeTokenInfoParcel::Marshalling function test dcap size > 32
537  * @tc.type: FUNC
538  * @tc.require: issueI6024A
539  */
540 HWTEST_F(AccessTokenParcelTest, NativeTokenInfoParcel003, TestSize.Level1)
541 {
542     std::vector<std::string> vec(33, "AT_CAP");
543     NativeTokenInfoParcel nativeTokenInfoParcel;
544     nativeTokenInfoParcel.nativeTokenInfoParams.apl = APL_NORMAL;
545     nativeTokenInfoParcel.nativeTokenInfoParams.ver = 0;
546     nativeTokenInfoParcel.nativeTokenInfoParams.processName = "processName";
547     nativeTokenInfoParcel.nativeTokenInfoParams.dcap = vec; // size is 33
548     nativeTokenInfoParcel.nativeTokenInfoParams.tokenID = 12; // 12 : tokenid
549     nativeTokenInfoParcel.nativeTokenInfoParams.tokenAttr = 0;
550     nativeTokenInfoParcel.nativeTokenInfoParams.nativeAcls = {};
551 
552     Parcel parcel;
553     EXPECT_NE(true, nativeTokenInfoParcel.Marshalling(parcel));
554 }
555 
556 /*
557  * @tc.name: NativeTokenInfoParcel004
558  * @tc.desc: NativeTokenInfoParcel::Marshalling function test nativeAcls size > 64
559  * @tc.type: FUNC
560  * @tc.require: issueI6024A
561  */
562 HWTEST_F(AccessTokenParcelTest, NativeTokenInfoParcel004, TestSize.Level1)
563 {
564     std::vector<std::string> vec(65, "AT_CAP");
565     NativeTokenInfoParcel nativeTokenInfoParcel;
566     nativeTokenInfoParcel.nativeTokenInfoParams.apl = APL_NORMAL;
567     nativeTokenInfoParcel.nativeTokenInfoParams.ver = 0;
568     nativeTokenInfoParcel.nativeTokenInfoParams.processName = "processName";
569     nativeTokenInfoParcel.nativeTokenInfoParams.dcap = {"AT_CAP"};
570     nativeTokenInfoParcel.nativeTokenInfoParams.tokenID = 12; // 12 : tokenid
571     nativeTokenInfoParcel.nativeTokenInfoParams.tokenAttr = 0;
572     nativeTokenInfoParcel.nativeTokenInfoParams.nativeAcls = vec; // size is 65
573 
574     Parcel parcel;
575     EXPECT_NE(true, nativeTokenInfoParcel.Marshalling(parcel));
576 }
577 
578 /**
579  * @tc.name: PermissionGrantInfoParcel001
580  * @tc.desc: Test PermissionGrantInfo Marshalling/Unmarshalling.
581  * @tc.type: FUNC
582  * @tc.require:
583  */
584 HWTEST_F(AccessTokenParcelTest, PermissionGrantInfoParcel001, TestSize.Level1)
585 {
586     PermissionGrantInfoParcel permissionGrantInfoParcel;
587     permissionGrantInfoParcel.info.grantBundleName = "com.ohos.permissionmanager";
588     permissionGrantInfoParcel.info.grantAbilityName = "com.ohos.permissionmanager.GrantAbility";
589 
590     Parcel parcel;
591     EXPECT_EQ(true, permissionGrantInfoParcel.Marshalling(parcel));
592     std::shared_ptr<PermissionGrantInfoParcel> readedData(PermissionGrantInfoParcel::Unmarshalling(parcel));
593     EXPECT_NE(nullptr, readedData);
594 }
595 
596 /**
597  * @tc.name: AtmToolsParamInfoParcel001
598  * @tc.desc: Test AtmToolsParamInfo Marshalling/Unmarshalling.
599  * @tc.type: FUNC
600  * @tc.require:
601  */
602 HWTEST_F(AccessTokenParcelTest, AtmToolsParamInfoParcel001, TestSize.Level1)
603 {
604     AtmToolsParamInfoParcel atmToolsParamInfoParcel;
605     atmToolsParamInfoParcel.info.type = DUMP_TOKEN;
606     atmToolsParamInfoParcel.info.tokenId = INVALID_TOKENID;
607     atmToolsParamInfoParcel.info.permissionName = "ohos.permission.CAMERA";
608     atmToolsParamInfoParcel.info.bundleName = "com.ohos.parceltest";
609     atmToolsParamInfoParcel.info.permissionName = "test_service";
610 
611     Parcel parcel;
612     EXPECT_EQ(true, atmToolsParamInfoParcel.Marshalling(parcel));
613     std::shared_ptr<AtmToolsParamInfoParcel> readedData(AtmToolsParamInfoParcel::Unmarshalling(parcel));
614     EXPECT_NE(nullptr, readedData);
615 }
616 } // namespace AccessToken
617 } // namespace Security
618 } // namespace OHOS
619