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