1 /*
2 * Copyright (c) 2021-2024 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 "permission_manager_test.h"
17
18 #include "access_token.h"
19 #include "access_token_error.h"
20 #include "callback_manager.h"
21 #ifdef SUPPORT_SANDBOX_APP
22 #define private public
23 #include "dlp_permission_set_manager.h"
24 #undef private
25 #endif
26 #define private public
27 #include "accesstoken_info_manager.h"
28 #undef private
29 #include "accesstoken_callback_stubs.h"
30 #include "callback_death_recipients.h"
31 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
32 #include "continuous_task_callback_info.h"
33 #endif
34
35 using namespace testing::ext;
36 using namespace OHOS;
37
38 namespace OHOS {
39 namespace Security {
40 namespace AccessToken {
41 namespace {
42 static constexpr uint32_t MAX_CALLBACK_SIZE = 1024;
43 static constexpr int32_t USER_ID = 100;
44 static constexpr int32_t INST_INDEX = 0;
45 static PermissionDef g_infoManagerTestPermDef1 = {
46 .permissionName = "open the door",
47 .bundleName = "accesstoken_test",
48 .grantMode = 1,
49 .availableLevel = APL_NORMAL,
50 .provisionEnable = false,
51 .distributedSceneEnable = false,
52 .label = "label",
53 .labelId = 1,
54 .description = "open the door",
55 .descriptionId = 1
56 };
57
58 static PermissionDef g_infoManagerTestPermDef2 = {
59 .permissionName = "break the door",
60 .bundleName = "accesstoken_test",
61 .grantMode = 1,
62 .availableLevel = APL_NORMAL,
63 .provisionEnable = false,
64 .distributedSceneEnable = false,
65 .label = "label",
66 .labelId = 1,
67 .description = "break the door",
68 .descriptionId = 1
69 };
70
71 static PermissionStatus g_infoManagerTestState1 = {
72 .permissionName = "open the door",
73 .grantStatus = 1,
74 .grantFlag = 1
75 };
76
77 static PermissionStatus g_infoManagerTestState2 = {
78 .permissionName = "break the door",
79 .grantStatus = 1,
80 .grantFlag = 1
81 };
82
83 static HapInfoParams g_infoManagerTestInfoParms = {
84 .userID = 1,
85 .bundleName = "accesstoken_test",
86 .instIndex = 0,
87 .appIDDesc = "testtesttesttest"
88 };
89
90 static HapPolicy g_infoManagerTestPolicyPrams1 = {
91 .apl = APL_NORMAL,
92 .domain = "test.domain",
93 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
94 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
95 };
96
97 static PermissionStatus g_infoManagerTestStateA = {
98 .grantStatus = PERMISSION_GRANTED,
99 .grantFlag = 1
100 };
101
102 static PermissionStatus g_infoManagerTestStateB = {
103 .grantStatus = PERMISSION_GRANTED,
104 .grantFlag = 1
105 };
106
107 static PermissionStatus g_infoManagerTestStateC = {
108 .grantStatus = PERMISSION_GRANTED,
109 .grantFlag = 1
110 };
111
112 static PermissionStatus g_infoManagerTestStateD = {
113 .grantStatus = PERMISSION_GRANTED,
114 .grantFlag = 1
115 };
116
117 static PermissionStatus g_permState1 = {
118 .permissionName = "ohos.permission.TEST",
119 .grantStatus = PermissionState::PERMISSION_DENIED,
120 .grantFlag = PermissionFlag::PERMISSION_SYSTEM_FIXED
121 };
122
123 static PermissionStatus g_permState2 = {
124 .permissionName = "ohos.permission.CAMERA",
125 .grantStatus = PermissionState::PERMISSION_DENIED,
126 .grantFlag = PermissionFlag::PERMISSION_SYSTEM_FIXED
127 };
128
129 static PermissionStatus g_permState6 = {
130 .permissionName = "ohos.permission.CAMERA",
131 .grantStatus = PermissionState::PERMISSION_DENIED,
132 .grantFlag = PermissionFlag::PERMISSION_POLICY_FIXED
133 };
134
135 static PermissionStatus g_permState7 = {
136 .permissionName = "ohos.permission.CAMERA",
137 .grantStatus = PermissionState::PERMISSION_GRANTED,
138 .grantFlag = PermissionFlag::PERMISSION_POLICY_FIXED
139 };
140
141 static PermissionStatus g_permState8 = {
142 .permissionName = "ohos.permission.CAMERA",
143 .grantStatus = PermissionState::PERMISSION_DENIED,
144 .grantFlag = PermissionFlag::PERMISSION_POLICY_FIXED | PermissionFlag::PERMISSION_USER_SET
145 };
146
147 static PermissionStatus g_permState9 = {
148 .permissionName = "ohos.permission.CAMERA",
149 .grantStatus = PermissionState::PERMISSION_GRANTED,
150 .grantFlag = PermissionFlag::PERMISSION_POLICY_FIXED | PermissionFlag::PERMISSION_USER_SET
151 };
152
153 static PermissionDef g_infoManagerPermDef1 = {
154 .permissionName = "ohos.permission.MEDIA_LOCATION",
155 .bundleName = "accesstoken_test",
156 .grantMode = USER_GRANT,
157 .availableLevel = APL_NORMAL,
158 .provisionEnable = false,
159 .distributedSceneEnable = false,
160 .label = "label",
161 .labelId = 1,
162 .description = "MEDIA_LOCATION",
163 .descriptionId = 1
164 };
165
166 static PermissionDef g_infoManagerPermDef2 = {
167 .permissionName = "ohos.permission.MICROPHONE",
168 .bundleName = "accesstoken_test",
169 .grantMode = USER_GRANT,
170 .availableLevel = APL_NORMAL,
171 .provisionEnable = false,
172 .distributedSceneEnable = false,
173 .label = "label",
174 .labelId = 1,
175 .description = "MICROPHONE",
176 .descriptionId = 1
177 };
178
179 static PermissionDef g_infoManagerPermDef3 = {
180 .permissionName = "ohos.permission.READ_CALENDAR",
181 .bundleName = "accesstoken_test",
182 .grantMode = USER_GRANT,
183 .availableLevel = APL_NORMAL,
184 .provisionEnable = false,
185 .distributedSceneEnable = false,
186 .label = "label",
187 .labelId = 1,
188 .description = "READ_CALENDAR",
189 .descriptionId = 1
190 };
191
192 static PermissionDef g_infoManagerPermDef4 = {
193 .permissionName = "ohos.permission.READ_CALL_LOG",
194 .bundleName = "accesstoken_test",
195 .grantMode = USER_GRANT,
196 .availableLevel = APL_NORMAL,
197 .provisionEnable = false,
198 .distributedSceneEnable = false,
199 .label = "label",
200 .labelId = 1,
201 .description = "READ_CALL_LOG",
202 .descriptionId = 1
203 };
204 }
205
SetUpTestCase()206 void PermissionManagerTest::SetUpTestCase()
207 {
208 }
209
TearDownTestCase()210 void PermissionManagerTest::TearDownTestCase()
211 {
212 sleep(3); // delay 3 minutes
213 }
214
SetUp()215 void PermissionManagerTest::SetUp()
216 {
217 if (accessTokenService_ != nullptr) {
218 return;
219 }
220 AccessTokenManagerService* ptr = new (std::nothrow) AccessTokenManagerService();
221 accessTokenService_ = sptr<AccessTokenManagerService>(ptr);
222 ASSERT_NE(nullptr, accessTokenService_);
223 if (appStateObserver_ != nullptr) {
224 return;
225 }
226 appStateObserver_ = std::make_shared<PermissionAppStateObserver>();
227 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
228 if (backgroundTaskObserver_ != nullptr) {
229 return;
230 }
231 backgroundTaskObserver_ = std::make_shared<PermissionBackgroundTaskObserver>();
232 #endif
233 if (formStateObserver_ != nullptr) {
234 return;
235 }
236 formStateObserver_ = std::make_shared<PermissionFormStateObserver>();
237 }
238
TearDown()239 void PermissionManagerTest::TearDown()
240 {
241 accessTokenService_ = nullptr;
242 appStateObserver_ = nullptr;
243 }
244
CreateTempHapTokenInfo()245 static AccessTokenID CreateTempHapTokenInfo()
246 {
247 g_infoManagerTestStateA.permissionName = "ohos.permission.APPROXIMATELY_LOCATION";
248 g_infoManagerTestStateA.grantStatus = PERMISSION_DENIED;
249 g_infoManagerTestStateB.permissionName = "ohos.permission.READ_PASTEBOARD";
250 g_infoManagerTestStateB.grantStatus = PERMISSION_DENIED;
251 static HapPolicy infoManagerTestPolicyPrams = {
252 .apl = APL_NORMAL,
253 .domain = "test.domain",
254 .permList = {},
255 .permStateList = { g_infoManagerTestStateA, g_infoManagerTestStateB}
256 };
257 static HapInfoParams infoManagerTestInfoParms = {
258 .userID = USER_ID,
259 .bundleName = "GrantTempPermission",
260 .instIndex = 0,
261 .dlpType = DLP_COMMON,
262 .appIDDesc = "GrantTempPermission"
263 };
264 // install hap
265 AccessTokenIDEx tokenIdEx = {0};
266 AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
267 infoManagerTestInfoParms, infoManagerTestPolicyPrams, tokenIdEx);
268 GTEST_LOG_(INFO) << "add a hap token";
269 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
270 return tokenID;
271 }
272
273 /**
274 * @tc.name: ScopeFilter001
275 * @tc.desc: Test filter scopes.
276 * @tc.type: FUNC
277 * @tc.require: issueI4V02P
278 */
279 HWTEST_F(PermissionManagerTest, ScopeFilter001, TestSize.Level1)
280 {
281 AccessTokenIDEx tokenIdEx = {0};
282 AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
283 g_infoManagerTestPolicyPrams1, tokenIdEx);
284
285 tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
286 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
287 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
288 EXPECT_NE(0, static_cast<int32_t>(tokenId));
289 PermStateChangeScope inScopeInfo;
290 PermStateChangeScope outScopeInfo;
291 PermStateChangeScope emptyScopeInfo;
292
293 // both empty
294 inScopeInfo.permList = {};
295 inScopeInfo.tokenIDs = {};
296 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
297
298 outScopeInfo = emptyScopeInfo;
299 inScopeInfo.tokenIDs = {123};
300 EXPECT_EQ(ERR_PARAM_INVALID,
301 PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
302 EXPECT_EQ(true, outScopeInfo.tokenIDs.empty());
303
304 outScopeInfo = emptyScopeInfo;
305 inScopeInfo.tokenIDs.clear();
306 inScopeInfo.tokenIDs = {123, tokenId, tokenId};
307 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
308 EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.tokenIDs.size()));
309
310 outScopeInfo = emptyScopeInfo;
311 inScopeInfo.tokenIDs.clear();
312 inScopeInfo.permList = {"ohos.permission.test_scopeFilter"};
313 EXPECT_EQ(ERR_PARAM_INVALID,
314 PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
315 EXPECT_EQ(true, outScopeInfo.permList.empty());
316
317 outScopeInfo = emptyScopeInfo;
318 inScopeInfo.permList.clear();
319 inScopeInfo.permList = {"ohos.permission.test_scopeFilter", "ohos.permission.CAMERA", "ohos.permission.CAMERA"};
320 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
321 EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.permList.size()));
322
323 outScopeInfo = emptyScopeInfo;
324 inScopeInfo.permList.clear();
325 inScopeInfo.tokenIDs = {123, tokenId, tokenId};
326 inScopeInfo.permList = {"ohos.permission.test_scopeFilter", "ohos.permission.CAMERA", "ohos.permission.CAMERA"};
327 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
328 EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.tokenIDs.size()));
329 EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.permList.size()));
330
331 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
332 }
333
334 /**
335 * @tc.name: AddPermStateChangeCallback001
336 * @tc.desc: Test AddPermStateChangeCallback.
337 * @tc.type: FUNC
338 * @tc.require: issueI4V02P
339 */
340 HWTEST_F(PermissionManagerTest, AddPermStateChangeCallback001, TestSize.Level1)
341 {
342 PermStateChangeScope inScopeInfo;
343 inScopeInfo.tokenIDs = {123};
344
345 EXPECT_EQ(ERR_PARAM_INVALID,
346 PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, nullptr));
347
348 inScopeInfo.permList = {"ohos.permission.CAMERA"};
349 EXPECT_EQ(ERR_PARAM_INVALID,
350 PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, nullptr));
351 EXPECT_EQ(ERR_PARAM_INVALID,
352 PermissionManager::GetInstance().RemovePermStateChangeCallback(nullptr));
353 }
354
355 class PermChangeCallback : public PermissionStateChangeCallbackStub {
356 public:
357 PermChangeCallback() = default;
358 virtual ~PermChangeCallback() = default;
359
360 void PermStateChangeCallback(PermStateChangeInfo& result) override;
361 bool AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient>& deathRecipient) override;
362 };
363
PermStateChangeCallback(PermStateChangeInfo & result)364 void PermChangeCallback::PermStateChangeCallback(PermStateChangeInfo& result)
365 {
366 }
367
AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient> & deathRecipient)368 bool PermChangeCallback::AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient>& deathRecipient)
369 {
370 return true;
371 }
372
373 /**
374 * @tc.name: AddPermStateChangeCallback002
375 * @tc.desc: Test AddPermStateChangeCallback with exceed limitation.
376 * @tc.type: FUNC
377 * @tc.require: issueI4V02P
378 */
379 HWTEST_F(PermissionManagerTest, AddPermStateChangeCallback002, TestSize.Level1)
380 {
381 PermStateChangeScope inScopeInfo;
382 inScopeInfo.tokenIDs = {};
383 inScopeInfo.permList = {"ohos.permission.CAMERA"};
384 std::vector<sptr<PermChangeCallback>> callbacks;
385
386 for (size_t i = 0; i < MAX_CALLBACK_SIZE; ++i) {
387 sptr<PermChangeCallback> callback = new (std::nothrow) PermChangeCallback();
388 ASSERT_NE(nullptr, callback);
389 ASSERT_EQ(RET_SUCCESS,
390 PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, callback->AsObject()));
391 callbacks.emplace_back(callback);
392 }
393
394 sptr<PermChangeCallback> callback = new (std::nothrow) PermChangeCallback();
395 ASSERT_NE(nullptr, callback);
396 ASSERT_NE(RET_SUCCESS,
397 PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, callback->AsObject()));
398
399 for (size_t i = 0; i < callbacks.size(); ++i) {
400 ASSERT_EQ(RET_SUCCESS,
401 PermissionManager::GetInstance().RemovePermStateChangeCallback(callbacks[i]->AsObject()));
402 }
403 }
404
405 /**
406 * @tc.name: GrantPermission001
407 * @tc.desc: Test GrantPermission abnormal branch.
408 * @tc.type: FUNC
409 * @tc.require: issueI5SSXG
410 */
411 HWTEST_F(PermissionManagerTest, GrantPermission001, TestSize.Level1)
412 {
413 int32_t ret;
414 AccessTokenID tokenID = 0;
415 ret = PermissionManager::GetInstance().GrantPermission(tokenID, "", PERMISSION_USER_FIXED);
416 ASSERT_EQ(ERR_PARAM_INVALID, ret);
417 ret = PermissionManager::GetInstance().GrantPermission(tokenID, "ohos.perm", PERMISSION_USER_FIXED);
418 ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret);
419 uint32_t invalidFlag = -1;
420 ret = PermissionManager::GetInstance().GrantPermission(tokenID, "ohos.permission.CAMERA", invalidFlag);
421 ASSERT_EQ(ERR_PARAM_INVALID, ret);
422 }
423
424 /**
425 * @tc.name: RevokePermission001
426 * @tc.desc: Test RevokePermission abnormal branch.
427 * @tc.type: FUNC
428 * @tc.require: issueI5SSXG
429 */
430 HWTEST_F(PermissionManagerTest, RevokePermission001, TestSize.Level1)
431 {
432 int32_t ret;
433 AccessTokenID tokenID = 0;
434 ret = PermissionManager::GetInstance().RevokePermission(tokenID, "", PERMISSION_USER_FIXED);
435 ASSERT_EQ(ERR_PARAM_INVALID, ret);
436 ret = PermissionManager::GetInstance().RevokePermission(tokenID, "ohos.perm", PERMISSION_USER_FIXED);
437 ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret);
438 uint32_t invalidFlag = -1;
439 ret = PermissionManager::GetInstance().RevokePermission(tokenID, "ohos.permission.CAMERA", invalidFlag);
440 ASSERT_EQ(ERR_PARAM_INVALID, ret);
441 }
442
443 /**
444 * @tc.name: GetReqPermissions001
445 * @tc.desc: GetReqPermissions with invalid tokenid
446 * @tc.type: FUNC
447 * @tc.require:
448 */
449 HWTEST_F(PermissionManagerTest, GetReqPermissions001, TestSize.Level1)
450 {
451 std::vector<PermissionStatus> result;
452
453 // permissionName is empty
454 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().GetReqPermissions(0, result, true));
455 ASSERT_TRUE(result.empty());
456 }
457
458 /**
459 * @tc.name: GetReqPermissions002
460 * @tc.desc: GetReqPermissions with valid tokenid
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(PermissionManagerTest, GetReqPermissions002, TestSize.Level1)
465 {
466 AccessTokenIDEx tokenIdEx = {0};
467 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
468 g_infoManagerTestPolicyPrams1, tokenIdEx);
469 ASSERT_EQ(RET_SUCCESS, ret);
470
471 std::vector<PermissionStatus> result;
472 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
473 // permissionName is empty
474 ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetReqPermissions(tokenId, result, true));
475
476 ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
477 ASSERT_EQ(RET_SUCCESS, ret);
478 }
479
480 /**
481 * @tc.name: GetSelfPermissionState001
482 * @tc.desc: PermissionManager::GetSelfPermissionState function test
483 * @tc.type: FUNC
484 * @tc.require:
485 */
486 HWTEST_F(PermissionManagerTest, GetSelfPermissionState001, TestSize.Level1)
487 {
488 std::vector<PermissionStatus> permsList1;
489 permsList1.emplace_back(g_permState1);
490 PermissionListState permState1;
491 permState1.permissionName = "ohos.permission.GetSelfPermissionStateTest";
492 int32_t apiVersion = ACCURATE_LOCATION_API_VERSION;
493
494 // permissionName no definition
495 PermissionManager::GetInstance().GetSelfPermissionState(permsList1, permState1, apiVersion);
496 ASSERT_EQ(PermissionOper::INVALID_OPER, permState1.state);
497
498 std::vector<PermissionStatus> permsList2;
499 permsList2.emplace_back(g_permState2);
500 PermissionListState permState2;
501 permState2.permissionName = "ohos.permission.CAMERA";
502
503 // flag not PERMISSION_DEFAULT_FLAG、PERMISSION_USER_SET or PERMISSION_USER_FIXED
504 PermissionManager::GetInstance().GetSelfPermissionState(permsList2, permState2, apiVersion);
505 ASSERT_EQ(PermissionOper::PASS_OPER, permState2.state);
506 }
507
508 /**
509 * @tc.name: GetSelfPermissionState002
510 * @tc.desc: PermissionManager::GetSelfPermissionState function test
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(PermissionManagerTest, GetSelfPermissionState002, TestSize.Level1)
515 {
516 std::vector<PermissionStatus> permsList1;
517 permsList1.emplace_back(g_permState6);
518 PermissionListState permState1;
519 permState1.permissionName = "ohos.permission.CAMERA";
520 int32_t apiVersion = ACCURATE_LOCATION_API_VERSION;
521
522 // flag is PERMISSION_POLICY_FIXED and state is denied, return SETTING_OPER
523 PermissionManager::GetInstance().GetSelfPermissionState(permsList1, permState1, apiVersion);
524 ASSERT_EQ(PermissionOper::SETTING_OPER, permState1.state);
525
526 std::vector<PermissionStatus> permsList2;
527 permsList2.emplace_back(g_permState7);
528 PermissionListState permState2;
529 permState2.permissionName = "ohos.permission.CAMERA";
530
531 // flag is PERMISSION_POLICY_FIXED and state is granted, return PASS_OPER
532 PermissionManager::GetInstance().GetSelfPermissionState(permsList2, permState2, apiVersion);
533 ASSERT_EQ(PermissionOper::PASS_OPER, permState2.state);
534
535 std::vector<PermissionStatus> permsList3;
536 permsList3.emplace_back(g_permState8);
537 PermissionListState permState3;
538 permState3.permissionName = "ohos.permission.CAMERA";
539
540 // flag is PERMISSION_POLICY_FIXED | PERMISSION_USER_SET and state is denied, return SETTING_OPER
541 PermissionManager::GetInstance().GetSelfPermissionState(permsList3, permState3, apiVersion);
542 ASSERT_EQ(PermissionOper::SETTING_OPER, permState3.state);
543
544 std::vector<PermissionStatus> permsList4;
545 permsList4.emplace_back(g_permState9);
546 PermissionListState permState4;
547 permState4.permissionName = "ohos.permission.CAMERA";
548
549 // flag is PERMISSION_POLICY_FIXED | PERMISSION_USER_SET and state is granted, return PASS_OPER
550 PermissionManager::GetInstance().GetSelfPermissionState(permsList4, permState4, apiVersion);
551 ASSERT_EQ(PermissionOper::PASS_OPER, permState4.state);
552 }
553
554 /**
555 * @tc.name: GetSelfPermissionState003
556 * @tc.desc: PermissionManager::GetSelfPermissionState function test
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(PermissionManagerTest, GetSelfPermissionState003, TestSize.Level1)
561 {
562 std::vector<PermissionStatus> permsList1;
563 permsList1.emplace_back(g_permState2);
564 std::string permissionName = "ohos.permission.CAMERA";
565 uint32_t oriStatus;
566 AccessTokenInfoManager::GetInstance().GetPermissionRequestToggleStatus(permissionName, oriStatus, 0);
567
568 AccessTokenInfoManager::GetInstance().SetPermissionRequestToggleStatus(permissionName,
569 PermissionRequestToggleStatus::CLOSED, 0);
570 uint32_t status;
571 AccessTokenInfoManager::GetInstance().GetPermissionRequestToggleStatus(permissionName, status, 0);
572 ASSERT_EQ(PermissionRequestToggleStatus::CLOSED, status);
573
574 AccessTokenInfoManager::GetInstance().SetPermissionRequestToggleStatus(permissionName, oriStatus, 0);
575 }
576
577 /**
578 * @tc.name: GetPermissionFlag001
579 * @tc.desc: PermissionManager::GetPermissionFlag function test
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(PermissionManagerTest, GetPermissionFlag001, TestSize.Level1)
584 {
585 AccessTokenID tokenID = 123; // 123 is random input
586 std::string permissionName;
587 uint32_t flag = 0;
588 PermissionDataBrief::GetInstance().DeleteBriefPermDataByTokenId(tokenID);
589 // permissionName invalid
590 ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().GetPermissionFlag(tokenID,
591 permissionName, flag));
592
593 permissionName = "ohos.permission.invalid";
594 // permissionName is not defined
595 ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, PermissionManager::GetInstance().GetPermissionFlag(tokenID,
596 permissionName, flag));
597
598 permissionName = "ohos.permission.CAMERA";
599 // tokenid in not exits
600 ASSERT_EQ(ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().GetPermissionFlag(tokenID,
601 permissionName, flag));
602 }
603
604 /**
605 * @tc.name: GetPermissionFlag002
606 * @tc.desc: PermissionManager::GetPermissionFlag function test
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 HWTEST_F(PermissionManagerTest, GetPermissionFlag002, TestSize.Level1)
611 {
612 HapInfoParams infoParms = {
613 .userID = 1,
614 .bundleName = "accesstoken_test",
615 .instIndex = 0,
616 .appIDDesc = "testtesttesttest"
617 };
618 PermissionStatus permStat = {
619 .permissionName = "ohos.permission.CAMERA",
620 .grantStatus = PermissionState::PERMISSION_DENIED,
621 .grantFlag = PermissionFlag::PERMISSION_SYSTEM_FIXED
622 };
623 HapPolicy policyPrams = {
624 .apl = APL_NORMAL,
625 .domain = "test.domain",
626 .permList = {},
627 .permStateList = {permStat}
628 };
629 AccessTokenIDEx tokenIdEx = {0};
630 int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoParms, policyPrams, tokenIdEx);
631 ASSERT_EQ(RET_SUCCESS, ret);
632 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
633 uint32_t flag;
634 ASSERT_EQ(ERR_PERMISSION_NOT_EXIST,
635 PermissionManager::GetInstance().GetPermissionFlag(tokenId, "ohos.permission.LOCATION", flag));
636
637 ASSERT_EQ(RET_SUCCESS,
638 PermissionManager::GetInstance().GetPermissionFlag(tokenId, permStat.permissionName, flag));
639
640 // delete test token
641 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
642 }
643
644 /**
645 * @tc.name: UpdateTokenPermissionState002
646 * @tc.desc: PermissionManager::UpdateTokenPermissionState function test
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(PermissionManagerTest, UpdateTokenPermissionState002, TestSize.Level1)
651 {
652 AccessTokenID tokenId = 123; // random input
653 std::string permissionName = "ohos.permission.DUMP";
654 bool isGranted = false;
655 uint32_t flag = 0;
656 // tokenId invalid
657 ASSERT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().UpdateTokenPermissionState(
658 tokenId, permissionName, isGranted, flag, true));
659
660 HapInfoParams info = {
661 .userID = USER_ID,
662 .bundleName = "permission_manager_test",
663 .instIndex = INST_INDEX,
664 .appIDDesc = "permission_manager_test"
665 };
666 HapPolicy policy = {
667 .apl = APL_NORMAL,
668 .domain = "domain"
669 };
670 AccessTokenIDEx tokenIdEx = {0};
671 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
672 ASSERT_NE(static_cast<AccessTokenID>(0), tokenIdEx.tokenIdExStruct.tokenID);
673 tokenId = tokenIdEx.tokenIdExStruct.tokenID;
674
675 std::shared_ptr<HapTokenInfoInner> infoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
676 infoPtr->SetRemote(true);
677 // remote token is true
678 ASSERT_EQ(AccessTokenError::ERR_IDENTITY_CHECK_FAILED, PermissionManager::GetInstance().UpdateTokenPermissionState(
679 tokenId, permissionName, isGranted, flag, true));
680 infoPtr->SetRemote(false);
681
682 // permission not in list
683 ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().UpdateTokenPermissionState(tokenId,
684 permissionName, isGranted, flag, true));
685
686 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
687 }
688
689 /**
690 * @tc.name: UpdateTokenPermissionState003
691 * @tc.desc: PermissionManager::UpdateTokenPermissionState function test
692 * @tc.type: FUNC
693 * @tc.require:
694 */
695 HWTEST_F(PermissionManagerTest, UpdateTokenPermissionState003, TestSize.Level1)
696 {
697 std::string permissionName = "ohos.permission.DUMP";
698 uint32_t flag = 0;
699
700 HapInfoParams info = {
701 .userID = USER_ID,
702 .bundleName = "permission_manager_test",
703 .instIndex = INST_INDEX,
704 .appIDDesc = "permission_manager_test"
705 };
706 PermissionStatus permStat = {
707 .permissionName = permissionName,
708 .grantStatus = PermissionState::PERMISSION_DENIED,
709 .grantFlag = PermissionFlag::PERMISSION_DEFAULT_FLAG
710 };
711 HapPolicy policy = {
712 .apl = APL_NORMAL,
713 .domain = "domain",
714 .permStateList = {permStat}
715 };
716 AccessTokenIDEx tokenIdEx = {0};
717 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
718 ASSERT_NE(static_cast<AccessTokenID>(0), tokenIdEx.tokenIdExStruct.tokenID);
719 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
720
721 flag = PERMISSION_ALLOW_THIS_TIME;
722 ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().UpdateTokenPermissionState(
723 tokenId, permissionName, false, flag, true));
724
725 flag = PERMISSION_COMPONENT_SET;
726 ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().UpdateTokenPermissionState(
727 tokenId, permissionName, false, flag, true));
728
729 flag = PERMISSION_USER_FIXED;
730 ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().UpdateTokenPermissionState(
731 tokenId, permissionName, false, flag, true));
732
733 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
734 }
735
736 /**
737 * @tc.name: IsAllowGrantTempPermission001
738 * @tc.desc: PermissionManager::IsAllowGrantTempPermission function test
739 * @tc.type: FUNC
740 * @tc.require:
741 */
742 HWTEST_F(PermissionManagerTest, IsAllowGrantTempPermission001, TestSize.Level1)
743 {
744 AccessTokenID tokenId = 123; // random input
745 std::string permissionName = "";
746 // tokenId invalid
747 ASSERT_EQ(false, TempPermissionObserver::GetInstance().IsAllowGrantTempPermission(tokenId, permissionName));
748 }
749
750 /**
751 * @tc.name: IsPermissionVaild001
752 * @tc.desc: PermissionManager::IsPermissionVaild function test
753 * @tc.type: FUNC
754 * @tc.require:
755 */
756 HWTEST_F(PermissionManagerTest, IsPermissionVaild001, TestSize.Level1)
757 {
758 std::string permissionName;
759 // permissionName invalid
760 ASSERT_EQ(false, PermissionManager::GetInstance().IsPermissionVaild(permissionName));
761
762 permissionName = "ohos.permission.PERMISSION_MANAGR_TEST";
763 // no definition
764 ASSERT_EQ(false, PermissionManager::GetInstance().IsPermissionVaild(permissionName));
765
766 permissionName = "ohos.permission.CAMERA";
767 ASSERT_EQ(true, PermissionManager::GetInstance().IsPermissionVaild(permissionName));
768 }
769
770 /**
771 * @tc.name: GetPermissionState001
772 * @tc.desc: TempPermissionObserver::GetPermissionState function test
773 * @tc.type: FUNC
774 * @tc.require:
775 */
776 HWTEST_F(PermissionManagerTest, GetPermissionState001, TestSize.Level1)
777 {
778 AccessTokenID tokenId = 123; // random input
779 std::vector<PermissionStatus> permissionStateList;
780 // tokenId invalid
781 ASSERT_EQ(false, TempPermissionObserver::GetInstance().GetPermissionState(tokenId, permissionStateList));
782
783 HapInfoParams info = {
784 .userID = USER_ID,
785 .bundleName = "permission_manager_test",
786 .instIndex = INST_INDEX,
787 .appIDDesc = "permission_manager_test"
788 };
789 HapPolicy policy = {
790 .apl = APL_NORMAL,
791 .domain = "domain"
792 };
793 AccessTokenIDEx tokenIdEx = {0};
794 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
795 ASSERT_NE(static_cast<AccessTokenID>(0), tokenIdEx.tokenIdExStruct.tokenID);
796 tokenId = tokenIdEx.tokenIdExStruct.tokenID;
797
798 std::shared_ptr<HapTokenInfoInner> infoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
799 infoPtr->SetRemote(true);
800 // remote token is true
801 ASSERT_EQ(false, TempPermissionObserver::GetInstance().GetPermissionState(tokenId, permissionStateList));
802 infoPtr->SetRemote(false);
803
804 ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
805 }
806
807 /**
808 * @tc.name: GetApiVersionByTokenId001
809 * @tc.desc: PermissionManager::GetApiVersionByTokenId function test
810 * @tc.type: FUNC
811 * @tc.require:
812 */
813 HWTEST_F(PermissionManagerTest, GetApiVersionByTokenId001, TestSize.Level1)
814 {
815 AccessTokenID tokenId = 940572671; // 940572671 is max butt tokenId: 001 11 0 000000 11111111111111111111
816 int32_t apiVersion = 0;
817
818 // type TOKEN_TYPE_BUTT
819 ASSERT_EQ(false, PermissionManager::GetInstance().GetApiVersionByTokenId(tokenId, apiVersion));
820
821 tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
822 // get token info err
823 ASSERT_EQ(false, PermissionManager::GetInstance().GetApiVersionByTokenId(tokenId, apiVersion));
824 }
825
826 /**
827 * @tc.name: VerifyHapAccessToken001
828 * @tc.desc: PermissionManager::VerifyHapAccessToken function test
829 * @tc.type: FUNC
830 * @tc.require:
831 */
832 HWTEST_F(PermissionManagerTest, VerifyHapAccessToken001, TestSize.Level1)
833 {
834 AccessTokenID tokenId = 123; // 123 is random input
835 std::string permissionName;
836
837 std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>();
838 ASSERT_NE(nullptr, hap);
839 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = hap;
840
841 ASSERT_EQ(PermissionState::PERMISSION_DENIED,
842 PermissionManager::GetInstance().VerifyHapAccessToken(tokenId, permissionName)); // permPolicySet is null
843
844 AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
845 }
846
847 /**
848 * @tc.name: GrantTempPermission001
849 * @tc.desc: Test grant temp permission revoke permission after switching to background
850 * @tc.type: FUNC
851 * @tc.require:
852 */
853 HWTEST_F(PermissionManagerTest, GrantTempPermission001, TestSize.Level1)
854 {
855 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
856 accessTokenService_->Initialize();
857 AccessTokenID tokenID = CreateTempHapTokenInfo();
858 TempPermissionObserver::GetInstance().RegisterCallback();
859 // change to foreground
860 AppStateData appStateData;
861 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
862 appStateData.accessTokenId = tokenID;
863 appStateObserver_->OnAppStateChanged(appStateData);
864 // grant temp permission
865 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
866 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
867 EXPECT_EQ(PERMISSION_GRANTED,
868 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
869 // change to background
870 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
871 appStateData.accessTokenId = tokenID;
872 appStateObserver_->OnAppStateChanged(appStateData);
873 EXPECT_EQ(PERMISSION_GRANTED,
874 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
875 TempPermissionObserver::GetInstance().UnRegisterCallback();
876 // UnRegisterCallback twice
877 TempPermissionObserver::GetInstance().UnRegisterCallback();
878 // remove hap
879 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
880 ASSERT_EQ(RET_SUCCESS, ret);
881 GTEST_LOG_(INFO) << "remove the token info";
882 }
883
884 /**
885 * @tc.name: GrantTempPermission002
886 * @tc.desc: Test grant temp permission switching to background and to foreground again
887 * @tc.type: FUNC
888 * @tc.require:
889 */
890 HWTEST_F(PermissionManagerTest, GrantTempPermission002, TestSize.Level1)
891 {
892 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
893 accessTokenService_->Initialize();
894 AccessTokenID tokenID = CreateTempHapTokenInfo();
895 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
896 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
897 EXPECT_EQ(PERMISSION_GRANTED,
898 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
899 // change to background
900 AppStateData appStateData;
901 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
902 appStateData.accessTokenId = tokenID;
903 appStateObserver_->OnAppStateChanged(appStateData);
904 EXPECT_EQ(PERMISSION_GRANTED,
905 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
906 // change to foreground
907 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
908 appStateObserver_->OnAppStateChanged(appStateData);
909 sleep(11);
910 EXPECT_EQ(PERMISSION_GRANTED,
911 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
912 // remove hap
913 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
914 ASSERT_EQ(RET_SUCCESS, ret);
915 GTEST_LOG_(INFO) << "remove the token info";
916 }
917
918 /**
919 * @tc.name: GrantTempPermission003
920 * @tc.desc: Test grant temp permission switching to background and has a form
921 * @tc.type: FUNC
922 * @tc.require:
923 */
924 HWTEST_F(PermissionManagerTest, GrantTempPermission003, TestSize.Level1)
925 {
926 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
927 accessTokenService_->Initialize();
928 AccessTokenID tokenID = CreateTempHapTokenInfo();
929 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
930 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
931 EXPECT_EQ(PERMISSION_GRANTED,
932 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
933 // create a form
934 FormInstance formInstance;
935 formInstance.bundleName_ = "GrantTempPermission";
936 formInstance.appIndex_ = 0;
937 formInstance.userId_ = USER_ID;
938 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
939 std::vector<FormInstance> formInstances;
940 formInstances.emplace_back(formInstance);
941 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
942 // change to background
943 AppStateData appStateData;
944 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
945 appStateData.accessTokenId = tokenID;
946 appStateObserver_->OnAppStateChanged(appStateData);
947 EXPECT_EQ(PERMISSION_GRANTED,
948 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
949 sleep(11);
950 EXPECT_EQ(PERMISSION_GRANTED,
951 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
952 // remove hap
953 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
954 ASSERT_EQ(RET_SUCCESS, ret);
955 GTEST_LOG_(INFO) << "remove the token info";
956 }
957
958 /**
959 * @tc.name: GrantTempPermission004
960 * @tc.desc: Test grant temp permission switching to background and create a form
961 * @tc.type: FUNC
962 * @tc.require:
963 */
964 HWTEST_F(PermissionManagerTest, GrantTempPermission004, TestSize.Level1)
965 {
966 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
967 accessTokenService_->Initialize();
968 AccessTokenID tokenID = CreateTempHapTokenInfo();
969 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
970 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
971 EXPECT_EQ(PERMISSION_GRANTED,
972 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
973 // change to background
974 AppStateData appStateData;
975 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
976 appStateData.accessTokenId = tokenID;
977 appStateObserver_->OnAppStateChanged(appStateData);
978 EXPECT_EQ(PERMISSION_GRANTED,
979 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
980 // create a form
981 FormInstance formInstance;
982 formInstance.bundleName_ = "GrantTempPermission";
983 formInstance.appIndex_ = 0;
984 formInstance.userId_ = USER_ID;
985 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
986 std::vector<FormInstance> formInstances;
987 formInstances.emplace_back(formInstance);
988 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
989 sleep(11);
990 EXPECT_EQ(PERMISSION_GRANTED,
991 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
992 // remove hap
993 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
994 ASSERT_EQ(RET_SUCCESS, ret);
995 GTEST_LOG_(INFO) << "remove the token info";
996 }
997
998 /**
999 * @tc.name: GrantTempPermission005
1000 * @tc.desc: Test grant temp permission switching to background and form change to invisible
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004 HWTEST_F(PermissionManagerTest, GrantTempPermission005, TestSize.Level1)
1005 {
1006 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1007 accessTokenService_->Initialize();
1008 AccessTokenID tokenID = CreateTempHapTokenInfo();
1009 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1010 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1011 EXPECT_EQ(PERMISSION_GRANTED,
1012 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1013 // change to background
1014 AppStateData appStateData;
1015 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1016 appStateData.accessTokenId = tokenID;
1017 appStateObserver_->OnAppStateChanged(appStateData);
1018 EXPECT_EQ(PERMISSION_GRANTED,
1019 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1020 // create a form
1021 FormInstance formInstance;
1022 formInstance.bundleName_ = "GrantTempPermission";
1023 formInstance.appIndex_ = 0;
1024 formInstance.userId_ = USER_ID;
1025 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1026 std::vector<FormInstance> formInstances;
1027 formInstances.emplace_back(formInstance);
1028 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1029 EXPECT_EQ(PERMISSION_GRANTED,
1030 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1031 // form invisible
1032 formInstances.clear();
1033 formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1034 formInstances.emplace_back(formInstance);
1035 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances);
1036 sleep(11);
1037 EXPECT_EQ(PERMISSION_DENIED,
1038 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1039 // remove hap
1040 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1041 ASSERT_EQ(RET_SUCCESS, ret);
1042 GTEST_LOG_(INFO) << "remove the token info";
1043 }
1044 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
1045 /**
1046 * @tc.name: GrantTempPermission006
1047 * @tc.desc: Test grant temp permission switching to background and have a background task
1048 * @tc.type: FUNC
1049 * @tc.require:
1050 */
1051 HWTEST_F(PermissionManagerTest, GrantTempPermission006, TestSize.Level1)
1052 {
1053 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1054 accessTokenService_->Initialize();
1055 AccessTokenID tokenID = CreateTempHapTokenInfo();
1056 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1057 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1058 EXPECT_EQ(PERMISSION_GRANTED,
1059 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1060 // create background task
1061 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1062 = std::make_shared<ContinuousTaskCallbackInfo>();
1063 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1064 continuousTaskCallbackInfo->tokenId_ = tokenID;
1065 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1066 // change to background
1067 AppStateData appStateData;
1068 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1069 appStateData.accessTokenId = tokenID;
1070 appStateObserver_->OnAppStateChanged(appStateData);
1071 EXPECT_EQ(PERMISSION_GRANTED,
1072 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1073 sleep(11);
1074 EXPECT_EQ(PERMISSION_GRANTED,
1075 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1076 // remove hap
1077 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1078 ASSERT_EQ(RET_SUCCESS, ret);
1079 GTEST_LOG_(INFO) << "remove the token info";
1080 }
1081
1082 /**
1083 * @tc.name: GrantTempPermission007
1084 * @tc.desc: Test grant temp permission switching to background and create a background task
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(PermissionManagerTest, GrantTempPermission007, TestSize.Level1)
1089 {
1090 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1091 accessTokenService_->Initialize();
1092 AccessTokenID tokenID = CreateTempHapTokenInfo();
1093 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1094 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1095 EXPECT_EQ(PERMISSION_GRANTED,
1096 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1097 // change to background
1098 AppStateData appStateData;
1099 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1100 appStateData.accessTokenId = tokenID;
1101 appStateObserver_->OnAppStateChanged(appStateData);
1102 // create background task
1103 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1104 = std::make_shared<ContinuousTaskCallbackInfo>();
1105 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1106 continuousTaskCallbackInfo->tokenId_ = tokenID;
1107 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1108 EXPECT_EQ(PERMISSION_GRANTED,
1109 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1110 sleep(11);
1111 EXPECT_EQ(PERMISSION_GRANTED,
1112 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1113 // remove hap
1114 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1115 ASSERT_EQ(RET_SUCCESS, ret);
1116 GTEST_LOG_(INFO) << "remove the token info";
1117 }
1118
1119 /**
1120 * @tc.name: GrantTempPermission008
1121 * @tc.desc: Test grant temp permission switching to background and remove a background task
1122 * @tc.type: FUNC
1123 * @tc.require:
1124 */
1125 HWTEST_F(PermissionManagerTest, GrantTempPermission008, TestSize.Level1)
1126 {
1127 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1128 accessTokenService_->Initialize();
1129 AccessTokenID tokenID = CreateTempHapTokenInfo();
1130 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1131 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1132 EXPECT_EQ(PERMISSION_GRANTED,
1133 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1134 // create background task
1135 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1136 = std::make_shared<ContinuousTaskCallbackInfo>();
1137 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1138 continuousTaskCallbackInfo->tokenId_ = tokenID;
1139 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1140 // change to background
1141 AppStateData appStateData;
1142 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1143 appStateData.accessTokenId = tokenID;
1144 appStateObserver_->OnAppStateChanged(appStateData);
1145 EXPECT_EQ(PERMISSION_GRANTED,
1146 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1147 // remove background task
1148 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1149 sleep(11);
1150 EXPECT_EQ(PERMISSION_DENIED,
1151 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1152 // remove hap
1153 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1154 ASSERT_EQ(RET_SUCCESS, ret);
1155 GTEST_LOG_(INFO) << "remove the token info";
1156 }
1157
1158 /**
1159 * @tc.name: GrantTempPermission009
1160 * @tc.desc: Test grant temp permission switching to background and has a background task and a form
1161 * @tc.type: FUNC
1162 * @tc.require:
1163 */
1164 HWTEST_F(PermissionManagerTest, GrantTempPermission009, TestSize.Level1)
1165 {
1166 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1167 accessTokenService_->Initialize();
1168 AccessTokenID tokenID = CreateTempHapTokenInfo();
1169 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1170 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1171 EXPECT_EQ(PERMISSION_GRANTED,
1172 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1173 // create background task
1174 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1175 = std::make_shared<ContinuousTaskCallbackInfo>();
1176 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1177 continuousTaskCallbackInfo->tokenId_ = tokenID;
1178 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1179 // create a form
1180 FormInstance formInstance;
1181 formInstance.bundleName_ = "GrantTempPermission";
1182 formInstance.appIndex_ = 0;
1183 formInstance.userId_ = USER_ID;
1184 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1185 std::vector<FormInstance> formInstances;
1186 formInstances.emplace_back(formInstance);
1187 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1188 // change to background
1189 AppStateData appStateData;
1190 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1191 appStateData.accessTokenId = tokenID;
1192 appStateObserver_->OnAppStateChanged(appStateData);
1193 EXPECT_EQ(PERMISSION_GRANTED,
1194 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1195 sleep(11);
1196 EXPECT_EQ(PERMISSION_GRANTED,
1197 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1198 // remove hap
1199 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1200 ASSERT_EQ(RET_SUCCESS, ret);
1201 GTEST_LOG_(INFO) << "remove the token info";
1202 }
1203
1204 /**
1205 * @tc.name: GrantTempPermission010
1206 * @tc.desc: Test grant temp permission switching to background and has a background task and a form, remove form
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 HWTEST_F(PermissionManagerTest, GrantTempPermission010, TestSize.Level1)
1211 {
1212 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1213 accessTokenService_->Initialize();
1214 AccessTokenID tokenID = CreateTempHapTokenInfo();
1215 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1216 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1217 EXPECT_EQ(PERMISSION_GRANTED,
1218 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1219 // create background task
1220 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1221 = std::make_shared<ContinuousTaskCallbackInfo>();
1222 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1223 continuousTaskCallbackInfo->tokenId_ = tokenID;
1224 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1225 // create a form
1226 FormInstance formInstance;
1227 formInstance.bundleName_ = "GrantTempPermission";
1228 formInstance.appIndex_ = 0;
1229 formInstance.userId_ = USER_ID;
1230 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1231 std::vector<FormInstance> formInstances;
1232 formInstances.emplace_back(formInstance);
1233 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1234 // change to background
1235 AppStateData appStateData;
1236 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1237 appStateData.accessTokenId = tokenID;
1238 appStateObserver_->OnAppStateChanged(appStateData);
1239 EXPECT_EQ(PERMISSION_GRANTED,
1240 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1241 // form change to invisible
1242 formInstances.clear();
1243 formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1244 formInstances.emplace_back(formInstance);
1245 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances);
1246 sleep(11);
1247 EXPECT_EQ(PERMISSION_GRANTED,
1248 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1249 // remove hap
1250 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1251 ASSERT_EQ(RET_SUCCESS, ret);
1252 GTEST_LOG_(INFO) << "remove the token info";
1253 }
1254
1255 /**
1256 * @tc.name: GrantTempPermission011
1257 * @tc.desc: Test grant temp permission switching to background and has a background task and a form, remove task
1258 * @tc.type: FUNC
1259 * @tc.require:
1260 */
1261 HWTEST_F(PermissionManagerTest, GrantTempPermission011, TestSize.Level1)
1262 {
1263 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1264 accessTokenService_->Initialize();
1265 AccessTokenID tokenID = CreateTempHapTokenInfo();
1266 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1267 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1268 EXPECT_EQ(PERMISSION_GRANTED,
1269 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1270 // create background task
1271 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1272 = std::make_shared<ContinuousTaskCallbackInfo>();
1273 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1274 continuousTaskCallbackInfo->tokenId_ = tokenID;
1275 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1276 // create a form
1277 FormInstance formInstance;
1278 formInstance.bundleName_ = "GrantTempPermission";
1279 formInstance.appIndex_ = 0;
1280 formInstance.userId_ = USER_ID;
1281 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1282 std::vector<FormInstance> formInstances;
1283 formInstances.emplace_back(formInstance);
1284 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1285 // change to background
1286 AppStateData appStateData;
1287 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1288 appStateData.accessTokenId = tokenID;
1289 appStateObserver_->OnAppStateChanged(appStateData);
1290 EXPECT_EQ(PERMISSION_GRANTED,
1291 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1292 // remove background tast
1293 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1294 sleep(11);
1295 EXPECT_EQ(PERMISSION_GRANTED,
1296 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1297 // remove hap
1298 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1299 ASSERT_EQ(RET_SUCCESS, ret);
1300 GTEST_LOG_(INFO) << "remove the token info";
1301 }
1302
1303 /**
1304 * @tc.name: GrantTempPermission012
1305 * @tc.desc: Test grant temp permission switching to background and has a background task and a form, remove form&task
1306 * @tc.type: FUNC
1307 * @tc.require:
1308 */
1309 HWTEST_F(PermissionManagerTest, GrantTempPermission012, TestSize.Level1)
1310 {
1311 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1312 accessTokenService_->Initialize();
1313 AccessTokenID tokenID = CreateTempHapTokenInfo();
1314 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1315 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1316 EXPECT_EQ(PERMISSION_GRANTED,
1317 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1318 // create background task
1319 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1320 = std::make_shared<ContinuousTaskCallbackInfo>();
1321 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1322 continuousTaskCallbackInfo->tokenId_ = tokenID;
1323 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1324 // create a form
1325 FormInstance formInstance;
1326 formInstance.bundleName_ = "GrantTempPermission";
1327 formInstance.appIndex_ = 0;
1328 formInstance.userId_ = USER_ID;
1329 formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1330 std::vector<FormInstance> formInstances;
1331 formInstances.emplace_back(formInstance);
1332 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1333 // change to background
1334 AppStateData appStateData;
1335 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1336 appStateData.accessTokenId = tokenID;
1337 appStateObserver_->OnAppStateChanged(appStateData);
1338 EXPECT_EQ(PERMISSION_GRANTED,
1339 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1340 // remove form
1341 formInstances.clear();
1342 formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1343 formInstances.emplace_back(formInstance);
1344 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances);
1345 sleep(11);
1346 EXPECT_EQ(PERMISSION_GRANTED,
1347 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1348 // remove background tast
1349 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1350 sleep(11);
1351 EXPECT_EQ(PERMISSION_DENIED,
1352 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1353 // remove hap
1354 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1355 ASSERT_EQ(RET_SUCCESS, ret);
1356 GTEST_LOG_(INFO) << "remove the token info";
1357 }
1358
1359 /**
1360 * @tc.name: GrantTempPermission013
1361 * @tc.desc: Test grant temp permission, Create multiple continuous task
1362 * @tc.type: FUNC
1363 * @tc.require:
1364 */
1365 HWTEST_F(PermissionManagerTest, GrantTempPermission013, TestSize.Level1)
1366 {
1367 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1368 accessTokenService_->Initialize();
1369 AccessTokenID tokenID = CreateTempHapTokenInfo();
1370 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1371 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1372 EXPECT_EQ(PERMISSION_GRANTED,
1373 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1374 // create background task
1375 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1376 = std::make_shared<ContinuousTaskCallbackInfo>();
1377 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::DATA_TRANSFER);
1378 continuousTaskCallbackInfo->tokenId_ = tokenID;
1379 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1380
1381 // create background task
1382 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo1
1383 = std::make_shared<ContinuousTaskCallbackInfo>();
1384 continuousTaskCallbackInfo1->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1385 continuousTaskCallbackInfo1->tokenId_ = tokenID;
1386 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo1);
1387
1388 // change to background
1389 AppStateData appStateData;
1390 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1391 appStateData.accessTokenId = tokenID;
1392 appStateObserver_->OnAppStateChanged(appStateData);
1393 EXPECT_EQ(PERMISSION_GRANTED,
1394 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1395
1396 // remove background tast
1397 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1398 sleep(11);
1399 EXPECT_EQ(PERMISSION_GRANTED,
1400 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1401 // remove background tast
1402 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo1);
1403 sleep(11);
1404 EXPECT_EQ(PERMISSION_DENIED,
1405 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1406 // remove hap
1407 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1408 ASSERT_EQ(RET_SUCCESS, ret);
1409 GTEST_LOG_(INFO) << "remove the token info";
1410 }
1411
1412 /**
1413 * @tc.name: GrantTempPermission014
1414 * @tc.desc: Test grant temp permission, Create multiple continuous task
1415 * @tc.type: FUNC
1416 * @tc.require:
1417 */
1418 HWTEST_F(PermissionManagerTest, GrantTempPermission014, TestSize.Level1)
1419 {
1420 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1421 accessTokenService_->Initialize();
1422 AccessTokenID tokenID = CreateTempHapTokenInfo();
1423 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1424 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1425 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1426 "ohos.permission.READ_PASTEBOARD", PERMISSION_ALLOW_THIS_TIME));
1427 EXPECT_EQ(PERMISSION_GRANTED,
1428 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1429 EXPECT_EQ(PERMISSION_GRANTED,
1430 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_PASTEBOARD"));
1431 // create background task
1432 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1433 = std::make_shared<ContinuousTaskCallbackInfo>();
1434 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1435 continuousTaskCallbackInfo->tokenId_ = tokenID;
1436 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1437
1438 // change to background
1439 AppStateData appStateData;
1440 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1441 appStateData.accessTokenId = tokenID;
1442 appStateObserver_->OnAppStateChanged(appStateData);
1443 sleep(11);
1444 EXPECT_EQ(PERMISSION_GRANTED,
1445 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1446 EXPECT_EQ(PERMISSION_GRANTED,
1447 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_PASTEBOARD"));
1448 // remove background tast
1449 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1450 sleep(11);
1451 EXPECT_EQ(PERMISSION_DENIED,
1452 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1453 EXPECT_EQ(PERMISSION_DENIED,
1454 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_PASTEBOARD"));
1455 // remove hap
1456 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1457 ASSERT_EQ(RET_SUCCESS, ret);
1458 GTEST_LOG_(INFO) << "remove the token info";
1459 }
1460 #endif
1461 /**
1462 * @tc.name: GrantTempPermission015
1463 * @tc.desc: Test grant temp permission process died
1464 * @tc.type: FUNC
1465 * @tc.require:
1466 */
1467 HWTEST_F(PermissionManagerTest, GrantTempPermission015, TestSize.Level1)
1468 {
1469 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1470 accessTokenService_->Initialize();
1471 AccessTokenID tokenID = CreateTempHapTokenInfo();
1472 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1473 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1474 EXPECT_EQ(PERMISSION_GRANTED,
1475 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1476 AppStateData appStateData;
1477 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_TERMINATED);
1478 appStateData.accessTokenId = tokenID;
1479 appStateObserver_->OnAppStopped(appStateData);
1480 EXPECT_EQ(PERMISSION_DENIED,
1481 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1482 // remove hap
1483 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1484 ASSERT_EQ(RET_SUCCESS, ret);
1485 GTEST_LOG_(INFO) << "remove the token info";
1486 }
1487
1488 /**
1489 * @tc.name: GrantTempPermission016
1490 * @tc.desc: Test grant & revoke temp permission
1491 * @tc.type: FUNC
1492 * @tc.require:
1493 */
1494 HWTEST_F(PermissionManagerTest, GrantTempPermission016, TestSize.Level1)
1495 {
1496 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1497 accessTokenService_->Initialize();
1498 AccessTokenID tokenID = CreateTempHapTokenInfo();
1499 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1500 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1501 EXPECT_EQ(PERMISSION_GRANTED,
1502 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1503 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().RevokePermission(tokenID,
1504 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1505 EXPECT_EQ(PERMISSION_DENIED,
1506 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1507 // remove hap
1508 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1509 ASSERT_EQ(RET_SUCCESS, ret);
1510 GTEST_LOG_(INFO) << "remove the token info";
1511 }
1512
1513 /**
1514 * @tc.name: GrantTempPermission017
1515 * @tc.desc: Test grant temp permission not root
1516 * @tc.type: FUNC
1517 * @tc.require:
1518 */
1519 HWTEST_F(PermissionManagerTest, GrantTempPermission017, TestSize.Level1)
1520 {
1521 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1522 accessTokenService_->Initialize();
1523 AccessTokenID tokenID = CreateTempHapTokenInfo();
1524 setuid(100);
1525 EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, PermissionManager::GetInstance().GrantPermission(tokenID,
1526 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1527 // remove hap
1528 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1529 ASSERT_EQ(RET_SUCCESS, ret);
1530 GTEST_LOG_(INFO) << "remove the token info";
1531 }
1532
1533 /**
1534 * @tc.name: GrantTempPermission018
1535 * @tc.desc: Test tokenID not in the list
1536 * @tc.type: FUNC
1537 * @tc.require:
1538 */
1539 HWTEST_F(PermissionManagerTest, GrantTempPermission018, TestSize.Level1)
1540 {
1541 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1542 accessTokenService_->Initialize();
1543 AccessTokenID tokenID = CreateTempHapTokenInfo();
1544 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1545 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_SYSTEM_FIXED));
1546
1547 // change to background
1548 AppStateData appStateData;
1549 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1550 appStateData.accessTokenId = tokenID;
1551 appStateObserver_->OnAppStateChanged(appStateData);
1552 EXPECT_EQ(PERMISSION_GRANTED,
1553 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1554 FormInstance formInstance;
1555 formInstance.bundleName_ = "GrantTempPermission";
1556 formInstance.appIndex_ = 0;
1557 formInstance.userId_ = USER_ID;
1558 formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1559 std::vector<FormInstance> formInstances;
1560 formInstances.emplace_back(formInstance);
1561 EXPECT_EQ(RET_SUCCESS,
1562 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances));
1563 EXPECT_EQ(PERMISSION_GRANTED,
1564 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1565
1566 EXPECT_EQ(RET_SUCCESS,
1567 formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances));
1568 EXPECT_EQ(PERMISSION_GRANTED,
1569 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1570
1571 // remove hap
1572 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1573 ASSERT_EQ(RET_SUCCESS, ret);
1574 GTEST_LOG_(INFO) << "remove the token info";
1575 }
1576 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
1577 /**
1578 * @tc.name: GrantTempPermission019
1579 * @tc.desc: Test tokenID not in the list
1580 * @tc.type: FUNC
1581 * @tc.require:
1582 */
1583 HWTEST_F(PermissionManagerTest, GrantTempPermission019, TestSize.Level1)
1584 {
1585 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1586 accessTokenService_->Initialize();
1587 AccessTokenID tokenID = CreateTempHapTokenInfo();
1588 EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1589 "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_SYSTEM_FIXED));
1590
1591 TempPermissionObserver::GetInstance().ModifyAppState(tokenID, 0, false);
1592 // create background task
1593 std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1594 = std::make_shared<ContinuousTaskCallbackInfo>();
1595 continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1596 continuousTaskCallbackInfo->tokenId_ = tokenID;
1597 backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1598 EXPECT_EQ(PERMISSION_GRANTED,
1599 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1600
1601 // remove background tast
1602 backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1603 EXPECT_EQ(PERMISSION_GRANTED,
1604 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1605
1606 TempPermissionObserver::GetInstance().RevokeAllTempPermission(tokenID);
1607 EXPECT_EQ(PERMISSION_GRANTED,
1608 AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1609 // remove hap
1610 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1611 ASSERT_EQ(RET_SUCCESS, ret);
1612 GTEST_LOG_(INFO) << "remove the token info";
1613 }
1614 #endif
1615 /**
1616 * @tc.name: GrantTempPermission020
1617 * @tc.desc: Test invalid permissionName
1618 * @tc.type: FUNC
1619 * @tc.require:
1620 */
1621 HWTEST_F(PermissionManagerTest, GrantTempPermission020, TestSize.Level1)
1622 {
1623 accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1624 accessTokenService_->Initialize();
1625 AccessTokenID tokenID = CreateTempHapTokenInfo();
1626 EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, PermissionManager::GetInstance().GrantPermission(tokenID,
1627 "ohos.permission.MICROPHONE", PERMISSION_ALLOW_THIS_TIME));
1628 TempPermissionObserver::GetInstance().UnRegisterCallback();
1629 // remove hap
1630 int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1631 ASSERT_EQ(RET_SUCCESS, ret);
1632 GTEST_LOG_(INFO) << "remove the token info";
1633 }
1634
1635 /**
1636 * @tc.name: PermissionCallbackTest001
1637 * @tc.desc: Test nullptr input for callback
1638 * @tc.type: FUNC
1639 * @tc.require:
1640 */
1641 HWTEST_F(PermissionManagerTest, PermissionCallbackTest001, TestSize.Level1)
1642 {
1643 PermStateChangeScope scope;
1644 EXPECT_EQ(AccessTokenError::ERR_PARAM_INVALID, CallbackManager::GetInstance().AddCallback(scope, nullptr));
1645 }
1646
1647 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
1648 /*
1649 * @tc.name: ContinuousTaskCallbackInfoParcel001
1650 * @tc.desc: ContinuousTaskCallbackInfo::Marshalling | Unmarshalling
1651 * @tc.type: FUNC
1652 * @tc.require:
1653 */
1654 HWTEST_F(PermissionManagerTest, ContinuousTaskCallbackInfoParcel001, TestSize.Level1)
1655 {
1656 ContinuousTaskCallbackInfo info;
1657 Parcel parcel;
1658 EXPECT_EQ(true, info.Marshalling(parcel));
1659
1660 auto p = ContinuousTaskCallbackInfo::Unmarshalling(parcel);
1661 EXPECT_NE(nullptr, p);
1662 EXPECT_EQ(info.typeId_, p->typeId_);
1663 EXPECT_EQ(info.creatorUid_, p->creatorUid_);
1664 EXPECT_EQ(info.creatorPid_, p->creatorPid_);
1665 EXPECT_EQ(info.abilityName_, p->abilityName_);
1666 EXPECT_EQ(info.isFromWebview_, p->isFromWebview_);
1667 EXPECT_EQ(info.isBatchApi_, p->isBatchApi_);
1668 EXPECT_EQ(info.typeIds_, p->typeIds_);
1669 EXPECT_EQ(info.abilityId_, p->abilityId_);
1670 EXPECT_EQ(info.tokenId_, p->tokenId_);
1671 }
1672 #endif
1673 } // namespace AccessToken
1674 } // namespace Security
1675 } // namespace OHOS
1676