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_info_manager_test.h"
17
18 #include <gmock/gmock.h>
19
20 #include "accesstoken_id_manager.h"
21 #include "access_token_error.h"
22 #define private public
23 #include "accesstoken_callback_stubs.h"
24 #include "accesstoken_info_manager.h"
25 #include "accesstoken_remote_token_manager.h"
26 #include "libraryloader.h"
27 #include "token_field_const.h"
28 #ifdef TOKEN_SYNC_ENABLE
29 #include "token_sync_kit_loader.h"
30 #endif
31 #include "permission_definition_cache.h"
32 #include "permission_manager.h"
33 #include "token_modify_notifier.h"
34 #undef private
35 #include "permission_validator.h"
36 #include "string_ex.h"
37 #include "token_setproc.h"
38
39 using namespace testing::ext;
40 using namespace OHOS;
41
42 namespace OHOS {
43 namespace Security {
44 namespace AccessToken {
45 namespace {
46 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
47 LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenInfoManagerTest"
48 };
49 static constexpr int32_t DEFAULT_API_VERSION = 8;
50 static constexpr int USER_ID = 100;
51 static constexpr int INST_INDEX = 0;
52 static PermissionDef g_infoManagerTestPermDef1 = {
53 .permissionName = "open the door",
54 .bundleName = "accesstoken_test",
55 .grantMode = 1,
56 .availableLevel = APL_NORMAL,
57 .provisionEnable = false,
58 .distributedSceneEnable = false,
59 .label = "label",
60 .labelId = 1,
61 .description = "open the door",
62 .descriptionId = 1
63 };
64
65 static PermissionDef g_infoManagerTestPermDef2 = {
66 .permissionName = "break the door",
67 .bundleName = "accesstoken_test",
68 .grantMode = 1,
69 .availableLevel = APL_NORMAL,
70 .provisionEnable = false,
71 .distributedSceneEnable = false,
72 .label = "label",
73 .labelId = 1,
74 .description = "break the door",
75 .descriptionId = 1
76 };
77
78 static PermissionStateFull g_infoManagerTestState1 = {
79 .permissionName = "open the door",
80 .isGeneral = true,
81 .resDeviceID = {"local"},
82 .grantStatus = {1},
83 .grantFlags = {1}
84 };
85
86 static PermissionStateFull g_infoManagerTestState2 = {
87 .permissionName = "break the door",
88 .isGeneral = false,
89 .resDeviceID = {"device 1", "device 2"},
90 .grantStatus = {1, 3},
91 .grantFlags = {1, 2}
92 };
93
94 static HapInfoParams g_infoManagerTestInfoParms = {
95 .userID = 1,
96 .bundleName = "accesstoken_test",
97 .instIndex = 0,
98 .appIDDesc = "testtesttesttest"
99 };
100
101 static HapPolicyParams g_infoManagerTestPolicyPrams1 = {
102 .apl = APL_NORMAL,
103 .domain = "test.domain",
104 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
105 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
106 };
107
108 static PermissionStateFull g_permState = {
109 .permissionName = "ohos.permission.CAMERA",
110 .isGeneral = false,
111 .resDeviceID = {"dev-001", "dev-001"},
112 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
113 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
114 };
115
116 #ifdef TOKEN_SYNC_ENABLE
117 static const int32_t FAKE_SYNC_RET = 0xabcdef;
118 class TokenSyncCallbackMock : public TokenSyncCallbackStub {
119 public:
120 TokenSyncCallbackMock() = default;
121 virtual ~TokenSyncCallbackMock() = default;
122
123 MOCK_METHOD(int32_t, GetRemoteHapTokenInfo, (const std::string&, AccessTokenID), (override));
124 MOCK_METHOD(int32_t, DeleteRemoteHapTokenInfo, (AccessTokenID), (override));
125 MOCK_METHOD(int32_t, UpdateRemoteHapTokenInfo, (const HapTokenInfoForSync&), (override));
126 };
127 #endif
128 }
129
SetUpTestCase()130 void AccessTokenInfoManagerTest::SetUpTestCase()
131 {
132 AccessTokenInfoManager::GetInstance().Init();
133 }
134
TearDownTestCase()135 void AccessTokenInfoManagerTest::TearDownTestCase()
136 {
137 sleep(3); // delay 3 minutes
138 }
139
SetUp()140 void AccessTokenInfoManagerTest::SetUp()
141 {
142 atManagerService_ = DelayedSingleton<AccessTokenManagerService>::GetInstance();
143 EXPECT_NE(nullptr, atManagerService_);
144 PermissionDef infoManagerPermDefA = {
145 .permissionName = "ohos.permission.CAMERA",
146 .bundleName = "accesstoken_test",
147 .grantMode = USER_GRANT,
148 .availableLevel = APL_NORMAL,
149 .provisionEnable = false,
150 .distributedSceneEnable = false,
151 };
152 PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDefA, 1);
153 PermissionDef infoManagerPermDefB = {
154 .permissionName = "ohos.permission.LOCATION",
155 .bundleName = "accesstoken_test",
156 .grantMode = USER_GRANT,
157 .availableLevel = APL_NORMAL,
158 .provisionEnable = false,
159 .distributedSceneEnable = false,
160 };
161 PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDefB, 1);
162 }
163
TearDown()164 void AccessTokenInfoManagerTest::TearDown()
165 {
166 atManagerService_ = nullptr;
167 }
168
169 /**
170 * @tc.name: HapTokenInfoInner001
171 * @tc.desc: HapTokenInfoInner::HapTokenInfoInner.
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(AccessTokenInfoManagerTest, HapTokenInfoInner001, TestSize.Level1)
176 {
177 AccessTokenID id = 0x20240112;
178 HapTokenInfo info = {
179 .apl = APL_NORMAL,
180 .ver = 1,
181 .userID = 1,
182 .bundleName = "com.ohos.access_token",
183 .instIndex = 1,
184 .appID = "testtesttesttest",
185 .deviceID = "deviceId",
186 .tokenID = id,
187 .tokenAttr = 0
188 };
189 std::vector<PermissionStateFull> permStateList;
190 std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>(id, info, permStateList);
191 ASSERT_EQ(hap->IsRemote(), false);
192 hap->SetRemote(true);
193 std::vector<GenericValues> valueList;
194 hap->StoreHapInfo(valueList);
195
196 hap->StorePermissionPolicy(valueList);
197 ASSERT_EQ(hap->IsRemote(), true);
198 hap->SetRemote(false);
199 int32_t version = hap->GetApiVersion(5608);
200 ASSERT_EQ(static_cast<int32_t>(608), version);
201 }
202
203 /**
204 * @tc.name: CreateHapTokenInfo001
205 * @tc.desc: Verify the CreateHapTokenInfo add one hap token function.
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo001, TestSize.Level1)
210 {
211 AccessTokenIDEx tokenIdEx = {0};
212 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
213 g_infoManagerTestPolicyPrams1, tokenIdEx);
214 ASSERT_EQ(RET_SUCCESS, ret);
215 GTEST_LOG_(INFO) << "add a hap token";
216
217 std::shared_ptr<HapTokenInfoInner> tokenInfo;
218 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
219 ASSERT_NE(nullptr, tokenInfo);
220 std::string infoDes;
221 tokenInfo->ToString(infoDes);
222 GTEST_LOG_(INFO) << "get hap token info:" << infoDes.c_str();
223
224 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
225 ASSERT_EQ(RET_SUCCESS, ret);
226 GTEST_LOG_(INFO) << "remove the token info";
227
228 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
229 ASSERT_EQ(nullptr, tokenInfo);
230 }
231
232 /**
233 * @tc.name: CreateHapTokenInfo002
234 * @tc.desc: Verify the CreateHapTokenInfo add one hap token twice function.
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo002, TestSize.Level1)
239 {
240 ACCESSTOKEN_LOG_INFO(LABEL, "AddHapToken001 fill data");
241
242 AccessTokenIDEx tokenIdEx = {0};
243 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
244 g_infoManagerTestPolicyPrams1, tokenIdEx);
245 ASSERT_EQ(RET_SUCCESS, ret);
246 GTEST_LOG_(INFO) << "add a hap token";
247
248 AccessTokenIDEx tokenIdEx1 = {0};
249 ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
250 g_infoManagerTestPolicyPrams1, tokenIdEx1);
251 ASSERT_EQ(RET_SUCCESS, ret);
252 ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, tokenIdEx1.tokenIdExStruct.tokenID);
253 GTEST_LOG_(INFO) << "add same hap token";
254 PermissionDef permDef;
255 ASSERT_EQ(RET_SUCCESS,
256 PermissionManager::GetInstance().GetDefPermission(g_infoManagerTestPermDef1.permissionName, permDef));
257 ASSERT_EQ(permDef.permissionName, g_infoManagerTestPermDef1.permissionName);
258
259 std::shared_ptr<HapTokenInfoInner> tokenInfo;
260 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx1.tokenIdExStruct.tokenID);
261 ASSERT_NE(nullptr, tokenInfo);
262
263 std::string infoDes;
264 tokenInfo->ToString(infoDes);
265 GTEST_LOG_(INFO) << "get hap token info:" << infoDes.c_str();
266
267 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx1.tokenIdExStruct.tokenID);
268 ASSERT_EQ(RET_SUCCESS, ret);
269 GTEST_LOG_(INFO) << "remove the token info";
270 }
271
272 /**
273 * @tc.name: CreateHapTokenInfo003
274 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test userID invalid
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo003, TestSize.Level1)
279 {
280 HapInfoParams info = {
281 .userID = -1
282 };
283 HapPolicyParams policy;
284 AccessTokenIDEx tokenIdEx;
285
286 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
287 }
288
289 /**
290 * @tc.name: CreateHapTokenInfo004
291 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test bundleName invalid
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo004, TestSize.Level1)
296 {
297 HapInfoParams info = {
298 .userID = USER_ID,
299 .bundleName = ""
300 };
301 HapPolicyParams policy;
302 AccessTokenIDEx tokenIdEx;
303
304 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
305 }
306
307 /**
308 * @tc.name: CreateHapTokenInfo005
309 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test appIDDesc invalid
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo005, TestSize.Level1)
314 {
315 HapInfoParams info = {
316 .userID = USER_ID,
317 .bundleName = "ohos.com.testtesttest",
318 .appIDDesc = ""
319 };
320 HapPolicyParams policy;
321 AccessTokenIDEx tokenIdEx;
322
323 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
324 }
325
326 /**
327 * @tc.name: CreateHapTokenInfo006
328 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test domain invalid
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo006, TestSize.Level1)
333 {
334 HapInfoParams info = {
335 .userID = USER_ID,
336 .bundleName = "ohos.com.testtesttest",
337 .appIDDesc = "who cares"
338 };
339 HapPolicyParams policy = {
340 .domain = ""
341 };
342 AccessTokenIDEx tokenIdEx;
343
344 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
345 }
346
347 /**
348 * @tc.name: CreateHapTokenInfo007
349 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test dlpType invalid
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo007, TestSize.Level1)
354 {
355 HapInfoParams info = {
356 .userID = USER_ID,
357 .bundleName = "ohos.com.testtesttest",
358 .dlpType = -1,
359 .appIDDesc = "who cares"
360 };
361 HapPolicyParams policy = {
362 .domain = "who cares"
363 };
364 AccessTokenIDEx tokenIdEx;
365
366 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
367 }
368
369 /**
370 * @tc.name: CreateHapTokenInfo008
371 * @tc.desc: AccessTokenInfoManager::CreateHapTokenInfo function test grant mode invalid
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(AccessTokenInfoManagerTest, CreateHapTokenInfo008, TestSize.Level1)
376 {
377 static PermissionDef permDef = {
378 .permissionName = "ohos.permission.test",
379 .bundleName = "accesstoken_test",
380 .grantMode = -1, // -1:invalid grant mode
381 .availableLevel = APL_NORMAL,
382 .provisionEnable = false,
383 .distributedSceneEnable = false,
384 .label = "label",
385 .labelId = 1,
386 .description = "open the door",
387 .descriptionId = 1
388 };
389 HapInfoParams info = {
390 .userID = USER_ID,
391 .bundleName = "ohos.com.testtesttest",
392 .appIDDesc = ""
393 };
394 HapPolicyParams policy = {
395 .apl = APL_NORMAL,
396 .domain = "test.domain",
397 .permList = {permDef}
398 };
399 AccessTokenIDEx tokenIdEx;
400 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
401 }
402
403 /**
404 * @tc.name: InitHapToken001
405 * @tc.desc: InitHapToken function test with invalid userID
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(AccessTokenInfoManagerTest, InitHapToken001, TestSize.Level1)
410 {
411 HapInfoParcel hapinfoParcel;
412 hapinfoParcel.hapInfoParameter = {
413 .userID = -1,
414 .bundleName = "accesstoken_test",
415 .instIndex = 0,
416 .dlpType = DLP_COMMON,
417 .appIDDesc = "testtesttesttest",
418 .apiVersion = DEFAULT_API_VERSION,
419 .isSystemApp = false,
420 };
421 HapPolicyParcel hapPolicyParcel;
422 hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
423 hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
424 AccessTokenIDEx tokenIdEx;
425 ASSERT_EQ(ERR_PARAM_INVALID, atManagerService_->InitHapToken(hapinfoParcel, hapPolicyParcel, tokenIdEx));
426 }
427
428 /**
429 * @tc.name: InitHapToken002
430 * @tc.desc: InitHapToken function test with invalid userID
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(AccessTokenInfoManagerTest, InitHapToken002, TestSize.Level1)
435 {
436 HapInfoParcel hapinfoParcel;
437 hapinfoParcel.hapInfoParameter = {
438 .userID = -1,
439 .bundleName = "accesstoken_test",
440 .instIndex = 0,
441 .dlpType = DLP_READ,
442 .appIDDesc = "testtesttesttest",
443 .apiVersion = DEFAULT_API_VERSION,
444 .isSystemApp = false,
445 };
446 HapPolicyParcel hapPolicyParcel;
447 hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
448 hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
449 AccessTokenIDEx tokenIdEx;
450 ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, atManagerService_->InitHapToken(hapinfoParcel, hapPolicyParcel, tokenIdEx));
451 }
452
453 /**
454 * @tc.name: InitHapToken003
455 * @tc.desc: InitHapToken function test with invalid apl permission
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(AccessTokenInfoManagerTest, InitHapToken003, TestSize.Level1)
460 {
461 HapInfoParcel info;
462 info.hapInfoParameter = {
463 .userID = 0,
464 .bundleName = "accesstoken_test",
465 .instIndex = 0,
466 .dlpType = DLP_COMMON,
467 .appIDDesc = "testtesttesttest",
468 .apiVersion = DEFAULT_API_VERSION,
469 .isSystemApp = false,
470 };
471 HapPolicyParcel policy;
472 PermissionStateFull permissionStateA = {
473 .permissionName = "ohos.permission.GET_ALL_APP_ACCOUNTS",
474 .isGeneral = true,
475 .resDeviceID = {"local"},
476 .grantStatus = {1},
477 .grantFlags = {1}
478 };
479 PermissionStateFull permissionStateB = {
480 .permissionName = "ohos.permission.PRELOAD_APPLICATION",
481 .isGeneral = true,
482 .resDeviceID = {"local"},
483 .grantStatus = {1},
484 .grantFlags = {1}
485 };
486 PermissionStateFull permissionStateC = {
487 .permissionName = "ohos.permission.test",
488 .isGeneral = true,
489 .resDeviceID = {"local"},
490 .grantStatus = {1},
491 .grantFlags = {1}
492 };
493 policy.hapPolicyParameter = {
494 .apl = APL_NORMAL,
495 .domain = "test",
496 .permList = {},
497 .permStateList = { permissionStateA }
498 };
499 AccessTokenIDEx fullTokenId = {0};
500 ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, atManagerService_->InitHapToken(info, policy, fullTokenId));
501
502 policy.hapPolicyParameter.permStateList = { permissionStateB, permissionStateC };
503 policy.hapPolicyParameter.aclRequestedList = { "ohos.permission.PRELOAD_APPLICATION" };
504 ASSERT_EQ(RET_SUCCESS, atManagerService_->InitHapToken(info, policy, fullTokenId));
505 }
506
507 /**
508 * @tc.name: IsTokenIdExist001
509 * @tc.desc: Verify the IsTokenIdExist exist accesstokenid.
510 * @tc.type: FUNC
511 * @tc.require:
512 */
513 HWTEST_F(AccessTokenInfoManagerTest, IsTokenIdExist001, TestSize.Level1)
514 {
515 AccessTokenID testId = 1;
516 ASSERT_EQ(AccessTokenInfoManager::GetInstance().IsTokenIdExist(testId), false);
517 }
518
519 /**
520 * @tc.name: GetHapTokenInfo001
521 * @tc.desc: Verify the GetHapTokenInfo abnormal and normal branch.
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenInfo001, TestSize.Level1)
526 {
527 AccessTokenIDEx tokenIdEx = {0};
528 int result;
529 HapTokenInfo hapInfo;
530 result = AccessTokenInfoManager::GetInstance().GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapInfo);
531 ASSERT_EQ(result, ERR_TOKENID_NOT_EXIST);
532
533 result = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
534 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
535 ASSERT_EQ(RET_SUCCESS, result);
536 GTEST_LOG_(INFO) << "add a hap token";
537 result = AccessTokenInfoManager::GetInstance().GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapInfo);
538 ASSERT_EQ(result, RET_SUCCESS);
539 result = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
540 ASSERT_EQ(RET_SUCCESS, result);
541 GTEST_LOG_(INFO) << "remove the token info";
542 }
543
544 /**
545 * @tc.name: GetHapPermissionPolicySet001
546 * @tc.desc: Verify the GetHapPermissionPolicySet abnormal and normal branch.
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(AccessTokenInfoManagerTest, GetHapPermissionPolicySet001, TestSize.Level1)
551 {
552 AccessTokenIDEx tokenIdEx = {0};
553 std::shared_ptr<PermissionPolicySet> permPolicySet =
554 AccessTokenInfoManager::GetInstance().GetHapPermissionPolicySet(tokenIdEx.tokenIdExStruct.tokenID);
555 ASSERT_EQ(permPolicySet, nullptr);
556
557 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
558 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
559 ASSERT_EQ(RET_SUCCESS, ret);
560 GTEST_LOG_(INFO) << "add a hap token";
561 permPolicySet = AccessTokenInfoManager::GetInstance().GetHapPermissionPolicySet(tokenIdEx.tokenIdExStruct.tokenID);
562 ASSERT_EQ(permPolicySet != nullptr, true);
563 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
564 ASSERT_EQ(RET_SUCCESS, ret);
565 GTEST_LOG_(INFO) << "remove the token info";
566 }
567
568 /**
569 * @tc.name: GetNativePermissionPolicySet001
570 * @tc.desc: Verify the GetNativePermissionPolicySet abnormal branch tokenID is invalid.
571 * @tc.type: FUNC
572 * @tc.require:
573 */
574 HWTEST_F(AccessTokenInfoManagerTest, GetNativePermissionPolicySet001, TestSize.Level1)
575 {
576 AccessTokenIDEx tokenIdEx = {0};
577 std::shared_ptr<PermissionPolicySet> permPolicySet =
578 AccessTokenInfoManager::GetInstance().GetNativePermissionPolicySet(tokenIdEx.tokenIdExStruct.tokenID);
579 ASSERT_EQ(permPolicySet, nullptr);
580 }
581
582 /**
583 * @tc.name: RemoveHapTokenInfo001
584 * @tc.desc: Verify the RemoveHapTokenInfo abnormal branch tokenID type is not true.
585 * @tc.type: FUNC
586 * @tc.require:
587 */
588 HWTEST_F(AccessTokenInfoManagerTest, RemoveHapTokenInfo001, TestSize.Level1)
589 {
590 AccessTokenIDEx tokenIdEx = {0};
591 // type != TOKEN_HAP
592 ASSERT_EQ(
593 ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID));
594
595 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
596 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
597 // hapTokenInfoMap_.count(id) == 0
598 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
599
600 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
601 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = nullptr;
602 ASSERT_EQ(ERR_TOKEN_INVALID, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId)); // info == nullptr
603 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
604
605 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
606 info->tokenInfoBasic_.userID = USER_ID;
607 info->tokenInfoBasic_.bundleName = "com.ohos.TEST";
608 info->tokenInfoBasic_.instIndex = INST_INDEX;
609 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
610 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
611 // count(HapUniqueKey) == 0
612 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
613
614 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP)); // removed above
615 AccessTokenID tokenId2 = 537919486; // 537919486: 001 00 0 000000 11111111111111111110
616 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
617 std::string hapUniqueKey = "com.ohos.TEST&" + std::to_string(USER_ID) + "&" + std::to_string(INST_INDEX);
618 AccessTokenInfoManager::GetInstance().hapTokenIdMap_[hapUniqueKey] = tokenId2;
619 // hapTokenIdMap_[HapUniqueKey] != id
620 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
621 AccessTokenInfoManager::GetInstance().hapTokenIdMap_.erase(hapUniqueKey);
622 }
623
624 /**
625 * @tc.name: GetHapTokenID001
626 * @tc.desc: Verify the GetHapTokenID by userID/bundleName/instIndex, function.
627 * @tc.type: FUNC
628 * @tc.require:
629 */
630 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenID001, TestSize.Level1)
631 {
632 AccessTokenIDEx tokenIdEx = {0};
633 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
634 g_infoManagerTestPolicyPrams1, tokenIdEx);
635 ASSERT_EQ(RET_SUCCESS, ret);
636 GTEST_LOG_(INFO) << "add a hap token";
637
638 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
639 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
640 AccessTokenID getTokenId = tokenIdEx.tokenIdExStruct.tokenID;
641 ASSERT_EQ(tokenIdEx.tokenIdExStruct.tokenID, getTokenId);
642 GTEST_LOG_(INFO) << "find hap info";
643
644 std::shared_ptr<HapTokenInfoInner> tokenInfo;
645 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
646 ASSERT_NE(nullptr, tokenInfo);
647 GTEST_LOG_(INFO) << "remove the token info";
648
649 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
650 ASSERT_EQ(RET_SUCCESS, ret);
651 GTEST_LOG_(INFO) << "remove the token info";
652 }
653
654 /**
655 * @tc.name: UpdateHapToken001
656 * @tc.desc: Verify the UpdateHapToken token function.
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken001, TestSize.Level1)
661 {
662 AccessTokenIDEx tokenIdEx = {0};
663 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
664 g_infoManagerTestPolicyPrams1, tokenIdEx);
665 ASSERT_EQ(RET_SUCCESS, ret);
666 GTEST_LOG_(INFO) << "add a hap token";
667
668 HapPolicyParams policy = g_infoManagerTestPolicyPrams1;
669 policy.apl = APL_SYSTEM_BASIC;
670 UpdateHapInfoParams info;
671 info.appIDDesc = std::string("updateAppId");
672 info.apiVersion = DEFAULT_API_VERSION;
673 info.isSystemApp = false;
674 ret = AccessTokenInfoManager::GetInstance().UpdateHapToken(
675 tokenIdEx, info, policy.permStateList, policy.apl, policy.permList);
676 ASSERT_EQ(RET_SUCCESS, ret);
677 GTEST_LOG_(INFO) << "update the hap token";
678
679 std::shared_ptr<HapTokenInfoInner> tokenInfo;
680 tokenInfo = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenIdEx.tokenIdExStruct.tokenID);
681 ASSERT_NE(nullptr, tokenInfo);
682 std::string infoDes;
683 tokenInfo->ToString(infoDes);
684 GTEST_LOG_(INFO) << "get hap token info:" << infoDes.c_str();
685
686 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
687 ASSERT_EQ(RET_SUCCESS, ret);
688 GTEST_LOG_(INFO) << "remove the token info";
689 }
690
691 /**
692 * @tc.name: UpdateHapToken002
693 * @tc.desc: Verify the UpdateHapToken token function abnormal branch.
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken002, TestSize.Level1)
698 {
699 AccessTokenIDEx tokenIdEx = {0};
700 HapPolicyParams policy = g_infoManagerTestPolicyPrams1;
701 policy.apl = APL_SYSTEM_BASIC;
702 UpdateHapInfoParams info;
703 info.appIDDesc = std::string("");
704 info.apiVersion = DEFAULT_API_VERSION;
705 info.isSystemApp = false;
706 int ret = AccessTokenInfoManager::GetInstance().UpdateHapToken(
707 tokenIdEx, info, policy.permStateList, policy.apl, policy.permList);
708 ASSERT_EQ(ERR_PARAM_INVALID, ret);
709
710 info.appIDDesc = std::string("updateAppId");
711 ret = AccessTokenInfoManager::GetInstance().UpdateHapToken(
712 tokenIdEx, info, policy.permStateList, policy.apl, policy.permList);
713 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, ret);
714 }
715
716 /**
717 * @tc.name: UpdateHapToken003
718 * @tc.desc: AccessTokenInfoManager::UpdateHapToken function test IsRemote_ true
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(AccessTokenInfoManagerTest, UpdateHapToken003, TestSize.Level1)
723 {
724 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
725 AccessTokenIDEx tokenIdEx = {0};
726 tokenIdEx.tokenIdExStruct.tokenID = tokenId;
727 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
728 info->isRemote_ = true;
729 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
730 HapPolicyParams policy;
731 UpdateHapInfoParams hapInfoParams;
732 hapInfoParams.appIDDesc = "who cares";
733 hapInfoParams.apiVersion = DEFAULT_API_VERSION;
734 hapInfoParams.isSystemApp = false;
735 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().UpdateHapToken(
736 tokenIdEx, hapInfoParams, policy.permStateList, policy.apl, policy.permList));
737 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
738 }
739
740 #ifdef TOKEN_SYNC_ENABLE
741 /**
742 * @tc.name: GetHapTokenSync001
743 * @tc.desc: Verify the GetHapTokenSync token function and abnormal branch.
744 * @tc.type: FUNC
745 * @tc.require:
746 */
747 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenSync001, TestSize.Level1)
748 {
749 AccessTokenIDEx tokenIdEx = {0};
750 int result;
751 result = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
752 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
753 ASSERT_EQ(RET_SUCCESS, result);
754 GTEST_LOG_(INFO) << "add a hap token";
755
756 HapTokenInfoForSync hapSync;
757 result = AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
758 ASSERT_EQ(result, RET_SUCCESS);
759
760 result = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
761 ASSERT_EQ(RET_SUCCESS, result);
762 GTEST_LOG_(INFO) << "remove the token info";
763
764 result = AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
765 ASSERT_NE(result, RET_SUCCESS);
766 }
767
768 /**
769 * @tc.name: GetHapTokenSync002
770 * @tc.desc: AccessTokenInfoManager::GetHapTokenSync function test permSetPtr is null
771 * @tc.type: FUNC
772 * @tc.require:
773 */
774 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenSync002, TestSize.Level1)
775 {
776 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
777 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
778 info->permPolicySet_ = nullptr;
779 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = info;
780 HapTokenInfoForSync hapSync;
781 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenId, hapSync));
782 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
783 }
784
785 /**
786 * @tc.name: GetHapTokenInfoFromRemote001
787 * @tc.desc: Verify the GetHapTokenInfoFromRemote token function .
788 * @tc.type: FUNC
789 * @tc.require:
790 */
791 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
792 {
793 AccessTokenIDEx tokenIdEx = {0};
794 int ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
795 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
796 ASSERT_EQ(RET_SUCCESS, ret);
797 GTEST_LOG_(INFO) << "add a hap token";
798
799 HapTokenInfoForSync hapSync;
800 ret = AccessTokenInfoManager::GetInstance().GetHapTokenInfoFromRemote(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
801 ASSERT_EQ(ret, RET_SUCCESS);
802
803 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
804 ASSERT_EQ(RET_SUCCESS, ret);
805 GTEST_LOG_(INFO) << "remove the token info";
806 }
807
808 /**
809 * @tc.name: RemoteHapTest001001
810 * @tc.desc: Verify the RemoteHap token function .
811 * @tc.type: FUNC
812 * @tc.require: issueI5RJBB
813 */
814 HWTEST_F(AccessTokenInfoManagerTest, RemoteHapTest001, TestSize.Level1)
815 {
816 AccessTokenIDEx tokenIdEx = {0};
817 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
818 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
819 ASSERT_EQ(RET_SUCCESS, ret);
820 GTEST_LOG_(INFO) << "add a hap token";
821
822 std::string deviceId = "device_1";
823 std::string deviceId2 = "device_2";
824 AccessTokenID mapID =
825 AccessTokenInfoManager::GetInstance().AllocLocalTokenID(deviceId, tokenIdEx.tokenIdExStruct.tokenID);
826 ASSERT_EQ(mapID == 0, true);
827 HapTokenInfoForSync hapSync;
828 ret = AccessTokenInfoManager::GetInstance().GetHapTokenInfoFromRemote(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
829 ASSERT_EQ(RET_SUCCESS, ret);
830 ret = AccessTokenInfoManager::GetInstance().SetRemoteHapTokenInfo(deviceId, hapSync);
831 ASSERT_EQ(RET_SUCCESS, ret);
832 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteDeviceTokens(deviceId);
833 ASSERT_EQ(RET_SUCCESS, ret);
834 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteDeviceTokens(deviceId2);
835 ASSERT_EQ(ERR_DEVICE_NOT_EXIST, ret);
836
837 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
838 ASSERT_EQ(RET_SUCCESS, ret);
839 GTEST_LOG_(INFO) << "remove the token info";
840 }
841
842 /**
843 * @tc.name: DeleteRemoteToken001
844 * @tc.desc: Verify the DeleteRemoteToken normal and abnormal branch.
845 * @tc.type: FUNC
846 * @tc.require: issueI5RJBB
847 */
848 HWTEST_F(AccessTokenInfoManagerTest, DeleteRemoteToken001, TestSize.Level1)
849 {
850 AccessTokenIDEx tokenIdEx = {0};
851 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
852 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
853 ASSERT_EQ(RET_SUCCESS, ret);
854 GTEST_LOG_(INFO) << "add a hap token";
855
856 std::string deviceId = "device_1";
857 std::string deviceId2 = "device_2";
858 AccessTokenID mapId =
859 AccessTokenInfoManager::GetInstance().AllocLocalTokenID(deviceId, tokenIdEx.tokenIdExStruct.tokenID);
860 ASSERT_EQ(mapId == 0, true);
861 HapTokenInfoForSync hapSync;
862 ret = AccessTokenInfoManager::GetInstance().GetHapTokenInfoFromRemote(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
863 ASSERT_EQ(RET_SUCCESS, ret);
864 ret = AccessTokenInfoManager::GetInstance().SetRemoteHapTokenInfo(deviceId, hapSync);
865 ASSERT_EQ(RET_SUCCESS, ret);
866 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceId, tokenIdEx.tokenIdExStruct.tokenID);
867 ASSERT_EQ(RET_SUCCESS, ret);
868 ret = AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceId2, tokenIdEx.tokenIdExStruct.tokenID);
869 ASSERT_NE(RET_SUCCESS, ret);
870
871 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
872 ASSERT_EQ(RET_SUCCESS, ret);
873 GTEST_LOG_(INFO) << "remove the token info";
874 }
875
SetRemoteHapTokenInfoTest(const std::string & deviceID,const HapTokenInfo & baseInfo)876 static bool SetRemoteHapTokenInfoTest(const std::string& deviceID, const HapTokenInfo& baseInfo)
877 {
878 std::vector<PermissionStateFull> permStateList;
879 permStateList.emplace_back(g_infoManagerTestState1);
880 HapTokenInfoForSync remoteTokenInfo = {
881 .baseInfo = baseInfo,
882 .permStateList = permStateList
883 };
884
885 return RET_SUCCESS == AccessTokenInfoManager::GetInstance().SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
886 }
887
888 /**
889 * @tc.name: SetRemoteHapTokenInfo001
890 * @tc.desc: set remote hap token info, token info is wrong
891 * @tc.type: FUNC
892 * @tc.require: issue5RJBB
893 */
894 HWTEST_F(AccessTokenInfoManagerTest, SetRemoteHapTokenInfo001, TestSize.Level1)
895 {
896 std::string deviceID = "deviceId";
897 HapTokenInfo rightBaseInfo = {
898 .apl = APL_NORMAL,
899 .ver = 1,
900 .userID = 1,
901 .bundleName = "com.ohos.access_token",
902 .instIndex = 1,
903 .appID = "testtesttesttest",
904 .deviceID = "deviceId",
905 .tokenID = 0x20100000,
906 .tokenAttr = 0
907 };
908 HapTokenInfo wrongBaseInfo = rightBaseInfo;
909 std::string wrongStr(10241, 'x');
910
911 EXPECT_EQ(false, SetRemoteHapTokenInfoTest("", wrongBaseInfo));
912
913 wrongBaseInfo.apl = (ATokenAplEnum)11; // wrong apl
914 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
915
916 wrongBaseInfo = rightBaseInfo;
917 wrongBaseInfo.deviceID = wrongStr; // wrong deviceID
918 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
919
920 wrongBaseInfo = rightBaseInfo;
921 wrongBaseInfo.userID = -1; // wrong userID
922 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
923
924 wrongBaseInfo = rightBaseInfo;
925 wrongBaseInfo.bundleName = wrongStr; // wrong bundleName
926 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
927
928 wrongBaseInfo = rightBaseInfo;
929 wrongBaseInfo.tokenID = 0; // wrong tokenID
930 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
931
932 wrongBaseInfo = rightBaseInfo;
933 wrongBaseInfo.appID = wrongStr; // wrong appID
934 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
935
936 wrongBaseInfo = rightBaseInfo;
937 wrongBaseInfo.dlpType = (HapDlpType)11;; // wrong dlpType
938 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
939
940 wrongBaseInfo = rightBaseInfo;
941 wrongBaseInfo.ver = 2; // 2: wrong version
942 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
943
944 wrongBaseInfo = rightBaseInfo;
945 wrongBaseInfo.tokenID = AccessTokenInfoManager::GetInstance().GetNativeTokenId("hdcd");
946 EXPECT_EQ(false, SetRemoteHapTokenInfoTest(deviceID, wrongBaseInfo));
947 }
948
949 /**
950 * @tc.name: NotifyTokenSyncTask001
951 * @tc.desc: TokenModifyNotifier::NotifyTokenSyncTask function test
952 * @tc.type: FUNC
953 * @tc.require:
954 */
955 HWTEST_F(AccessTokenInfoManagerTest, NotifyTokenSyncTask001, TestSize.Level1)
956 {
957 std::vector<AccessTokenID> modifiedTokenList = TokenModifyNotifier::GetInstance().modifiedTokenList_; // backup
958 TokenModifyNotifier::GetInstance().modifiedTokenList_.clear();
959
960 AccessTokenID tokenId = 123; // 123 is random input
961
962 TokenModifyNotifier::GetInstance().modifiedTokenList_.emplace_back(tokenId);
963 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().modifiedTokenList_.size() > 0);
964 TokenModifyNotifier::GetInstance().NotifyTokenSyncTask();
965
966 TokenModifyNotifier::GetInstance().modifiedTokenList_ = modifiedTokenList; // recovery
967 }
968
969 /**
970 * @tc.name: RegisterTokenSyncCallback001
971 * @tc.desc: TokenModifyNotifier::RegisterTokenSyncCallback function test
972 * @tc.type: FUNC
973 * @tc.require:
974 */
975 HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenSyncCallback001, TestSize.Level1)
976 {
977 setuid(3020);
978 sptr<TokenSyncCallbackMock> callback = new (std::nothrow) TokenSyncCallbackMock();
979 ASSERT_NE(nullptr, callback);
980 EXPECT_EQ(RET_SUCCESS,
981 atManagerService_->RegisterTokenSyncCallback(callback->AsObject()));
982 EXPECT_NE(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_);
983 EXPECT_NE(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackDeathRecipient_);
984
985 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_)).WillOnce(testing::Return(FAKE_SYNC_RET));
986 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_->GetRemoteHapTokenInfo("", 0));
987
988 EXPECT_CALL(*callback, DeleteRemoteHapTokenInfo(testing::_)).WillOnce(testing::Return(FAKE_SYNC_RET));
989 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_->DeleteRemoteHapTokenInfo(0));
990
991 HapTokenInfoForSync tokenInfo;
992 EXPECT_CALL(*callback, UpdateRemoteHapTokenInfo(testing::_)).WillOnce(testing::Return(FAKE_SYNC_RET));
993 EXPECT_EQ(FAKE_SYNC_RET,
994 TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_->UpdateRemoteHapTokenInfo(tokenInfo));
995 EXPECT_EQ(RET_SUCCESS,
996 atManagerService_->UnRegisterTokenSyncCallback());
997 EXPECT_EQ(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_);
998 EXPECT_EQ(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackDeathRecipient_);
999 setuid(0);
1000 }
1001
1002 /**
1003 * @tc.name: RegisterTokenSyncCallback002
1004 * @tc.desc: TokenModifyNotifier::RegisterTokenSyncCallback function test
1005 * @tc.type: FUNC
1006 * @tc.require:
1007 */
1008 HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenSyncCallback002, TestSize.Level1)
1009 {
1010 setuid(3020);
1011 sptr<TokenSyncCallbackMock> callback = new (std::nothrow) TokenSyncCallbackMock();
1012 ASSERT_NE(nullptr, callback);
1013 EXPECT_EQ(RET_SUCCESS,
1014 atManagerService_->RegisterTokenSyncCallback(callback->AsObject()));
1015 EXPECT_NE(nullptr, TokenModifyNotifier::GetInstance().tokenSyncCallbackObject_);
1016 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_))
1017 .WillOnce(testing::Return(FAKE_SYNC_RET));
1018 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance().GetRemoteHapTokenInfo("", 0));
1019
1020 std::vector<AccessTokenID> modifiedTokenList =
1021 TokenModifyNotifier::GetInstance().modifiedTokenList_; // backup
1022 std::vector<AccessTokenID> deleteTokenList = TokenModifyNotifier::GetInstance().deleteTokenList_;
1023 TokenModifyNotifier::GetInstance().modifiedTokenList_.clear();
1024 TokenModifyNotifier::GetInstance().deleteTokenList_.clear();
1025
1026 // add a hap token
1027 AccessTokenIDEx tokenIdEx = {123};
1028 int32_t result = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
1029 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
1030 EXPECT_EQ(RET_SUCCESS, result);
1031
1032 HapTokenInfoForSync hapSync;
1033 result = AccessTokenInfoManager::GetInstance().GetHapTokenSync(tokenIdEx.tokenIdExStruct.tokenID, hapSync);
1034 ASSERT_EQ(result, RET_SUCCESS);
1035 TokenModifyNotifier::GetInstance().modifiedTokenList_.emplace_back(tokenIdEx.tokenIdExStruct.tokenID);
1036 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().modifiedTokenList_.size() > 0);
1037 TokenModifyNotifier::GetInstance().deleteTokenList_.clear();
1038
1039 EXPECT_CALL(*callback, UpdateRemoteHapTokenInfo(testing::_)) // 0 is a test ret
1040 .WillOnce(testing::Return(0));
1041 TokenModifyNotifier::GetInstance().NotifyTokenSyncTask();
1042
1043 TokenModifyNotifier::GetInstance().deleteTokenList_.emplace_back(tokenIdEx.tokenIdExStruct.tokenID);
1044 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().deleteTokenList_.size() > 0);
1045 EXPECT_CALL(*callback, DeleteRemoteHapTokenInfo(testing::_)) // 0 is a test ret
1046 .WillOnce(testing::Return(0));
1047 TokenModifyNotifier::GetInstance().NotifyTokenSyncTask();
1048
1049 TokenModifyNotifier::GetInstance().modifiedTokenList_ = modifiedTokenList; // recovery
1050 TokenModifyNotifier::GetInstance().deleteTokenList_ = deleteTokenList;
1051 EXPECT_EQ(RET_SUCCESS,
1052 atManagerService_->UnRegisterTokenSyncCallback());
1053 setuid(0);
1054 }
1055
1056 /**
1057 * @tc.name: GetRemoteHapTokenInfo001
1058 * @tc.desc: TokenModifyNotifier::GetRemoteHapTokenInfo function test
1059 * @tc.type: FUNC
1060 * @tc.require:
1061 */
1062 HWTEST_F(AccessTokenInfoManagerTest, GetRemoteHapTokenInfo001, TestSize.Level1)
1063 {
1064 setuid(3020);
1065 sptr<TokenSyncCallbackMock> callback = new (std::nothrow) TokenSyncCallbackMock();
1066 ASSERT_NE(nullptr, callback);
1067 EXPECT_EQ(RET_SUCCESS, atManagerService_->RegisterTokenSyncCallback(callback->AsObject()));
1068 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_))
1069 .WillOnce(testing::Return(FAKE_SYNC_RET));
1070 EXPECT_EQ(FAKE_SYNC_RET, TokenModifyNotifier::GetInstance()
1071 .GetRemoteHapTokenInfo("invalid_id", 0)); // this is a test input
1072
1073 EXPECT_CALL(*callback, GetRemoteHapTokenInfo(testing::_, testing::_))
1074 .WillOnce(testing::Return(TOKEN_SYNC_OPENSOURCE_DEVICE));
1075 EXPECT_EQ(TOKEN_SYNC_IPC_ERROR, TokenModifyNotifier::GetInstance()
1076 .GetRemoteHapTokenInfo("invalid_id", 0)); // this is a test input
1077 EXPECT_EQ(RET_SUCCESS,
1078 atManagerService_->UnRegisterTokenSyncCallback());
1079 setuid(0);
1080 }
1081
1082 /**
1083 * @tc.name: UpdateRemoteHapTokenInfo001
1084 * @tc.desc: AccessTokenInfoManager::UpdateRemoteHapTokenInfo function test
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(AccessTokenInfoManagerTest, UpdateRemoteHapTokenInfo001, TestSize.Level1)
1089 {
1090 AccessTokenID mapID = 0;
1091 HapTokenInfoForSync hapSync;
1092
1093 // infoPtr is null
1094 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().UpdateRemoteHapTokenInfo(mapID, hapSync));
1095
1096 mapID = 123; // 123 is random input
1097 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
1098 info->SetRemote(true);
1099 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[mapID] = info;
1100
1101 // remote is true
1102 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().UpdateRemoteHapTokenInfo(mapID, hapSync));
1103
1104 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(mapID);
1105 }
1106
1107 /**
1108 * @tc.name: CreateRemoteHapTokenInfo001
1109 * @tc.desc: AccessTokenInfoManager::CreateRemoteHapTokenInfo function test
1110 * @tc.type: FUNC
1111 * @tc.require:
1112 */
1113 HWTEST_F(AccessTokenInfoManagerTest, CreateRemoteHapTokenInfo001, TestSize.Level1)
1114 {
1115 AccessTokenID mapID = 123; // 123 is random input
1116 HapTokenInfoForSync hapSync;
1117
1118 hapSync.baseInfo.tokenID = 123; // 123 is random input
1119 std::shared_ptr<HapTokenInfoInner> info = std::make_shared<HapTokenInfoInner>();
1120 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[123] = info;
1121
1122 // count(id) exsit
1123 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateRemoteHapTokenInfo(mapID, hapSync));
1124
1125 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(123);
1126 }
1127
1128 /**
1129 * @tc.name: DeleteRemoteToken002
1130 * @tc.desc: AccessTokenInfoManager::DeleteRemoteToken function test
1131 * @tc.type: FUNC
1132 * @tc.require:
1133 */
1134 HWTEST_F(AccessTokenInfoManagerTest, DeleteRemoteToken002, TestSize.Level1)
1135 {
1136 std::string deviceID = "dev-001";
1137 AccessTokenID tokenID = 123; // 123 is random input
1138
1139 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID,
1140 AccessTokenInfoManager::GetInstance().DeleteRemoteToken("", tokenID));
1141
1142 AccessTokenRemoteDevice device;
1143 device.DeviceID_ = deviceID;
1144 // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
1145 device.MappingTokenIDPairMap_.insert(std::pair<AccessTokenID, AccessTokenID>(tokenID, 537919487));
1146 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_[deviceID] = device;
1147
1148 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(537919487, TOKEN_HAP));
1149 // hap mapID 537919487 is not exist
1150 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceID, tokenID));
1151 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.erase(deviceID);
1152 AccessTokenIDManager::GetInstance().ReleaseTokenId(537919487);
1153
1154 // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
1155 device.MappingTokenIDPairMap_[tokenID] = 672137215;
1156 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_[deviceID] = device;
1157
1158 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(672137215, TOKEN_NATIVE));
1159 // native mapID 672137215 is not exist
1160 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().DeleteRemoteToken(deviceID, tokenID));
1161 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.erase(deviceID);
1162 AccessTokenIDManager::GetInstance().ReleaseTokenId(672137215);
1163 }
1164
1165 /**
1166 * @tc.name: AllocLocalTokenID001
1167 * @tc.desc: AccessTokenInfoManager::AllocLocalTokenID function test
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(AccessTokenInfoManagerTest, AllocLocalTokenID001, TestSize.Level1)
1172 {
1173 std::string remoteDeviceID;
1174 AccessTokenID remoteTokenID = 0;
1175
1176 ASSERT_EQ(static_cast<AccessTokenID>(0), AccessTokenInfoManager::GetInstance().AllocLocalTokenID(remoteDeviceID,
1177 remoteTokenID)); // remoteDeviceID invalid
1178
1179 // deviceID invalid + tokenID == 0
1180 ASSERT_EQ(static_cast<AccessTokenID>(0),
1181 AccessTokenInfoManager::GetInstance().GetRemoteNativeTokenID(remoteDeviceID, remoteTokenID));
1182
1183 // deviceID invalid
1184 ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().DeleteRemoteDeviceTokens(remoteDeviceID));
1185
1186 remoteDeviceID = "dev-001";
1187 ASSERT_EQ(static_cast<AccessTokenID>(0), AccessTokenInfoManager::GetInstance().AllocLocalTokenID(remoteDeviceID,
1188 remoteTokenID)); // remoteTokenID invalid
1189
1190 // deviceID valid + tokenID == 0
1191 ASSERT_EQ(static_cast<AccessTokenID>(0),
1192 AccessTokenInfoManager::GetInstance().GetRemoteNativeTokenID(remoteDeviceID, remoteTokenID));
1193
1194 remoteTokenID = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
1195 // deviceID valid + tokenID != 0 + type != native + type != shell
1196 ASSERT_EQ(static_cast<AccessTokenID>(0),
1197 AccessTokenInfoManager::GetInstance().GetRemoteNativeTokenID(remoteDeviceID, remoteTokenID));
1198 }
1199 #endif
1200
1201 /**
1202 * @tc.name: Dump001
1203 * @tc.desc: Dump tokeninfo.
1204 * @tc.type: FUNC
1205 * @tc.require: issueI4V02P
1206 */
1207 HWTEST_F(AccessTokenInfoManagerTest, Dump001, TestSize.Level1)
1208 {
1209 int fd = -1;
1210 std::vector<std::u16string> args;
1211
1212 // fd is 0
1213 ASSERT_NE(RET_SUCCESS, atManagerService_->Dump(fd, args));
1214
1215 fd = 123; // 123：valid fd
1216
1217 // hidumper
1218 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1219
1220 // hidumper -h
1221 args.emplace_back(Str8ToStr16("-h"));
1222 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1223
1224 args.clear();
1225 // hidumper -a
1226 args.emplace_back(Str8ToStr16("-a"));
1227 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1228
1229 args.clear();
1230 // hidumper -t
1231 args.emplace_back(Str8ToStr16("-t"));
1232 ASSERT_NE(RET_SUCCESS, atManagerService_->Dump(fd, args));
1233
1234 args.clear();
1235 // hidumper -t
1236 args.emplace_back(Str8ToStr16("-t"));
1237 args.emplace_back(Str8ToStr16("-1")); // illegal tokenId
1238 ASSERT_NE(RET_SUCCESS, atManagerService_->Dump(fd, args));
1239
1240 args.clear();
1241 // hidumper -t
1242 args.emplace_back(Str8ToStr16("-t"));
1243 args.emplace_back(Str8ToStr16("123")); // invalid tokenId
1244 ASSERT_EQ(RET_SUCCESS, atManagerService_->Dump(fd, args));
1245 }
1246
1247 /**
1248 * @tc.name: DumpTokenInfo001
1249 * @tc.desc: Test DumpTokenInfo with invalid tokenId.
1250 * @tc.type: FUNC
1251 * @tc.require: issueI4V02P
1252 */
1253 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo001, TestSize.Level1)
1254 {
1255 std::string dumpInfo;
1256 AtmToolsParamInfo info;
1257 info.tokenId = static_cast<AccessTokenID>(0);
1258 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1259 EXPECT_EQ(false, dumpInfo.empty());
1260
1261 dumpInfo.clear();
1262 info.tokenId = static_cast<AccessTokenID>(123);
1263 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1264 EXPECT_EQ("invalid tokenId", dumpInfo);
1265 }
1266
1267 /**
1268 * @tc.name: DumpTokenInfo002
1269 * @tc.desc: Test DumpTokenInfo with hap tokenId.
1270 * @tc.type: FUNC
1271 * @tc.require: issueI4V02P
1272 */
1273 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo002, TestSize.Level1)
1274 {
1275 AccessTokenIDEx tokenIdEx = {0};
1276 AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
1277 g_infoManagerTestPolicyPrams1, tokenIdEx);
1278
1279 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
1280 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
1281 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1282 EXPECT_NE(0, static_cast<int>(tokenId));
1283 std::string dumpInfo;
1284 AtmToolsParamInfo info;
1285 info.tokenId = tokenId;
1286 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1287 EXPECT_EQ(false, dumpInfo.empty());
1288
1289 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(
1290 tokenIdEx.tokenIdExStruct.tokenID);
1291 ASSERT_EQ(RET_SUCCESS, ret);
1292 GTEST_LOG_(INFO) << "remove the token info";
1293 }
1294
1295 /**
1296 * @tc.name: DumpTokenInfo003
1297 * @tc.desc: Test DumpTokenInfo with native tokenId.
1298 * @tc.type: FUNC
1299 * @tc.require: issueI4V02P
1300 */
1301 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo003, TestSize.Level1)
1302 {
1303 std::string dumpInfo;
1304 AtmToolsParamInfo info;
1305 info.tokenId = AccessTokenInfoManager::GetInstance().GetNativeTokenId("accesstoken_service");
1306 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1307 EXPECT_EQ(false, dumpInfo.empty());
1308 }
1309
1310 /**
1311 * @tc.name: DumpTokenInfo004
1312 * @tc.desc: Test DumpTokenInfo with shell tokenId.
1313 * @tc.type: FUNC
1314 * @tc.require: issueI4V02P
1315 */
1316 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo004, TestSize.Level1)
1317 {
1318 std::string dumpInfo;
1319 AtmToolsParamInfo info;
1320 info.tokenId = AccessTokenInfoManager::GetInstance().GetNativeTokenId("hdcd");
1321 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1322 EXPECT_EQ(false, dumpInfo.empty());
1323 }
1324
1325 /**
1326 * @tc.name: DumpTokenInfo006
1327 * @tc.desc: Test DumpTokenInfo with native processName.
1328 * @tc.type: FUNC
1329 * @tc.require: issueI4V02P
1330 */
1331 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo006, TestSize.Level1)
1332 {
1333 std::string dumpInfo;
1334 AtmToolsParamInfo info;
1335 info.processName = "hdcd";
1336 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1337 EXPECT_EQ(false, dumpInfo.empty());
1338 }
1339
1340 /**
1341 * @tc.name: DumpTokenInfo007
1342 * @tc.desc: Test DumpTokenInfo with hap bundleName.
1343 * @tc.type: FUNC
1344 * @tc.require: issueI4V02P
1345 */
1346 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo007, TestSize.Level1)
1347 {
1348 AccessTokenIDEx tokenIdEx = {0};
1349 AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
1350 g_infoManagerTestPolicyPrams1, tokenIdEx);
1351
1352 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
1353 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
1354 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1355 EXPECT_NE(0, static_cast<int>(tokenId));
1356
1357 std::string dumpInfo;
1358 AtmToolsParamInfo info;
1359 info.bundleName = g_infoManagerTestInfoParms.bundleName;
1360 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo);
1361 EXPECT_EQ(false, dumpInfo.empty());
1362
1363 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(
1364 tokenIdEx.tokenIdExStruct.tokenID);
1365 ASSERT_EQ(RET_SUCCESS, ret);
1366 }
1367
1368 /**
1369 * @tc.name: AccessTokenInfoManager001
1370 * @tc.desc: AccessTokenInfoManager::~AccessTokenInfoManager+Init function test hasInited_ is false
1371 * @tc.type: FUNC
1372 * @tc.require:
1373 */
1374 HWTEST_F(AccessTokenInfoManagerTest, AccessTokenInfoManager001, TestSize.Level1)
1375 {
1376 AccessTokenInfoManager::GetInstance().hasInited_ = true;
1377 AccessTokenInfoManager::GetInstance().Init();
1378 AccessTokenInfoManager::GetInstance().hasInited_ = false;
1379 ASSERT_EQ(false, AccessTokenInfoManager::GetInstance().hasInited_);
1380 }
1381
1382 /**
1383 * @tc.name: GetHapUniqueStr001
1384 * @tc.desc: AccessTokenInfoManager::GetHapUniqueStr function test info is null
1385 * @tc.type: FUNC
1386 * @tc.require:
1387 */
1388 HWTEST_F(AccessTokenInfoManagerTest, GetHapUniqueStr001, TestSize.Level1)
1389 {
1390 std::shared_ptr<HapTokenInfoInner> info = nullptr;
1391 ASSERT_EQ("", AccessTokenInfoManager::GetInstance().GetHapUniqueStr(info));
1392 }
1393
1394 /**
1395 * @tc.name: AddHapTokenInfo001
1396 * @tc.desc: AccessTokenInfoManager::AddHapTokenInfo function test info is null
1397 * @tc.type: FUNC
1398 * @tc.require:
1399 */
1400 HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenInfo001, TestSize.Level1)
1401 {
1402 std::shared_ptr<HapTokenInfoInner> info = nullptr;
1403 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().AddHapTokenInfo(info));
1404 }
1405
1406 /**
1407 * @tc.name: AddHapTokenInfo002
1408 * @tc.desc: AccessTokenInfoManager::AddHapTokenInfo function test count(id) > 0
1409 * @tc.type: FUNC
1410 * @tc.require:
1411 */
1412 HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenInfo002, TestSize.Level1)
1413 {
1414 HapInfoParams info = {
1415 .userID = USER_ID,
1416 .bundleName = "accesstoken_info_manager_test",
1417 .instIndex = INST_INDEX,
1418 .appIDDesc = "accesstoken_info_manager_test"
1419 };
1420 HapPolicyParams policy = {
1421 .apl = APL_NORMAL,
1422 .domain = "domain"
1423 };
1424 AccessTokenIDEx tokenIdEx = {0};
1425 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
1426 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1427 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
1428
1429 std::shared_ptr<HapTokenInfoInner> infoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
1430 ASSERT_NE(0, AccessTokenInfoManager::GetInstance().AddHapTokenInfo(infoPtr));
1431
1432 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
1433 }
1434
1435 /**
1436 * @tc.name: GetHapTokenID002
1437 * @tc.desc: test GetHapTokenID function abnomal branch
1438 * @tc.type: FUNC
1439 * @tc.require: issueI60F1M
1440 */
1441 HWTEST_F(AccessTokenInfoManagerTest, GetHapTokenID002, TestSize.Level1)
1442 {
1443 AccessTokenIDEx tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(
1444 USER_ID, "com.ohos.test", INST_INDEX);
1445 ASSERT_EQ(static_cast<AccessTokenID>(0), tokenIdEx.tokenIDEx);
1446 }
1447
1448 /**
1449 * @tc.name: AddNativeTokenInfo001
1450 * @tc.desc: AccessTokenInfoManager::AddNativeTokenInfo function test
1451 * @tc.type: FUNC
1452 * @tc.require: issueI62M6G
1453 */
1454 HWTEST_F(AccessTokenInfoManagerTest, AddNativeTokenInfo001, TestSize.Level1)
1455 {
1456 std::shared_ptr<NativeTokenInfoInner> info = nullptr;
1457 ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(info)); // info is null
1458
1459 AccessTokenID tokenId = AccessTokenInfoManager::GetInstance().GetNativeTokenId("accesstoken_service");
1460 info = std::make_shared<NativeTokenInfoInner>();
1461 info->tokenInfoBasic_.tokenID = tokenId;
1462 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(info)); // count(id) > 0
1463
1464 // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
1465 info->tokenInfoBasic_.tokenID = 672137215;
1466 info->tokenInfoBasic_.processName = "accesstoken_service";
1467 // 672137214 is max-1 native tokenId: 001 01 0 000000 11111111111111111110
1468 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_[672137214] = info;
1469 // count(processName) > 0
1470 ASSERT_EQ(ERR_PROCESS_NOT_EXIST, AccessTokenInfoManager::GetInstance().AddNativeTokenInfo(info));
1471
1472 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_.erase(672137214);
1473 }
1474
1475 /**
1476 * @tc.name: RemoveNativeTokenInfo001
1477 * @tc.desc: AccessTokenInfoManager::RemoveNativeTokenInfo function test
1478 * @tc.type: FUNC
1479 * @tc.require: issueI62M6G
1480 */
1481 HWTEST_F(AccessTokenInfoManagerTest, RemoveNativeTokenInfo001, TestSize.Level1)
1482 {
1483 AccessTokenID tokenId = 672137215; // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
1484 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId)); // count(id) == 0
1485
1486 std::shared_ptr<NativeTokenInfoInner> info = std::make_shared<NativeTokenInfoInner>();
1487 info->isRemote_ = true;
1488 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_[tokenId] = info;
1489 ASSERT_NE(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId)); // remote is true
1490 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_.erase(tokenId);
1491
1492 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_NATIVE));
1493 info->isRemote_ = false;
1494 info->tokenInfoBasic_.processName = "testtesttest";
1495 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_[tokenId] = info;
1496 // count(processName) == 0
1497 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveNativeTokenInfo(tokenId)); // erase in function
1498 AccessTokenIDManager::GetInstance().ReleaseTokenId(tokenId);
1499 }
1500
1501 /**
1502 * @tc.name: TryUpdateExistNativeToken001
1503 * @tc.desc: AccessTokenInfoManager::TryUpdateExistNativeToken function test
1504 * @tc.type: FUNC
1505 * @tc.require:
1506 */
1507 HWTEST_F(AccessTokenInfoManagerTest, TryUpdateExistNativeToken001, TestSize.Level1)
1508 {
1509 std::shared_ptr<NativeTokenInfoInner> infoPtr = nullptr;
1510 ASSERT_EQ(false, AccessTokenInfoManager::GetInstance().TryUpdateExistNativeToken(infoPtr)); // infoPtr is null
1511 }
1512
1513 /**
1514 * @tc.name: ProcessNativeTokenInfos001
1515 * @tc.desc: AccessTokenInfoManager::ProcessNativeTokenInfos function test AddNativeTokenInfo fail
1516 * @tc.type: FUNC
1517 * @tc.require:
1518 */
1519 HWTEST_F(AccessTokenInfoManagerTest, ProcessNativeTokenInfos001, TestSize.Level1)
1520 {
1521 AccessTokenID tokenId = 672137215; // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
1522 AccessTokenID tokenId2 = 672137214; // 672137214: 001 01 0 000000 11111111111111111110
1523 std::vector<std::shared_ptr<NativeTokenInfoInner>> tokenInfos;
1524 std::shared_ptr<NativeTokenInfoInner> info = std::make_shared<NativeTokenInfoInner>();
1525 info->tokenInfoBasic_.tokenID = tokenId2;
1526 info->tokenInfoBasic_.processName = "testtesttest";
1527 ASSERT_NE("", info->tokenInfoBasic_.processName);
1528 tokenInfos.emplace_back(info);
1529 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_[tokenId] = info;
1530 AccessTokenInfoManager::GetInstance().nativeTokenIdMap_["testtesttest"] = tokenId;
1531 AccessTokenInfoManager::GetInstance().ProcessNativeTokenInfos(tokenInfos);
1532 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_.erase(tokenId);
1533 AccessTokenInfoManager::GetInstance().nativeTokenIdMap_.erase("testtesttest");
1534 }
1535
1536 /**
1537 * @tc.name: Insert001
1538 * @tc.desc: PermissionDefinitionCache::Insert function test
1539 * @tc.type: FUNC
1540 * @tc.require:
1541 */
1542 HWTEST_F(AccessTokenInfoManagerTest, Insert001, TestSize.Level1)
1543 {
1544 PermissionDef info = {
1545 .permissionName = "ohos.permission.CAMERA",
1546 .bundleName = "com.ohos.test",
1547 .grantMode = 0,
1548 .availableLevel = ATokenAplEnum::APL_NORMAL,
1549 .provisionEnable = false,
1550 .distributedSceneEnable = false,
1551 .label = "buzhidao",
1552 .labelId = 100, // 100 is random input
1553 .description = "buzhidao",
1554 .descriptionId = 100 // 100 is random input
1555 };
1556 AccessTokenID tokenId = 123; // 123 is random input
1557
1558 ASSERT_EQ(false, PermissionDefinitionCache::GetInstance().Insert(info, tokenId)); // permission has insert
1559 }
1560
1561 /**
1562 * @tc.name: IsGrantedModeEqualInner001
1563 * @tc.desc: PermissionDefinitionCache::IsGrantedModeEqualInner function test
1564 * @tc.type: FUNC
1565 * @tc.require:
1566 */
1567 HWTEST_F(AccessTokenInfoManagerTest, IsGrantedModeEqualInner001, TestSize.Level1)
1568 {
1569 std::string permissionName = "ohos.permission.CAMERA";
1570 int grantMode = 0;
1571
1572 // find permission not reach end
1573 ASSERT_EQ(true, PermissionDefinitionCache::GetInstance().IsGrantedModeEqualInner(permissionName, grantMode));
1574
1575 permissionName = "ohos.permission.INVALID";
1576 // can't find permission
1577 ASSERT_EQ(false, PermissionDefinitionCache::GetInstance().IsGrantedModeEqualInner(permissionName, grantMode));
1578 }
1579
1580 /**
1581 * @tc.name: RestorePermDefInfo001
1582 * @tc.desc: PermissionDefinitionCache::RestorePermDefInfo function test
1583 * @tc.type: FUNC
1584 * @tc.require:
1585 */
1586 HWTEST_F(AccessTokenInfoManagerTest, RestorePermDefInfo001, TestSize.Level1)
1587 {
1588 GenericValues value;
1589 value.Put(TokenFiledConst::FIELD_AVAILABLE_LEVEL, ATokenAplEnum::APL_INVALID);
1590
1591 std::vector<GenericValues> values;
1592 values.emplace_back(value);
1593
1594 // ret not RET_SUCCESS
1595 ASSERT_NE(RET_SUCCESS, PermissionDefinitionCache::GetInstance().RestorePermDefInfo(values));
1596 }
1597
1598 /**
1599 * @tc.name: IsPermissionDefValid001
1600 * @tc.desc: PermissionValidator::IsPermissionDefValid function test
1601 * @tc.type: FUNC
1602 * @tc.require:
1603 */
1604 HWTEST_F(AccessTokenInfoManagerTest, IsPermissionDefValid001, TestSize.Level1)
1605 {
1606 PermissionDef permDef = {
1607 .permissionName = "ohos.permission.TEST",
1608 .bundleName = "com.ohos.test",
1609 .grantMode = static_cast<GrantMode>(2),
1610 .availableLevel = ATokenAplEnum::APL_NORMAL,
1611 .provisionEnable = false,
1612 .distributedSceneEnable = false,
1613 .label = "buzhidao",
1614 .labelId = 100, // 100 is random input
1615 .description = "buzhidao",
1616 .descriptionId = 100 // 100 is random input
1617 };
1618
1619 // ret not RET_SUCCESS
1620 ASSERT_EQ(false, PermissionValidator::IsPermissionDefValid(permDef)); // grant mode invalid
1621
1622 permDef.grantMode = GrantMode::USER_GRANT;
1623 permDef.availableType = ATokenAvailableTypeEnum::INVALID;
1624 ASSERT_EQ(false, PermissionValidator::IsPermissionDefValid(permDef)); // availableType invalid
1625 }
1626
1627 /**
1628 * @tc.name: IsPermissionStateValid001
1629 * @tc.desc: PermissionValidator::IsPermissionStateValid function test
1630 * @tc.type: FUNC
1631 * @tc.require:
1632 */
1633 HWTEST_F(AccessTokenInfoManagerTest, IsPermissionStateValid001, TestSize.Level1)
1634 {
1635 std::string permissionName;
1636 std::string deviceID = "dev-001";
1637 int grantState = PermissionState::PERMISSION_DENIED;
1638 uint32_t grantFlag = PermissionFlag::PERMISSION_DEFAULT_FLAG;
1639
1640 std::vector<std::string> resDeviceID;
1641 std::vector<int> grantStates;
1642 std::vector<uint32_t> grantFlags;
1643
1644 resDeviceID.emplace_back(deviceID);
1645 grantStates.emplace_back(grantState);
1646 grantFlags.emplace_back(grantFlag);
1647
1648 PermissionStateFull permState = {
1649 .permissionName = permissionName,
1650 .isGeneral = false,
1651 .resDeviceID = resDeviceID,
1652 .grantStatus = grantStates,
1653 .grantFlags = grantFlags
1654 };
1655
1656 ASSERT_EQ(false, PermissionValidator::IsPermissionStateValid(permState)); // permissionName empty
1657
1658 permState.permissionName = "com.ohos.TEST";
1659 permState.resDeviceID.emplace_back("dev-002");
1660 // deviceID nums not equal status nums or flag nums
1661 ASSERT_EQ(false, PermissionValidator::IsPermissionStateValid(permState));
1662
1663 permState.grantStatus.emplace_back(PermissionState::PERMISSION_DENIED);
1664 // deviceID nums not equal flag nums
1665 ASSERT_EQ(false, PermissionValidator::IsPermissionStateValid(permState));
1666
1667 permState.grantFlags.emplace_back(PermissionFlag::PERMISSION_DEFAULT_FLAG);
1668 ASSERT_EQ(true, PermissionValidator::IsPermissionStateValid(permState));
1669 }
1670
1671 /**
1672 * @tc.name: FilterInvalidPermissionDef001
1673 * @tc.desc: PermissionValidator::FilterInvalidPermissionDef function test
1674 * @tc.type: FUNC
1675 * @tc.require:
1676 */
1677 HWTEST_F(AccessTokenInfoManagerTest, FilterInvalidPermissionDef001, TestSize.Level1)
1678 {
1679 PermissionDef permDef = {
1680 .permissionName = "ohos.permission.TEST",
1681 .bundleName = "com.ohos.test",
1682 .grantMode = GrantMode::SYSTEM_GRANT,
1683 .availableLevel = ATokenAplEnum::APL_NORMAL,
1684 .provisionEnable = false,
1685 .distributedSceneEnable = false,
1686 .label = "buzhidao",
1687 .labelId = 100, // 100 is random input
1688 .description = "buzhidao",
1689 .descriptionId = 100 // 100 is random input
1690 };
1691
1692 std::vector<PermissionDef> permList;
1693 permList.emplace_back(permDef);
1694 permList.emplace_back(permDef);
1695
1696 ASSERT_EQ(static_cast<uint32_t>(2), permList.size());
1697
1698 std::vector<PermissionDef> result;
1699 PermissionValidator::FilterInvalidPermissionDef(permList, result); // permDefSet.count != 0
1700 ASSERT_EQ(static_cast<uint32_t>(1), result.size());
1701 }
1702
1703 /**
1704 * @tc.name: DeduplicateResDevID001
1705 * @tc.desc: PermissionValidator::DeduplicateResDevID function test
1706 * @tc.type: FUNC
1707 * @tc.require:
1708 */
1709 HWTEST_F(AccessTokenInfoManagerTest, DeduplicateResDevID001, TestSize.Level1)
1710 {
1711 GTEST_LOG_(INFO) << "DeduplicateResDevID001";
1712 PermissionStateFull permState = {
1713 .permissionName = "ohos.permission.TEST",
1714 .isGeneral = false,
1715 .resDeviceID = {"dev-001", "dev-001"},
1716 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1717 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1718 };
1719 GTEST_LOG_(INFO) << "DeduplicateResDevID001_1";
1720 ASSERT_EQ(static_cast<uint32_t>(2), permState.resDeviceID.size());
1721
1722 std::vector<PermissionStateFull> permList;
1723 permList.emplace_back(permState);
1724 std::vector<PermissionStateFull> result;
1725 GTEST_LOG_(INFO) << "DeduplicateResDevID001_2";
1726 PermissionValidator::FilterInvalidPermissionState(TOKEN_NATIVE, false, permList, result); // resDevId.count != 0
1727 GTEST_LOG_(INFO) << "DeduplicateResDevID001_3";
1728 ASSERT_EQ(static_cast<uint32_t>(1), result[0].resDeviceID.size());
1729 }
1730
1731 /**
1732 * @tc.name: Update001
1733 * @tc.desc: PermissionPolicySet::Update function test
1734 * @tc.type: FUNC
1735 * @tc.require:
1736 */
1737 HWTEST_F(AccessTokenInfoManagerTest, Update001, TestSize.Level1)
1738 {
1739 PermissionStateFull perm1 = {
1740 .permissionName = "ohos.permission.TEST1",
1741 .isGeneral = false,
1742 .resDeviceID = {"dev-001", "dev-001"},
1743 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1744 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1745 };
1746 PermissionStateFull perm2 = {
1747 .permissionName = "ohos.permission.TEST2",
1748 .isGeneral = true,
1749 .resDeviceID = {"dev-001", "dev-001"},
1750 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1751 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1752 };
1753 PermissionStateFull perm3 = {
1754 .permissionName = "ohos.permission.TEST1",
1755 .isGeneral = true,
1756 .resDeviceID = {"dev-001", "dev-001"},
1757 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1758 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1759 };
1760 ASSERT_EQ(false, perm1.permissionName == perm2.permissionName);
1761 ASSERT_EQ(true, perm1.permissionName == perm3.permissionName);
1762 ASSERT_EQ(false, perm1.isGeneral == perm3.isGeneral);
1763
1764 AccessTokenID tokenId = 123; // 123 is random input
1765 std::vector<PermissionStateFull> permStateList1;
1766 permStateList1.emplace_back(perm1);
1767 std::vector<PermissionStateFull> permStateList2;
1768 permStateList1.emplace_back(perm2);
1769 std::vector<PermissionStateFull> permStateList3;
1770 permStateList1.emplace_back(perm3);
1771
1772 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1773 permStateList1);
1774
1775 policySet->Update(permStateList2); // iter reach end
1776 policySet->Update(permStateList3); // permNew.isGeneral != permOld.isGeneral
1777 }
1778
1779 /**
1780 * @tc.name: RestorePermissionPolicy001
1781 * @tc.desc: PermissionPolicySet::RestorePermissionPolicy function test
1782 * @tc.type: FUNC
1783 * @tc.require:
1784 */
1785 HWTEST_F(AccessTokenInfoManagerTest, RestorePermissionPolicy001, TestSize.Level1)
1786 {
1787 GenericValues value1;
1788 value1.Put(TokenFiledConst::FIELD_TOKEN_ID, 123); // 123 is random input
1789 value1.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, true);
1790 value1.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
1791 value1.Put(TokenFiledConst::FIELD_DEVICE_ID, "dev-001");
1792 value1.Put(TokenFiledConst::FIELD_GRANT_STATE, static_cast<PermissionState>(3));
1793 value1.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
1794
1795 AccessTokenID tokenId = 123; // 123 is random input
1796 std::vector<GenericValues> permStateRes1;
1797 permStateRes1.emplace_back(value1);
1798
1799 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::RestorePermissionPolicy(tokenId,
1800 permStateRes1); // ret != RET_SUCCESS
1801
1802 ASSERT_EQ(tokenId, policySet->tokenId_);
1803
1804 GenericValues value2;
1805 value2.Put(TokenFiledConst::FIELD_TOKEN_ID, 123); // 123 is random input
1806 value2.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, true);
1807 value2.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
1808 value2.Put(TokenFiledConst::FIELD_DEVICE_ID, "dev-002");
1809 value2.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_DENIED);
1810 value2.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
1811 GenericValues value3;
1812 value3.Put(TokenFiledConst::FIELD_TOKEN_ID, 123); // 123 is random input
1813 value3.Put(TokenFiledConst::FIELD_GRANT_IS_GENERAL, true);
1814 value3.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
1815 value3.Put(TokenFiledConst::FIELD_DEVICE_ID, "dev-003");
1816 value3.Put(TokenFiledConst::FIELD_GRANT_STATE, PermissionState::PERMISSION_DENIED);
1817 value3.Put(TokenFiledConst::FIELD_GRANT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG);
1818
1819 std::vector<GenericValues> permStateRes2;
1820 permStateRes2.emplace_back(value2);
1821 permStateRes2.emplace_back(value3);
1822
1823 std::shared_ptr<PermissionPolicySet> policySet2 = PermissionPolicySet::RestorePermissionPolicy(tokenId,
1824 permStateRes2); // state.permissionName == iter->permissionName
1825 ASSERT_EQ(static_cast<uint32_t>(2), policySet2->permStateList_[0].resDeviceID.size());
1826 }
1827
1828 /**
1829 * @tc.name: VerifyPermissionStatus001
1830 * @tc.desc: PermissionPolicySet::VerifyPermissionStatus function test
1831 * @tc.type: FUNC
1832 * @tc.require:
1833 */
1834 HWTEST_F(AccessTokenInfoManagerTest, VerifyPermissionStatus001, TestSize.Level1)
1835 {
1836 PermissionStateFull perm = {
1837 .permissionName = "ohos.permission.TEST",
1838 .isGeneral = false,
1839 .resDeviceID = {"dev-001", "dev-001"},
1840 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1841 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1842 };
1843
1844 AccessTokenID tokenId = 123; // 123 is random input
1845 std::vector<PermissionStateFull> permStateList;
1846 permStateList.emplace_back(perm);
1847
1848 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1849 permStateList);
1850
1851 // isGeneral is false
1852 ASSERT_EQ(PermissionState::PERMISSION_DENIED, policySet->VerifyPermissionStatus("ohos.permission.TEST"));
1853 }
1854
1855 /**
1856 * @tc.name: QueryPermissionFlag001
1857 * @tc.desc: PermissionPolicySet::QueryPermissionFlag function test
1858 * @tc.type: FUNC
1859 * @tc.require:
1860 */
1861 HWTEST_F(AccessTokenInfoManagerTest, QueryPermissionFlag001, TestSize.Level1)
1862 {
1863 PermissionDef def = {
1864 .permissionName = "ohos.permission.TEST",
1865 .bundleName = "QueryPermissionFlag001",
1866 .grantMode = 1,
1867 .availableLevel = APL_NORMAL,
1868 .provisionEnable = false,
1869 .distributedSceneEnable = false,
1870 .label = "label",
1871 .labelId = 1,
1872 .description = "description",
1873 .descriptionId = 1
1874 };
1875 PermissionStateFull perm = {
1876 .permissionName = "ohos.permission.TEST",
1877 .isGeneral = false,
1878 .resDeviceID = {"dev-001", "dev-001"},
1879 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1880 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1881 };
1882
1883 AccessTokenID tokenId = 0x280bc140; // 0x280bc140 is random native
1884 PermissionDefinitionCache::GetInstance().Insert(def, tokenId);
1885 std::vector<PermissionStateFull> permStateList;
1886 permStateList.emplace_back(perm);
1887
1888 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1889 permStateList);
1890
1891 // perm.permissionName != permissionName
1892 int flag = 0;
1893 ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, policySet->QueryPermissionFlag("ohos.permission.TEST1", flag));
1894 // isGeneral is false
1895 ASSERT_EQ(ERR_PARAM_INVALID, policySet->QueryPermissionFlag("ohos.permission.TEST", flag));
1896
1897 perm.isGeneral = true;
1898 std::shared_ptr<PermissionPolicySet> policySet1 = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1899 permStateList);
1900 // isGeneral is true
1901 ASSERT_EQ(ERR_PARAM_INVALID, policySet1->QueryPermissionFlag("ohos.permission.TEST", flag));
1902 }
1903
1904 /**
1905 * @tc.name: UpdatePermissionStatus001
1906 * @tc.desc: PermissionPolicySet::UpdatePermissionStatus function test
1907 * @tc.type: FUNC
1908 * @tc.require:
1909 */
1910 HWTEST_F(AccessTokenInfoManagerTest, UpdatePermissionStatus001, TestSize.Level1)
1911 {
1912 PermissionStateFull perm = {
1913 .permissionName = "ohos.permission.TEST",
1914 .isGeneral = false,
1915 .resDeviceID = {"dev-001", "dev-001"},
1916 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1917 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1918 };
1919
1920 AccessTokenID tokenId = 789; // 789 is random input
1921 std::vector<PermissionStateFull> permStateList;
1922 permStateList.emplace_back(perm);
1923
1924 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1925 permStateList);
1926
1927 // iter reach the end
1928 bool isGranted = false;
1929 uint32_t flag = PermissionFlag::PERMISSION_DEFAULT_FLAG;
1930 ASSERT_EQ(ERR_PARAM_INVALID, policySet->UpdatePermissionStatus("ohos.permission.TEST1",
1931 isGranted, flag));
1932
1933 // isGeneral is false
1934 ASSERT_EQ(RET_SUCCESS, policySet->UpdatePermissionStatus("ohos.permission.TEST",
1935 isGranted, flag));
1936 }
1937
1938 /**
1939 * @tc.name: ResetUserGrantPermissionStatus001
1940 * @tc.desc: PermissionPolicySet::ResetUserGrantPermissionStatus function test
1941 * @tc.type: FUNC
1942 * @tc.require:
1943 */
1944 HWTEST_F(AccessTokenInfoManagerTest, ResetUserGrantPermissionStatus001, TestSize.Level1)
1945 {
1946 PermissionStateFull perm = {
1947 .permissionName = "ohos.permission.TEST",
1948 .isGeneral = false,
1949 .resDeviceID = {"dev-001", "dev-001"},
1950 .grantStatus = {PermissionState::PERMISSION_DENIED, PermissionState::PERMISSION_DENIED},
1951 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG, PermissionFlag::PERMISSION_DEFAULT_FLAG}
1952 };
1953
1954 AccessTokenID tokenId = 1011; // 1011 is random input
1955 std::vector<PermissionStateFull> permStateList;
1956 permStateList.emplace_back(perm);
1957
1958 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1959 permStateList);
1960
1961 ASSERT_EQ(tokenId, policySet->tokenId_);
1962
1963 // isGeneral is false
1964 policySet->ResetUserGrantPermissionStatus();
1965 }
1966
1967 /**
1968 * @tc.name: PermStateFullToString001
1969 * @tc.desc: PermissionPolicySet::PermStateFullToString function test
1970 * @tc.type: FUNC
1971 * @tc.require:
1972 */
1973 HWTEST_F(AccessTokenInfoManagerTest, PermStateFullToString001, TestSize.Level1)
1974 {
1975 AccessTokenID tokenId = 123; // 123 is random input
1976 std::vector<PermissionStateFull> permStateList;
1977 permStateList.emplace_back(g_permState);
1978
1979 std::shared_ptr<PermissionPolicySet> policySet = PermissionPolicySet::BuildPermissionPolicySet(tokenId,
1980 permStateList);
1981
1982 ASSERT_EQ(tokenId, policySet->tokenId_);
1983
1984 std::string info;
1985 // iter != end - 1
1986 policySet->PermStateFullToString(g_permState, info);
1987 }
1988
1989 #ifdef TOKEN_SYNC_ENABLE
1990 /**
1991 * @tc.name: MapRemoteDeviceTokenToLocal001
1992 * @tc.desc: AccessTokenRemoteTokenManager::MapRemoteDeviceTokenToLocal function test
1993 * @tc.type: FUNC
1994 * @tc.require:
1995 */
1996 HWTEST_F(AccessTokenInfoManagerTest, MapRemoteDeviceTokenToLocal001, TestSize.Level1)
1997 {
1998 std::map<std::string, AccessTokenRemoteDevice> remoteDeviceMap;
1999 remoteDeviceMap = AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_; // backup
2000 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.clear();
2001
2002 std::string deviceID;
2003 AccessTokenID remoteID = 0;
2004
2005 // input invalid
2006 ASSERT_EQ(static_cast<AccessTokenID>(0),
2007 AccessTokenRemoteTokenManager::GetInstance().MapRemoteDeviceTokenToLocal(deviceID, remoteID));
2008
2009 remoteID = 940572671; // 940572671 is max butt tokenId: 001 11 0 000000 11111111111111111111
2010 deviceID = "dev-001";
2011
2012 // tokeType invalid
2013 ASSERT_EQ(static_cast<AccessTokenID>(0),
2014 AccessTokenRemoteTokenManager::GetInstance().MapRemoteDeviceTokenToLocal(deviceID, remoteID));
2015
2016 remoteID = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111, no need to register
2017 std::map<AccessTokenID, AccessTokenID> MappingTokenIDPairMap;
2018 MappingTokenIDPairMap[537919487] = 456; // 456 is random input
2019 AccessTokenRemoteDevice device = {
2020 .DeviceID_ = "dev-001",
2021 .MappingTokenIDPairMap_ = MappingTokenIDPairMap
2022 };
2023 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_["dev-001"] = device;
2024
2025 // count(remoteID) > 0
2026 ASSERT_EQ(static_cast<AccessTokenID>(456),
2027 AccessTokenRemoteTokenManager::GetInstance().MapRemoteDeviceTokenToLocal(deviceID, remoteID));
2028
2029 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_ = remoteDeviceMap; // recovery
2030 }
2031
2032 /**
2033 * @tc.name: GetDeviceAllRemoteTokenID001
2034 * @tc.desc: AccessTokenRemoteTokenManager::GetDeviceAllRemoteTokenID function test
2035 * @tc.type: FUNC
2036 * @tc.require:
2037 */
2038 HWTEST_F(AccessTokenInfoManagerTest, GetDeviceAllRemoteTokenID001, TestSize.Level1)
2039 {
2040 std::string deviceID;
2041 std::vector<AccessTokenID> remoteIDs;
2042
2043 // deviceID invalid
2044 ASSERT_EQ(ERR_PARAM_INVALID,
2045 AccessTokenRemoteTokenManager::GetInstance().GetDeviceAllRemoteTokenID(deviceID, remoteIDs));
2046 }
2047
2048 /**
2049 * @tc.name: RemoveDeviceMappingTokenID001
2050 * @tc.desc: AccessTokenRemoteTokenManager::RemoveDeviceMappingTokenID function test
2051 * @tc.type: FUNC
2052 * @tc.require:
2053 */
2054 HWTEST_F(AccessTokenInfoManagerTest, RemoveDeviceMappingTokenID001, TestSize.Level1)
2055 {
2056 std::map<std::string, AccessTokenRemoteDevice> remoteDeviceMap;
2057 remoteDeviceMap = AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_; // backup
2058 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_.clear();
2059
2060 std::string deviceID;
2061 AccessTokenID remoteID = 0;
2062
2063 // input invalid
2064 ASSERT_NE(RET_SUCCESS,
2065 AccessTokenRemoteTokenManager::GetInstance().RemoveDeviceMappingTokenID(deviceID, remoteID));
2066
2067 deviceID = "dev-001";
2068 remoteID = 123; // 123 is random input
2069
2070 // count < 1
2071 ASSERT_NE(RET_SUCCESS,
2072 AccessTokenRemoteTokenManager::GetInstance().RemoveDeviceMappingTokenID(deviceID, remoteID));
2073
2074 AccessTokenRemoteTokenManager::GetInstance().remoteDeviceMap_ = remoteDeviceMap; // recovery
2075 }
2076
2077 /**
2078 * @tc.name: AddHapTokenObservation001
2079 * @tc.desc: TokenModifyNotifier::AddHapTokenObservation function test
2080 * @tc.type: FUNC
2081 * @tc.require:
2082 */
2083 HWTEST_F(AccessTokenInfoManagerTest, AddHapTokenObservation001, TestSize.Level1)
2084 {
2085 std::set<AccessTokenID> observationSet = TokenModifyNotifier::GetInstance().observationSet_; // backup
2086 TokenModifyNotifier::GetInstance().observationSet_.clear();
2087
2088 AccessTokenID tokenId = 123; // 123 is random input
2089
2090 TokenModifyNotifier::GetInstance().observationSet_.insert(tokenId);
2091 ASSERT_EQ(true, TokenModifyNotifier::GetInstance().observationSet_.count(tokenId) > 0);
2092
2093 // count > 0
2094 TokenModifyNotifier::GetInstance().AddHapTokenObservation(tokenId);
2095 TokenModifyNotifier::GetInstance().NotifyTokenModify(tokenId);
2096
2097 TokenModifyNotifier::GetInstance().observationSet_ = observationSet; // recovery
2098 }
2099 #endif
2100
2101 /**
2102 * @tc.name: RestoreNativeTokenInfo001
2103 * @tc.desc: NativeTokenInfoInner::RestoreNativeTokenInfo function test
2104 * @tc.type: FUNC
2105 * @tc.require:
2106 */
2107 HWTEST_F(AccessTokenInfoManagerTest, RestoreNativeTokenInfo001, TestSize.Level1)
2108 {
2109 std::shared_ptr<NativeTokenInfoInner> native = std::make_shared<NativeTokenInfoInner>();
2110 ASSERT_NE(nullptr, native);
2111
2112 std::string info;
2113 native->ToString(info); // permPolicySet_ is null
2114
2115 AccessTokenID tokenId = 0;
2116 std::string processName;
2117 int apl = static_cast<int>(ATokenAplEnum::APL_INVALID);
2118 int version = 10; // 10 is random input which only need not equal 1
2119 std::vector<std::string> dcap;
2120 std::vector<std::string> nativeAcls;
2121 std::vector<PermissionStateFull> permStateList;
2122 GenericValues inGenericValues;
2123 std::vector<GenericValues> permStateRes;
2124
2125 // processName invalid
2126 TokenInfo tokenInfo = {
2127 .id = tokenId,
2128 .processName = processName,
2129 .apl = apl
2130 };
2131 ASSERT_NE(RET_SUCCESS, native->Init(tokenInfo, dcap, nativeAcls, permStateList));
2132
2133 inGenericValues.Put(TokenFiledConst::FIELD_PROCESS_NAME, processName);
2134 // processName invalid
2135 ASSERT_NE(RET_SUCCESS, native->RestoreNativeTokenInfo(tokenId, inGenericValues, permStateRes));
2136 inGenericValues.Remove(TokenFiledConst::FIELD_PROCESS_NAME);
2137
2138 tokenInfo.processName = "token_sync";
2139 // apl invalid
2140 ASSERT_NE(RET_SUCCESS, native->Init(tokenInfo, dcap, nativeAcls, permStateList));
2141
2142 inGenericValues.Put(TokenFiledConst::FIELD_PROCESS_NAME, processName);
2143 inGenericValues.Put(TokenFiledConst::FIELD_APL, apl);
2144 // apl invalid
2145 ASSERT_NE(RET_SUCCESS, native->RestoreNativeTokenInfo(tokenId, inGenericValues, permStateRes));
2146 inGenericValues.Remove(TokenFiledConst::FIELD_APL);
2147
2148 apl = static_cast<int>(ATokenAplEnum::APL_NORMAL);
2149 inGenericValues.Put(TokenFiledConst::FIELD_APL, apl);
2150 inGenericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, version);
2151 // version invalid
2152 ASSERT_NE(RET_SUCCESS, native->RestoreNativeTokenInfo(tokenId, inGenericValues, permStateRes));
2153 }
2154
2155 /**
2156 * @tc.name: Init001
2157 * @tc.desc: NativeTokenInfoInner::Init function test
2158 * @tc.type: FUNC
2159 * @tc.require:
2160 */
2161 HWTEST_F(AccessTokenInfoManagerTest, Init001, TestSize.Level1)
2162 {
2163 std::shared_ptr<NativeTokenInfoInner> native = std::make_shared<NativeTokenInfoInner>();
2164 ASSERT_NE(nullptr, native);
2165
2166 AccessTokenID tokenId = 0;
2167 std::string processName = "tdd_0112";
2168 int apl = static_cast<int>(ATokenAplEnum::APL_NORMAL);
2169 std::vector<std::string> dcap;
2170 std::vector<std::string> nativeAcls;
2171 std::vector<PermissionStateFull> permStateList;
2172
2173 // processName invalid
2174 TokenInfo tokenInfo = {
2175 .id = tokenId,
2176 .processName = processName,
2177 .apl = apl
2178 };
2179 ASSERT_EQ(RET_SUCCESS, native->Init(tokenInfo, dcap, nativeAcls, permStateList));
2180 native->GetNativeAcls();
2181 native->SetRemote(true);
2182 ASSERT_EQ(true, native->IsRemote());
2183 }
2184
2185 /**
2186 * @tc.name: RestoreHapTokenInfo001
2187 * @tc.desc: HapTokenInfoInner::RestoreHapTokenInfo function test
2188 * @tc.type: FUNC
2189 * @tc.require:
2190 */
2191 HWTEST_F(AccessTokenInfoManagerTest, RestoreHapTokenInfo001, TestSize.Level1)
2192 {
2193 std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>();
2194 ASSERT_NE(nullptr, hap);
2195
2196 AccessTokenID tokenId = 0;
2197 GenericValues tokenValue;
2198 std::vector<GenericValues> permStateRes;
2199 std::string bundleName;
2200 std::string appIDDesc;
2201 std::string deviceID;
2202 int aplNum = static_cast<int>(ATokenAplEnum::APL_INVALID);
2203 int version = 10; // 10 is random input which only need not equal 1
2204 HapPolicyParams policy;
2205 UpdateHapInfoParams hapInfo;
2206 hapInfo.apiVersion = DEFAULT_API_VERSION;
2207 hapInfo.isSystemApp = false;
2208 hap->Update(hapInfo, policy.permStateList, policy.apl); // permPolicySet_ is null
2209
2210 std::string info;
2211 hap->ToString(info); // permPolicySet_ is null
2212
2213 std::vector<GenericValues> hapInfoValues;
2214 std::vector<GenericValues> permStateValues;
2215 hap->StoreHapInfo(hapInfoValues);
2216 hap->StorePermissionPolicy(permStateValues); // permPolicySet_ is null
2217
2218
2219 tokenValue.Put(TokenFiledConst::FIELD_BUNDLE_NAME, bundleName);
2220 // bundleName invalid
2221 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2222 tokenValue.Remove(TokenFiledConst::FIELD_BUNDLE_NAME);
2223
2224 bundleName = "com.ohos.permissionmanger";
2225 tokenValue.Put(TokenFiledConst::FIELD_BUNDLE_NAME, bundleName);
2226 tokenValue.Put(TokenFiledConst::FIELD_APP_ID, appIDDesc);
2227 // appID invalid
2228 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2229 tokenValue.Remove(TokenFiledConst::FIELD_APP_ID);
2230
2231 appIDDesc = "what's this";
2232 tokenValue.Put(TokenFiledConst::FIELD_APP_ID, appIDDesc);
2233 tokenValue.Put(TokenFiledConst::FIELD_DEVICE_ID, deviceID);
2234 // deviceID invalid
2235 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2236 tokenValue.Remove(TokenFiledConst::FIELD_DEVICE_ID);
2237
2238 deviceID = "dev-001";
2239 tokenValue.Put(TokenFiledConst::FIELD_DEVICE_ID, deviceID);
2240 tokenValue.Put(TokenFiledConst::FIELD_APL, aplNum);
2241 // apl invalid
2242 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2243
2244 aplNum = static_cast<int>(ATokenAplEnum::APL_NORMAL);
2245 tokenValue.Put(TokenFiledConst::FIELD_APL, aplNum);
2246 tokenValue.Put(TokenFiledConst::FIELD_TOKEN_VERSION, version);
2247 // version invalid
2248 ASSERT_EQ(ERR_PARAM_INVALID, hap->RestoreHapTokenInfo(tokenId, tokenValue, permStateRes));
2249 }
2250
2251 /**
2252 * @tc.name: RegisterTokenId001
2253 * @tc.desc: AccessTokenIDManager::RegisterTokenId function test
2254 * @tc.type: FUNC
2255 * @tc.require:
2256 */
2257 HWTEST_F(AccessTokenInfoManagerTest, RegisterTokenId001, TestSize.Level1)
2258 {
2259 // 1477443583 is max abnormal butt tokenId which version is 2: 010 11 0 000000 11111111111111111111
2260 AccessTokenID tokenId = 1477443583;
2261 ATokenTypeEnum type = ATokenTypeEnum::TOKEN_HAP;
2262
2263 // version != 1 + type dismatch
2264 ASSERT_NE(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, type));
2265
2266 AccessTokenIDEx tokenIdEx = {0};
2267 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
2268 g_infoManagerTestPolicyPrams1, tokenIdEx));
2269
2270 // register repeat
2271 ASSERT_NE(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(
2272 tokenIdEx.tokenIdExStruct.tokenID, type));
2273 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID));
2274 }
2275
2276 /**
2277 * @tc.name: DumpTokenInfo005
2278 * @tc.desc: AccessTokenInfoManager::DumpTokenInfo function test
2279 * @tc.type: FUNC
2280 * @tc.require:
2281 */
2282 HWTEST_F(AccessTokenInfoManagerTest, DumpTokenInfo005, TestSize.Level1)
2283 {
2284 AccessTokenID tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
2285 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_HAP));
2286 std::string dumpInfo;
2287 AtmToolsParamInfo info;
2288 info.tokenId = tokenId;
2289 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo); // hap infoPtr is null
2290 ASSERT_EQ("", dumpInfo);
2291 AccessTokenIDManager::GetInstance().ReleaseTokenId(tokenId);
2292
2293 tokenId = 672137215; // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
2294 ASSERT_EQ(RET_SUCCESS, AccessTokenIDManager::GetInstance().RegisterTokenId(tokenId, TOKEN_NATIVE));
2295 info.tokenId = tokenId;
2296 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo); // native infoPtr is null
2297 ASSERT_EQ("", dumpInfo);
2298 AccessTokenIDManager::GetInstance().ReleaseTokenId(tokenId);
2299
2300 std::shared_ptr<HapTokenInfoInner> hap = nullptr;
2301 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[537919487] = hap;
2302 info.tokenId = static_cast<AccessTokenID>(0);
2303 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo); // iter->second is null
2304 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(537919487);
2305
2306 std::shared_ptr<NativeTokenInfoInner> native = nullptr;
2307 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_[672137215] = native;
2308 AccessTokenInfoManager::GetInstance().DumpTokenInfo(info, dumpInfo); // iter->second is null
2309 AccessTokenInfoManager::GetInstance().nativeTokenInfoMap_.erase(672137215);
2310 }
2311
2312 /**
2313 * @tc.name: ClearAllSecCompGrantedPerm001
2314 * @tc.desc: ClearAllSecCompGrantedPerm function test
2315 * @tc.type: FUNC
2316 * @tc.require:
2317 */
2318 HWTEST_F(AccessTokenInfoManagerTest, ClearAllSecCompGrantedPerm001, TestSize.Level1)
2319 {
2320 AccessTokenIDEx tokenIdEx = {0};
2321 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
2322 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
2323 ASSERT_EQ(RET_SUCCESS, ret);
2324 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2325
2326 ASSERT_EQ(
2327 PERMISSION_DENIED, PermissionManager::GetInstance().VerifyAccessToken(tokenId, "ohos.permission.LOCATION"));
2328 PermissionManager::GetInstance().GrantPermission(tokenId, "ohos.permission.LOCATION", PERMISSION_COMPONENT_SET);
2329 ASSERT_EQ(
2330 PERMISSION_GRANTED, PermissionManager::GetInstance().VerifyAccessToken(tokenId, "ohos.permission.LOCATION"));
2331
2332 std::string deviceId;
2333 atManagerService_->OnRemoveSystemAbility(SECURITY_COMPONENT_SERVICE_ID, deviceId);
2334 ASSERT_EQ(
2335 PERMISSION_DENIED, PermissionManager::GetInstance().VerifyAccessToken(tokenId, "ohos.permission.LOCATION"));
2336
2337 // delete test token
2338 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
2339 }
2340
2341 /**
2342 * @tc.name: ClearAllSecCompGrantedPerm002
2343 * @tc.desc: PermissionManager::ClearAllSecCompGrantedPerm function test
2344 * @tc.type: FUNC
2345 * @tc.require:
2346 */
2347 HWTEST_F(AccessTokenInfoManagerTest, ClearAllSecCompGrantedPerm002, TestSize.Level1)
2348 {
2349 AccessTokenID tokenId = 123; // 123 is random input
2350 std::vector<AccessTokenID> idList;
2351 idList.emplace_back(tokenId);
2352 PermissionManager::GetInstance().ClearAllSecCompGrantedPerm(idList); // permPolicySet is null
2353 auto tokenInfoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
2354 ASSERT_EQ(tokenInfoPtr, nullptr);
2355 }
2356
2357 /**
2358 * @tc.name: SetPermDialogCap001
2359 * @tc.desc: SetPermDialogCap with HapUniqueKey not exist
2360 * @tc.type: FUNC
2361 * @tc.require:
2362 */
2363 HWTEST_F(AccessTokenInfoManagerTest, SetPermDialogCap001, TestSize.Level1)
2364 {
2365 AccessTokenID tokenId = 123; // 123: invalid tokenid
2366 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true));
2367 }
2368
2369 /**
2370 * @tc.name: SetPermDialogCap002
2371 * @tc.desc: SetPermDialogCap with abnormal branch
2372 * @tc.type: FUNC
2373 * @tc.require:
2374 */
2375 HWTEST_F(AccessTokenInfoManagerTest, SetPermDialogCap002, TestSize.Level1)
2376 {
2377 AccessTokenIDEx tokenIdEx = {0};
2378 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
2379 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
2380 ASSERT_EQ(RET_SUCCESS, ret);
2381 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2382
2383 // SetPermDialogCap successfull
2384 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true));
2385 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2386 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, false));
2387 ASSERT_EQ(false, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2388
2389 std::shared_ptr<HapTokenInfoInner> back = AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId];
2390
2391 // tokeninfo of hapTokenInfoMap_ is nullptr, return true(forbid)
2392 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = nullptr;
2393 ASSERT_EQ(ERR_TOKENID_NOT_EXIST,
2394 AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true)); // info is null
2395 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2396
2397 // token is not found in hapTokenInfoMap_, return true(forbid)
2398 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
2399 ASSERT_EQ(ERR_TOKENID_NOT_EXIST,
2400 AccessTokenInfoManager::GetInstance().SetPermDialogCap(tokenId, true)); // info is null
2401 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(tokenId));
2402 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = back;
2403
2404 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
2405 }
2406
2407 /**
2408 * @tc.name: GetPermDialogCap001
2409 * @tc.desc: GetPermDialogCap with abnormal branch
2410 * @tc.type: FUNC
2411 * @tc.require:
2412 */
2413 HWTEST_F(AccessTokenInfoManagerTest, GetPermDialogCap001, TestSize.Level1)
2414 {
2415 // invalid token
2416 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(INVALID_TOKENID));
2417
2418 // nonexist token
2419 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(123)); // 123: tokenid
2420
2421 // tokeninfo is nullptr
2422 HapBaseInfo baseInfo = {
2423 .userID = g_infoManagerTestInfoParms.userID,
2424 .bundleName = g_infoManagerTestInfoParms.bundleName,
2425 .instIndex = g_infoManagerTestInfoParms.instIndex,
2426 };
2427 AccessTokenIDEx tokenIdEx = {0};
2428 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
2429 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams1, tokenIdEx);
2430 ASSERT_EQ(RET_SUCCESS, ret);
2431 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2432 std::shared_ptr<HapTokenInfoInner> back = AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId];
2433 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = nullptr;
2434 ASSERT_EQ(true, AccessTokenInfoManager::GetInstance().GetPermDialogCap(123)); // 123: tokenid
2435
2436 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = back;
2437 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
2438 }
2439
2440 /**
2441 * @tc.name: AllocHapToken001
2442 * @tc.desc: alloc hap create haptokeninfo failed.
2443 * @tc.type: FUNC
2444 * @tc.require:
2445 */
2446 HWTEST_F(AccessTokenInfoManagerTest, AllocHapToken001, TestSize.Level1)
2447 {
2448 HapInfoParcel hapinfoParcel;
2449 hapinfoParcel.hapInfoParameter = {
2450 .userID = -1,
2451 .bundleName = "accesstoken_test",
2452 .instIndex = 0,
2453 .appIDDesc = "testtesttesttest",
2454 .apiVersion = DEFAULT_API_VERSION,
2455 .isSystemApp = false,
2456 };
2457 HapPolicyParcel hapPolicyParcel;
2458 hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL;
2459 hapPolicyParcel.hapPolicyParameter.domain = "test.domain";
2460
2461 AccessTokenIDEx tokenIDEx = atManagerService_->AllocHapToken(hapinfoParcel, hapPolicyParcel);
2462 ASSERT_EQ(INVALID_TOKENID, tokenIDEx.tokenIDEx);
2463 }
2464
2465 /**
2466 * @tc.name: OnStart001
2467 * @tc.desc: service is running.
2468 * @tc.type: FUNC
2469 * @tc.require:
2470 */
2471 HWTEST_F(AccessTokenInfoManagerTest, OnStart001, TestSize.Level1)
2472 {
2473 ServiceRunningState state = atManagerService_->state_;
2474 atManagerService_->state_ = ServiceRunningState::STATE_RUNNING;
2475 atManagerService_->OnStart();
2476 ASSERT_EQ(ServiceRunningState::STATE_RUNNING, atManagerService_->state_);
2477 atManagerService_->state_ = state;
2478 }
2479
2480 /**
2481 * @tc.name: Dlopen001
2482 * @tc.desc: Open a not exist lib & not exist func
2483 * @tc.type: FUNC
2484 * @tc.require:
2485 */
2486 HWTEST_F(AccessTokenInfoManagerTest, Dlopen001, TestSize.Level1)
2487 {
2488 LibraryLoader loader1("libnotexist.z.so"); // is a not exist path
2489 EXPECT_EQ(nullptr, loader1.handle_);
2490
2491 LibraryLoader loader2("libaccesstoken_manager_service.z.so"); // is a exist lib without create func
2492 EXPECT_EQ(nullptr, loader2.instance_);
2493 EXPECT_NE(nullptr, loader2.handle_);
2494 }
2495
2496 #ifdef TOKEN_SYNC_ENABLE
2497 /**
2498 * @tc.name: Dlopen002
2499 * @tc.desc: Open a exist lib & exist func
2500 * @tc.type: FUNC
2501 * @tc.require:
2502 */
2503 HWTEST_F(AccessTokenInfoManagerTest, Dlopen002, TestSize.Level1)
2504 {
2505 LibraryLoader loader(TOKEN_SYNC_LIBPATH);
2506 TokenSyncKitInterface* tokenSyncKit = loader.GetObject<TokenSyncKitInterface>();
2507 EXPECT_NE(nullptr, loader.handle_);
2508 EXPECT_NE(nullptr, tokenSyncKit);
2509 }
2510 #endif
2511
2512 /**
2513 * @tc.name: OnRemoteRequest001
2514 * @tc.desc: Test OnRemoteRequest
2515 * @tc.type: FUNC
2516 * @tc.require:
2517 */
2518 HWTEST_F(AccessTokenInfoManagerTest, OnRemoteRequest001, TestSize.Level1)
2519 {
2520 uint32_t code = 0;
2521 MessageParcel data;
2522 MessageParcel reply;
2523 MessageOption option;
2524 data.WriteInterfaceToken(u"this is a test interface");
2525 EXPECT_EQ(ERROR_IPC_REQUEST_FAIL, atManagerService_->OnRemoteRequest(code, data, reply, option));
2526
2527 std::map<uint32_t, AccessTokenManagerStub::RequestFuncType> oldMap = atManagerService_->requestFuncMap_;
2528 atManagerService_->requestFuncMap_.clear();
2529 atManagerService_->requestFuncMap_[1] = nullptr;
2530
2531 data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor());
2532 EXPECT_NE(NO_ERROR, atManagerService_->OnRemoteRequest(code, data, reply, option));
2533
2534 data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor());
2535 EXPECT_NE(NO_ERROR, atManagerService_->OnRemoteRequest(1, data, reply, option));
2536
2537 atManagerService_->requestFuncMap_ = oldMap;
2538 }
2539 } // namespace AccessToken
2540 } // namespace Security
2541 } // namespace OHOS
2542