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