1 /*
2 * Copyright (c) 2021-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 "accesstoken_kit_test.h"
17 #include <thread>
18
19 #include "accesstoken_kit.h"
20 #include "nativetoken_kit.h"
21 #include "accesstoken_log.h"
22 #include "token_setproc.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::Security::AccessToken;
26
27 namespace {
28 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenKitTest"};
29
30 PermissionStateFull g_grantPermissionReq = {
31 .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
32 .isGeneral = true,
33 .resDeviceID = {"device"},
34 .grantStatus = {PermissionState::PERMISSION_GRANTED},
35 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
36 };
37 PermissionStateFull g_revokePermissionReq = {
38 .permissionName = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS",
39 .isGeneral = true,
40 .resDeviceID = {"device"},
41 .grantStatus = {PermissionState::PERMISSION_GRANTED},
42 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
43 };
44
45 PermissionDef g_infoManagerTestPermDef1 = {
46 .permissionName = "ohos.permission.test1",
47 .bundleName = "accesstoken_test",
48 .grantMode = 1,
49 .label = "label",
50 .labelId = 1,
51 .description = "open the door",
52 .descriptionId = 1,
53 .availableLevel = APL_NORMAL
54 };
55
56 PermissionDef g_infoManagerTestPermDef2 = {
57 .permissionName = "ohos.permission.test2",
58 .bundleName = "accesstoken_test",
59 .grantMode = 1,
60 .label = "label",
61 .labelId = 1,
62 .description = "break the door",
63 .descriptionId = 1,
64 .availableLevel = APL_NORMAL
65 };
66
67 PermissionStateFull g_infoManagerTestState1 = {
68 .grantFlags = {1},
69 .grantStatus = {PermissionState::PERMISSION_GRANTED},
70 .isGeneral = true,
71 .permissionName = "ohos.permission.test1",
72 .resDeviceID = {"local"}
73 };
74
75 PermissionStateFull g_infoManagerTestState2 = {
76 .permissionName = "ohos.permission.test2",
77 .isGeneral = false,
78 .grantFlags = {1, 2},
79 .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED},
80 .resDeviceID = {"device 1", "device 2"}
81 };
82
83 HapInfoParams g_infoManagerTestInfoParms = {
84 .bundleName = "accesstoken_test",
85 .userID = 1,
86 .instIndex = 0,
87 .appIDDesc = "testtesttesttest"
88 };
89
90 HapPolicyParams g_infoManagerTestPolicyPrams = {
91 .apl = APL_NORMAL,
92 .domain = "test.domain",
93 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
94 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
95 };
96
97 HapInfoParams g_infoManagerTestInfoParmsBak = {
98 .bundleName = "accesstoken_test",
99 .userID = 1,
100 .instIndex = 0,
101 .appIDDesc = "testtesttesttest"
102 };
103
104 HapPolicyParams g_infoManagerTestPolicyPramsBak = {
105 .apl = APL_NORMAL,
106 .domain = "test.domain",
107 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
108 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
109 };
110 }
111
SetUpTestCase()112 void AccessTokenKitTest::SetUpTestCase()
113 {
114 // make test case clean
115 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
116 g_infoManagerTestInfoParms.bundleName,
117 g_infoManagerTestInfoParms.instIndex);
118 AccessTokenKit::DeleteToken(tokenID);
119
120 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
121 AccessTokenKit::DeleteToken(tokenID);
122 }
123
TearDownTestCase()124 void AccessTokenKitTest::TearDownTestCase()
125 {
126 }
127
SetUp()128 void AccessTokenKitTest::SetUp()
129 {
130 g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak;
131 g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak;
132 HapInfoParams info = {
133 .userID = TEST_USER_ID,
134 .bundleName = TEST_BUNDLE_NAME,
135 .instIndex = 0,
136 .appIDDesc = "appIDDesc",
137 };
138
139 HapPolicyParams policy = {
140 .apl = APL_NORMAL,
141 .domain = "domain"
142 };
143
144 PermissionDef permissionDefAlpha = {
145 .permissionName = TEST_PERMISSION_NAME_ALPHA,
146 .bundleName = TEST_BUNDLE_NAME,
147 .grantMode = GrantMode::USER_GRANT,
148 .availableLevel = APL_NORMAL,
149 .provisionEnable = false,
150 .distributedSceneEnable = false
151 };
152
153 PermissionDef permissionDefBeta = {
154 .permissionName = TEST_PERMISSION_NAME_BETA,
155 .bundleName = TEST_BUNDLE_NAME,
156 .grantMode = GrantMode::SYSTEM_GRANT,
157 .availableLevel = APL_NORMAL,
158 .provisionEnable = false,
159 .distributedSceneEnable = false
160 };
161 PermissionDef testPermDef1 = {
162 .permissionName = "ohos.permission.testPermDef1",
163 .bundleName = TEST_BUNDLE_NAME,
164 .grantMode = GrantMode::USER_GRANT,
165 .availableLevel = APL_NORMAL,
166 .provisionEnable = false,
167 .distributedSceneEnable = false
168 };
169
170 PermissionDef testPermDef2 = {
171 .permissionName = "ohos.permission.testPermDef2",
172 .bundleName = TEST_BUNDLE_NAME,
173 .grantMode = GrantMode::USER_GRANT,
174 .availableLevel = APL_NORMAL,
175 .provisionEnable = false,
176 .distributedSceneEnable = false
177 };
178
179 PermissionDef testPermDef3 = {
180 .permissionName = "ohos.permission.testPermDef3",
181 .bundleName = TEST_BUNDLE_NAME,
182 .grantMode = GrantMode::USER_GRANT,
183 .availableLevel = APL_NORMAL,
184 .provisionEnable = false,
185 .distributedSceneEnable = false
186 };
187 PermissionDef testPermDef4 = {
188 .permissionName = "ohos.permission.testPermDef4",
189 .bundleName = TEST_BUNDLE_NAME,
190 .grantMode = GrantMode::USER_GRANT,
191 .availableLevel = APL_NORMAL,
192 .provisionEnable = false,
193 .distributedSceneEnable = false
194 };
195 policy.permList.emplace_back(permissionDefAlpha);
196 policy.permList.emplace_back(permissionDefBeta);
197 policy.permList.emplace_back(testPermDef1);
198 policy.permList.emplace_back(testPermDef2);
199 policy.permList.emplace_back(testPermDef3);
200 policy.permList.emplace_back(testPermDef4);
201
202 PermissionStateFull permStatAlpha = {
203 .permissionName = TEST_PERMISSION_NAME_ALPHA,
204 .isGeneral = true,
205 .resDeviceID = {"device"},
206 .grantStatus = {PermissionState::PERMISSION_DENIED},
207 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
208 };
209 PermissionStateFull permStatBeta = {
210 .permissionName = TEST_PERMISSION_NAME_BETA,
211 .isGeneral = true,
212 .resDeviceID = {"device"},
213 .grantStatus = {PermissionState::PERMISSION_GRANTED},
214 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
215 };
216 PermissionStateFull permTestState1 = {
217 .grantFlags = {0},
218 .grantStatus = {PermissionState::PERMISSION_DENIED},
219 .isGeneral = true,
220 .permissionName = "ohos.permission.testPermDef1",
221 .resDeviceID = {"local"}
222 };
223
224 PermissionStateFull permTestState2 = {
225 .grantFlags = {1},
226 .grantStatus = {PermissionState::PERMISSION_DENIED},
227 .isGeneral = true,
228 .permissionName = "ohos.permission.testPermDef2",
229 .resDeviceID = {"local"}
230 };
231
232 PermissionStateFull permTestState3 = {
233 .grantFlags = {2},
234 .grantStatus = {PermissionState::PERMISSION_DENIED},
235 .isGeneral = true,
236 .permissionName = "ohos.permission.testPermDef3",
237 .resDeviceID = {"local"}
238 };
239
240 PermissionStateFull permTestState4 = {
241 .grantFlags = {1},
242 .grantStatus = {PermissionState::PERMISSION_GRANTED},
243 .isGeneral = true,
244 .permissionName = "ohos.permission.testPermDef4",
245 .resDeviceID = {"local"}
246 };
247
248 policy.permStateList.emplace_back(permStatAlpha);
249 policy.permStateList.emplace_back(permStatBeta);
250 policy.permStateList.emplace_back(g_grantPermissionReq);
251 policy.permStateList.emplace_back(g_revokePermissionReq);
252 policy.permStateList.emplace_back(permTestState1);
253 policy.permStateList.emplace_back(permTestState1);
254 policy.permStateList.emplace_back(permTestState2);
255 policy.permStateList.emplace_back(permTestState3);
256 policy.permStateList.emplace_back(permTestState4);
257 AccessTokenKit::AllocHapToken(info, policy);
258 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
259 g_infoManagerTestInfoParms.bundleName,
260 g_infoManagerTestInfoParms.instIndex);
261 AccessTokenKit::DeleteToken(tokenID);
262 (void)remove("/data/token.json");
263
264 ACCESSTOKEN_LOG_INFO(LABEL, "SetUp ok.");
265 }
266
TearDown()267 void AccessTokenKitTest::TearDown()
268 {
269 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
270 AccessTokenKit::DeleteToken(tokenID);
271 }
272
GetAccessTokenID(int userID,std::string bundleName,int instIndex)273 unsigned int AccessTokenKitTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex)
274 {
275 return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
276 }
277
DeleteTestToken() const278 void AccessTokenKitTest::DeleteTestToken() const
279 {
280 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
281 g_infoManagerTestInfoParms.bundleName,
282 g_infoManagerTestInfoParms.instIndex);
283 int ret = AccessTokenKit::DeleteToken(tokenID);
284 if (tokenID != 0) {
285 ASSERT_EQ(RET_SUCCESS, ret);
286 }
287 }
288
AllocTestToken() const289 void AccessTokenKitTest::AllocTestToken() const
290 {
291 AccessTokenIDEx tokenIdEx = {0};
292 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
293 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
294 }
295
296 /**
297 * @tc.name: GetDefPermission001
298 * @tc.desc: Get permission definition info after AllocHapToken function has been invoked.
299 * @tc.type: FUNC
300 * @tc.require:AR000GM5FC AR000GK6TG
301 */
302 HWTEST_F(AccessTokenKitTest, GetDefPermission001, TestSize.Level1)
303 {
304 PermissionDef permDefResultAlpha;
305 int ret = AccessTokenKit::GetDefPermission(TEST_PERMISSION_NAME_ALPHA, permDefResultAlpha);
306 ASSERT_EQ(RET_SUCCESS, ret);
307 ASSERT_EQ(TEST_PERMISSION_NAME_ALPHA, permDefResultAlpha.permissionName);
308
309 PermissionDef permDefResultBeta;
310 ret = AccessTokenKit::GetDefPermission(TEST_PERMISSION_NAME_BETA, permDefResultBeta);
311 ASSERT_EQ(RET_SUCCESS, ret);
312 ASSERT_EQ(TEST_PERMISSION_NAME_BETA, permDefResultBeta.permissionName);
313 }
314
315 /**
316 * @tc.name: GetDefPermission002
317 * @tc.desc: Get permission definition info that permission is invalid.
318 * @tc.type: FUNC
319 * @tc.require:AR000GM5FC
320 */
321 HWTEST_F(AccessTokenKitTest, GetDefPermission002, TestSize.Level1)
322 {
323 PermissionDef permDefResult;
324 int ret = AccessTokenKit::GetDefPermission(TEST_PERMISSION_NAME_GAMMA, permDefResult);
325 ASSERT_EQ(RET_FAILED, ret);
326
327 ret = AccessTokenKit::GetDefPermission("", permDefResult);
328 ASSERT_EQ(RET_FAILED, ret);
329
330 std::string invalidPerm(INVALID_PERMNAME_LEN, 'a');
331 ret = AccessTokenKit::GetDefPermission(invalidPerm, permDefResult);
332 ASSERT_EQ(RET_FAILED, ret);
333 }
334
335 /**
336 * @tc.name: GetDefPermission003
337 * @tc.desc: GetDefPermission is invoked multiple times.
338 * @tc.type: FUNC
339 * @tc.require:AR000GM5FC
340 */
341 HWTEST_F(AccessTokenKitTest, GetDefPermission003, TestSize.Level0)
342 {
343 int ret = RET_FAILED;
344 for (int i = 0; i < CYCLE_TIMES; i++) {
345 PermissionDef permDefResultAlpha;
346 ret = AccessTokenKit::GetDefPermission(TEST_PERMISSION_NAME_ALPHA, permDefResultAlpha);
347 ASSERT_EQ(RET_SUCCESS, ret);
348 ASSERT_EQ(TEST_PERMISSION_NAME_ALPHA, permDefResultAlpha.permissionName);
349 }
350 }
351
352 /**
353 * @tc.name: GetDefPermissions001
354 * @tc.desc: Get permission definition info list after AllocHapToken function has been invoked.
355 * @tc.type: FUNC
356 * @tc.require:AR000GM5FC AR000GK6TG
357 */
358 HWTEST_F(AccessTokenKitTest, GetDefPermissions001, TestSize.Level1)
359 {
360 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
361 ASSERT_NE(0, tokenID);
362 std::vector<PermissionDef> permDefList;
363 int ret = AccessTokenKit::GetDefPermissions(tokenID, permDefList);
364 ASSERT_EQ(RET_SUCCESS, ret);
365 ASSERT_EQ(6, permDefList.size());
366 }
367
368 /**
369 * @tc.name: GetDefPermissions002
370 * @tc.desc: Get permission definition info list after clear permission definition list
371 * @tc.type: FUNC
372 * @tc.require:AR000GM5FC
373 */
374 HWTEST_F(AccessTokenKitTest, GetDefPermissions002, TestSize.Level1)
375 {
376 HapPolicyParams testPolicyPrams = g_infoManagerTestPolicyPrams;
377 testPolicyPrams.permList.clear();
378 AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, testPolicyPrams);
379
380 AccessTokenID tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
381 g_infoManagerTestInfoParms.bundleName,
382 g_infoManagerTestInfoParms.instIndex);
383 ASSERT_NE(0, tokenID);
384
385 std::vector<PermissionDef> permDefList;
386 int ret = AccessTokenKit::GetDefPermissions(tokenID, permDefList);
387 ASSERT_EQ(RET_SUCCESS, ret);
388 ASSERT_EQ(0, permDefList.size());
389
390 AccessTokenKit::DeleteToken(tokenID);
391 }
392
393 /**
394 * @tc.name: GetDefPermissions003
395 * @tc.desc: Get permission definition info list that tokenID is invalid.
396 * @tc.type: FUNC
397 * @tc.require:AR000GM5FC
398 */
399 HWTEST_F(AccessTokenKitTest, GetDefPermissions003, TestSize.Level1)
400 {
401 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
402 ASSERT_NE(0, tokenID);
403 AccessTokenKit::DeleteToken(tokenID);
404
405 std::vector<PermissionDef> permDefList;
406 int ret = AccessTokenKit::GetDefPermissions(TEST_TOKENID_INVALID, permDefList);
407 ASSERT_EQ(RET_FAILED, ret);
408
409 std::vector<PermissionDef> permDefListRes;
410 ret = AccessTokenKit::GetDefPermissions(tokenID, permDefListRes);
411 ASSERT_EQ(RET_FAILED, ret);
412 ASSERT_EQ(0, permDefListRes.size());
413 }
414
415 /**
416 * @tc.name: GetDefPermissions004
417 * @tc.desc: GetDefPermissions is invoked multiple times.
418 * @tc.type: FUNC
419 * @tc.require:AR000GM5FC
420 */
421 HWTEST_F(AccessTokenKitTest, GetDefPermissions004, TestSize.Level0)
422 {
423 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
424 ASSERT_NE(0, tokenID);
425 int ret = RET_FAILED;
426 for (int i = 0; i < CYCLE_TIMES; i++) {
427 std::vector<PermissionDef> permDefList;
428 ret = AccessTokenKit::GetDefPermissions(tokenID, permDefList);
429 ASSERT_EQ(RET_SUCCESS, ret);
430 ASSERT_EQ(6, permDefList.size());
431 }
432 }
433
434 /**
435 * @tc.name: GetReqPermissions001
436 * @tc.desc: Get user granted permission state info.
437 * @tc.type: FUNC
438 * @tc.require:AR000GM5FC AR000GK6TG
439 */
440 HWTEST_F(AccessTokenKitTest, GetReqPermissions001, TestSize.Level1)
441 {
442 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
443 ASSERT_NE(0, tokenID);
444 std::vector<PermissionStateFull> permStatList;
445 int ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false);
446 ASSERT_EQ(RET_SUCCESS, ret);
447 ASSERT_EQ(5, permStatList.size());
448 ASSERT_EQ(TEST_PERMISSION_NAME_ALPHA, permStatList[0].permissionName);
449
450 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
451 ASSERT_EQ(ret, permStatList[0].grantStatus[0]);
452 }
453
454 /**
455 * @tc.name: GetReqPermissions002
456 * @tc.desc: Get system granted permission state info.
457 * @tc.type: FUNC
458 * @tc.require:AR000GM5FC
459 */
460 HWTEST_F(AccessTokenKitTest, GetReqPermissions002, TestSize.Level1)
461 {
462 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
463 ASSERT_NE(0, tokenID);
464 std::vector<PermissionStateFull> permStatList;
465 int ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, true);
466 ASSERT_EQ(RET_SUCCESS, ret);
467 ASSERT_EQ(3, permStatList.size());
468 ASSERT_EQ(TEST_PERMISSION_NAME_BETA, permStatList[0].permissionName);
469
470 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_BETA);
471 ASSERT_EQ(ret, permStatList[0].grantStatus[0]);
472 }
473
474 /**
475 * @tc.name: GetReqPermissions003
476 * @tc.desc: Get user granted permission state info after clear request permission list.
477 * @tc.type: FUNC
478 * @tc.require:AR000GM5FC
479 */
480 HWTEST_F(AccessTokenKitTest, GetReqPermissions003, TestSize.Level1)
481 {
482 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
483 ASSERT_NE(0, tokenID);
484
485 HapTokenInfo hapInfo;
486 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo);
487 ASSERT_EQ(RET_SUCCESS, ret);
488
489 HapPolicyParams policy = {
490 .apl = hapInfo.apl,
491 .domain = "domain"
492 };
493 policy.permStateList.clear();
494
495 ret = AccessTokenKit::UpdateHapToken(tokenID, hapInfo.appID, policy);
496 ASSERT_EQ(RET_SUCCESS, ret);
497
498 std::vector<PermissionStateFull> permStatUserList;
499 ret = AccessTokenKit::GetReqPermissions(tokenID, permStatUserList, false);
500 ASSERT_EQ(RET_SUCCESS, ret);
501 ASSERT_EQ(0, permStatUserList.size());
502
503 std::vector<PermissionStateFull> permStatSystemList;
504 ret = AccessTokenKit::GetReqPermissions(tokenID, permStatSystemList, true);
505 ASSERT_EQ(RET_SUCCESS, ret);
506 ASSERT_EQ(0, permStatSystemList.size());
507 }
508
509 /**
510 * @tc.name: GetReqPermissions004
511 * @tc.desc: Get permission state info list that tokenID is invalid.
512 * @tc.type: FUNC
513 * @tc.require:AR000GM5FC
514 */
515 HWTEST_F(AccessTokenKitTest, GetReqPermissions004, TestSize.Level1)
516 {
517 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
518 ASSERT_NE(0, tokenID);
519
520 std::vector<PermissionStateFull> permStatList;
521 int ret = AccessTokenKit::GetReqPermissions(TEST_TOKENID_INVALID, permStatList, false);
522 ASSERT_EQ(RET_FAILED, ret);
523
524 AccessTokenKit::DeleteToken(tokenID);
525
526 ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false);
527 ASSERT_EQ(RET_FAILED, ret);
528 ASSERT_EQ(0, permStatList.size());
529 }
530
531 /**
532 * @tc.name: GetReqPermissions005
533 * @tc.desc: GetReqPermissions is invoked multiple times.
534 * @tc.type: FUNC
535 * @tc.require:AR000GM5FC
536 */
537 HWTEST_F(AccessTokenKitTest, GetReqPermissions005, TestSize.Level0)
538 {
539 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
540 ASSERT_NE(0, tokenID);
541 int ret = RET_FAILED;
542 for (int i = 0; i < CYCLE_TIMES; i++) {
543 std::vector<PermissionStateFull> permStatList;
544 ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false);
545 ASSERT_EQ(RET_SUCCESS, ret);
546 ASSERT_EQ(5, permStatList.size());
547 ASSERT_EQ(TEST_PERMISSION_NAME_ALPHA, permStatList[0].permissionName);
548 }
549 }
550
551 /**
552 * @tc.name: GetPermissionFlag001
553 * @tc.desc: Get permission flag after grant permission.
554 * @tc.type: FUNC
555 * @tc.require:AR000GM5FC AR000GK6TG
556 */
557 HWTEST_F(AccessTokenKitTest, GetPermissionFlag001, TestSize.Level1)
558 {
559 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
560 ASSERT_NE(0, tokenID);
561 int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
562 ASSERT_EQ(RET_SUCCESS, ret);
563
564 ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
565 ASSERT_EQ(PERMISSION_USER_FIXED, ret);
566 }
567
568 /**
569 * @tc.name: GetPermissionFlag002
570 * @tc.desc: Get permission flag that tokenID or permission is invalid.
571 * @tc.type: FUNC
572 * @tc.require:AR000GM5FC
573 */
574 HWTEST_F(AccessTokenKitTest, GetPermissionFlag002, TestSize.Level1)
575 {
576 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
577 ASSERT_NE(0, tokenID);
578
579 int ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_GAMMA);
580 ASSERT_EQ(DEFAULT_PERMISSION_FLAGS, ret);
581
582 ret = AccessTokenKit::GetPermissionFlag(tokenID, "");
583 ASSERT_EQ(DEFAULT_PERMISSION_FLAGS, ret);
584
585 std::string invalidPerm(INVALID_PERMNAME_LEN, 'a');
586 ret = AccessTokenKit::GetPermissionFlag(tokenID, invalidPerm);
587 ASSERT_EQ(DEFAULT_PERMISSION_FLAGS, ret);
588
589 ret = AccessTokenKit::GetPermissionFlag(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_ALPHA);
590 ASSERT_EQ(DEFAULT_PERMISSION_FLAGS, ret);
591
592 AccessTokenKit::DeleteToken(tokenID);
593
594 ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
595 ASSERT_EQ(DEFAULT_PERMISSION_FLAGS, ret);
596 }
597
598 /**
599 * @tc.name: GetPermissionFlag003
600 * @tc.desc: GetPermissionFlag is invoked multiple times.
601 * @tc.type: FUNC
602 * @tc.require:AR000GM5FC
603 */
604 HWTEST_F(AccessTokenKitTest, GetPermissionFlag003, TestSize.Level0)
605 {
606 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
607 ASSERT_NE(0, tokenID);
608 int ret = RET_FAILED;
609 for (int i = 0; i < CYCLE_TIMES; i++) {
610 ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
611 ASSERT_EQ(RET_SUCCESS, ret);
612
613 ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
614 ASSERT_EQ(PERMISSION_USER_FIXED, ret);
615 }
616 }
617
618 /**
619 * @tc.name: VerifyAccessToken001
620 * @tc.desc: Verify user granted permission.
621 * @tc.type: FUNC
622 * @tc.require:AR000GK6T8 AR000GK6TG
623 */
624 HWTEST_F(AccessTokenKitTest, VerifyAccessToken001, TestSize.Level0)
625 {
626 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
627 ASSERT_NE(0, tokenID);
628 int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
629 ASSERT_EQ(RET_SUCCESS, ret);
630
631 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
632 ASSERT_EQ(PERMISSION_GRANTED, ret);
633
634 ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
635 ASSERT_EQ(RET_SUCCESS, ret);
636
637 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
638 ASSERT_EQ(PERMISSION_DENIED, ret);
639 }
640
641 /**
642 * @tc.name: VerifyAccessToken002
643 * @tc.desc: Verify system granted permission.
644 * @tc.type: FUNC
645 * @tc.require:AR000GK6T8
646 */
647 HWTEST_F(AccessTokenKitTest, VerifyAccessToken002, TestSize.Level0)
648 {
649 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
650 ASSERT_NE(0, tokenID);
651 int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
652 ASSERT_EQ(RET_SUCCESS, ret);
653
654 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_BETA);
655 ASSERT_EQ(PERMISSION_GRANTED, ret);
656
657 ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
658 ASSERT_EQ(RET_SUCCESS, ret);
659
660 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_BETA);
661 ASSERT_EQ(PERMISSION_DENIED, ret);
662 }
663
664 /**
665 * @tc.name: VerifyAccessToken003
666 * @tc.desc: Verify permission that tokenID or permission is invalid.
667 * @tc.type: FUNC
668 * @tc.require:AR000GK6T8
669 */
670 HWTEST_F(AccessTokenKitTest, VerifyAccessToken003, TestSize.Level0)
671 {
672 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
673 ASSERT_NE(0, tokenID);
674 int ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_GAMMA);
675 ASSERT_EQ(PERMISSION_DENIED, ret);
676
677 ret = AccessTokenKit::VerifyAccessToken(tokenID, "");
678 ASSERT_EQ(PERMISSION_DENIED, ret);
679
680 std::string invalidPerm(INVALID_PERMNAME_LEN, 'a');
681 ret = AccessTokenKit::VerifyAccessToken(tokenID, invalidPerm);
682 ASSERT_EQ(PERMISSION_DENIED, ret);
683
684 AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_BETA);
685 ASSERT_EQ(PERMISSION_DENIED, ret);
686
687 AccessTokenKit::DeleteToken(tokenID);
688
689 AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_BETA);
690 ASSERT_EQ(PERMISSION_DENIED, ret);
691 }
692
693 /**
694 * @tc.name: VerifyAccessToken004
695 * @tc.desc: Verify permission after update.
696 * @tc.type: FUNC
697 * @tc.require:AR000GK6T8
698 */
699 HWTEST_F(AccessTokenKitTest, VerifyAccessToken004, TestSize.Level0)
700 {
701 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
702 ASSERT_NE(0, tokenID);
703
704 int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
705 ASSERT_EQ(RET_SUCCESS, ret);
706
707 HapTokenInfo hapInfo;
708 ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo);
709 ASSERT_EQ(RET_SUCCESS, ret);
710
711 std::vector<PermissionDef> permDefList;
712 ret = AccessTokenKit::GetDefPermissions(tokenID, permDefList);
713 ASSERT_EQ(RET_SUCCESS, ret);
714
715 std::vector<PermissionStateFull> permStatList;
716 ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false);
717 ASSERT_EQ(RET_SUCCESS, ret);
718
719 HapPolicyParams policy = {
720 .apl = hapInfo.apl,
721 .domain = "domain",
722 .permList = permDefList,
723 .permStateList = permStatList
724 };
725
726 ret = AccessTokenKit::UpdateHapToken(tokenID, hapInfo.appID, policy);
727 ASSERT_EQ(RET_SUCCESS, ret);
728
729 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
730 ASSERT_EQ(PERMISSION_GRANTED, ret);
731 }
732
733 /**
734 * @tc.name: GrantPermission001
735 * @tc.desc: Grant permission that has ohos.permission.GRANT_SENSITIVE_PERMISSIONS
736 * @tc.type: FUNC
737 * @tc.require:AR000GK6TF AR000GK6TG
738 */
739 HWTEST_F(AccessTokenKitTest, GrantPermission001, TestSize.Level0)
740 {
741 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
742 ASSERT_NE(0, tokenID);
743 int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
744 ASSERT_EQ(RET_SUCCESS, ret);
745
746 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
747 ASSERT_EQ(PERMISSION_GRANTED, ret);
748
749 ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
750 ASSERT_EQ(RET_SUCCESS, ret);
751
752 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
753 ASSERT_EQ(PERMISSION_GRANTED, ret);
754 }
755
756 /**
757 * @tc.name: GrantPermission002
758 * @tc.desc: Grant permission that tokenID or permission is invalid.
759 * @tc.type: FUNC
760 * @tc.require:AR000GK6TF
761 */
762 HWTEST_F(AccessTokenKitTest, GrantPermission002, TestSize.Level0)
763 {
764 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
765 ASSERT_NE(0, tokenID);
766
767 int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_GAMMA, PERMISSION_USER_FIXED);
768 ASSERT_EQ(RET_SUCCESS, ret);
769
770 ret = AccessTokenKit::GrantPermission(tokenID, "", PERMISSION_USER_FIXED);
771 ASSERT_EQ(RET_FAILED, ret);
772
773 std::string invalidPerm(INVALID_PERMNAME_LEN, 'a');
774 ret = AccessTokenKit::GrantPermission(tokenID, invalidPerm, PERMISSION_USER_FIXED);
775 ASSERT_EQ(RET_FAILED, ret);
776
777 ret = AccessTokenKit::GrantPermission(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
778 ASSERT_EQ(RET_FAILED, ret);
779
780 AccessTokenKit::DeleteToken(tokenID);
781
782 ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
783 ASSERT_EQ(RET_SUCCESS, ret);
784 }
785
786 /**
787 * @tc.name: GrantPermission003
788 * @tc.desc: GrantPermission is invoked multiple times.
789 * @tc.type: FUNC
790 * @tc.require:AR000GK6TF
791 */
792 HWTEST_F(AccessTokenKitTest, GrantPermission003, TestSize.Level0)
793 {
794 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
795 ASSERT_NE(0, tokenID);
796 int ret = RET_FAILED;
797 for (int i = 0; i < CYCLE_TIMES; i++) {
798 ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
799 ASSERT_EQ(RET_SUCCESS, ret);
800
801 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
802 ASSERT_EQ(PERMISSION_GRANTED, ret);
803
804 ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
805 ASSERT_EQ(PERMISSION_USER_FIXED, ret);
806 }
807 }
808
809 /**
810 * @tc.name: RevokePermission001
811 * @tc.desc: Revoke permission that has ohos.permission.GRANT_SENSITIVE_PERMISSIONS
812 * @tc.type: FUNC
813 * @tc.require:AR000GK6TF AR000GK6TG
814 */
815 HWTEST_F(AccessTokenKitTest, RevokePermission001, TestSize.Level0)
816 {
817 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
818 ASSERT_NE(0, tokenID);
819 int ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
820 ASSERT_EQ(RET_SUCCESS, ret);
821
822 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
823 ASSERT_EQ(PERMISSION_DENIED, ret);
824
825 ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
826 ASSERT_EQ(RET_SUCCESS, ret);
827
828 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
829 ASSERT_EQ(PERMISSION_DENIED, ret);
830 }
831
832 /**
833 * @tc.name: RevokePermission002
834 * @tc.desc: Revoke permission that tokenID or permission is invalid.
835 * @tc.type: FUNC
836 * @tc.require:AR000GK6TF
837 */
838 HWTEST_F(AccessTokenKitTest, RevokePermission002, TestSize.Level0)
839 {
840 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
841 ASSERT_NE(0, tokenID);
842
843 int ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_GAMMA, PERMISSION_USER_FIXED);
844 ASSERT_EQ(RET_SUCCESS, ret);
845
846 ret = AccessTokenKit::RevokePermission(tokenID, "", PERMISSION_USER_FIXED);
847 ASSERT_EQ(RET_FAILED, ret);
848
849 std::string invalidPerm(INVALID_PERMNAME_LEN, 'a');
850 ret = AccessTokenKit::RevokePermission(tokenID, invalidPerm, PERMISSION_USER_FIXED);
851 ASSERT_EQ(RET_FAILED, ret);
852
853 ret = AccessTokenKit::RevokePermission(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
854 ASSERT_EQ(RET_FAILED, ret);
855
856 AccessTokenKit::DeleteToken(tokenID);
857
858 ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED);
859 ASSERT_EQ(RET_SUCCESS, ret);
860 }
861
862 /**
863 * @tc.name: RevokePermission003
864 * @tc.desc: RevokePermission is invoked multiple times.
865 * @tc.type: FUNC
866 * @tc.require:AR000GK6TF
867 */
868 HWTEST_F(AccessTokenKitTest, RevokePermission003, TestSize.Level0)
869 {
870 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
871 ASSERT_NE(0, tokenID);
872 int ret = RET_FAILED;
873 for (int i = 0; i < CYCLE_TIMES; i++) {
874 ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
875 ASSERT_EQ(RET_SUCCESS, ret);
876
877 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
878 ASSERT_EQ(PERMISSION_DENIED, ret);
879
880 ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
881 ASSERT_EQ(PERMISSION_USER_FIXED, ret);
882 }
883 }
884
885 /**
886 * @tc.name: ClearUserGrantedPermissionState001
887 * @tc.desc: Clear user/system granted permission after ClearUserGrantedPermissionState has been invoked.
888 * @tc.type: FUNC
889 * @tc.require:AR000GK6TF AR000GK6TG
890 */
891 HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState001, TestSize.Level0)
892 {
893 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
894 ASSERT_NE(0, tokenID);
895 int ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID);
896 ASSERT_EQ(RET_SUCCESS, ret);
897
898 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
899 ASSERT_EQ(PERMISSION_DENIED, ret);
900
901 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_BETA);
902 ASSERT_EQ(PERMISSION_GRANTED, ret);
903 }
904
905 /**
906 * @tc.name: ClearUserGrantedPermissionState002
907 * @tc.desc: Clear user/system granted permission that tokenID or permission is invalid.
908 * @tc.type: FUNC
909 * @tc.require:AR000GK6TF
910 */
911 HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState002, TestSize.Level0)
912 {
913 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
914 ASSERT_NE(0, tokenID);
915
916 int ret = AccessTokenKit::ClearUserGrantedPermissionState(TEST_TOKENID_INVALID);
917 ASSERT_EQ(RET_FAILED, ret);
918
919 AccessTokenKit::DeleteToken(tokenID);
920
921 ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID);
922 ASSERT_EQ(RET_SUCCESS, ret);
923 }
924
925 /**
926 * @tc.name: ClearUserGrantedPermissionState003
927 * @tc.desc: ClearUserGrantedPermissionState is invoked multiple times.
928 * @tc.type: FUNC
929 * @tc.require:AR000GK6TF
930 */
931 HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState003, TestSize.Level0)
932 {
933 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
934 ASSERT_NE(0, tokenID);
935 int ret = RET_FAILED;
936 for (int i = 0; i < CYCLE_TIMES; i++) {
937 ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID);
938 ASSERT_EQ(RET_SUCCESS, ret);
939
940 ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
941 ASSERT_EQ(PERMISSION_DENIED, ret);
942 }
943 }
944
945 /**
946 * @tc.name: GetTokenType001
947 * @tc.desc: get the token type.
948 * @tc.type: FUNC
949 * @tc.require:AR000GK6TH
950 */
951 HWTEST_F(AccessTokenKitTest, GetTokenType001, TestSize.Level0)
952 {
953 AllocTestToken();
954 AccessTokenID tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
955 g_infoManagerTestInfoParms.bundleName,
956 g_infoManagerTestInfoParms.instIndex);
957 int ret = AccessTokenKit::GetTokenType(tokenID);
958 ASSERT_EQ(TOKEN_HAP, ret);
959 DeleteTestToken();
960 }
961
962 /**
963 * @tc.name: GetHapTokenInfo001
964 * @tc.desc: get the token info and verify.
965 * @tc.type: FUNC
966 * @tc.require:AR000GK6TH
967 */
968 HWTEST_F(AccessTokenKitTest, GetHapTokenInfo001, TestSize.Level0)
969 {
970 HapTokenInfo hapTokenInfoRes;
971 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
972 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
973 ASSERT_EQ(RET_SUCCESS, ret);
974
975 ASSERT_EQ(hapTokenInfoRes.apl, APL_NORMAL);
976 ASSERT_EQ(hapTokenInfoRes.userID, TEST_USER_ID);
977 ASSERT_EQ(hapTokenInfoRes.tokenID, tokenID);
978 ASSERT_EQ(hapTokenInfoRes.tokenAttr, 0);
979 ASSERT_EQ(hapTokenInfoRes.instIndex, 0);
980
981 ASSERT_EQ(hapTokenInfoRes.appID, "appIDDesc");
982
983 ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME);
984 }
985
986 /**
987 * @tc.name: GetHapTokenInfo002
988 * @tc.desc: try to get the token info with invalid tokenId.
989 * @tc.type: FUNC
990 * @tc.require:AR000GK6TH
991 */
992 HWTEST_F(AccessTokenKitTest, GetHapTokenInfo002, TestSize.Level0)
993 {
994 HapTokenInfo hapTokenInfoRes;
995 int ret = AccessTokenKit::GetHapTokenInfo(TEST_TOKENID_INVALID, hapTokenInfoRes);
996 ASSERT_EQ(RET_FAILED, ret);
997 }
998
999 /**
1000 * @tc.name: DeleteToken001
1001 * @tc.desc: Cannot get permission definition info after DeleteToken function has been invoked.
1002 * @tc.type: FUNC
1003 * @tc.require:AR000GK6TI
1004 */
1005 HWTEST_F(AccessTokenKitTest, DeleteToken001, TestSize.Level1)
1006 {
1007 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
1008 PermissionDef permDefResultAlpha;
1009 int ret = AccessTokenKit::GetDefPermission(TEST_PERMISSION_NAME_ALPHA, permDefResultAlpha);
1010 ASSERT_EQ(TEST_PERMISSION_NAME_ALPHA, permDefResultAlpha.permissionName);
1011 ASSERT_EQ(RET_SUCCESS, ret);
1012
1013 ret = AccessTokenKit::DeleteToken(tokenID);
1014 ASSERT_EQ(RET_SUCCESS, ret);
1015
1016 PermissionDef defResult;
1017 ret = AccessTokenKit::GetDefPermission(TEST_PERMISSION_NAME_ALPHA, defResult);
1018 ASSERT_EQ(RET_FAILED, ret);
1019 }
1020
1021 /**
1022 * @tc.name: DeleteToken002
1023 * @tc.desc: Delete invalid tokenID.
1024 * @tc.type: FUNC
1025 * @tc.require:AR000GK6TI
1026 */
1027 HWTEST_F(AccessTokenKitTest, DeleteToken002, TestSize.Level1)
1028 {
1029 int ret = AccessTokenKit::DeleteToken(TEST_USER_ID_INVALID);
1030 ASSERT_EQ(RET_FAILED, ret);
1031 }
1032
1033 /**
1034 * @tc.name: DeleteToken002
1035 * @tc.desc: Delete invalid tokenID.
1036 * @tc.type: FUNC
1037 * @tc.require:AR000GK6TI
1038 */
1039 HWTEST_F(AccessTokenKitTest, DeleteToken003, TestSize.Level1)
1040 {
1041 HapTokenInfo hapTokenInfoRes;
1042 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
1043
1044 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1045 ASSERT_EQ(RET_SUCCESS, ret);
1046
1047 ret = AccessTokenKit::DeleteToken(tokenID);
1048 ASSERT_EQ(RET_SUCCESS, ret);
1049
1050 ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1051 ASSERT_EQ(RET_FAILED, ret);
1052 }
1053
1054 /**
1055 * @tc.name: DeleteToken004
1056 * @tc.desc: alloc a tokenId successfully, delete it successfully the first time and fail to delte it again.
1057 * @tc.type: FUNC
1058 * @tc.require:AR000GK6TI
1059 */
1060 HWTEST_F(AccessTokenKitTest, DeleteToken004, TestSize.Level1)
1061 {
1062 AccessTokenIDEx tokenIdEx = {0};
1063 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1064 GTEST_LOG_(INFO) << "tokenIdEx.tokenIdExStruct.tokenID :" << tokenIdEx.tokenIdExStruct.tokenID;
1065 AccessTokenID tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1066 g_infoManagerTestInfoParms.bundleName,
1067 g_infoManagerTestInfoParms.instIndex);
1068
1069 int ret = AccessTokenKit::DeleteToken(tokenID);
1070 GTEST_LOG_(INFO) << "g_infoManagerTestInfoParms.userID :" << g_infoManagerTestInfoParms.userID;
1071 GTEST_LOG_(INFO) << "g_infoManagerTestInfoParms.bundleName :" << g_infoManagerTestInfoParms.bundleName.c_str();
1072 GTEST_LOG_(INFO) << "g_infoManagerTestInfoParms.instIndex :" << g_infoManagerTestInfoParms.instIndex;
1073 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1074 ASSERT_EQ(RET_SUCCESS, ret);
1075 ret = AccessTokenKit::DeleteToken(tokenID);
1076 ASSERT_EQ(RET_FAILED, ret);
1077 }
1078
1079 /**
1080 * @tc.name: GetHapTokenID001
1081 * @tc.desc: get hap tokenid.
1082 * @tc.type: FUNC
1083 * @tc.require:AR000GK6TH
1084 */
1085 HWTEST_F(AccessTokenKitTest, GetHapTokenID001, TestSize.Level1)
1086 {
1087 HapTokenInfo hapTokenInfoRes;
1088 AccessTokenID tokenID;
1089 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
1090
1091 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1092 ASSERT_EQ(RET_SUCCESS, ret);
1093 ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME);
1094 }
1095
1096 /**
1097 * @tc.name: GetHapTokenID002
1098 * @tc.desc: cannot get hap tokenid with invalid userId.
1099 * @tc.type: FUNC
1100 * @tc.require:AR000GK6TH
1101 */
1102 HWTEST_F(AccessTokenKitTest, GetHapTokenID002, TestSize.Level1)
1103 {
1104 AccessTokenID tokenID;
1105 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0);
1106 ASSERT_EQ(0, tokenID);
1107 }
1108
1109 /**
1110 * @tc.name: GetHapTokenID003
1111 * @tc.desc: cannot get hap tokenid with invalid bundlename.
1112 * @tc.type: FUNC
1113 * @tc.require:AR000GK6TH
1114 */
1115 HWTEST_F(AccessTokenKitTest, GetHapTokenID003, TestSize.Level1)
1116 {
1117 AccessTokenID tokenID;
1118 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "invalid bundlename", 0);
1119 ASSERT_EQ(0, tokenID);
1120 }
1121
1122 /**
1123 * @tc.name: GetHapTokenID003
1124 * @tc.desc: cannot get hap tokenid with invalid bundlename.
1125 * @tc.type: FUNC
1126 * @tc.require:AR000GK6TH
1127 */
1128 HWTEST_F(AccessTokenKitTest, GetHapTokenID004, TestSize.Level1)
1129 {
1130 AccessTokenID tokenID;
1131 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff);
1132 ASSERT_EQ(0, tokenID);
1133 }
1134
1135 /**
1136 * @tc.name: AllocHapToken001
1137 * @tc.desc: alloc a tokenId successfully, delete it successfully the first time and fail to delte it again.
1138 * @tc.type: FUNC
1139 * @tc.require:AR000GK6TJ
1140 */
1141 HWTEST_F(AccessTokenKitTest, AllocHapToken001, TestSize.Level1)
1142 {
1143 AccessTokenIDEx tokenIdEx = {0};
1144 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1145 GTEST_LOG_(INFO) << "tokenIdEx.tokenIdExStruct.tokenID :" << tokenIdEx.tokenIdExStruct.tokenID;
1146 AccessTokenID tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1147 g_infoManagerTestInfoParms.bundleName,
1148 g_infoManagerTestInfoParms.instIndex);
1149 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1150 int ret = AccessTokenKit::DeleteToken(tokenID);
1151 ASSERT_EQ(RET_SUCCESS, ret);
1152 ret = AccessTokenKit::DeleteToken(tokenID);
1153 ASSERT_EQ(RET_FAILED, ret);
1154 }
1155
1156 /**
1157 * @tc.name: AllocHapToken002
1158 * @tc.desc: alloc a tokenId successfully,
1159 * and fail to alloc it with the same info and policy again.
1160 * @tc.type: FUNC
1161 * @tc.require:AR000GK6TJ
1162 */
1163 HWTEST_F(AccessTokenKitTest, AllocHapToken002, TestSize.Level1)
1164 {
1165 AccessTokenIDEx tokenIdEx = {0};
1166 AccessTokenID tokenID;
1167 int ret;
1168
1169 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1170 g_infoManagerTestInfoParms.bundleName,
1171 g_infoManagerTestInfoParms.instIndex);
1172
1173 ret = AccessTokenKit::DeleteToken(tokenID);
1174 GTEST_LOG_(INFO) << "DeleteToken ret:" << ret;
1175 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1176
1177 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1178 GTEST_LOG_(INFO) << "tokenIdEx.tokenIdExStruct.tokenID :" << tokenIdEx.tokenIdExStruct.tokenID;
1179
1180 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1181 g_infoManagerTestInfoParms.bundleName,
1182 g_infoManagerTestInfoParms.instIndex);
1183 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1184 ASSERT_NE(0, tokenID);
1185
1186 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1187 ASSERT_EQ(0, tokenIdEx.tokenIdExStruct.tokenID);
1188
1189 ret = AccessTokenKit::DeleteToken(tokenID);
1190 ASSERT_EQ(RET_SUCCESS, ret);
1191 }
1192
1193 /**
1194 * @tc.name: AllocHapToken003
1195 * @tc.desc: cannot alloc a tokenId with invalid bundlename.
1196 * @tc.type: FUNC
1197 * @tc.require:AR000GK6TJ
1198 */
1199 HWTEST_F(AccessTokenKitTest, AllocHapToken003, TestSize.Level1)
1200 {
1201 std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x');
1202 AccessTokenIDEx tokenIdEx = {0};
1203 int ret;
1204 AccessTokenID tokenID;
1205
1206 DeleteTestToken();
1207 GTEST_LOG_(INFO) << "get hap token info:" << invalidBundleName.length();
1208 g_infoManagerTestInfoParms.bundleName = invalidBundleName;
1209 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1210
1211 ASSERT_EQ(0, tokenIdEx.tokenIdExStruct.tokenID);
1212
1213 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1214 g_infoManagerTestInfoParms.bundleName,
1215 g_infoManagerTestInfoParms.instIndex);
1216 ASSERT_EQ(0, tokenID);
1217 ret = AccessTokenKit::DeleteToken(tokenID);
1218 ASSERT_EQ(RET_FAILED, ret);
1219
1220 g_infoManagerTestInfoParms.bundleName = "accesstoken_test";
1221 }
1222
1223 /**
1224 * @tc.name: AllocHapToken004
1225 * @tc.desc: cannot alloc a tokenId with invalid apl.
1226 * @tc.type: FUNC
1227 * @tc.require:AR000GK6TJ
1228 */
1229 HWTEST_F(AccessTokenKitTest, AllocHapToken004, TestSize.Level1)
1230 {
1231 AccessTokenIDEx tokenIdEx = {0};
1232 AccessTokenID tokenID;
1233 ATokenAplEnum typeBackUp = g_infoManagerTestPolicyPrams.apl;
1234 DeleteTestToken();
1235
1236 g_infoManagerTestPolicyPrams.apl = (ATokenAplEnum)5;
1237 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1238
1239 ASSERT_EQ(0, tokenIdEx.tokenIdExStruct.tokenID);
1240
1241 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1242 g_infoManagerTestInfoParms.bundleName,
1243 g_infoManagerTestInfoParms.instIndex);
1244 ASSERT_EQ(0, tokenID);
1245 int ret = AccessTokenKit::DeleteToken(tokenID);
1246 ASSERT_EQ(RET_FAILED, ret);
1247 g_infoManagerTestPolicyPrams.apl = typeBackUp;
1248 }
1249
1250 /**
1251 * @tc.name: AllocHapToken005
1252 * @tc.desc: can alloc a tokenId when bundlename in permdef is different with bundlename in info.
1253 * @tc.type: FUNC
1254 * @tc.require:AR000GK6TJ
1255 */
1256 HWTEST_F(AccessTokenKitTest, AllocHapToken005, TestSize.Level1)
1257 {
1258 AccessTokenIDEx tokenIdEx = {0};
1259 std::string backUp;
1260 std::string backUpPermission;
1261 std::string bundleNameBackUp = g_infoManagerTestPermDef1.bundleName;
1262 DeleteTestToken();
1263
1264 backUp = g_infoManagerTestPolicyPrams.permList[0].bundleName;
1265 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1266
1267 g_infoManagerTestPolicyPrams.permList[0].bundleName = "invalid_bundleName";
1268 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp01";
1269 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1270 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
1271
1272 PermissionDef permDefResultBeta;
1273 int ret = AccessTokenKit::GetDefPermission(
1274 g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResultBeta);
1275 ASSERT_EQ(RET_SUCCESS, ret);
1276 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[1].permissionName, permDefResultBeta);
1277 ASSERT_EQ(RET_SUCCESS, ret);
1278 g_infoManagerTestPolicyPrams.permList[0].bundleName = backUp;
1279 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1280 }
1281
1282 /**
1283 * @tc.name: AllocHapToken006
1284 * @tc.desc: can alloc a tokenId with a invalid permList permissionName.
1285 * @tc.type: FUNC
1286 * @tc.require:AR000GK6TJ
1287 */
1288 HWTEST_F(AccessTokenKitTest, AllocHapToken006, TestSize.Level1)
1289 {
1290 AccessTokenIDEx tokenIdEx = {0};
1291 std::string backUp;
1292 DeleteTestToken();
1293
1294 const std::string invalidPermissionName (INVALID_PERMNAME_LEN, 'x');
1295 backUp = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1296 g_infoManagerTestPolicyPrams.permList[0].permissionName = invalidPermissionName;
1297 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1298 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
1299
1300 PermissionDef permDefResultBeta;
1301 int ret = AccessTokenKit::GetDefPermission(invalidPermissionName, permDefResultBeta);
1302 ASSERT_EQ(RET_FAILED, ret);
1303 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[1].permissionName, permDefResultBeta);
1304 ASSERT_EQ(RET_SUCCESS, ret);
1305 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUp;
1306 }
1307
1308 /**
1309 * @tc.name: AllocHapToken007
1310 * @tc.desc: can alloc a tokenId with invalid permdef.
1311 * @tc.type: FUNC
1312 * @tc.require:AR000GK6TJ
1313 */
1314 HWTEST_F(AccessTokenKitTest, AllocHapToken007, TestSize.Level1)
1315 {
1316 AccessTokenIDEx tokenIdEx = {0};
1317 std::string backUp;
1318 std::string backUpPermission;
1319 DeleteTestToken();
1320
1321 const std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x');
1322 backUp = g_infoManagerTestPolicyPrams.permList[0].bundleName;
1323 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1324
1325 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp02";
1326 g_infoManagerTestPolicyPrams.permList[0].bundleName = invalidBundleName;
1327 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1328 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
1329
1330 PermissionDef permDefResultBeta;
1331 int ret = AccessTokenKit::GetDefPermission(
1332 g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResultBeta);
1333 ASSERT_EQ(RET_FAILED, ret);
1334 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[1].permissionName, permDefResultBeta);
1335 ASSERT_EQ(RET_SUCCESS, ret);
1336 g_infoManagerTestPolicyPrams.permList[0].bundleName = backUp;
1337 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1338 }
1339
1340 /**
1341 * @tc.name: AllocHapToken008
1342 * @tc.desc: can alloc a tokenId with invalid permdef.
1343 * @tc.type: FUNC
1344 * @tc.require:AR000GK6TJ
1345 */
1346 HWTEST_F(AccessTokenKitTest, AllocHapToken008, TestSize.Level1)
1347 {
1348 AccessTokenIDEx tokenIdEx = {0};
1349 std::string backUp;
1350 std::string backUpPermission;
1351 DeleteTestToken();
1352
1353 const std::string invalidLabel (INVALID_LABEL_LEN, 'x');
1354 backUp = g_infoManagerTestPolicyPrams.permList[0].label;
1355 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1356 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp03";
1357 g_infoManagerTestPolicyPrams.permList[0].label = invalidLabel;
1358 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1359 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
1360
1361 PermissionDef permDefResultBeta;
1362 int ret = AccessTokenKit::GetDefPermission(
1363 g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResultBeta);
1364 ASSERT_EQ(RET_FAILED, ret);
1365 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[1].permissionName, permDefResultBeta);
1366 ASSERT_EQ(RET_SUCCESS, ret);
1367 g_infoManagerTestPolicyPrams.permList[0].label = backUp;
1368 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1369 }
1370
1371 /**
1372 * @tc.name: AllocHapToken009
1373 * @tc.desc: can alloc a tokenId with invalid permdef.
1374 * @tc.type: FUNC
1375 * @tc.require:AR000GK6TJ
1376 */
1377 HWTEST_F(AccessTokenKitTest, AllocHapToken009, TestSize.Level1)
1378 {
1379 AccessTokenIDEx tokenIdEx = {0};
1380 std::string backUp;
1381 std::string backUpPermission;
1382 DeleteTestToken();
1383
1384 const std::string invalidDescription (INVALID_DESCRIPTION_LEN, 'x');
1385 backUp = g_infoManagerTestPolicyPrams.permList[0].description;
1386 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1387
1388 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp04";
1389 g_infoManagerTestPolicyPrams.permList[0].description = invalidDescription;
1390 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1391 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
1392
1393 PermissionDef permDefResultBeta;
1394 int ret = AccessTokenKit::GetDefPermission(
1395 g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResultBeta);
1396 ASSERT_EQ(RET_FAILED, ret);
1397 ret = AccessTokenKit::GetDefPermission(
1398 g_infoManagerTestPolicyPrams.permList[1].permissionName, permDefResultBeta);
1399 ASSERT_EQ(RET_SUCCESS, ret);
1400
1401 g_infoManagerTestPolicyPrams.permList[0].description = backUp;
1402 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1403 }
1404
ExistInVector(vector<unsigned int> array,unsigned int value)1405 static bool ExistInVector(vector<unsigned int> array, unsigned int value)
1406 {
1407 vector<unsigned int>::iterator it;
1408 it = find(array.begin(), array.end(), value);
1409 if (it != array.end()) {
1410 return true;
1411 } else {
1412 return false;
1413 }
1414 }
1415
1416 /**
1417 * @tc.name: AllocHapToken010
1418 * @tc.desc: alloc and delete in a loop.
1419 * @tc.type: FUNC
1420 * @tc.require:AR000GK6TJ
1421 */
1422 HWTEST_F(AccessTokenKitTest, AllocHapToken010, TestSize.Level1)
1423 {
1424 AccessTokenIDEx tokenIdEx = {0};
1425 AccessTokenID tokenID;
1426 int ret;
1427 bool exist = false;
1428 int allocFlag = 0;
1429 int deleteFlag = 0;
1430
1431 DeleteTestToken();
1432 vector<unsigned int> obj;
1433 for (int i = 0; i < CYCLE_TIMES; i++) {
1434 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1435 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
1436 g_infoManagerTestInfoParms.bundleName,
1437 g_infoManagerTestInfoParms.instIndex);
1438
1439 exist = ExistInVector(obj, tokenID);
1440 if (exist) {
1441 allocFlag = 1;
1442 }
1443 obj.push_back(tokenID);
1444
1445 ret = AccessTokenKit::DeleteToken(tokenID);
1446 if (RET_SUCCESS != ret) {
1447 deleteFlag = 1;
1448 }
1449 }
1450 ASSERT_EQ(allocFlag, 0);
1451 ASSERT_EQ(deleteFlag, 0);
1452 }
1453
1454 /**
1455 * @tc.name: AllocHapToken011
1456 * @tc.desc: cannot alloc a tokenId with invalid appIDDesc.
1457 * @tc.type: FUNC
1458 * @tc.require:AR000GK6TJ
1459 */
1460 HWTEST_F(AccessTokenKitTest, AllocHapToken011, TestSize.Level1)
1461 {
1462 std::string invalidAppIDDesc (INVALID_APPIDDESC_LEN, 'x');
1463 std::string backup;
1464 AccessTokenIDEx tokenIdEx = {0};
1465
1466 DeleteTestToken();
1467 backup = g_infoManagerTestInfoParms.appIDDesc;
1468 g_infoManagerTestInfoParms.appIDDesc = invalidAppIDDesc;
1469 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1470 ASSERT_EQ(0, tokenIdEx.tokenIdExStruct.tokenID);
1471 g_infoManagerTestInfoParms.appIDDesc = backup;
1472 }
1473
1474 /**
1475 * @tc.name: AllocHapToken012
1476 * @tc.desc: cannot alloc a tokenId with invalid bundleName.
1477 * @tc.type: FUNC
1478 * @tc.require:AR000GK6TJ
1479 */
1480 HWTEST_F(AccessTokenKitTest, AllocHapToken012, TestSize.Level1)
1481 {
1482 std::string backup;
1483 AccessTokenIDEx tokenIdEx = {0};
1484
1485 backup = g_infoManagerTestInfoParms.bundleName;
1486 g_infoManagerTestInfoParms.bundleName = "";
1487 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1488 ASSERT_EQ(0, tokenIdEx.tokenIdExStruct.tokenID);
1489 g_infoManagerTestInfoParms.bundleName = backup;
1490 }
1491
1492 /**
1493 * @tc.name: AllocHapToken013
1494 * @tc.desc: cannot alloc a tokenId with invalid appIDDesc.
1495 * @tc.type: FUNC
1496 * @tc.require:AR000GK6TJ
1497 */
1498 HWTEST_F(AccessTokenKitTest, AllocHapToken013, TestSize.Level1)
1499 {
1500 std::string backup;
1501 AccessTokenIDEx tokenIdEx = {0};
1502
1503 backup = g_infoManagerTestInfoParms.appIDDesc;
1504 g_infoManagerTestInfoParms.appIDDesc = "";
1505 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1506 ASSERT_EQ(0, tokenIdEx.tokenIdExStruct.tokenID);
1507 g_infoManagerTestInfoParms.appIDDesc = backup;
1508 }
1509
1510 /**
1511 * @tc.name: AllocHapToken014
1512 * @tc.desc: can alloc a tokenId with permList permissionName as "".
1513 * @tc.type: FUNC
1514 * @tc.require:AR000GK6TJ
1515 */
1516 HWTEST_F(AccessTokenKitTest, AllocHapToken014, TestSize.Level1)
1517 {
1518 std::string backup;
1519 AccessTokenIDEx tokenIdEx = {0};
1520
1521 backup = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1522 g_infoManagerTestPolicyPrams.permList[0].permissionName = "";
1523 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1524 PermissionDef permDefResultBeta;
1525 int ret = AccessTokenKit::GetDefPermission("", permDefResultBeta);
1526 ASSERT_EQ(RET_FAILED, ret);
1527 g_infoManagerTestPolicyPrams.permList[0].permissionName = backup;
1528 }
1529
1530 /**
1531 * @tc.name: AllocHapToken015
1532 * @tc.desc: can alloc a tokenId with permList bundleName as "".
1533 * @tc.type: FUNC
1534 * @tc.require:AR000GK6TJ
1535 */
1536 HWTEST_F(AccessTokenKitTest, AllocHapToken015, TestSize.Level1)
1537 {
1538 std::string backup;
1539 std::string backUpPermission;
1540 AccessTokenIDEx tokenIdEx = {0};
1541
1542 backup = g_infoManagerTestPolicyPrams.permList[0].bundleName;
1543 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1544 g_infoManagerTestPolicyPrams.permList[0].bundleName = "";
1545 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp05";
1546 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1547
1548 PermissionDef permDefResultBeta;
1549 int ret = AccessTokenKit::GetDefPermission(
1550 g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResultBeta);
1551 ASSERT_EQ(RET_FAILED, ret);
1552 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[1].permissionName, permDefResultBeta);
1553 ASSERT_EQ(RET_SUCCESS, ret);
1554 g_infoManagerTestPolicyPrams.permList[0].bundleName = backup;
1555 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1556 }
1557
1558 /**
1559 * @tc.name: AllocHapToken016
1560 * @tc.desc: can alloc a tokenId with label as "".
1561 * @tc.type: FUNC
1562 * @tc.require:AR000GK6TJ
1563 */
1564 HWTEST_F(AccessTokenKitTest, AllocHapToken016, TestSize.Level1)
1565 {
1566 std::string backup;
1567 std::string backUpPermission;
1568 AccessTokenIDEx tokenIdEx = {0};
1569
1570 backup = g_infoManagerTestPolicyPrams.permList[0].label;
1571 g_infoManagerTestPolicyPrams.permList[0].label = "";
1572 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1573 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp06";
1574 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1575
1576 PermissionDef permDefResult;
1577 int ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1578 ASSERT_EQ(ret, RET_SUCCESS);
1579 g_infoManagerTestPolicyPrams.permList[0].label = backup;
1580 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1581 }
1582
1583 /**
1584 * @tc.name: AllocHapToken017
1585 * @tc.desc: cannot alloc a tokenId with invalid permdef.
1586 * @tc.type: FUNC
1587 * @tc.require:AR000GK6TJ
1588 */
1589 HWTEST_F(AccessTokenKitTest, AllocHapToken017, TestSize.Level1)
1590 {
1591 std::string backUpPermission;
1592 std::string backup;
1593 AccessTokenIDEx tokenIdEx = {0};
1594
1595 backup = g_infoManagerTestPolicyPrams.permList[0].description;
1596 g_infoManagerTestPolicyPrams.permList[0].description = "";
1597 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1598 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp07";
1599 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1600
1601 PermissionDef permDefResult;
1602 int ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1603 ASSERT_EQ(ret, RET_SUCCESS);
1604 g_infoManagerTestPolicyPrams.permList[0].description = backup;
1605 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1606 }
1607
1608 /**
1609 * @tc.name: UpdateHapToken001
1610 * @tc.desc: alloc a tokenId successfully, update it successfully and verify it.
1611 * @tc.type: FUNC
1612 * @tc.require:AR000GK6TJ
1613 */
1614 HWTEST_F(AccessTokenKitTest, UpdateHapToken001, TestSize.Level1)
1615 {
1616 int userID = g_infoManagerTestInfoParms.userID;
1617 const std::string bundleName = g_infoManagerTestInfoParms.bundleName;
1618 int instIndex = g_infoManagerTestInfoParms.instIndex;
1619
1620 const std::string appIDDesc = "housework app";
1621
1622 DeleteTestToken();
1623 AccessTokenIDEx tokenIdEx = {0};
1624 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1625 GTEST_LOG_(INFO) << "tokenID :" << tokenIdEx.tokenIdExStruct.tokenID;
1626 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
1627 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1628 g_infoManagerTestPolicyPrams.apl = APL_SYSTEM_BASIC;
1629
1630 int ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1631 ASSERT_EQ(0, ret);
1632
1633 HapTokenInfo hapTokenInfoRes;
1634 ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1635 ASSERT_EQ(RET_SUCCESS, ret);
1636
1637 ASSERT_EQ(hapTokenInfoRes.appID, "housework app");
1638 ASSERT_EQ(hapTokenInfoRes.apl, APL_SYSTEM_BASIC);
1639
1640 ret = AccessTokenKit::DeleteToken(tokenID);
1641 ASSERT_EQ(RET_SUCCESS, ret);
1642 }
1643
1644 /**
1645 * @tc.name: UpdateHapToken002
1646 * @tc.desc: cannot update hap token info with invalid userId.
1647 * @tc.type: FUNC
1648 * @tc.require:AR000GK6TJ
1649 */
1650 HWTEST_F(AccessTokenKitTest, UpdateHapToken002, TestSize.Level1)
1651 {
1652 int ret = AccessTokenKit::UpdateHapToken(TEST_USER_ID_INVALID, "appIDDesc", g_infoManagerTestPolicyPrams);
1653 ASSERT_EQ(RET_FAILED, ret);
1654 }
1655
1656 /**
1657 * @tc.name: UpdateHapToken003
1658 * @tc.desc: cannot update hap token info with invalid appIDDesc.
1659 * @tc.type: FUNC
1660 * @tc.require:AR000GK6TJ
1661 */
1662 HWTEST_F(AccessTokenKitTest, UpdateHapToken003, TestSize.Level1)
1663 {
1664 int userID = g_infoManagerTestInfoParms.userID;
1665 const std::string bundleName = g_infoManagerTestInfoParms.bundleName;
1666 int instIndex = g_infoManagerTestInfoParms.instIndex;
1667
1668 const std::string appIDDesc (INVALID_APPIDDESC_LEN, 'x');
1669
1670 AccessTokenIDEx tokenIdEx = {0};
1671 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1672
1673 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
1674
1675 int ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1676 ASSERT_EQ(RET_FAILED, ret);
1677
1678 HapTokenInfo hapTokenInfoRes;
1679 ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1680 ASSERT_EQ(RET_SUCCESS, ret);
1681
1682 ASSERT_EQ(hapTokenInfoRes.appID, "testtesttesttest");
1683
1684 ret = AccessTokenKit::DeleteToken(tokenID);
1685 ASSERT_EQ(RET_SUCCESS, ret);
1686 }
1687
1688 /**
1689 * @tc.name: UpdateHapToken004
1690 * @tc.desc: cannot update a tokenId with invalid apl.
1691 * @tc.type: FUNC
1692 * @tc.require:AR000GK6TJ
1693 */
1694 HWTEST_F(AccessTokenKitTest, UpdateHapToken004, TestSize.Level1)
1695 {
1696 int userID = g_infoManagerTestInfoParms.userID;
1697 const std::string bundleName = g_infoManagerTestInfoParms.bundleName;
1698 int instIndex = g_infoManagerTestInfoParms.instIndex;
1699
1700 const std::string appIDDesc = "housework app";
1701
1702 AccessTokenIDEx tokenIdEx = {0};
1703 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1704
1705 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
1706
1707 g_infoManagerTestPolicyPrams.apl = (ATokenAplEnum)5;
1708
1709 int ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1710 ASSERT_EQ(RET_FAILED, ret);
1711
1712 HapTokenInfo hapTokenInfoRes;
1713 ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1714 ASSERT_EQ(RET_SUCCESS, ret);
1715
1716 ASSERT_EQ(hapTokenInfoRes.apl, APL_NORMAL);
1717
1718 ret = AccessTokenKit::DeleteToken(tokenID);
1719 ASSERT_EQ(RET_SUCCESS, ret);
1720 }
1721
1722 /**
1723 * @tc.name: UpdateHapToken005
1724 * @tc.desc: cannot update a tokenId with invalid string value.
1725 * @tc.type: FUNC
1726 * @tc.require:AR000GK6TJ
1727 */
1728 HWTEST_F(AccessTokenKitTest, UpdateHapToken005, TestSize.Level1)
1729 {
1730 std::string backUpPermission;
1731 const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc;
1732 PermissionDef permDefResult;
1733
1734 DeleteTestToken();
1735 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1736 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1737 ASSERT_NE(0, tokenID);
1738
1739 std::string backup = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1740 g_infoManagerTestPolicyPrams.permList[0].permissionName = "";
1741 int ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1742 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1743 ASSERT_EQ(RET_FAILED, ret);
1744 g_infoManagerTestPolicyPrams.permList[0].permissionName = backup;
1745
1746 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1747 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp11";
1748 backup = g_infoManagerTestPolicyPrams.permList[0].bundleName;
1749 g_infoManagerTestPolicyPrams.permList[0].bundleName = "";
1750 ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1751 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1752 ASSERT_EQ(RET_FAILED, ret);
1753 g_infoManagerTestPolicyPrams.permList[0].bundleName = backup;
1754 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1755
1756 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1757 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp12";
1758 backup = g_infoManagerTestPolicyPrams.permList[0].label;
1759 g_infoManagerTestPolicyPrams.permList[0].label = "";
1760 ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1761 ASSERT_EQ(RET_SUCCESS, ret);
1762 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1763 ASSERT_EQ(RET_SUCCESS, ret);
1764 g_infoManagerTestPolicyPrams.permList[0].label = backup;
1765 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1766
1767 backUpPermission = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1768 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.testtmp13";
1769 backup = g_infoManagerTestPolicyPrams.permList[0].description;
1770 g_infoManagerTestPolicyPrams.permList[0].description = "";
1771 ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1772 ASSERT_EQ(RET_SUCCESS, ret);
1773 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1774 ASSERT_EQ(RET_SUCCESS, ret);
1775 g_infoManagerTestPolicyPrams.permList[0].description = backup;
1776 g_infoManagerTestPolicyPrams.permList[0].permissionName = backUpPermission;
1777
1778 ret = AccessTokenKit::DeleteToken(tokenID);
1779 ASSERT_EQ(RET_SUCCESS, ret);
1780 }
1781
1782 /**
1783 * @tc.name: UpdateHapToken006
1784 * @tc.desc: update a batch of tokenId.
1785 * @tc.type: FUNC
1786 * @tc.require:AR000GK6TJ
1787 */
1788 HWTEST_F(AccessTokenKitTest, UpdateHapToken006, TestSize.Level1)
1789 {
1790 int allocFlag = 0;
1791 int updateFlag = 0;
1792 int deleteFlag = 0;
1793 AccessTokenIDEx tokenIdEx = {0};
1794 AccessTokenID tokenID;
1795 int ret;
1796 vector<AccessTokenID> obj;
1797 bool exist;
1798 const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc;
1799 HapInfoParams infoManagerTestInfo = g_infoManagerTestInfoParms;
1800 DeleteTestToken();
1801
1802 for (int i = 0; i < CYCLE_TIMES; i++) {
1803 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfo, g_infoManagerTestPolicyPrams);
1804 tokenID = GetAccessTokenID(infoManagerTestInfo.userID,
1805 infoManagerTestInfo.bundleName,
1806 infoManagerTestInfo.instIndex);
1807
1808 exist = ExistInVector(obj, tokenID);
1809 if (exist) {
1810 allocFlag = 1;
1811 break;
1812 }
1813 obj.push_back(tokenID);
1814 infoManagerTestInfo.userID++;
1815 }
1816
1817 infoManagerTestInfo.instIndex = 1;
1818 g_infoManagerTestPolicyPrams.apl = APL_SYSTEM_BASIC;
1819 for (int i = 0; i < obj.size(); i++) {
1820 ret = AccessTokenKit::UpdateHapToken(obj[i], appIDDesc, g_infoManagerTestPolicyPrams);
1821 if (RET_SUCCESS != ret) {
1822 updateFlag = 1;
1823 break;
1824 }
1825 }
1826 g_infoManagerTestPolicyPrams.apl = APL_NORMAL;
1827
1828 for (int i = 0; i < obj.size(); i++) {
1829 ret = AccessTokenKit::DeleteToken(obj[i]);
1830 if (RET_SUCCESS != ret) {
1831 deleteFlag = 1;
1832 }
1833 }
1834 ASSERT_EQ(allocFlag, 0);
1835 ASSERT_EQ(updateFlag, 0);
1836 ASSERT_EQ(deleteFlag, 0);
1837 }
1838
1839 /**
1840 * @tc.name: UpdateHapToken007
1841 * @tc.desc: add new permissdef.
1842 * @tc.type: FUNC
1843 * @tc.require:AR000GK6TJ
1844 */
1845 HWTEST_F(AccessTokenKitTest, UpdateHapToken007, TestSize.Level1)
1846 {
1847 int ret;
1848 std::string backup;
1849 const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc;
1850 DeleteTestToken();
1851
1852 AccessTokenIDEx tokenIdEx = {0};
1853 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1854 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1855 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1856
1857 PermissionDef permDefResult;
1858 /* check permission define before update */
1859 ret = AccessTokenKit::GetDefPermission("ohos.permission.test3", permDefResult);
1860 ASSERT_EQ(RET_FAILED, ret);
1861
1862 backup = g_infoManagerTestPolicyPrams.permList[0].permissionName;
1863 g_infoManagerTestPolicyPrams.permList[0].permissionName = "ohos.permission.test3";
1864 ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1865 ASSERT_EQ(RET_SUCCESS, ret);
1866 g_infoManagerTestPolicyPrams.permList[0].permissionName = backup;
1867
1868 GTEST_LOG_(INFO) << "permissionName :" << g_infoManagerTestPolicyPrams.permList[0].permissionName;
1869
1870 ret = AccessTokenKit::GetDefPermission("ohos.permission.test3", permDefResult);
1871 if (ret != RET_SUCCESS) {
1872 ret = AccessTokenKit::DeleteToken(tokenID);
1873 ASSERT_EQ(RET_SUCCESS, ret);
1874 }
1875 ASSERT_EQ(RET_SUCCESS, ret);
1876 ASSERT_EQ("ohos.permission.test3", permDefResult.permissionName);
1877
1878 ret = AccessTokenKit::DeleteToken(tokenID);
1879 ASSERT_EQ(RET_SUCCESS, ret);
1880 }
1881 /**
1882 * @tc.name: UpdateHapToken008
1883 * @tc.desc: modify permissdef's grantMode.
1884 * @tc.type: FUNC
1885 * @tc.require:AR000GK6TJ
1886 */
1887 HWTEST_F(AccessTokenKitTest, UpdateHapToken008, TestSize.Level1)
1888 {
1889 int ret;
1890 std::string backup;
1891 const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc;
1892 DeleteTestToken();
1893
1894 AccessTokenIDEx tokenIdEx = {0};
1895 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1896 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1897 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1898
1899 PermissionDef permDefResult;
1900 /* check permission define before update */
1901 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1902 ASSERT_EQ(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult.permissionName);
1903 ASSERT_EQ("label", permDefResult.label);
1904 ASSERT_EQ(1, permDefResult.grantMode);
1905 ASSERT_EQ(RET_SUCCESS, ret);
1906
1907 backup = g_infoManagerTestPolicyPrams.permList[0].label;
1908 g_infoManagerTestPolicyPrams.permList[0].grantMode = 0;
1909 g_infoManagerTestPolicyPrams.permList[0].label = "updated label";
1910 ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, g_infoManagerTestPolicyPrams);
1911 ASSERT_EQ(RET_SUCCESS, ret);
1912 g_infoManagerTestPolicyPrams.permList[0].label = backup;
1913 g_infoManagerTestPolicyPrams.permList[0].grantMode = 1;
1914
1915 /* check permission define after update */
1916 ret = AccessTokenKit::GetDefPermission(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult);
1917 ASSERT_EQ(g_infoManagerTestPolicyPrams.permList[0].permissionName, permDefResult.permissionName);
1918 ASSERT_EQ("updated label", permDefResult.label);
1919 ASSERT_EQ(0, permDefResult.grantMode);
1920 ASSERT_EQ(RET_SUCCESS, ret);
1921
1922 ret = AccessTokenKit::DeleteToken(tokenID);
1923 ASSERT_EQ(RET_SUCCESS, ret);
1924 }
1925
1926 /**
1927 * @tc.name: UpdateHapToken009
1928 * @tc.desc: old permission define will not update its grantStatus.
1929 * @tc.type: FUNC
1930 * @tc.require:AR000GK6TJ
1931 */
1932 HWTEST_F(AccessTokenKitTest, UpdateHapToken009, TestSize.Level1)
1933 {
1934 int ret;
1935 std::vector<PermissionDef> permDefList;
1936 const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc;
1937 PermissionDef infoManagerTestPermDef = g_infoManagerTestPermDef1;
1938 PermissionStateFull infoManagerTestState = {
1939 .grantFlags = {PermissionState::PERMISSION_DENIED},
1940 .grantStatus = {3},
1941 .isGeneral = true,
1942 .permissionName = "ohos.permission.test1",
1943 .resDeviceID = {"local"}};
1944
1945 HapPolicyParams infoManagerTestPolicyPrams = {
1946 .apl = APL_NORMAL,
1947 .domain = "test.domain",
1948 .permList = {infoManagerTestPermDef},
1949 .permStateList = {infoManagerTestState}};
1950
1951 DeleteTestToken();
1952 AccessTokenIDEx tokenIdEx = {0};
1953 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1954 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1955 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
1956
1957 ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.test1");
1958 ASSERT_EQ(ret, g_infoManagerTestState1.grantStatus[0]);
1959
1960 ret = AccessTokenKit::UpdateHapToken(tokenID, appIDDesc, infoManagerTestPolicyPrams);
1961
1962 ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.test1");
1963 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
1964
1965 ret = AccessTokenKit::DeleteToken(tokenID);
1966 ASSERT_EQ(RET_SUCCESS, ret);
1967 }
1968
ThreadTestFunc01(void * args)1969 static void *ThreadTestFunc01(void *args)
1970 {
1971 ATokenTypeEnum type;
1972 AccessTokenID tokenID;
1973
1974 for (int i = 0; i < CYCLE_TIMES; i++) {
1975 tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
1976 g_infoManagerTestInfoParms.bundleName,
1977 g_infoManagerTestInfoParms.instIndex);
1978 type = AccessTokenKit::GetTokenType(tokenID);
1979 if (type != TOKEN_HAP) {
1980 GTEST_LOG_(INFO) << "ThreadTestFunc01 failed" << tokenID;
1981 }
1982 }
1983 return NULL;
1984 }
1985
ThreadTestFunc02(void * args)1986 static void *ThreadTestFunc02(void *args)
1987 {
1988 int ret;
1989 AccessTokenID tokenID;
1990 HapTokenInfo hapTokenInfoRes;
1991
1992 for (int i = 0; i < CYCLE_TIMES; i++) {
1993 tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
1994 g_infoManagerTestInfoParms.bundleName,
1995 g_infoManagerTestInfoParms.instIndex);
1996 ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
1997 if (ret != RET_SUCCESS) {
1998 GTEST_LOG_(INFO) << "ThreadTestFunc02 failed" << tokenID;
1999 }
2000 }
2001 return NULL;
2002 }
2003
2004 /**
2005 * @tc.name: AllocHapToken011
2006 * @tc.desc: Mulitpulthread test.
2007 * @tc.type: FUNC
2008 * @tc.require:AR000GK6TJ
2009 */
2010 HWTEST_F(AccessTokenKitTest, Mulitpulthread001, TestSize.Level1)
2011 {
2012 int ret;
2013 AccessTokenIDEx tokenIdEx = {0};
2014 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
2015 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
2016 pthread_t tid[2];
2017 (void)pthread_create(&tid[0], 0, &ThreadTestFunc01, NULL);
2018 (void)pthread_create(&tid[1], 0, &ThreadTestFunc01, NULL);
2019 pthread_join(tid[0], NULL);
2020 pthread_join(tid[1], NULL);
2021
2022 (void)pthread_create(&tid[0], 0, &ThreadTestFunc02, NULL);
2023 (void)pthread_create(&tid[1], 0, &ThreadTestFunc02, NULL);
2024 pthread_join(tid[0], NULL);
2025 pthread_join(tid[1], NULL);
2026
2027 ret = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID);
2028 ASSERT_EQ(RET_SUCCESS, ret);
2029 }
2030
ConcurrencyTask(unsigned int tokenID)2031 void ConcurrencyTask(unsigned int tokenID)
2032 {
2033 for (int i = 0; i < CYCLE_TIMES; i++) {
2034 AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_FIXED);
2035 AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
2036 AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
2037
2038 AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_ALPHA, PERMISSION_USER_SET);
2039 AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA);
2040 AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_ALPHA);
2041 }
2042 }
2043
2044 /**
2045 * @tc.name: ConcurrencyTest001
2046 * @tc.desc: Concurrency testing
2047 * @tc.type: FUNC
2048 * @tc.require:AR000GM5FC AR000GK6T8 AR000GK6TF
2049 */
2050 HWTEST_F(AccessTokenKitTest, ConcurrencyTest001, TestSize.Level1)
2051 {
2052 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
2053 ASSERT_NE(0, tokenID);
2054 std::vector<std::thread> threadVec;
2055 for (int i = 0; i < THREAD_NUM; i++) {
2056 threadVec.emplace_back(std::thread(ConcurrencyTask, tokenID));
2057 }
2058 for (auto it = threadVec.begin(); it != threadVec.end(); it++) {
2059 it->join();
2060 }
2061 }
2062
2063 /**
2064 * @tc.name: CheckNativeDCap001
2065 * @tc.desc: cannot Check native dcap with invalid tokenID.
2066 * @tc.type: FUNC
2067 * @tc.require:AR000GK6TD
2068 */
2069 HWTEST_F(AccessTokenKitTest, CheckNativeDCap001, TestSize.Level1)
2070 {
2071 AccessTokenID tokenID = 0;
2072 const std::string dcap = "AT_CAP";
2073 int ret = AccessTokenKit::CheckNativeDCap(tokenID, dcap);
2074 ASSERT_EQ(RET_FAILED, ret);
2075
2076 tokenID = 1;
2077 ret = AccessTokenKit::CheckNativeDCap(tokenID, dcap);
2078 ASSERT_EQ(RET_FAILED, ret);
2079 }
2080
2081 /**
2082 * @tc.name: CheckNativeDCap002
2083 * @tc.desc: cannot Check native dcap with invalid dcap.
2084 * @tc.type: FUNC
2085 * @tc.require:AR000GK6TD
2086 */
2087 HWTEST_F(AccessTokenKitTest, CheckNativeDCap002, TestSize.Level1)
2088 {
2089 AccessTokenID tokenID = 0Xff;
2090 const std::string invalidDcap (INVALID_DCAP_LEN, 'x');
2091 int ret = AccessTokenKit::CheckNativeDCap(tokenID, invalidDcap);
2092 ASSERT_EQ(RET_FAILED, ret);
2093 }
2094
2095 /**
2096 * @tc.name: GetNativeTokenInfo001
2097 * @tc.desc: cannot get native token with invalid tokenID.
2098 * @tc.type: FUNC
2099 * @tc.require:AR000GK6TD
2100 */
2101 HWTEST_F(AccessTokenKitTest, GetNativeTokenInfo001, TestSize.Level1)
2102 {
2103 AccessTokenID tokenID = 0;
2104 NativeTokenInfo findInfo;
2105 int ret = AccessTokenKit::GetNativeTokenInfo(tokenID, findInfo);
2106 ASSERT_EQ(ret, RET_FAILED);
2107
2108 tokenID = 0xff;
2109 ret = AccessTokenKit::GetNativeTokenInfo(tokenID, findInfo);
2110 ASSERT_EQ(ret, RET_FAILED);
2111 }
2112
2113 /**
2114 * @tc.name: GetTokenTypeFlag001
2115 * @tc.desc: cannot get token type with tokenID.
2116 * @tc.type: FUNC
2117 * @tc.require:AR000GK6TD
2118 */
2119 HWTEST_F(AccessTokenKitTest, GetTokenTypeFlag001, TestSize.Level1)
2120 {
2121 AccessTokenID tokenID = 0;
2122 ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenID);
2123 ASSERT_EQ(ret, TOKEN_INVALID);
2124 }
2125
2126 /**
2127 * @tc.name: GetTokenTypeFlag002
2128 * @tc.desc: Get token type with native tokenID.
2129 * @tc.type: FUNC
2130 * @tc.require:AR000GK6TD
2131 */
2132 HWTEST_F(AccessTokenKitTest, GetTokenTypeFlag002, TestSize.Level1)
2133 {
2134 uint64_t tokenId01 = GetAccessTokenId("GetTokenTypeFlag002", nullptr, 0, "system_core");
2135
2136 AccessTokenID tokenID = tokenId01 & 0xffffffff;
2137 ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenID);
2138 ASSERT_EQ(ret, TOKEN_NATIVE);
2139 }
2140
2141 /**
2142 * @tc.name: GetSelfPermissionsState001
2143 * @tc.desc: get permission list state
2144 * @tc.type: FUNC
2145 * @tc.require:AR000GK6T6
2146 */
2147 HWTEST_F(AccessTokenKitTest, GetSelfPermissionsState001, TestSize.Level1)
2148 {
2149 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
2150 ASSERT_NE(0, tokenID);
2151 ASSERT_EQ(0, SetSelfTokenID(tokenID));
2152
2153 PermissionListState perm1 = {
2154 .permissionName = "ohos.permission.testPermDef1",
2155 .state = -1,
2156 };
2157 PermissionListState perm2 = {
2158 .permissionName = "ohos.permission.testPermDef2",
2159 .state = -1,
2160 };
2161 PermissionListState perm3 = {
2162 .permissionName = "ohos.permission.testPermDef3",
2163 .state = -1,
2164 };
2165 PermissionListState perm4 = {
2166 .permissionName = "ohos.permission.testPermDef4",
2167 .state = -1,
2168 };
2169
2170 std::vector<PermissionListState> permsList1;
2171 permsList1.emplace_back(perm1);
2172 permsList1.emplace_back(perm2);
2173 permsList1.emplace_back(perm3);
2174 permsList1.emplace_back(perm4);
2175
2176 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList1);
2177 ASSERT_EQ(DYNAMIC_OPER, ret);
2178 ASSERT_EQ(4, permsList1.size());
2179 ASSERT_EQ(DYNAMIC_OPER, permsList1[0].state);
2180 ASSERT_EQ(DYNAMIC_OPER, permsList1[1].state);
2181 ASSERT_EQ(SETTING_OPER, permsList1[2].state);
2182 ASSERT_EQ(PASS_OPER, permsList1[3].state);
2183 ASSERT_EQ("ohos.permission.testPermDef1", permsList1[0].permissionName);
2184 ASSERT_EQ("ohos.permission.testPermDef2", permsList1[1].permissionName);
2185 ASSERT_EQ("ohos.permission.testPermDef3", permsList1[2].permissionName);
2186 ASSERT_EQ("ohos.permission.testPermDef4", permsList1[3].permissionName);
2187
2188 PermissionListState perm5 = {
2189 .permissionName = "ohos.permission.testPermDef5",
2190 .state = -1,
2191 };
2192 permsList1.emplace_back(perm5);
2193 ret = AccessTokenKit::GetSelfPermissionsState(permsList1);
2194 ASSERT_EQ(INVALID_OPER, permsList1[4].state);
2195 ASSERT_EQ(DYNAMIC_OPER, ret);
2196
2197 std::vector<PermissionListState> permsList2;
2198 permsList2.emplace_back(perm3);
2199 permsList2.emplace_back(perm4);
2200 ret = AccessTokenKit::GetSelfPermissionsState(permsList2);
2201 ASSERT_EQ(SETTING_OPER, permsList2[0].state);
2202 ASSERT_EQ(PASS_OPER, permsList2[1].state);
2203 ASSERT_EQ(PASS_OPER, ret);
2204
2205 permsList2.emplace_back(perm5);
2206 ret = AccessTokenKit::GetSelfPermissionsState(permsList2);
2207 ASSERT_EQ(SETTING_OPER, permsList2[0].state);
2208 ASSERT_EQ(PASS_OPER, permsList2[1].state);
2209 ASSERT_EQ(INVALID_OPER, permsList2[2].state);
2210 ASSERT_EQ(PASS_OPER, ret);
2211
2212 std::vector<PermissionListState> permsList3;
2213 permsList3.emplace_back(perm5);
2214 ret = AccessTokenKit::GetSelfPermissionsState(permsList3);
2215 ASSERT_EQ(INVALID_OPER, permsList3[0].state);
2216 ASSERT_EQ(PASS_OPER, ret);
2217 }
2218
2219 /**
2220 * @tc.name: GetTokenTypeFlag003
2221 * @tc.desc: Get token type with hap tokenID.
2222 * @tc.type: FUNC
2223 * @tc.require:AR000GK6TD
2224 */
2225 HWTEST_F(AccessTokenKitTest, GetTokenTypeFlag003, TestSize.Level1)
2226 {
2227 AccessTokenIDEx tokenIdEx = {0};
2228 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
2229 ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
2230
2231 ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenIdEx.tokenIdExStruct.tokenID);
2232 ASSERT_EQ(ret, TOKEN_HAP);
2233
2234 int res = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID);
2235 ASSERT_EQ(RET_SUCCESS, res);
2236 }
2237
2238 #ifdef TOKEN_SYNC_ENABLE
2239 /**
2240 * @tc.name: SetRemoteHapTokenInfo001
2241 * @tc.desc: set remote hap token info success
2242 * @tc.type: FUNC
2243 * @tc.require:AR000GK6T5
2244 */
2245 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo001, TestSize.Level1)
2246 {
2247 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo001 start.");
2248 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2249 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2250 HapTokenInfo baseInfo = {
2251 .apl = APL_NORMAL,
2252 .ver = 1,
2253 .userID = 1,
2254 .bundleName = "com.ohos.access_token",
2255 .instIndex = 1,
2256 .appID = "testtesttesttest",
2257 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2258 .tokenID = 0x20100000,
2259 .tokenAttr = 0
2260 };
2261
2262 PermissionStateFull infoManagerTestState = {
2263 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2264 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2265 .isGeneral = true,
2266 .permissionName = "ohos.permission.test1",
2267 .resDeviceID = {"local"}};
2268 std::vector<PermissionStateFull> permStateList;
2269 permStateList.emplace_back(infoManagerTestState);
2270
2271 HapTokenInfoForSync remoteTokenInfo = {
2272 .baseInfo = baseInfo,
2273 .permStateList = permStateList
2274 };
2275
2276 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2277 ASSERT_EQ(ret, RET_SUCCESS);
2278
2279 // Get local map token ID
2280 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2281 ASSERT_NE(mapID, 0);
2282
2283 // check local map token
2284 HapTokenInfo resultInfo;
2285 ret = AccessTokenKit::GetHapTokenInfo(mapID, resultInfo);
2286 ASSERT_EQ(ret, RET_SUCCESS);
2287 ASSERT_EQ(resultInfo.apl, remoteTokenInfo.baseInfo.apl);
2288 ASSERT_EQ(resultInfo.ver, remoteTokenInfo.baseInfo.ver);
2289 ASSERT_EQ(resultInfo.userID, remoteTokenInfo.baseInfo.userID);
2290 ASSERT_EQ(resultInfo.bundleName, remoteTokenInfo.baseInfo.bundleName);
2291 ASSERT_EQ(resultInfo.instIndex, remoteTokenInfo.baseInfo.instIndex);
2292 ASSERT_EQ(resultInfo.appID, remoteTokenInfo.baseInfo.appID);
2293 ASSERT_EQ(resultInfo.deviceID, remoteTokenInfo.baseInfo.deviceID);
2294 ASSERT_NE(resultInfo.tokenID, remoteTokenInfo.baseInfo.tokenID); // tokenID already is map tokenID
2295 ASSERT_EQ(resultInfo.tokenAttr, remoteTokenInfo.baseInfo.tokenAttr);
2296
2297 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2298 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
2299
2300 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2301 ASSERT_EQ(ret, RET_SUCCESS);
2302 }
2303
2304 /**
2305 * @tc.name: SetRemoteHapTokenInfo002
2306 * @tc.desc: set remote hap token info, token info is wrong
2307 * @tc.type: FUNC
2308 * @tc.require:AR000GK6T5
2309 */
2310 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo002, TestSize.Level1)
2311 {
2312 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo002 start.");
2313 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2314 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2315 HapTokenInfo rightBaseInfo = {
2316 .apl = APL_NORMAL,
2317 .ver = 1,
2318 .userID = 1,
2319 .bundleName = "com.ohos.access_token",
2320 .instIndex = 1,
2321 .appID = "testtesttesttest",
2322 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2323 .tokenID = 0x20100000,
2324 .tokenAttr = 0
2325 };
2326
2327 HapTokenInfo wrongBaseInfo = rightBaseInfo;
2328 wrongBaseInfo.apl = (ATokenAplEnum)11; // wrong apl
2329
2330 PermissionStateFull infoManagerTestState = {
2331 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2332 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2333 .isGeneral = true,
2334 .permissionName = "ohos.permission.test1",
2335 .resDeviceID = {"local"}};
2336 std::vector<PermissionStateFull> permStateList;
2337 permStateList.emplace_back(infoManagerTestState);
2338
2339 HapTokenInfoForSync remoteTokenInfo = {
2340 .baseInfo = wrongBaseInfo,
2341 .permStateList = permStateList
2342 };
2343
2344 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2345 ASSERT_NE(ret, RET_SUCCESS);
2346
2347 std::string wrongStr(10241, 'x');
2348
2349 wrongBaseInfo = rightBaseInfo;
2350 wrongBaseInfo.appID = wrongStr; // wrong appID
2351 remoteTokenInfo.baseInfo = wrongBaseInfo;
2352 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2353 ASSERT_NE(ret, RET_SUCCESS);
2354
2355 wrongBaseInfo = rightBaseInfo;
2356 wrongBaseInfo.bundleName = wrongStr; // wrong bundleName
2357 remoteTokenInfo.baseInfo = wrongBaseInfo;
2358 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2359 ASSERT_NE(ret, RET_SUCCESS);
2360
2361 wrongBaseInfo = rightBaseInfo;
2362 wrongBaseInfo.deviceID = wrongStr; // wrong deviceID
2363 remoteTokenInfo.baseInfo = wrongBaseInfo;
2364 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2365 ASSERT_NE(ret, RET_SUCCESS);
2366
2367 wrongBaseInfo = rightBaseInfo;
2368 wrongBaseInfo.tokenID = 0; // wrong tokenID
2369 remoteTokenInfo.baseInfo = wrongBaseInfo;
2370 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2371 ASSERT_NE(ret, RET_SUCCESS);
2372 }
2373
2374 /**
2375 * @tc.name: SetRemoteHapTokenInfo003
2376 * @tc.desc: set remote hap token wrong permission grant
2377 * @tc.type: FUNC
2378 * @tc.require:AR000GK6T5
2379 */
2380 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo003, TestSize.Level1)
2381 {
2382 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo003 start.");
2383 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2384 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2385 HapTokenInfo baseInfo = {
2386 .apl = APL_NORMAL,
2387 .ver = 1,
2388 .userID = 1,
2389 .bundleName = "com.ohos.access_token",
2390 .instIndex = 1,
2391 .appID = "testtesttesttest",
2392 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2393 .tokenID = 0x20100000,
2394 .tokenAttr = 0
2395 };
2396
2397 PermissionStateFull infoManagerTestState = {
2398 .grantFlags = {11}, // wrong flags
2399 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2400 .isGeneral = true,
2401 .permissionName = "ohos.permission.test1",
2402 .resDeviceID = {"local"}};
2403 std::vector<PermissionStateFull> permStateList;
2404 permStateList.emplace_back(infoManagerTestState);
2405
2406 HapTokenInfoForSync remoteTokenInfo = {
2407 .baseInfo = baseInfo,
2408 .permStateList = permStateList
2409 };
2410
2411 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2412 ASSERT_EQ(ret, RET_SUCCESS);
2413
2414 // Get local map token ID
2415 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2416 ASSERT_NE(mapID, 0);
2417
2418 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2419 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
2420
2421 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2422 ASSERT_EQ(ret, RET_SUCCESS);
2423 }
2424
2425 /**
2426 * @tc.name: SetRemoteHapTokenInfo004
2427 * @tc.desc: update remote hap token when remote exist
2428 * @tc.type: FUNC
2429 * @tc.require:AR000GK6T5
2430 */
2431 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo004, TestSize.Level1)
2432 {
2433 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo004 start.");
2434 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2435 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2436 HapTokenInfo baseInfo = {
2437 .apl = APL_NORMAL,
2438 .ver = 1,
2439 .userID = 1,
2440 .bundleName = "com.ohos.access_token",
2441 .instIndex = 1,
2442 .appID = "testtesttesttest",
2443 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2444 .tokenID = 0x20100000,
2445 .tokenAttr = 0
2446 };
2447
2448 PermissionStateFull infoManagerTestState = {
2449 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2450 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
2451 .isGeneral = true,
2452 .permissionName = "ohos.permission.test1",
2453 .resDeviceID = {"local"}};
2454 std::vector<PermissionStateFull> permStateList;
2455 permStateList.emplace_back(infoManagerTestState);
2456
2457 HapTokenInfoForSync remoteTokenInfo = {
2458 .baseInfo = baseInfo,
2459 .permStateList = permStateList
2460 };
2461
2462 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2463 ASSERT_EQ(ret, RET_SUCCESS);
2464
2465 // Get local map token ID
2466 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2467 ASSERT_NE(mapID, 0);
2468
2469 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2470 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
2471
2472 remoteTokenInfo.permStateList[0].grantStatus[0] = PermissionState::PERMISSION_GRANTED; // second granted
2473 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2474 ASSERT_EQ(ret, RET_SUCCESS);
2475
2476 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2477 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
2478
2479 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2480 ASSERT_EQ(ret, RET_SUCCESS);
2481 }
2482
2483 /**
2484 * @tc.name: SetRemoteHapTokenInfo005
2485 * @tc.desc: add remote hap token, it can not grant by GrantPermission
2486 * @tc.type: FUNC
2487 * @tc.require:AR000GK6T5
2488 */
2489 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo005, TestSize.Level1)
2490 {
2491 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo005 start.");
2492 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2493 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2494 HapTokenInfo baseInfo = {
2495 .apl = APL_NORMAL,
2496 .ver = 1,
2497 .userID = 1,
2498 .bundleName = "com.ohos.access_token",
2499 .instIndex = 1,
2500 .appID = "testtesttesttest",
2501 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2502 .tokenID = 0x20100000,
2503 .tokenAttr = 0
2504 };
2505
2506 PermissionStateFull infoManagerTestState = {
2507 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2508 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
2509 .isGeneral = true,
2510 .permissionName = "ohos.permission.test1",
2511 .resDeviceID = {"local"}};
2512 std::vector<PermissionStateFull> permStateList;
2513 permStateList.emplace_back(infoManagerTestState);
2514
2515 HapTokenInfoForSync remoteTokenInfo = {
2516 .baseInfo = baseInfo,
2517 .permStateList = permStateList
2518 };
2519
2520 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2521 ASSERT_EQ(ret, RET_SUCCESS);
2522
2523 // Get local map token ID
2524 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2525 ASSERT_NE(mapID, 0);
2526
2527 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2528 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
2529
2530 ret = AccessTokenKit::GrantPermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED);
2531 ASSERT_EQ(ret, RET_SUCCESS);
2532
2533 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2534 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
2535
2536 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2537 ASSERT_EQ(ret, RET_SUCCESS);
2538 }
2539
2540 /**
2541 * @tc.name: SetRemoteHapTokenInfo006
2542 * @tc.desc: add remote hap token, it can not revoke by RevokePermission
2543 * @tc.type: FUNC
2544 * @tc.require:AR000GK6T5
2545 */
2546 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo006, TestSize.Level1)
2547 {
2548 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo006 start.");
2549 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2550 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2551 HapTokenInfo baseInfo = {
2552 .apl = APL_NORMAL,
2553 .ver = 1,
2554 .userID = 1,
2555 .bundleName = "com.ohos.access_token",
2556 .instIndex = 1,
2557 .appID = "testtesttesttest",
2558 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2559 .tokenID = 0x20100000,
2560 .tokenAttr = 0
2561 };
2562
2563 PermissionStateFull infoManagerTestState = {
2564 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2565 .grantStatus = {PermissionState::PERMISSION_GRANTED}, // first grant
2566 .isGeneral = true,
2567 .permissionName = "ohos.permission.test1",
2568 .resDeviceID = {"local"}};
2569 std::vector<PermissionStateFull> permStateList;
2570 permStateList.emplace_back(infoManagerTestState);
2571
2572 HapTokenInfoForSync remoteTokenInfo = {
2573 .baseInfo = baseInfo,
2574 .permStateList = permStateList
2575 };
2576
2577 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2578 ASSERT_EQ(ret, RET_SUCCESS);
2579
2580 // Get local map token ID
2581 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2582 ASSERT_NE(mapID, 0);
2583
2584 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2585 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
2586
2587 ret = AccessTokenKit::RevokePermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED);
2588 ASSERT_EQ(ret, RET_SUCCESS);
2589
2590 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2591 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
2592
2593 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2594 ASSERT_EQ(ret, RET_SUCCESS);
2595 }
2596
2597 /**
2598 * @tc.name: SetRemoteHapTokenInfo007
2599 * @tc.desc: add remote hap token, it can not delete by DeleteToken
2600 * @tc.type: FUNC
2601 * @tc.require:AR000GK6T5
2602 */
2603 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo007, TestSize.Level1)
2604 {
2605 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo007 start.");
2606 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2607 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2608 HapTokenInfo baseInfo = {
2609 .apl = APL_NORMAL,
2610 .ver = 1,
2611 .userID = 1,
2612 .bundleName = "com.ohos.access_token",
2613 .instIndex = 1,
2614 .appID = "testtesttesttest",
2615 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2616 .tokenID = 0x20100000,
2617 .tokenAttr = 0
2618 };
2619
2620 PermissionStateFull infoManagerTestState = {
2621 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2622 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
2623 .isGeneral = true,
2624 .permissionName = "ohos.permission.test1",
2625 .resDeviceID = {"local"}};
2626 std::vector<PermissionStateFull> permStateList;
2627 permStateList.emplace_back(infoManagerTestState);
2628
2629 HapTokenInfoForSync remoteTokenInfo = {
2630 .baseInfo = baseInfo,
2631 .permStateList = permStateList
2632 };
2633
2634 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2635 ASSERT_EQ(ret, RET_SUCCESS);
2636
2637 // Get local map token ID
2638 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2639 ASSERT_NE(mapID, 0);
2640
2641 ret = AccessTokenKit::DeleteToken(mapID);
2642 ASSERT_EQ(ret, RET_FAILED);
2643
2644 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2645 ASSERT_EQ(ret, RET_SUCCESS);
2646 }
2647
2648 /**
2649 * @tc.name: SetRemoteHapTokenInfo008
2650 * @tc.desc: add remote hap token, it can not update by UpdateHapToken
2651 * @tc.type: FUNC
2652 * @tc.require:AR000GK6T5
2653 */
2654 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo008, TestSize.Level1)
2655 {
2656 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo008 start.");
2657 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2658 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2659 HapTokenInfo baseInfo = {
2660 .apl = APL_NORMAL,
2661 .ver = 1,
2662 .userID = 1,
2663 .bundleName = "com.ohos.access_token",
2664 .instIndex = 1,
2665 .appID = "testtesttesttest",
2666 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2667 .tokenID = 0x20100000,
2668 .tokenAttr = 0
2669 };
2670
2671 PermissionStateFull infoManagerTestState = {
2672 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED},
2673 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
2674 .isGeneral = true,
2675 .permissionName = "ohos.permission.test1",
2676 .resDeviceID = {"local"}};
2677 std::vector<PermissionStateFull> permStateList;
2678 permStateList.emplace_back(infoManagerTestState);
2679
2680 HapTokenInfoForSync remoteTokenInfo = {
2681 .baseInfo = baseInfo,
2682 .permStateList = permStateList
2683 };
2684
2685 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2686 ASSERT_EQ(ret, RET_SUCCESS);
2687
2688 // Get local map token ID
2689 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2690 ASSERT_NE(mapID, 0);
2691
2692 HapPolicyParams policy;
2693
2694 ret = AccessTokenKit::UpdateHapToken(mapID, "updateFailed", policy);
2695 ASSERT_EQ(ret, RET_FAILED);
2696
2697 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2698 ASSERT_EQ(ret, RET_SUCCESS);
2699 }
2700
2701 /**
2702 * @tc.name: SetRemoteHapTokenInfo009
2703 * @tc.desc: add remote hap token, it can not clear by ClearUserGrantedPermissionState
2704 * @tc.type: FUNC
2705 * @tc.require:AR000GK6T5
2706 */
2707 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo009, TestSize.Level1)
2708 {
2709 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo009 start.");
2710 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2711 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2712 HapTokenInfo baseInfo = {
2713 .apl = APL_NORMAL,
2714 .ver = 1,
2715 .userID = 1,
2716 .bundleName = "com.ohos.access_token",
2717 .instIndex = 1,
2718 .appID = "testtesttesttest",
2719 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2720 .tokenID = 0x20100000,
2721 .tokenAttr = 0
2722 };
2723
2724 PermissionStateFull infoManagerTestState = {
2725 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
2726 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2727 .isGeneral = true,
2728 .permissionName = "ohos.permission.test1",
2729 .resDeviceID = {"local"}};
2730 std::vector<PermissionStateFull> permStateList;
2731 permStateList.emplace_back(infoManagerTestState);
2732
2733 HapTokenInfoForSync remoteTokenInfo = {
2734 .baseInfo = baseInfo,
2735 .permStateList = permStateList
2736 };
2737
2738 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2739 ASSERT_EQ(ret, RET_SUCCESS);
2740
2741 // Get local map token ID
2742 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2743 ASSERT_NE(mapID, 0);
2744
2745 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2746 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
2747
2748 ret = AccessTokenKit::ClearUserGrantedPermissionState(mapID);
2749 ASSERT_EQ(ret, RET_SUCCESS);
2750
2751 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
2752 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
2753
2754 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2755 ASSERT_EQ(ret, RET_SUCCESS);
2756 }
2757
2758 /**
2759 * @tc.name: SetRemoteHapTokenInfo010
2760 * @tc.desc: tokenID is not hap token
2761 * @tc.type: FUNC
2762 * @tc.require:AR000GK6T5
2763 */
2764 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo010, TestSize.Level1)
2765 {
2766 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo009 start.");
2767 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2768 HapTokenInfo baseInfo = {
2769 .apl = APL_NORMAL,
2770 .ver = 1,
2771 .userID = 1,
2772 .bundleName = "com.ohos.access_token",
2773 .instIndex = 1,
2774 .appID = "testtesttesttest",
2775 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2776 .tokenID = 0x28100000,
2777 .tokenAttr = 0
2778 };
2779
2780 PermissionStateFull infoManagerTestState = {
2781 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
2782 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2783 .isGeneral = true,
2784 .permissionName = "ohos.permission.test1",
2785 .resDeviceID = {"local"}};
2786 std::vector<PermissionStateFull> permStateList;
2787 permStateList.emplace_back(infoManagerTestState);
2788
2789 HapTokenInfoForSync remoteTokenInfo = {
2790 .baseInfo = baseInfo,
2791 .permStateList = permStateList
2792 };
2793
2794 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2795 ASSERT_NE(ret, RET_SUCCESS);
2796 }
2797
2798 /**
2799 * @tc.name: DeleteRemoteDeviceToken001
2800 * @tc.desc: delete exist device mapping tokenId
2801 * @tc.type: FUNC
2802 * @tc.require:AR000GK6TA
2803 */
2804 HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceToken001, TestSize.Level1)
2805 {
2806 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
2807 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2808 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2809 HapTokenInfo baseInfo = {
2810 .apl = APL_NORMAL,
2811 .ver = 1,
2812 .userID = 1,
2813 .bundleName = "com.ohos.access_token",
2814 .instIndex = 1,
2815 .appID = "testtesttesttest",
2816 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2817 .tokenID = 0x20100000,
2818 .tokenAttr = 0
2819 };
2820
2821 PermissionStateFull infoManagerTestState = {
2822 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
2823 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2824 .isGeneral = true,
2825 .permissionName = "ohos.permission.test1",
2826 .resDeviceID = {"local"}};
2827 std::vector<PermissionStateFull> permStateList;
2828 permStateList.emplace_back(infoManagerTestState);
2829
2830 HapTokenInfoForSync remoteTokenInfo = {
2831 .baseInfo = baseInfo,
2832 .permStateList = permStateList
2833 };
2834
2835 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2836 ASSERT_EQ(ret, RET_SUCCESS);
2837
2838 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2839 ASSERT_NE(mapID, 0);
2840
2841 HapTokenInfo info;
2842 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
2843 ASSERT_EQ(ret, RET_SUCCESS);
2844
2845 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2846 ASSERT_EQ(ret, RET_SUCCESS);
2847
2848 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
2849 ASSERT_NE(ret, RET_SUCCESS);
2850 }
2851
2852 /**
2853 * @tc.name: DeleteRemoteDeviceToken002
2854 * @tc.desc: delete exist device mapping tokenId
2855 * @tc.type: FUNC
2856 * @tc.require:AR000GK6TA
2857 */
2858 HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceToken002, TestSize.Level1)
2859 {
2860 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
2861 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2862 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2863 HapTokenInfo baseInfo = {
2864 .apl = APL_NORMAL,
2865 .ver = 1,
2866 .userID = 1,
2867 .bundleName = "com.ohos.access_token",
2868 .instIndex = 1,
2869 .appID = "testtesttesttest",
2870 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2871 .tokenID = 0x20100000,
2872 .tokenAttr = 0
2873 };
2874
2875 PermissionStateFull infoManagerTestState = {
2876 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
2877 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2878 .isGeneral = true,
2879 .permissionName = "ohos.permission.test1",
2880 .resDeviceID = {"local"}};
2881 std::vector<PermissionStateFull> permStateList;
2882 permStateList.emplace_back(infoManagerTestState);
2883
2884 HapTokenInfoForSync remoteTokenInfo = {
2885 .baseInfo = baseInfo,
2886 .permStateList = permStateList
2887 };
2888
2889 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2890 ASSERT_EQ(ret, RET_SUCCESS);
2891
2892 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2893 ASSERT_NE(mapID, 0);
2894
2895 HapTokenInfo info;
2896 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
2897 ASSERT_EQ(ret, RET_SUCCESS);
2898
2899 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0);
2900 ASSERT_NE(ret, RET_SUCCESS);
2901
2902 // deviceID is wrong
2903 std::string wrongStr(10241, 'x');
2904 deviceID = wrongStr;
2905 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2906 ASSERT_NE(ret, RET_SUCCESS);
2907 }
2908
2909 /**
2910 * @tc.name: DeleteRemoteDeviceToken003
2911 * @tc.desc: delete exist device mapping tokenId
2912 * @tc.type: FUNC
2913 * @tc.require:AR000GK6TA
2914 */
2915 HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceToken003, TestSize.Level1)
2916 {
2917 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceToken003 start.");
2918 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2919 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2920
2921 int ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2922 ASSERT_NE(ret, RET_SUCCESS);
2923 }
2924
2925 /**
2926 * @tc.name: DeleteRemoteDeviceTokens001
2927 * @tc.desc: delete all mapping tokens of exist device
2928 * @tc.type: FUNC
2929 * @tc.require:AR000GK6TA
2930 */
2931 HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceTokens001, TestSize.Level1)
2932 {
2933 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
2934 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2935 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2936 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100001);
2937 HapTokenInfo baseInfo = {
2938 .apl = APL_NORMAL,
2939 .ver = 1,
2940 .userID = 1,
2941 .bundleName = "com.ohos.access_token",
2942 .instIndex = 1,
2943 .appID = "testtesttesttest",
2944 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
2945 .tokenID = 0x20100000,
2946 .tokenAttr = 0
2947 };
2948
2949 PermissionStateFull infoManagerTestState = {
2950 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
2951 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2952 .isGeneral = true,
2953 .permissionName = "ohos.permission.test1",
2954 .resDeviceID = {"local"}};
2955 std::vector<PermissionStateFull> permStateList;
2956 permStateList.emplace_back(infoManagerTestState);
2957
2958 HapTokenInfoForSync remoteTokenInfo = {
2959 .baseInfo = baseInfo,
2960 .permStateList = permStateList
2961 };
2962
2963 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
2964 ASSERT_EQ(ret, RET_SUCCESS);
2965
2966 HapTokenInfoForSync remoteTokenInfo1 = remoteTokenInfo;
2967 remoteTokenInfo1.baseInfo.tokenID = 0x20100001;
2968 remoteTokenInfo1.baseInfo.bundleName = "com.ohos.access_token1";
2969 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo1);
2970 ASSERT_EQ(ret, RET_SUCCESS);
2971
2972 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
2973 ASSERT_NE(mapID, 0);
2974 AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100001);
2975 ASSERT_NE(mapID1, 0);
2976
2977 ret = AccessTokenKit::DeleteRemoteDeviceTokens(deviceID);
2978 ASSERT_EQ(ret, RET_SUCCESS);
2979
2980 HapTokenInfo info;
2981 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
2982 ASSERT_NE(ret, RET_SUCCESS);
2983 ret = AccessTokenKit::GetHapTokenInfo(mapID1, info);
2984 ASSERT_NE(ret, RET_SUCCESS);
2985 }
2986
2987 /**
2988 * @tc.name: DeleteRemoteDeviceTokens002
2989 * @tc.desc: delete all mapping tokens of NOT exist device
2990 * @tc.type: FUNC
2991 * @tc.require:AR000GK6TA
2992 */
2993 HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceTokens002, TestSize.Level1)
2994 {
2995 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens002 start.");
2996 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
2997 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
2998 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100001);
2999 HapTokenInfo baseInfo = {
3000 .apl = APL_NORMAL,
3001 .ver = 1,
3002 .userID = 1,
3003 .bundleName = "com.ohos.access_token",
3004 .instIndex = 1,
3005 .appID = "testtesttesttest",
3006 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
3007 .tokenID = 0x20100000,
3008 .tokenAttr = 0
3009 };
3010
3011 PermissionStateFull infoManagerTestState = {
3012 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
3013 .grantStatus = {PermissionState::PERMISSION_GRANTED},
3014 .isGeneral = true,
3015 .permissionName = "ohos.permission.test1",
3016 .resDeviceID = {"local"}};
3017 std::vector<PermissionStateFull> permStateList;
3018 permStateList.emplace_back(infoManagerTestState);
3019
3020 HapTokenInfoForSync remoteTokenInfo = {
3021 .baseInfo = baseInfo,
3022 .permStateList = permStateList
3023 };
3024
3025 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
3026 ASSERT_EQ(ret, RET_SUCCESS);
3027
3028 HapTokenInfoForSync remoteTokenInfo1 = remoteTokenInfo;
3029 remoteTokenInfo1.baseInfo.tokenID = 0x20100001;
3030 remoteTokenInfo1.baseInfo.bundleName = "com.ohos.access_token1";
3031 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo1);
3032 ASSERT_EQ(ret, RET_SUCCESS);
3033
3034 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
3035 ASSERT_NE(mapID, 0);
3036 AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100001);
3037 ASSERT_NE(mapID1, 0);
3038
3039 ret = AccessTokenKit::DeleteRemoteDeviceTokens("1111111");
3040 ASSERT_NE(ret, RET_SUCCESS);
3041
3042 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
3043 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100001);
3044 }
3045
3046 /**
3047 * @tc.name: GetHapTokenInfoFromRemote001
3048 * @tc.desc: get normal local tokenInfo
3049 * @tc.type: FUNC
3050 * @tc.require:AR000GK6TA
3051 */
3052 HWTEST_F(AccessTokenKitTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
3053 {
3054 ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote001 start.");
3055 AccessTokenIDEx tokenIdEx = {0};
3056 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
3057 AccessTokenID localTokenID = tokenIdEx.tokenIdExStruct.tokenID;
3058
3059 HapTokenInfoForSync infoSync;
3060 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(localTokenID, infoSync);
3061 ASSERT_EQ(ret, RET_SUCCESS);
3062 ASSERT_EQ(infoSync.baseInfo.apl, g_infoManagerTestPolicyPrams.apl);
3063 ASSERT_EQ(infoSync.permStateList.size(), 2);
3064 ASSERT_EQ(infoSync.permStateList[1].grantFlags.size(), 2);
3065
3066 ASSERT_EQ(infoSync.permStateList[0].permissionName, g_infoManagerTestPolicyPrams.permStateList[0].permissionName);
3067 ASSERT_EQ(infoSync.permStateList[0].grantFlags[0], g_infoManagerTestPolicyPrams.permStateList[0].grantFlags[0]);
3068 ASSERT_EQ(infoSync.permStateList[0].grantStatus[0], g_infoManagerTestPolicyPrams.permStateList[0].grantStatus[0]);
3069 ASSERT_EQ(infoSync.permStateList[0].resDeviceID[0], g_infoManagerTestPolicyPrams.permStateList[0].resDeviceID[0]);
3070 ASSERT_EQ(infoSync.permStateList[0].isGeneral, g_infoManagerTestPolicyPrams.permStateList[0].isGeneral);
3071
3072 ASSERT_EQ(infoSync.permStateList[1].permissionName, g_infoManagerTestPolicyPrams.permStateList[1].permissionName);
3073 ASSERT_EQ(infoSync.permStateList[1].grantFlags[0], g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[0]);
3074 ASSERT_EQ(infoSync.permStateList[1].grantStatus[0], g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[0]);
3075 ASSERT_EQ(infoSync.permStateList[1].resDeviceID[0], g_infoManagerTestPolicyPrams.permStateList[1].resDeviceID[0]);
3076 ASSERT_EQ(infoSync.permStateList[1].isGeneral, g_infoManagerTestPolicyPrams.permStateList[1].isGeneral);
3077
3078 ASSERT_EQ(infoSync.permStateList[1].grantFlags[1], g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[1]);
3079 ASSERT_EQ(infoSync.permStateList[1].grantStatus[1], g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[1]);
3080 ASSERT_EQ(infoSync.permStateList[1].resDeviceID[1], g_infoManagerTestPolicyPrams.permStateList[1].resDeviceID[1]);
3081
3082 ASSERT_EQ(infoSync.baseInfo.bundleName, g_infoManagerTestInfoParms.bundleName);
3083 ASSERT_EQ(infoSync.baseInfo.userID, g_infoManagerTestInfoParms.userID);
3084 ASSERT_EQ(infoSync.baseInfo.instIndex, g_infoManagerTestInfoParms.instIndex);
3085 ASSERT_EQ(infoSync.baseInfo.appID, g_infoManagerTestInfoParms.appIDDesc);
3086 ASSERT_EQ(infoSync.baseInfo.ver, 1);
3087 ASSERT_EQ(infoSync.baseInfo.tokenID, localTokenID);
3088 ASSERT_EQ(infoSync.baseInfo.tokenAttr, 0);
3089
3090 AccessTokenKit::DeleteToken(localTokenID);
3091 }
3092
3093 /**
3094 * @tc.name: GetHapTokenInfoFromRemote002
3095 * @tc.desc: get remote mapping tokenInfo
3096 * @tc.type: FUNC
3097 * @tc.require:AR000GK6TA
3098 */
3099 HWTEST_F(AccessTokenKitTest, GetHapTokenInfoFromRemote002, TestSize.Level1)
3100 {
3101 ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote002 start.");
3102 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
3103 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
3104 HapTokenInfo baseInfo = {
3105 .apl = APL_NORMAL,
3106 .ver = 1,
3107 .userID = 1,
3108 .bundleName = "com.ohos.access_token",
3109 .instIndex = 1,
3110 .appID = "testtesttesttest",
3111 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
3112 .tokenID = 0x20100000,
3113 .tokenAttr = 0
3114 };
3115
3116 PermissionStateFull infoManagerTestState = {
3117 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
3118 .grantStatus = {PermissionState::PERMISSION_GRANTED},
3119 .isGeneral = true,
3120 .permissionName = "ohos.permission.test1",
3121 .resDeviceID = {"local"}};
3122 std::vector<PermissionStateFull> permStateList;
3123 permStateList.emplace_back(infoManagerTestState);
3124
3125 HapTokenInfoForSync remoteTokenInfo = {
3126 .baseInfo = baseInfo,
3127 .permStateList = permStateList
3128 };
3129
3130 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
3131 ASSERT_EQ(ret, RET_SUCCESS);
3132
3133 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
3134 ASSERT_NE(mapID, 0);
3135
3136 HapTokenInfoForSync infoSync;
3137 ret = AccessTokenKit::GetHapTokenInfoFromRemote(mapID, infoSync);
3138 ASSERT_NE(ret, RET_SUCCESS);
3139
3140 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
3141 }
3142
3143 /**
3144 * @tc.name: GetHapTokenInfoFromRemote003
3145 * @tc.desc: get wrong tokenInfo
3146 * @tc.type: FUNC
3147 * @tc.require:AR000GK6TA
3148 */
3149 HWTEST_F(AccessTokenKitTest, GetHapTokenInfoFromRemote003, TestSize.Level1)
3150 {
3151 ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote003 start.");
3152 HapTokenInfoForSync infoSync;
3153 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(0, infoSync);
3154 ASSERT_NE(ret, RET_SUCCESS);
3155 }
3156
3157 /**
3158 * @tc.name: AllocLocalTokenID001
3159 * @tc.desc: get already mapping tokenInfo, makesure ipc right
3160 * @tc.type: FUNC
3161 * @tc.require:AR000GK6T5
3162 */
3163 HWTEST_F(AccessTokenKitTest, AllocLocalTokenID001, TestSize.Level1)
3164 {
3165 ACCESSTOKEN_LOG_INFO(LABEL, "AllocLocalTokenID001 start.");
3166 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
3167 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
3168 HapTokenInfo baseInfo = {
3169 .apl = APL_NORMAL,
3170 .ver = 1,
3171 .userID = 1,
3172 .bundleName = "com.ohos.access_token",
3173 .instIndex = 1,
3174 .appID = "testtesttesttest",
3175 .deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2",
3176 .tokenID = 0x20100000,
3177 .tokenAttr = 0
3178 };
3179
3180 PermissionStateFull infoManagerTestState = {
3181 .grantFlags = {PermissionFlag::PERMISSION_USER_SET},
3182 .grantStatus = {PermissionState::PERMISSION_GRANTED},
3183 .isGeneral = true,
3184 .permissionName = "ohos.permission.test1",
3185 .resDeviceID = {"local"}};
3186 std::vector<PermissionStateFull> permStateList;
3187 permStateList.emplace_back(infoManagerTestState);
3188
3189 HapTokenInfoForSync remoteTokenInfo = {
3190 .baseInfo = baseInfo,
3191 .permStateList = permStateList
3192 };
3193
3194 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
3195 ASSERT_EQ(ret, RET_SUCCESS);
3196
3197 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(deviceID, 0x20100000);
3198 ASSERT_NE(mapID, 0);
3199 }
3200
3201 /**
3202 * @tc.name: GetAllNativeTokenInfo001
3203 * @tc.desc: get all native token with dcaps
3204 * @tc.type: FUNC
3205 * @tc.require:AR000GK6T6
3206 */
3207 HWTEST_F(AccessTokenKitTest, GetAllNativeTokenInfo001, TestSize.Level1)
3208 {
3209 ACCESSTOKEN_LOG_INFO(LABEL, "GetAllNativeTokenInfo001 start.");
3210
3211 std::vector<NativeTokenInfo> nativeTokenInfosRes;
3212 int ret = AccessTokenKit::GetAllNativeTokenInfo(nativeTokenInfosRes);
3213 ASSERT_EQ(ret, RET_SUCCESS);
3214 }
3215
3216 /**
3217 * @tc.name: SetRemoteNativeTokenInfo001
3218 * @tc.desc: set already mapping tokenInfo
3219 * @tc.type: FUNC
3220 * @tc.require:AR000GK6T6
3221 */
3222 HWTEST_F(AccessTokenKitTest, SetRemoteNativeTokenInfo001, TestSize.Level1)
3223 {
3224 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteNativeTokenInfo001 start.");
3225 std::string deviceID = "ea82205d1f9964346ee12e17ec0f362bb7203fca7c62d82899ffa917f9cbe6b2";
3226
3227 NativeTokenInfo native1 = {
3228 .apl = APL_NORMAL,
3229 .ver = 1,
3230 .processName = "native_test1",
3231 .dcap = {"SYSDCAP", "DMSDCAP"},
3232 .tokenID = 0x28000000,
3233 .tokenAttr = 0
3234 };
3235
3236 std::vector<NativeTokenInfo> nativeTokenInfoList;
3237 nativeTokenInfoList.emplace_back(native1);
3238
3239 int ret = AccessTokenKit::SetRemoteNativeTokenInfo(deviceID, nativeTokenInfoList);
3240 ASSERT_EQ(ret, RET_SUCCESS);
3241
3242 AccessTokenID mapID = AccessTokenKit::GetRemoteNativeTokenID(deviceID, 0x28000000);
3243 ASSERT_NE(mapID, 0);
3244
3245 NativeTokenInfo resultInfo;
3246 ret = AccessTokenKit::GetNativeTokenInfo(mapID, resultInfo);
3247 ASSERT_EQ(ret, RET_SUCCESS);
3248
3249 ASSERT_EQ(resultInfo.apl, native1.apl);
3250 ASSERT_EQ(resultInfo.ver, native1.ver);
3251 ASSERT_EQ(resultInfo.processName, native1.processName);
3252 ASSERT_EQ(resultInfo.dcap.size(), 2);
3253 ASSERT_EQ(resultInfo.dcap[0], "SYSDCAP");
3254 ASSERT_EQ(resultInfo.dcap[1], "DMSDCAP");
3255 ASSERT_EQ(resultInfo.tokenID, mapID);
3256 ASSERT_EQ(resultInfo.tokenAttr, native1.tokenAttr);
3257 }
3258 #endif
3259