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 #ifdef SUPPORT_SANDBOX_APP
21 #define private public
22 #include "dlp_permission_set_manager.h"
23 #include "dlp_permission_set_parser.h"
24 #undef private
25 #endif
26 #define private public
27 #include "accesstoken_info_manager.h"
28 #include "permission_definition_cache.h"
29 #undef private
30 #include "accesstoken_callback_stubs.h"
31 #include "callback_death_recipients.h"
32 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
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 PermissionStateFull g_infoManagerTestState1 = {
73     .permissionName = "open the door",
74     .isGeneral = true,
75     .resDeviceID = {"local"},
76     .grantStatus = {1},
77     .grantFlags = {1}
78 };
79 
80 static PermissionStateFull g_infoManagerTestState2 = {
81     .permissionName = "break the door",
82     .isGeneral = false,
83     .resDeviceID = {"device 1", "device 2"},
84     .grantStatus = {1, 3},
85     .grantFlags = {1, 2}
86 };
87 
88 static HapInfoParams g_infoManagerTestInfoParms = {
89     .userID = 1,
90     .bundleName = "accesstoken_test",
91     .instIndex = 0,
92     .appIDDesc = "testtesttesttest"
93 };
94 
95 static HapPolicyParams g_infoManagerTestPolicyPrams1 = {
96     .apl = APL_NORMAL,
97     .domain = "test.domain",
98     .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
99     .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
100 };
101 
102 static PermissionStateFull g_infoManagerTestStateA = {
103     .isGeneral = true,
104     .resDeviceID = {"local"},
105     .grantStatus = {PERMISSION_GRANTED},
106     .grantFlags = {1}
107 };
108 
109 static PermissionStateFull g_infoManagerTestStateB = {
110     .isGeneral = true,
111     .resDeviceID = {"local"},
112     .grantStatus = {PERMISSION_GRANTED},
113     .grantFlags = {1}
114 };
115 
116 static PermissionStateFull g_infoManagerTestStateC = {
117     .isGeneral = true,
118     .resDeviceID = {"local"},
119     .grantStatus = {PERMISSION_GRANTED},
120     .grantFlags = {1}
121 };
122 
123 static PermissionStateFull g_infoManagerTestStateD = {
124     .isGeneral = true,
125     .resDeviceID = {"local"},
126     .grantStatus = {PERMISSION_GRANTED},
127     .grantFlags = {1}
128 };
129 
130 static PermissionStateFull g_permState1 = {
131     .permissionName = "ohos.permission.TEST",
132     .isGeneral = false,
133     .resDeviceID = {"dev-001"},
134     .grantStatus = {PermissionState::PERMISSION_DENIED},
135     .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
136 };
137 
138 static PermissionStateFull g_permState2 = {
139     .permissionName = "ohos.permission.CAMERA",
140     .isGeneral = false,
141     .resDeviceID = {"dev-001"},
142     .grantStatus = {PermissionState::PERMISSION_DENIED},
143     .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
144 };
145 
146 static PermissionStateFull g_permState6 = {
147     .permissionName = "ohos.permission.CAMERA",
148     .isGeneral = true,
149     .resDeviceID = {"dev-001"},
150     .grantStatus = {PermissionState::PERMISSION_DENIED},
151     .grantFlags = {PermissionFlag::PERMISSION_POLICY_FIXED}
152 };
153 
154 static PermissionStateFull g_permState7 = {
155     .permissionName = "ohos.permission.CAMERA",
156     .isGeneral = true,
157     .resDeviceID = {"dev-001"},
158     .grantStatus = {PermissionState::PERMISSION_GRANTED},
159     .grantFlags = {PermissionFlag::PERMISSION_POLICY_FIXED}
160 };
161 
162 static PermissionStateFull g_permState8 = {
163     .permissionName = "ohos.permission.CAMERA",
164     .isGeneral = true,
165     .resDeviceID = {"dev-001"},
166     .grantStatus = {PermissionState::PERMISSION_DENIED},
167     .grantFlags = {PermissionFlag::PERMISSION_POLICY_FIXED | PermissionFlag::PERMISSION_USER_SET}
168 };
169 
170 static PermissionStateFull g_permState9 = {
171     .permissionName = "ohos.permission.CAMERA",
172     .isGeneral = true,
173     .resDeviceID = {"dev-001"},
174     .grantStatus = {PermissionState::PERMISSION_GRANTED},
175     .grantFlags = {PermissionFlag::PERMISSION_POLICY_FIXED | PermissionFlag::PERMISSION_USER_SET}
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     PermissionDef infoManagerPermDef = {
264         .permissionName = "ohos.permission.CAMERA",
265         .bundleName = "accesstoken_test",
266         .grantMode = USER_GRANT,
267         .availableLevel = APL_NORMAL,
268         .provisionEnable = false,
269         .distributedSceneEnable = false,
270         .label = "label",
271         .labelId = 1,
272         .description = "CAMERA",
273         .descriptionId = 1
274     };
275     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
276     infoManagerPermDef.permissionName = "ohos.permission.APPROXIMATELY_LOCATION";
277     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
278     infoManagerPermDef.permissionName = "ohos.permission.LOCATION";
279     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
280     infoManagerPermDef.permissionName = "ohos.permission.CAPTURE_SCREEN";
281     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
282     infoManagerPermDef.permissionName = "ohos.permission.CHANGE_ABILITY_ENABLED_STATE";
283     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
284     infoManagerPermDef.permissionName = "ohos.permission.CLEAN_APPLICATION_DATA";
285     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
286     infoManagerPermDef.permissionName = "ohos.permission.COMMONEVENT_STICKY";
287     PermissionDefinitionCache::GetInstance().Insert(infoManagerPermDef, 1);
288 }
289 
TearDown()290 void PermissionManagerTest::TearDown()
291 {
292     accessTokenService_ = nullptr;
293     appStateObserver_ = nullptr;
294 }
295 
CreateTempHapTokenInfo()296 static AccessTokenID CreateTempHapTokenInfo()
297 {
298     g_infoManagerTestStateA.permissionName = "ohos.permission.APPROXIMATELY_LOCATION";
299     g_infoManagerTestStateA.grantStatus[0] = PERMISSION_DENIED;
300     g_infoManagerTestStateB.permissionName = "ohos.permission.READ_PASTEBOARD";
301     g_infoManagerTestStateB.grantStatus[0] = PERMISSION_DENIED;
302     static HapPolicyParams infoManagerTestPolicyPrams = {
303         .apl = APL_NORMAL,
304         .domain = "test.domain",
305         .permList = {},
306         .permStateList = { g_infoManagerTestStateA, g_infoManagerTestStateB}
307     };
308     static HapInfoParams infoManagerTestInfoParms = {
309         .userID = USER_ID,
310         .bundleName = "GrantTempPermission",
311         .instIndex = 0,
312         .dlpType = DLP_COMMON,
313         .appIDDesc = "GrantTempPermission"
314     };
315     // install hap
316     AccessTokenIDEx tokenIdEx = {0};
317     AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(
318         infoManagerTestInfoParms, infoManagerTestPolicyPrams, tokenIdEx);
319     GTEST_LOG_(INFO) << "add a hap token";
320     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
321     return tokenID;
322 }
323 
324 #ifdef SUPPORT_SANDBOX_APP
PrepareJsonData1()325 static void PrepareJsonData1()
326 {
327     std::string testStr = R"({"dlpPermissions":[)"\
328         R"({"name":"ohos.permission.CAPTURE_SCREEN","dlpGrantRange":"none"},)"\
329         R"({"name":"ohos.permission.CHANGE_ABILITY_ENABLED_STATE","dlpGrantRange":"all"},)"\
330         R"({"name":"ohos.permission.CLEAN_APPLICATION_DATA","dlpGrantRange":"full_control"}]})";
331 
332     std::vector<PermissionDlpMode> dlpPerms;
333     int32_t res = DlpPermissionSetParser::GetInstance().ParserDlpPermsRawData(testStr, dlpPerms);
334     if (res != RET_SUCCESS) {
335         GTEST_LOG_(INFO) << "ParserDlpPermsRawData failed:";
336     }
337     for (auto iter = dlpPerms.begin(); iter != dlpPerms.end(); iter++) {
338         GTEST_LOG_(INFO) << "iter:" << iter->permissionName.c_str();
339     }
340     DlpPermissionSetManager::GetInstance().ProcessDlpPermInfos(dlpPerms);
341 }
342 
343 /**
344  * @tc.name: DlpPermissionConfig001
345  * @tc.desc: test DLP_COMMON app with system_grant permissions.
346  * @tc.type: FUNC
347  * @tc.require: SR000GVIGR
348  */
HWTEST_F(PermissionManagerTest, DlpPermissionConfig001, TestSize.Level1)349 HWTEST_F(PermissionManagerTest, DlpPermissionConfig001, TestSize.Level1)
350 {
351     PrepareJsonData1();
352 
353     g_infoManagerTestStateA.permissionName = "ohos.permission.CAPTURE_SCREEN";
354     g_infoManagerTestStateB.permissionName = "ohos.permission.CHANGE_ABILITY_ENABLED_STATE";
355     g_infoManagerTestStateC.permissionName = "ohos.permission.CLEAN_APPLICATION_DATA";
356     g_infoManagerTestStateD.permissionName = "ohos.permission.COMMONEVENT_STICKY";
357 
358     static HapPolicyParams infoManagerTestPolicyPrams = {
359         .apl = APL_NORMAL,
360         .domain = "test.domain1",
361         .permList = {},
362         .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB,
363                           g_infoManagerTestStateC, g_infoManagerTestStateD}
364     };
365     static HapInfoParams infoManagerTestInfoParms = {
366         .userID = 1,
367         .bundleName = "DlpPermissionConfig001",
368         .instIndex = 0,
369         .dlpType = DLP_COMMON,
370         .appIDDesc = "DlpPermissionConfig001"
371     };
372     AccessTokenIDEx tokenIdEx = {0};
373     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoManagerTestInfoParms,
374         infoManagerTestPolicyPrams, tokenIdEx);
375     ASSERT_EQ(RET_SUCCESS, ret);
376     GTEST_LOG_(INFO) << "add a hap token";
377 
378     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
379     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
380         tokenID, "ohos.permission.COMMONEVENT_STICKY");
381     ASSERT_EQ(PERMISSION_GRANTED, ret);
382     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
383         tokenID, "ohos.permission.CAPTURE_SCREEN");
384     ASSERT_EQ(PERMISSION_GRANTED, ret);
385     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
386         tokenID, "ohos.permission.CHANGE_ABILITY_ENABLED_STATE");
387     ASSERT_EQ(PERMISSION_GRANTED, ret);
388     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
389         tokenID, "ohos.permission.CLEAN_APPLICATION_DATA");
390     ASSERT_EQ(PERMISSION_GRANTED, ret);
391 
392     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
393     ASSERT_EQ(RET_SUCCESS, ret);
394     GTEST_LOG_(INFO) << "remove the token info";
395 }
396 
397 /**
398  * @tc.name: DlpPermissionConfig002
399  * @tc.desc: test DLP_READ app with system_grant permissions.
400  * @tc.type: FUNC
401  * @tc.require: SR000GVIGR
402  */
HWTEST_F(PermissionManagerTest, DlpPermissionConfig002, TestSize.Level1)403 HWTEST_F(PermissionManagerTest, DlpPermissionConfig002, TestSize.Level1)
404 {
405     PrepareJsonData1();
406 
407     g_infoManagerTestStateA.permissionName = "ohos.permission.CAPTURE_SCREEN";
408     g_infoManagerTestStateB.permissionName = "ohos.permission.CHANGE_ABILITY_ENABLED_STATE";
409     g_infoManagerTestStateC.permissionName = "ohos.permission.CLEAN_APPLICATION_DATA";
410     g_infoManagerTestStateD.permissionName = "ohos.permission.COMMONEVENT_STICKY";
411 
412     static HapPolicyParams infoManagerTestPolicyPrams = {
413         .apl = APL_NORMAL,
414         .domain = "test.domain2",
415         .permList = {},
416         .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB,
417                           g_infoManagerTestStateC, g_infoManagerTestStateD}
418     };
419     static HapInfoParams infoManagerTestInfoParms = {
420         .userID = 1,
421         .bundleName = "DlpPermissionConfig002",
422         .instIndex = 0,
423         .dlpType = DLP_READ,
424         .appIDDesc = "DlpPermissionConfig002"
425     };
426     AccessTokenIDEx tokenIdEx = {0};
427     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoManagerTestInfoParms,
428         infoManagerTestPolicyPrams, tokenIdEx);
429     ASSERT_EQ(RET_SUCCESS, ret);
430     GTEST_LOG_(INFO) << "add a hap token";
431 
432     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
433     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
434         tokenID, "ohos.permission.CAPTURE_SCREEN");
435     ASSERT_EQ(PERMISSION_DENIED, ret);
436     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
437         tokenID, "ohos.permission.COMMONEVENT_STICKY");
438     ASSERT_EQ(PERMISSION_GRANTED, ret);
439     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
440         tokenID, "ohos.permission.CHANGE_ABILITY_ENABLED_STATE");
441     ASSERT_EQ(PERMISSION_GRANTED, ret);
442     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
443         tokenID, "ohos.permission.CLEAN_APPLICATION_DATA");
444     ASSERT_EQ(PERMISSION_DENIED, ret);
445 
446     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
447     ASSERT_EQ(RET_SUCCESS, ret);
448     GTEST_LOG_(INFO) << "remove the token info";
449 }
450 
451 /**
452  * @tc.name: DlpPermissionConfig003
453  * @tc.desc: test DLP_FULL_CONTROL app with system_grant permissions.
454  * @tc.type: FUNC
455  * @tc.require: SR000GVIGR
456  */
HWTEST_F(PermissionManagerTest, DlpPermissionConfig003, TestSize.Level1)457 HWTEST_F(PermissionManagerTest, DlpPermissionConfig003, TestSize.Level1)
458 {
459     PrepareJsonData1();
460 
461     g_infoManagerTestStateA.permissionName = "ohos.permission.CAPTURE_SCREEN";
462     g_infoManagerTestStateB.permissionName = "ohos.permission.CHANGE_ABILITY_ENABLED_STATE";
463     g_infoManagerTestStateC.permissionName = "ohos.permission.CLEAN_APPLICATION_DATA";
464     g_infoManagerTestStateD.permissionName = "ohos.permission.COMMONEVENT_STICKY";
465 
466     static HapPolicyParams infoManagerTestPolicyPrams = {
467         .apl = APL_NORMAL,
468         .domain = "test.domain3",
469         .permList = {},
470         .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB,
471                           g_infoManagerTestStateC, g_infoManagerTestStateD}
472     };
473     static HapInfoParams infoManagerTestInfoParms = {
474         .userID = 1,
475         .bundleName = "DlpPermissionConfig003",
476         .instIndex = 0,
477         .dlpType = DLP_FULL_CONTROL,
478         .appIDDesc = "DlpPermissionConfig003"
479     };
480     AccessTokenIDEx tokenIdEx = {0};
481     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoManagerTestInfoParms,
482         infoManagerTestPolicyPrams, tokenIdEx);
483     ASSERT_EQ(RET_SUCCESS, ret);
484     GTEST_LOG_(INFO) << "add a hap token";
485 
486     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
487     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
488         tokenID, "ohos.permission.CLEAN_APPLICATION_DATA");
489     ASSERT_EQ(PERMISSION_GRANTED, ret);
490     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
491         tokenID, "ohos.permission.COMMONEVENT_STICKY");
492     ASSERT_EQ(PERMISSION_GRANTED, ret);
493     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
494         tokenID, "ohos.permission.CAPTURE_SCREEN");
495     ASSERT_EQ(PERMISSION_DENIED, ret);
496     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(
497         tokenID, "ohos.permission.CHANGE_ABILITY_ENABLED_STATE");
498     ASSERT_EQ(PERMISSION_GRANTED, ret);
499     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
500     ASSERT_EQ(RET_SUCCESS, ret);
501     GTEST_LOG_(INFO) << "remove the token info";
502 }
503 
PrepareUserPermState()504 static void PrepareUserPermState()
505 {
506     g_infoManagerTestStateA.permissionName = "ohos.permission.MEDIA_LOCATION";
507     g_infoManagerTestStateA.grantStatus[0] = PERMISSION_DENIED;
508     g_infoManagerTestStateB.permissionName = "ohos.permission.MICROPHONE";
509     g_infoManagerTestStateB.grantStatus[0] = PERMISSION_DENIED;
510     g_infoManagerTestStateC.permissionName = "ohos.permission.READ_CALENDAR";
511     g_infoManagerTestStateC.grantStatus[0] = PERMISSION_DENIED;
512     g_infoManagerTestStateD.permissionName = "ohos.permission.READ_CALL_LOG";
513     g_infoManagerTestStateD.grantStatus[0] = PERMISSION_DENIED;
514 }
515 
PrepareJsonData2()516 static void PrepareJsonData2()
517 {
518     std::string testStr = R"({"dlpPermissions":[)"\
519         R"({"name":"ohos.permission.MEDIA_LOCATION","dlpGrantRange":"none"},)"\
520         R"({"name":"ohos.permission.MICROPHONE","dlpGrantRange":"all"},)"\
521         R"({"name":"ohos.permission.READ_CALENDAR","dlpGrantRange":"full_control"}]})";
522 
523     std::vector<PermissionDlpMode> dlpPermissions;
524     int32_t res = DlpPermissionSetParser::GetInstance().ParserDlpPermsRawData(testStr, dlpPermissions);
525     if (res != RET_SUCCESS) {
526         GTEST_LOG_(INFO) << "ParserDlpPermsRawData failed:";
527     }
528     DlpPermissionSetManager::GetInstance().ProcessDlpPermInfos(dlpPermissions);
529 }
530 
531 /**
532  * @tc.name: DlpPermissionConfig004
533  * @tc.desc: test DLP_COMMON app with user_grant permissions.
534  * @tc.type: FUNC
535  * @tc.require: SR000GVIGR
536  */
HWTEST_F(PermissionManagerTest, DlpPermissionConfig004, TestSize.Level1)537 HWTEST_F(PermissionManagerTest, DlpPermissionConfig004, TestSize.Level1)
538 {
539     PrepareJsonData2();
540     PrepareUserPermState();
541 
542     static HapPolicyParams infoManagerTestPolicyPrams = {
543         .apl = APL_NORMAL,
544         .domain = "test.domain4",
545         .permList = {g_infoManagerPermDef1, g_infoManagerPermDef2,
546                      g_infoManagerPermDef3, g_infoManagerPermDef4},
547         .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB,
548                           g_infoManagerTestStateC, g_infoManagerTestStateD}
549     };
550     static HapInfoParams infoManagerTestInfoParms = {
551         .userID = 1,
552         .bundleName = "DlpPermissionConfig004",
553         .instIndex = 0,
554         .dlpType = DLP_COMMON,
555         .appIDDesc = "DlpPermissionConfig004"
556     };
557     AccessTokenIDEx tokenIdEx = {0};
558     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoManagerTestInfoParms,
559         infoManagerTestPolicyPrams, tokenIdEx);
560     ASSERT_EQ(RET_SUCCESS, ret);
561     GTEST_LOG_(INFO) << "add a hap token";
562 
563     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
564 
565     PermissionManager::GetInstance().GrantPermission(tokenID,
566         "ohos.permission.MEDIA_LOCATION", PERMISSION_USER_FIXED);
567     PermissionManager::GetInstance().GrantPermission(tokenID,
568         "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED);
569     PermissionManager::GetInstance().GrantPermission(tokenID,
570         "ohos.permission.READ_CALENDAR", PERMISSION_USER_FIXED);
571     ASSERT_EQ(RET_SUCCESS, ret);
572     PermissionManager::GetInstance().GrantPermission(tokenID,
573         "ohos.permission.READ_CALL_LOG", PERMISSION_USER_FIXED);
574 
575     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.MEDIA_LOCATION");
576     ASSERT_EQ(PERMISSION_GRANTED, ret);
577     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE");
578     ASSERT_EQ(PERMISSION_GRANTED, ret);
579     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_CALENDAR");
580     ASSERT_EQ(PERMISSION_GRANTED, ret);
581     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_CALL_LOG");
582     ASSERT_EQ(PERMISSION_GRANTED, ret);
583 
584     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
585     ASSERT_EQ(RET_SUCCESS, ret);
586     GTEST_LOG_(INFO) << "remove the token info";
587 }
588 
589 /**
590  * @tc.name: DlpPermissionConfig005
591  * @tc.desc: test DLP_READ app with user_grant permissions.
592  * @tc.type: FUNC
593  * @tc.require: SR000GVIGR
594  */
HWTEST_F(PermissionManagerTest, DlpPermissionConfig005, TestSize.Level1)595 HWTEST_F(PermissionManagerTest, DlpPermissionConfig005, TestSize.Level1)
596 {
597     PrepareJsonData2();
598     PrepareUserPermState();
599 
600     static HapPolicyParams infoManagerTestPolicyPrams = {
601         .apl = APL_NORMAL,
602         .domain = "test.domain5",
603         .permList = {g_infoManagerPermDef1, g_infoManagerPermDef2,
604                      g_infoManagerPermDef3, g_infoManagerPermDef4},
605         .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB,
606                           g_infoManagerTestStateC, g_infoManagerTestStateD}
607     };
608     static HapInfoParams infoManagerTestInfoParms = {
609         .userID = 1,
610         .bundleName = "DlpPermissionConfig005",
611         .instIndex = 0,
612         .dlpType = DLP_READ,
613         .appIDDesc = "DlpPermissionConfig005"
614     };
615     AccessTokenIDEx tokenIdEx = {0};
616     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoManagerTestInfoParms,
617         infoManagerTestPolicyPrams, tokenIdEx);
618     ASSERT_EQ(RET_SUCCESS, ret);
619     GTEST_LOG_(INFO) << "add a hap token";
620 
621     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
622 
623     PermissionManager::GetInstance().GrantPermission(tokenID,
624         "ohos.permission.READ_CALENDAR", PERMISSION_USER_FIXED);
625     PermissionManager::GetInstance().GrantPermission(tokenID,
626         "ohos.permission.READ_CALL_LOG", PERMISSION_USER_FIXED);
627     PermissionManager::GetInstance().GrantPermission(tokenID,
628         "ohos.permission.MEDIA_LOCATION", PERMISSION_USER_FIXED);
629     PermissionManager::GetInstance().GrantPermission(tokenID,
630         "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED);
631 
632     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_CALENDAR");
633     ASSERT_EQ(PERMISSION_DENIED, ret);
634     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_CALL_LOG");
635     ASSERT_EQ(PERMISSION_GRANTED, ret);
636     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.MEDIA_LOCATION");
637     ASSERT_EQ(PERMISSION_DENIED, ret);
638     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE");
639     ASSERT_EQ(PERMISSION_GRANTED, ret);
640 
641     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
642     ASSERT_EQ(RET_SUCCESS, ret);
643     GTEST_LOG_(INFO) << "remove the token info";
644 }
645 
646 /**
647  * @tc.name: DlpPermissionConfig006
648  * @tc.desc: test DLP_FULL_CONTROL app with user_grant permissions.
649  * @tc.type: FUNC
650  * @tc.require:
651  */
HWTEST_F(PermissionManagerTest, DlpPermissionConfig006, TestSize.Level1)652 HWTEST_F(PermissionManagerTest, DlpPermissionConfig006, TestSize.Level1)
653 {
654     PrepareJsonData2();
655     PrepareUserPermState();
656 
657     static HapPolicyParams infoManagerTestPolicyPrams = {
658         .apl = APL_NORMAL,
659         .domain = "test.domain6",
660         .permList = {g_infoManagerPermDef1, g_infoManagerPermDef2,
661                      g_infoManagerPermDef3, g_infoManagerPermDef4},
662         .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB,
663                           g_infoManagerTestStateC, g_infoManagerTestStateD}
664     };
665     static HapInfoParams infoManagerTestInfoParms = {
666         .userID = 1,
667         .bundleName = "DlpPermissionConfig006",
668         .instIndex = 0,
669         .dlpType = DLP_FULL_CONTROL,
670         .appIDDesc = "DlpPermissionConfig006"
671     };
672     AccessTokenIDEx tokenIdEx = {0};
673     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoManagerTestInfoParms,
674         infoManagerTestPolicyPrams, tokenIdEx);
675     ASSERT_EQ(RET_SUCCESS, ret);
676     GTEST_LOG_(INFO) << "add a hap token";
677 
678     AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
679 
680     PermissionManager::GetInstance().GrantPermission(tokenID,
681         "ohos.permission.READ_CALENDAR", PERMISSION_USER_FIXED);
682     PermissionManager::GetInstance().GrantPermission(tokenID,
683         "ohos.permission.MEDIA_LOCATION", PERMISSION_USER_FIXED);
684     PermissionManager::GetInstance().GrantPermission(tokenID,
685         "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED);
686     PermissionManager::GetInstance().GrantPermission(tokenID,
687         "ohos.permission.READ_CALL_LOG", PERMISSION_USER_FIXED);
688 
689     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_CALENDAR");
690     ASSERT_EQ(PERMISSION_GRANTED, ret);
691     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.MEDIA_LOCATION");
692     ASSERT_EQ(PERMISSION_DENIED, ret);
693     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE");
694     ASSERT_EQ(PERMISSION_GRANTED, ret);
695     ret = AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_CALL_LOG");
696     ASSERT_EQ(PERMISSION_GRANTED, ret);
697 
698     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
699     ASSERT_EQ(RET_SUCCESS, ret);
700     GTEST_LOG_(INFO) << "remove the token info";
701 }
702 #endif
703 
704 /**
705  * @tc.name: ScopeFilter001
706  * @tc.desc: Test filter scopes.
707  * @tc.type: FUNC
708  * @tc.require: issueI4V02P
709  */
HWTEST_F(PermissionManagerTest, ScopeFilter001, TestSize.Level1)710 HWTEST_F(PermissionManagerTest, ScopeFilter001, TestSize.Level1)
711 {
712     AccessTokenIDEx tokenIdEx = {0};
713     AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
714         g_infoManagerTestPolicyPrams1, tokenIdEx);
715 
716     tokenIdEx = AccessTokenInfoManager::GetInstance().GetHapTokenID(g_infoManagerTestInfoParms.userID,
717         g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
718     AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
719     EXPECT_NE(0, static_cast<int32_t>(tokenId));
720     PermStateChangeScope inScopeInfo;
721     PermStateChangeScope outScopeInfo;
722     PermStateChangeScope emptyScopeInfo;
723 
724     // both empty
725     inScopeInfo.permList = {};
726     inScopeInfo.tokenIDs = {};
727     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
728 
729     outScopeInfo = emptyScopeInfo;
730     inScopeInfo.tokenIDs = {123};
731     EXPECT_EQ(ERR_PARAM_INVALID,
732         PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
733     EXPECT_EQ(true, outScopeInfo.tokenIDs.empty());
734 
735     outScopeInfo = emptyScopeInfo;
736     inScopeInfo.tokenIDs.clear();
737     inScopeInfo.tokenIDs = {123, tokenId, tokenId};
738     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
739     EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.tokenIDs.size()));
740 
741     outScopeInfo = emptyScopeInfo;
742     inScopeInfo.tokenIDs.clear();
743     inScopeInfo.permList = {"ohos.permission.test_scopeFilter"};
744     EXPECT_EQ(ERR_PARAM_INVALID,
745         PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
746     EXPECT_EQ(true, outScopeInfo.permList.empty());
747 
748     outScopeInfo = emptyScopeInfo;
749     inScopeInfo.permList.clear();
750     inScopeInfo.permList = {"ohos.permission.test_scopeFilter", "ohos.permission.CAMERA", "ohos.permission.CAMERA"};
751     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
752     EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.permList.size()));
753 
754     outScopeInfo = emptyScopeInfo;
755     inScopeInfo.permList.clear();
756     inScopeInfo.tokenIDs = {123, tokenId, tokenId};
757     inScopeInfo.permList = {"ohos.permission.test_scopeFilter", "ohos.permission.CAMERA", "ohos.permission.CAMERA"};
758     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().ScopeFilter(inScopeInfo, outScopeInfo));
759     EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.tokenIDs.size()));
760     EXPECT_EQ(1, static_cast<int32_t>(outScopeInfo.permList.size()));
761 
762     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
763 }
764 
765 /**
766  * @tc.name: AddPermStateChangeCallback001
767  * @tc.desc: Test AddPermStateChangeCallback.
768  * @tc.type: FUNC
769  * @tc.require: issueI4V02P
770  */
HWTEST_F(PermissionManagerTest, AddPermStateChangeCallback001, TestSize.Level1)771 HWTEST_F(PermissionManagerTest, AddPermStateChangeCallback001, TestSize.Level1)
772 {
773     PermStateChangeScope inScopeInfo;
774     inScopeInfo.tokenIDs = {123};
775 
776     EXPECT_EQ(ERR_PARAM_INVALID,
777         PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, nullptr));
778 
779     inScopeInfo.permList = {"ohos.permission.CAMERA"};
780     EXPECT_EQ(ERR_PARAM_INVALID,
781         PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, nullptr));
782     EXPECT_EQ(ERR_PARAM_INVALID,
783         PermissionManager::GetInstance().RemovePermStateChangeCallback(nullptr));
784 }
785 
786 class PermChangeCallback : public PermissionStateChangeCallbackStub {
787 public:
788     PermChangeCallback() = default;
789     virtual ~PermChangeCallback() = default;
790 
791     void PermStateChangeCallback(PermStateChangeInfo& result) override;
792 };
793 
PermStateChangeCallback(PermStateChangeInfo& result)794 void PermChangeCallback::PermStateChangeCallback(PermStateChangeInfo& result)
795 {
796 }
797 
798 /**
799  * @tc.name: AddPermStateChangeCallback002
800  * @tc.desc: Test AddPermStateChangeCallback with exceed limitation.
801  * @tc.type: FUNC
802  * @tc.require: issueI4V02P
803  */
HWTEST_F(PermissionManagerTest, AddPermStateChangeCallback002, TestSize.Level1)804 HWTEST_F(PermissionManagerTest, AddPermStateChangeCallback002, TestSize.Level1)
805 {
806     PermStateChangeScope inScopeInfo;
807     inScopeInfo.tokenIDs = {};
808     inScopeInfo.permList = {"ohos.permission.CAMERA"};
809     std::vector<sptr<PermChangeCallback>> callbacks;
810 
811     for (size_t i = 0; i < MAX_CALLBACK_SIZE; ++i) {
812         sptr<PermChangeCallback> callback = new (std::nothrow) PermChangeCallback();
813         ASSERT_NE(nullptr, callback);
814         ASSERT_EQ(RET_SUCCESS,
815             PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, callback->AsObject()));
816         callbacks.emplace_back(callback);
817     }
818 
819     sptr<PermChangeCallback> callback = new (std::nothrow) PermChangeCallback();
820     ASSERT_NE(nullptr, callback);
821     ASSERT_NE(RET_SUCCESS,
822         PermissionManager::GetInstance().AddPermStateChangeCallback(inScopeInfo, callback->AsObject()));
823 
824     for (size_t i = 0; i < callbacks.size(); ++i) {
825         ASSERT_EQ(RET_SUCCESS,
826             PermissionManager::GetInstance().RemovePermStateChangeCallback(callbacks[i]->AsObject()));
827     }
828 }
829 
830 /**
831  * @tc.name: GrantPermission001
832  * @tc.desc: Test GrantPermission abnormal branch.
833  * @tc.type: FUNC
834  * @tc.require: issueI5SSXG
835  */
HWTEST_F(PermissionManagerTest, GrantPermission001, TestSize.Level1)836 HWTEST_F(PermissionManagerTest, GrantPermission001, TestSize.Level1)
837 {
838     int32_t ret;
839     AccessTokenID tokenID = 0;
840     ret = PermissionManager::GetInstance().GrantPermission(tokenID, "", PERMISSION_USER_FIXED);
841     ASSERT_EQ(ERR_PARAM_INVALID, ret);
842     ret = PermissionManager::GetInstance().GrantPermission(tokenID, "ohos.perm", PERMISSION_USER_FIXED);
843     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret);
844     uint32_t invalidFlag = -1;
845     ret = PermissionManager::GetInstance().GrantPermission(tokenID, "ohos.permission.CAMERA", invalidFlag);
846     ASSERT_EQ(ERR_PARAM_INVALID, ret);
847 }
848 
849 /**
850  * @tc.name: RevokePermission001
851  * @tc.desc: Test RevokePermission abnormal branch.
852  * @tc.type: FUNC
853  * @tc.require: issueI5SSXG
854  */
HWTEST_F(PermissionManagerTest, RevokePermission001, TestSize.Level1)855 HWTEST_F(PermissionManagerTest, RevokePermission001, TestSize.Level1)
856 {
857     int32_t ret;
858     AccessTokenID tokenID = 0;
859     ret = PermissionManager::GetInstance().RevokePermission(tokenID, "", PERMISSION_USER_FIXED);
860     ASSERT_EQ(ERR_PARAM_INVALID, ret);
861     ret = PermissionManager::GetInstance().RevokePermission(tokenID, "ohos.perm", PERMISSION_USER_FIXED);
862     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret);
863     uint32_t invalidFlag = -1;
864     ret = PermissionManager::GetInstance().RevokePermission(tokenID, "ohos.permission.CAMERA", invalidFlag);
865     ASSERT_EQ(ERR_PARAM_INVALID, ret);
866 }
867 
868 /**
869  * @tc.name: GetDefPermission001
870  * @tc.desc: GetDefPermission with invalid permission
871  * @tc.type: FUNC
872  * @tc.require:
873  */
HWTEST_F(PermissionManagerTest, GetDefPermission001, TestSize.Level1)874 HWTEST_F(PermissionManagerTest, GetDefPermission001, TestSize.Level1)
875 {
876     std::string permissionName;
877     PermissionDef permissionDefResult;
878 
879     // permissionName is empty
880     ASSERT_EQ(
881         ERR_PARAM_INVALID, PermissionManager::GetInstance().GetDefPermission(permissionName, permissionDefResult));
882 
883     // permissionName is not tmpty, but invalid
884     permissionName = "invalid permisiion";
885     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST,
886         PermissionManager::GetInstance().GetDefPermission(permissionName, permissionDefResult));
887 }
888 
889 /**
890  * @tc.name: GetDefPermission002
891  * @tc.desc: GetDefPermission with valid permission
892  * @tc.type: FUNC
893  * @tc.require:
894  */
HWTEST_F(PermissionManagerTest, GetDefPermission002, TestSize.Level1)895 HWTEST_F(PermissionManagerTest, GetDefPermission002, TestSize.Level1)
896 {
897     std::string permissionName = "ohos.permission.CAMERA";
898     PermissionDef permissionDefResult;
899 
900     // permissionName invalid
901     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetDefPermission(permissionName, permissionDefResult));
902 }
903 
904 /**
905  * @tc.name: GetDefPermissions001
906  * @tc.desc: GetDefPermissions with invalid tokenid
907  * @tc.type: FUNC
908  * @tc.require:
909  */
HWTEST_F(PermissionManagerTest, GetDefPermissions001, TestSize.Level1)910 HWTEST_F(PermissionManagerTest, GetDefPermissions001, TestSize.Level1)
911 {
912     std::vector<PermissionDef> result;
913 
914     // permissionName is empty
915     ASSERT_EQ(ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().GetDefPermissions(0, result));
916     ASSERT_TRUE(result.empty());
917 }
918 
919 /**
920  * @tc.name: GetDefPermissions002
921  * @tc.desc: GetDefPermissions with valid tokenid
922  * @tc.type: FUNC
923  * @tc.require:
924  */
HWTEST_F(PermissionManagerTest, GetDefPermissions002, TestSize.Level1)925 HWTEST_F(PermissionManagerTest, GetDefPermissions002, TestSize.Level1)
926 {
927     AccessTokenIDEx tokenIdEx = {0};
928     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
929         g_infoManagerTestPolicyPrams1, tokenIdEx);
930     ASSERT_EQ(RET_SUCCESS, ret);
931 
932     std::vector<PermissionDef> result;
933     AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
934     // permissionName is empty
935     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetDefPermissions(tokenId, result));
936     ASSERT_TRUE(!result.empty());
937 
938     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
939     ASSERT_EQ(RET_SUCCESS, ret);
940 }
941 
942 /**
943  * @tc.name: GetReqPermissions001
944  * @tc.desc: GetReqPermissions with invalid tokenid
945  * @tc.type: FUNC
946  * @tc.require:
947  */
HWTEST_F(PermissionManagerTest, GetReqPermissions001, TestSize.Level1)948 HWTEST_F(PermissionManagerTest, GetReqPermissions001, TestSize.Level1)
949 {
950     std::vector<PermissionStateFull> result;
951 
952     // permissionName is empty
953     ASSERT_EQ(ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().GetReqPermissions(0, result, true));
954     ASSERT_TRUE(result.empty());
955 }
956 
957 /**
958  * @tc.name: GetReqPermissions002
959  * @tc.desc: GetReqPermissions with valid tokenid
960  * @tc.type: FUNC
961  * @tc.require:
962  */
HWTEST_F(PermissionManagerTest, GetReqPermissions002, TestSize.Level1)963 HWTEST_F(PermissionManagerTest, GetReqPermissions002, TestSize.Level1)
964 {
965     AccessTokenIDEx tokenIdEx = {0};
966     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(g_infoManagerTestInfoParms,
967         g_infoManagerTestPolicyPrams1, tokenIdEx);
968     ASSERT_EQ(RET_SUCCESS, ret);
969 
970     std::vector<PermissionStateFull> result;
971     AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
972     // permissionName is empty
973     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetReqPermissions(tokenId, result, true));
974 
975     ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID);
976     ASSERT_EQ(RET_SUCCESS, ret);
977 }
978 
979 /**
980  * @tc.name: GetSelfPermissionState001
981  * @tc.desc: PermissionManager::GetSelfPermissionState function test
982  * @tc.type: FUNC
983  * @tc.require:
984  */
HWTEST_F(PermissionManagerTest, GetSelfPermissionState001, TestSize.Level1)985 HWTEST_F(PermissionManagerTest, GetSelfPermissionState001, TestSize.Level1)
986 {
987     std::vector<PermissionStateFull> permsList1;
988     permsList1.emplace_back(g_permState1);
989     PermissionListState permState1;
990     permState1.permissionName = "ohos.permission.GetSelfPermissionStateTest";
991     int32_t apiVersion = ACCURATE_LOCATION_API_VERSION;
992 
993     // permissionName no definition
994     PermissionManager::GetInstance().GetSelfPermissionState(permsList1, permState1, apiVersion);
995     ASSERT_EQ(PermissionOper::INVALID_OPER, permState1.state);
996 
997     std::vector<PermissionStateFull> permsList2;
998     permsList2.emplace_back(g_permState2);
999     PermissionListState permState2;
1000     permState2.permissionName = "ohos.permission.CAMERA";
1001 
1002     // flag not PERMISSION_DEFAULT_FLAG、PERMISSION_USER_SET or PERMISSION_USER_FIXED
1003     PermissionManager::GetInstance().GetSelfPermissionState(permsList2, permState2, apiVersion);
1004     ASSERT_EQ(PermissionOper::PASS_OPER, permState2.state);
1005 }
1006 
1007 /**
1008  * @tc.name: GetSelfPermissionState002
1009  * @tc.desc: PermissionManager::GetSelfPermissionState function test
1010  * @tc.type: FUNC
1011  * @tc.require:
1012  */
HWTEST_F(PermissionManagerTest, GetSelfPermissionState002, TestSize.Level1)1013 HWTEST_F(PermissionManagerTest, GetSelfPermissionState002, TestSize.Level1)
1014 {
1015     std::vector<PermissionStateFull> permsList1;
1016     permsList1.emplace_back(g_permState6);
1017     PermissionListState permState1;
1018     permState1.permissionName = "ohos.permission.CAMERA";
1019     int32_t apiVersion = ACCURATE_LOCATION_API_VERSION;
1020 
1021     // flag is PERMISSION_POLICY_FIXED and state is denied, return SETTING_OPER
1022     PermissionManager::GetInstance().GetSelfPermissionState(permsList1, permState1, apiVersion);
1023     ASSERT_EQ(PermissionOper::SETTING_OPER, permState1.state);
1024 
1025     std::vector<PermissionStateFull> permsList2;
1026     permsList2.emplace_back(g_permState7);
1027     PermissionListState permState2;
1028     permState2.permissionName = "ohos.permission.CAMERA";
1029 
1030     // flag is PERMISSION_POLICY_FIXED and state is granted, return PASS_OPER
1031     PermissionManager::GetInstance().GetSelfPermissionState(permsList2, permState2, apiVersion);
1032     ASSERT_EQ(PermissionOper::PASS_OPER, permState2.state);
1033 
1034     std::vector<PermissionStateFull> permsList3;
1035     permsList3.emplace_back(g_permState8);
1036     PermissionListState permState3;
1037     permState3.permissionName = "ohos.permission.CAMERA";
1038 
1039     // flag is PERMISSION_POLICY_FIXED | PERMISSION_USER_SET and state is denied, return SETTING_OPER
1040     PermissionManager::GetInstance().GetSelfPermissionState(permsList3, permState3, apiVersion);
1041     ASSERT_EQ(PermissionOper::SETTING_OPER, permState3.state);
1042 
1043     std::vector<PermissionStateFull> permsList4;
1044     permsList4.emplace_back(g_permState9);
1045     PermissionListState permState4;
1046     permState4.permissionName = "ohos.permission.CAMERA";
1047 
1048     // flag is PERMISSION_POLICY_FIXED | PERMISSION_USER_SET and state is granted, return PASS_OPER
1049     PermissionManager::GetInstance().GetSelfPermissionState(permsList4, permState4, apiVersion);
1050     ASSERT_EQ(PermissionOper::PASS_OPER, permState4.state);
1051 }
1052 
1053 /**
1054  * @tc.name: GetSelfPermissionState003
1055  * @tc.desc: PermissionManager::GetSelfPermissionState function test
1056  * @tc.type: FUNC
1057  * @tc.require:
1058  */
HWTEST_F(PermissionManagerTest, GetSelfPermissionState003, TestSize.Level1)1059 HWTEST_F(PermissionManagerTest, GetSelfPermissionState003, TestSize.Level1)
1060 {
1061     std::vector<PermissionStateFull> permsList1;
1062     permsList1.emplace_back(g_permState2);
1063     std::string permissionName = "ohos.permission.CAMERA";
1064     uint32_t oriStatus;
1065     PermissionManager::GetInstance().GetPermissionRequestToggleStatus(permissionName, oriStatus, 0);
1066 
1067     PermissionManager::GetInstance().SetPermissionRequestToggleStatus(permissionName,
1068         PermissionRequestToggleStatus::CLOSED, 0);
1069     uint32_t status;
1070     PermissionManager::GetInstance().GetPermissionRequestToggleStatus(permissionName, status, 0);
1071     ASSERT_EQ(PermissionRequestToggleStatus::CLOSED, status);
1072 
1073     PermissionManager::GetInstance().SetPermissionRequestToggleStatus(permissionName, oriStatus, 0);
1074 }
1075 
1076 /**
1077  * @tc.name: SetPermissionRequestToggleStatus001
1078  * @tc.desc: PermissionManager::SetPermissionRequestToggleStatus function test with invalid permissionName, invalid
1079  * status and invalid userID.
1080  * @tc.type: FUNC
1081  * @tc.require:
1082  */
HWTEST_F(PermissionManagerTest, SetPermissionRequestToggleStatus001, TestSize.Level1)1083 HWTEST_F(PermissionManagerTest, SetPermissionRequestToggleStatus001, TestSize.Level1)
1084 {
1085     int32_t userID = -1;
1086     uint32_t status = PermissionRequestToggleStatus::CLOSED;
1087     std::string permissionName = "ohos.permission.CAMERA";
1088 
1089     // UserId is invalid.
1090     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1091         permissionName, status, userID));
1092 
1093     // Permission name is invalid.
1094     userID = 123;
1095     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1096         "", status, userID));
1097 
1098     // PermissionName is not defined.
1099     permissionName = "ohos.permission.invalid";
1100     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1101         permissionName, status, userID));
1102 
1103     // Permission is system_grant.
1104     permissionName = "ohos.permission.USE_BLUETOOTH";
1105     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1106         permissionName, status, userID));
1107 
1108     // Status is invalid.
1109     status = -1;
1110     permissionName = "ohos.permission.CAMERA";
1111     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1112         permissionName, status, userID));
1113 }
1114 
1115 /**
1116  * @tc.name: SetPermissionRequestToggleStatus002
1117  * @tc.desc: PermissionManager::SetPermissionRequestToggleStatus function test with normal process.
1118  * @tc.type: FUNC
1119  * @tc.require:
1120  */
HWTEST_F(PermissionManagerTest, SetPermissionRequestToggleStatus002, TestSize.Level1)1121 HWTEST_F(PermissionManagerTest, SetPermissionRequestToggleStatus002, TestSize.Level1)
1122 {
1123     int32_t userID = 123;
1124     uint32_t status = PermissionRequestToggleStatus::CLOSED;
1125     std::string permissionName = "ohos.permission.CAMERA";
1126 
1127     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1128         permissionName, status, userID));
1129 
1130     status = PermissionRequestToggleStatus::OPEN;
1131     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1132         permissionName, status, userID));
1133 }
1134 
1135 /**
1136  * @tc.name: GetPermissionRequestToggleStatus001
1137  * @tc.desc: PermissionManager::GetPermissionRequestToggleStatus function test with invalid userID, invalid permission
1138  * name.
1139  * @tc.type: FUNC
1140  * @tc.require:
1141  */
HWTEST_F(PermissionManagerTest, GetPermissionRequestToggleStatus001, TestSize.Level1)1142 HWTEST_F(PermissionManagerTest, GetPermissionRequestToggleStatus001, TestSize.Level1)
1143 {
1144     int32_t userID = -1;
1145     uint32_t status;
1146     std::string permissionName = "ohos.permission.CAMERA";
1147 
1148     // UserId is invalid.
1149     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1150         permissionName, status, userID));
1151 
1152     // PermissionName is invalid.
1153     userID = 123;
1154     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1155         "", status, userID));
1156 
1157     // PermissionName is not defined.
1158     permissionName = "ohos.permission.invalid";
1159     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1160         permissionName, status, userID));
1161 
1162     // Permission is system_grant.
1163     permissionName = "ohos.permission.USE_BLUETOOTH";
1164     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1165         permissionName, status, userID));
1166 }
1167 
1168 /**
1169  * @tc.name: GetPermissionRequestToggleStatus002
1170  * @tc.desc: PermissionManager::GetPermissionRequestToggleStatus function test with normal process.
1171  * @tc.type: FUNC
1172  * @tc.require:
1173  */
HWTEST_F(PermissionManagerTest, GetPermissionRequestToggleStatus002, TestSize.Level1)1174 HWTEST_F(PermissionManagerTest, GetPermissionRequestToggleStatus002, TestSize.Level1)
1175 {
1176     int32_t userID = 123;
1177     uint32_t setStatusClose = PermissionRequestToggleStatus::CLOSED;
1178     uint32_t setStatusOpen = PermissionRequestToggleStatus::OPEN;
1179     uint32_t getStatus;
1180 
1181     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1182         "ohos.permission.CAMERA", getStatus, userID));
1183 
1184     ASSERT_EQ(setStatusOpen, getStatus);
1185 
1186     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1187         "ohos.permission.CAMERA", setStatusClose, userID));
1188 
1189     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1190         "ohos.permission.CAMERA", getStatus, userID));
1191 
1192     ASSERT_EQ(setStatusClose, getStatus);
1193 
1194     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().SetPermissionRequestToggleStatus(
1195         "ohos.permission.CAMERA", setStatusOpen, userID));
1196 
1197     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GetPermissionRequestToggleStatus(
1198         "ohos.permission.CAMERA", getStatus, userID));
1199 
1200     ASSERT_EQ(setStatusOpen, getStatus);
1201 }
1202 
1203 /**
1204  * @tc.name: GetPermissionFlag001
1205  * @tc.desc: PermissionManager::GetPermissionFlag function test
1206  * @tc.type: FUNC
1207  * @tc.require:
1208  */
HWTEST_F(PermissionManagerTest, GetPermissionFlag001, TestSize.Level1)1209 HWTEST_F(PermissionManagerTest, GetPermissionFlag001, TestSize.Level1)
1210 {
1211     AccessTokenID tokenID = 123; // 123 is random input
1212     std::string permissionName;
1213     uint32_t flag = 0;
1214 
1215     // permissionName invalid
1216     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().GetPermissionFlag(tokenID,
1217         permissionName, flag));
1218 
1219     permissionName = "ohos.permission.invalid";
1220     // permissionName is not defined
1221     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, PermissionManager::GetInstance().GetPermissionFlag(tokenID,
1222         permissionName, flag));
1223 
1224     permissionName = "ohos.permission.CAMERA";
1225     // tokenid in not exits
1226     ASSERT_EQ(ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().GetPermissionFlag(tokenID,
1227         permissionName, flag));
1228 }
1229 
1230 /**
1231  * @tc.name: GetPermissionFlag002
1232  * @tc.desc: PermissionManager::GetPermissionFlag function test
1233  * @tc.type: FUNC
1234  * @tc.require:
1235  */
HWTEST_F(PermissionManagerTest, GetPermissionFlag002, TestSize.Level1)1236 HWTEST_F(PermissionManagerTest, GetPermissionFlag002, TestSize.Level1)
1237 {
1238     HapInfoParams infoParms = {
1239         .userID = 1,
1240         .bundleName = "accesstoken_test",
1241         .instIndex = 0,
1242         .appIDDesc = "testtesttesttest"
1243     };
1244     PermissionStateFull permStat = {
1245         .permissionName = "ohos.permission.CAMERA",
1246         .isGeneral = true,
1247         .resDeviceID = {"dev-001"},
1248         .grantStatus = {PermissionState::PERMISSION_DENIED},
1249         .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
1250     };
1251     HapPolicyParams policyPrams = {
1252         .apl = APL_NORMAL,
1253         .domain = "test.domain",
1254         .permList = {},
1255         .permStateList = {permStat}
1256     };
1257     AccessTokenIDEx tokenIdEx = {0};
1258     int32_t ret = AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(infoParms, policyPrams, tokenIdEx);
1259     ASSERT_EQ(RET_SUCCESS, ret);
1260     AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1261     uint32_t flag;
1262     ASSERT_EQ(ERR_PERMISSION_NOT_EXIST,
1263         PermissionManager::GetInstance().GetPermissionFlag(tokenId, "ohos.permission.LOCATION", flag));
1264 
1265     ASSERT_EQ(RET_SUCCESS,
1266         PermissionManager::GetInstance().GetPermissionFlag(tokenId, permStat.permissionName, flag));
1267 
1268     // delete test token
1269     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
1270 }
1271 
1272 /**
1273  * @tc.name: UpdateTokenPermissionState002
1274  * @tc.desc: PermissionManager::UpdateTokenPermissionState function test
1275  * @tc.type: FUNC
1276  * @tc.require:
1277  */
HWTEST_F(PermissionManagerTest, UpdateTokenPermissionState002, TestSize.Level1)1278 HWTEST_F(PermissionManagerTest, UpdateTokenPermissionState002, TestSize.Level1)
1279 {
1280     AccessTokenID tokenId = 123; // random input
1281     std::string permissionName = "ohos.permission.DUMP";
1282     bool isGranted = false;
1283     uint32_t flag = 0;
1284     // tokenId invalid
1285     ASSERT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, PermissionManager::GetInstance().UpdateTokenPermissionState(
1286         tokenId, permissionName, isGranted, flag, true));
1287 
1288     HapInfoParams info = {
1289         .userID = USER_ID,
1290         .bundleName = "permission_manager_test",
1291         .instIndex = INST_INDEX,
1292         .appIDDesc = "permission_manager_test"
1293     };
1294     HapPolicyParams policy = {
1295         .apl = APL_NORMAL,
1296         .domain = "domain"
1297     };
1298     AccessTokenIDEx tokenIdEx = {0};
1299     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
1300     ASSERT_NE(static_cast<AccessTokenID>(0), tokenIdEx.tokenIdExStruct.tokenID);
1301     tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1302 
1303     std::shared_ptr<HapTokenInfoInner> infoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
1304     infoPtr->SetRemote(true);
1305     // remote token is true
1306     ASSERT_EQ(AccessTokenError::ERR_IDENTITY_CHECK_FAILED, PermissionManager::GetInstance().UpdateTokenPermissionState(
1307         tokenId, permissionName, isGranted, flag, true));
1308     infoPtr->SetRemote(false);
1309 
1310     // permission not in list
1311     ASSERT_EQ(ERR_PARAM_INVALID, PermissionManager::GetInstance().UpdateTokenPermissionState(tokenId,
1312         permissionName, isGranted, flag, true));
1313 
1314     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
1315 }
1316 
1317 /**
1318  * @tc.name: UpdateTokenPermissionState003
1319  * @tc.desc: PermissionManager::UpdateTokenPermissionState function test
1320  * @tc.type: FUNC
1321  * @tc.require:
1322  */
HWTEST_F(PermissionManagerTest, UpdateTokenPermissionState003, TestSize.Level1)1323 HWTEST_F(PermissionManagerTest, UpdateTokenPermissionState003, TestSize.Level1)
1324 {
1325     std::string permissionName = "ohos.permission.DUMP";
1326     uint32_t flag = 0;
1327 
1328     HapInfoParams info = {
1329         .userID = USER_ID,
1330         .bundleName = "permission_manager_test",
1331         .instIndex = INST_INDEX,
1332         .appIDDesc = "permission_manager_test"
1333     };
1334     PermissionStateFull permStat = {
1335         .permissionName = permissionName,
1336         .isGeneral = true,
1337         .resDeviceID = {"dev-001"},
1338         .grantStatus = {PermissionState::PERMISSION_DENIED},
1339         .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
1340     };
1341     HapPolicyParams policy = {
1342         .apl = APL_NORMAL,
1343         .domain = "domain",
1344         .permStateList = {permStat}
1345     };
1346     AccessTokenIDEx tokenIdEx = {0};
1347     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
1348     ASSERT_NE(static_cast<AccessTokenID>(0), tokenIdEx.tokenIdExStruct.tokenID);
1349     AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1350 
1351     flag = PERMISSION_ALLOW_THIS_TIME;
1352     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().UpdateTokenPermissionState(
1353         tokenId, permissionName, false, flag, true));
1354 
1355     flag = PERMISSION_COMPONENT_SET;
1356     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().UpdateTokenPermissionState(
1357         tokenId, permissionName, false, flag, true));
1358 
1359     flag = PERMISSION_USER_FIXED;
1360     ASSERT_EQ(RET_SUCCESS, PermissionManager::GetInstance().UpdateTokenPermissionState(
1361         tokenId, permissionName, false, flag, true));
1362 
1363     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
1364 }
1365 
1366 /**
1367  * @tc.name: IsAllowGrantTempPermission001
1368  * @tc.desc: PermissionManager::IsAllowGrantTempPermission function test
1369  * @tc.type: FUNC
1370  * @tc.require:
1371  */
HWTEST_F(PermissionManagerTest, IsAllowGrantTempPermission001, TestSize.Level1)1372 HWTEST_F(PermissionManagerTest, IsAllowGrantTempPermission001, TestSize.Level1)
1373 {
1374     AccessTokenID tokenId = 123; // random input
1375     std::string permissionName = "";
1376     // tokenId invalid
1377     ASSERT_EQ(false, TempPermissionObserver::GetInstance().IsAllowGrantTempPermission(tokenId, permissionName));
1378 }
1379 
1380 /**
1381  * @tc.name: IsPermissionVaild001
1382  * @tc.desc: PermissionManager::IsPermissionVaild function test
1383  * @tc.type: FUNC
1384  * @tc.require:
1385  */
HWTEST_F(PermissionManagerTest, IsPermissionVaild001, TestSize.Level1)1386 HWTEST_F(PermissionManagerTest, IsPermissionVaild001, TestSize.Level1)
1387 {
1388     std::string permissionName;
1389     // permissionName invalid
1390     ASSERT_EQ(false, PermissionManager::GetInstance().IsPermissionVaild(permissionName));
1391 
1392     permissionName = "ohos.permission.PERMISSION_MANAGR_TEST";
1393     // no definition
1394     ASSERT_EQ(false, PermissionManager::GetInstance().IsPermissionVaild(permissionName));
1395 
1396     permissionName = "ohos.permission.CAMERA";
1397     ASSERT_EQ(true, PermissionManager::GetInstance().IsPermissionVaild(permissionName));
1398 }
1399 
1400 /**
1401  * @tc.name: GetPermissionStateFull001
1402  * @tc.desc: TempPermissionObserver::GetPermissionStateFull function test
1403  * @tc.type: FUNC
1404  * @tc.require:
1405  */
HWTEST_F(PermissionManagerTest, GetPermissionStateFull001, TestSize.Level1)1406 HWTEST_F(PermissionManagerTest, GetPermissionStateFull001, TestSize.Level1)
1407 {
1408     AccessTokenID tokenId = 123; // random input
1409     std::vector<PermissionStateFull> permissionStateFullList;
1410     // tokenId invalid
1411     ASSERT_EQ(false, TempPermissionObserver::GetInstance().GetPermissionStateFull(tokenId, permissionStateFullList));
1412 
1413     HapInfoParams info = {
1414         .userID = USER_ID,
1415         .bundleName = "permission_manager_test",
1416         .instIndex = INST_INDEX,
1417         .appIDDesc = "permission_manager_test"
1418     };
1419     HapPolicyParams policy = {
1420         .apl = APL_NORMAL,
1421         .domain = "domain"
1422     };
1423     AccessTokenIDEx tokenIdEx = {0};
1424     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().CreateHapTokenInfo(info, policy, tokenIdEx));
1425     ASSERT_NE(static_cast<AccessTokenID>(0), tokenIdEx.tokenIdExStruct.tokenID);
1426     tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1427 
1428     std::shared_ptr<HapTokenInfoInner> infoPtr = AccessTokenInfoManager::GetInstance().GetHapTokenInfoInner(tokenId);
1429     infoPtr->SetRemote(true);
1430     // remote token is true
1431     ASSERT_EQ(false, TempPermissionObserver::GetInstance().GetPermissionStateFull(tokenId, permissionStateFullList));
1432     infoPtr->SetRemote(false);
1433 
1434     ASSERT_EQ(RET_SUCCESS, AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenId));
1435 }
1436 
1437 /**
1438  * @tc.name: GetApiVersionByTokenId001
1439  * @tc.desc: PermissionManager::GetApiVersionByTokenId function test
1440  * @tc.type: FUNC
1441  * @tc.require:
1442  */
HWTEST_F(PermissionManagerTest, GetApiVersionByTokenId001, TestSize.Level1)1443 HWTEST_F(PermissionManagerTest, GetApiVersionByTokenId001, TestSize.Level1)
1444 {
1445     AccessTokenID tokenId = 940572671; // 940572671 is max butt tokenId: 001 11 0 000000 11111111111111111111
1446     int32_t apiVersion = 0;
1447 
1448     // type TOKEN_TYPE_BUTT
1449     ASSERT_EQ(false, PermissionManager::GetInstance().GetApiVersionByTokenId(tokenId, apiVersion));
1450 
1451     tokenId = 537919487; // 537919487 is max hap tokenId: 001 00 0 000000 11111111111111111111
1452     // get token info err
1453     ASSERT_EQ(false, PermissionManager::GetInstance().GetApiVersionByTokenId(tokenId, apiVersion));
1454 }
1455 
1456 /**
1457  * @tc.name: VerifyHapAccessToken001
1458  * @tc.desc: PermissionManager::VerifyHapAccessToken function test
1459  * @tc.type: FUNC
1460  * @tc.require:
1461  */
HWTEST_F(PermissionManagerTest, VerifyHapAccessToken001, TestSize.Level1)1462 HWTEST_F(PermissionManagerTest, VerifyHapAccessToken001, TestSize.Level1)
1463 {
1464     AccessTokenID tokenId = 123; // 123 is random input
1465     std::string permissionName;
1466 
1467     std::shared_ptr<HapTokenInfoInner> hap = std::make_shared<HapTokenInfoInner>();
1468     ASSERT_NE(nullptr, hap);
1469     AccessTokenInfoManager::GetInstance().hapTokenInfoMap_[tokenId] = hap;
1470 
1471     ASSERT_EQ(PermissionState::PERMISSION_DENIED,
1472         PermissionManager::GetInstance().VerifyHapAccessToken(tokenId, permissionName)); // permPolicySet is null
1473 
1474     AccessTokenInfoManager::GetInstance().hapTokenInfoMap_.erase(tokenId);
1475 }
1476 
1477 /**
1478  * @tc.name: GrantTempPermission001
1479  * @tc.desc: Test grant temp permission revoke permission after switching to background
1480  * @tc.type: FUNC
1481  * @tc.require:
1482  */
HWTEST_F(PermissionManagerTest, GrantTempPermission001, TestSize.Level1)1483 HWTEST_F(PermissionManagerTest, GrantTempPermission001, TestSize.Level1)
1484 {
1485     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1486     accessTokenService_->Initialize();
1487     AccessTokenID tokenID = CreateTempHapTokenInfo();
1488     TempPermissionObserver::GetInstance().RegisterCallback();
1489     // change to foreground
1490     AppStateData appStateData;
1491     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
1492     appStateData.accessTokenId = tokenID;
1493     appStateObserver_->OnAppStateChanged(appStateData);
1494     // grant temp permission
1495     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1496         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1497     EXPECT_EQ(PERMISSION_GRANTED,
1498         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1499     // change to background
1500     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1501     appStateData.accessTokenId = tokenID;
1502     appStateObserver_->OnAppStateChanged(appStateData);
1503     EXPECT_EQ(PERMISSION_GRANTED,
1504         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1505     TempPermissionObserver::GetInstance().UnRegisterCallback();
1506     // UnRegisterCallback twice
1507     TempPermissionObserver::GetInstance().UnRegisterCallback();
1508     // remove hap
1509     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1510     ASSERT_EQ(RET_SUCCESS, ret);
1511     GTEST_LOG_(INFO) << "remove the token info";
1512 }
1513 
1514 /**
1515  * @tc.name: GrantTempPermission002
1516  * @tc.desc: Test grant temp permission switching to background and to foreground again
1517  * @tc.type: FUNC
1518  * @tc.require:
1519  */
HWTEST_F(PermissionManagerTest, GrantTempPermission002, TestSize.Level1)1520 HWTEST_F(PermissionManagerTest, GrantTempPermission002, TestSize.Level1)
1521 {
1522     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1523     accessTokenService_->Initialize();
1524     AccessTokenID tokenID = CreateTempHapTokenInfo();
1525     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1526         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1527     EXPECT_EQ(PERMISSION_GRANTED,
1528         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1529     // change to background
1530     AppStateData appStateData;
1531     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1532     appStateData.accessTokenId = tokenID;
1533     appStateObserver_->OnAppStateChanged(appStateData);
1534     EXPECT_EQ(PERMISSION_GRANTED,
1535         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1536     // change to foreground
1537     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
1538     appStateObserver_->OnAppStateChanged(appStateData);
1539     sleep(11);
1540     EXPECT_EQ(PERMISSION_GRANTED,
1541         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1542     // remove hap
1543     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1544     ASSERT_EQ(RET_SUCCESS, ret);
1545     GTEST_LOG_(INFO) << "remove the token info";
1546 }
1547 
1548 /**
1549  * @tc.name: GrantTempPermission003
1550  * @tc.desc: Test grant temp permission switching to background and has a form
1551  * @tc.type: FUNC
1552  * @tc.require:
1553  */
HWTEST_F(PermissionManagerTest, GrantTempPermission003, TestSize.Level1)1554 HWTEST_F(PermissionManagerTest, GrantTempPermission003, TestSize.Level1)
1555 {
1556     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1557     accessTokenService_->Initialize();
1558     AccessTokenID tokenID = CreateTempHapTokenInfo();
1559     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1560         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1561     EXPECT_EQ(PERMISSION_GRANTED,
1562         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1563     // create a form
1564     FormInstance formInstance;
1565     formInstance.bundleName_ = "GrantTempPermission";
1566     formInstance.appIndex_ = 0;
1567     formInstance.userId_ = USER_ID;
1568     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1569     std::vector<FormInstance> formInstances;
1570     formInstances.emplace_back(formInstance);
1571     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
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     // remove hap
1583     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1584     ASSERT_EQ(RET_SUCCESS, ret);
1585     GTEST_LOG_(INFO) << "remove the token info";
1586 }
1587 
1588 /**
1589  * @tc.name: GrantTempPermission004
1590  * @tc.desc: Test grant temp permission switching to background and create a form
1591  * @tc.type: FUNC
1592  * @tc.require:
1593  */
HWTEST_F(PermissionManagerTest, GrantTempPermission004, TestSize.Level1)1594 HWTEST_F(PermissionManagerTest, GrantTempPermission004, TestSize.Level1)
1595 {
1596     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1597     accessTokenService_->Initialize();
1598     AccessTokenID tokenID = CreateTempHapTokenInfo();
1599     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1600         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1601     EXPECT_EQ(PERMISSION_GRANTED,
1602         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1603     // change to background
1604     AppStateData appStateData;
1605     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1606     appStateData.accessTokenId = tokenID;
1607     appStateObserver_->OnAppStateChanged(appStateData);
1608     EXPECT_EQ(PERMISSION_GRANTED,
1609         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1610     // create a form
1611     FormInstance formInstance;
1612     formInstance.bundleName_ = "GrantTempPermission";
1613     formInstance.appIndex_ = 0;
1614     formInstance.userId_ = USER_ID;
1615     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1616     std::vector<FormInstance> formInstances;
1617     formInstances.emplace_back(formInstance);
1618     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1619     sleep(11);
1620     EXPECT_EQ(PERMISSION_GRANTED,
1621         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1622     // remove hap
1623     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1624     ASSERT_EQ(RET_SUCCESS, ret);
1625     GTEST_LOG_(INFO) << "remove the token info";
1626 }
1627 
1628 /**
1629  * @tc.name: GrantTempPermission005
1630  * @tc.desc: Test grant temp permission switching to background and form change to invisible
1631  * @tc.type: FUNC
1632  * @tc.require:
1633  */
HWTEST_F(PermissionManagerTest, GrantTempPermission005, TestSize.Level1)1634 HWTEST_F(PermissionManagerTest, GrantTempPermission005, TestSize.Level1)
1635 {
1636     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1637     accessTokenService_->Initialize();
1638     AccessTokenID tokenID = CreateTempHapTokenInfo();
1639     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1640         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1641     EXPECT_EQ(PERMISSION_GRANTED,
1642         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1643     // change to background
1644     AppStateData appStateData;
1645     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1646     appStateData.accessTokenId = tokenID;
1647     appStateObserver_->OnAppStateChanged(appStateData);
1648     EXPECT_EQ(PERMISSION_GRANTED,
1649         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1650     // create a form
1651     FormInstance formInstance;
1652     formInstance.bundleName_ = "GrantTempPermission";
1653     formInstance.appIndex_ = 0;
1654     formInstance.userId_ = USER_ID;
1655     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1656     std::vector<FormInstance> formInstances;
1657     formInstances.emplace_back(formInstance);
1658     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1659     EXPECT_EQ(PERMISSION_GRANTED,
1660         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1661     // form invisible
1662     formInstances.clear();
1663     formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1664     formInstances.emplace_back(formInstance);
1665     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances);
1666     sleep(11);
1667     EXPECT_EQ(PERMISSION_DENIED,
1668         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1669     // remove hap
1670     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1671     ASSERT_EQ(RET_SUCCESS, ret);
1672     GTEST_LOG_(INFO) << "remove the token info";
1673 }
1674 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
1675 /**
1676  * @tc.name: GrantTempPermission006
1677  * @tc.desc: Test grant temp permission switching to background and have a background task
1678  * @tc.type: FUNC
1679  * @tc.require:
1680  */
HWTEST_F(PermissionManagerTest, GrantTempPermission006, TestSize.Level1)1681 HWTEST_F(PermissionManagerTest, GrantTempPermission006, TestSize.Level1)
1682 {
1683     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1684     accessTokenService_->Initialize();
1685     AccessTokenID tokenID = CreateTempHapTokenInfo();
1686     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1687         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1688     EXPECT_EQ(PERMISSION_GRANTED,
1689         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1690     // create background task
1691     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1692         = std::make_shared<ContinuousTaskCallbackInfo>();
1693     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1694     continuousTaskCallbackInfo->tokenId_ = tokenID;
1695     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1696     // change to background
1697     AppStateData appStateData;
1698     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1699     appStateData.accessTokenId = tokenID;
1700     appStateObserver_->OnAppStateChanged(appStateData);
1701     EXPECT_EQ(PERMISSION_GRANTED,
1702         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1703     sleep(11);
1704     EXPECT_EQ(PERMISSION_GRANTED,
1705         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1706     // remove hap
1707     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1708     ASSERT_EQ(RET_SUCCESS, ret);
1709     GTEST_LOG_(INFO) << "remove the token info";
1710 }
1711 
1712 /**
1713  * @tc.name: GrantTempPermission007
1714  * @tc.desc: Test grant temp permission switching to background and create a background task
1715  * @tc.type: FUNC
1716  * @tc.require:
1717  */
HWTEST_F(PermissionManagerTest, GrantTempPermission007, TestSize.Level1)1718 HWTEST_F(PermissionManagerTest, GrantTempPermission007, TestSize.Level1)
1719 {
1720     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1721     accessTokenService_->Initialize();
1722     AccessTokenID tokenID = CreateTempHapTokenInfo();
1723     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1724         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1725     EXPECT_EQ(PERMISSION_GRANTED,
1726         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1727     // change to background
1728     AppStateData appStateData;
1729     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1730     appStateData.accessTokenId = tokenID;
1731     appStateObserver_->OnAppStateChanged(appStateData);
1732     // create background task
1733     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1734         = std::make_shared<ContinuousTaskCallbackInfo>();
1735     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1736     continuousTaskCallbackInfo->tokenId_ = tokenID;
1737     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1738     EXPECT_EQ(PERMISSION_GRANTED,
1739         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1740     sleep(11);
1741     EXPECT_EQ(PERMISSION_GRANTED,
1742         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1743     // remove hap
1744     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1745     ASSERT_EQ(RET_SUCCESS, ret);
1746     GTEST_LOG_(INFO) << "remove the token info";
1747 }
1748 
1749 /**
1750  * @tc.name: GrantTempPermission008
1751  * @tc.desc: Test grant temp permission switching to background and remove a background task
1752  * @tc.type: FUNC
1753  * @tc.require:
1754  */
HWTEST_F(PermissionManagerTest, GrantTempPermission008, TestSize.Level1)1755 HWTEST_F(PermissionManagerTest, GrantTempPermission008, TestSize.Level1)
1756 {
1757     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1758     accessTokenService_->Initialize();
1759     AccessTokenID tokenID = CreateTempHapTokenInfo();
1760     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1761         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1762     EXPECT_EQ(PERMISSION_GRANTED,
1763         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1764     // create background task
1765     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1766         = std::make_shared<ContinuousTaskCallbackInfo>();
1767     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1768     continuousTaskCallbackInfo->tokenId_ = tokenID;
1769     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1770     // change to background
1771     AppStateData appStateData;
1772     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1773     appStateData.accessTokenId = tokenID;
1774     appStateObserver_->OnAppStateChanged(appStateData);
1775     EXPECT_EQ(PERMISSION_GRANTED,
1776         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1777     // remove background task
1778     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1779     sleep(11);
1780     EXPECT_EQ(PERMISSION_DENIED,
1781         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1782     // remove hap
1783     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1784     ASSERT_EQ(RET_SUCCESS, ret);
1785     GTEST_LOG_(INFO) << "remove the token info";
1786 }
1787 
1788 /**
1789  * @tc.name: GrantTempPermission009
1790  * @tc.desc: Test grant temp permission switching to background and has a background task and a form
1791  * @tc.type: FUNC
1792  * @tc.require:
1793  */
HWTEST_F(PermissionManagerTest, GrantTempPermission009, TestSize.Level1)1794 HWTEST_F(PermissionManagerTest, GrantTempPermission009, TestSize.Level1)
1795 {
1796     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1797     accessTokenService_->Initialize();
1798     AccessTokenID tokenID = CreateTempHapTokenInfo();
1799     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1800         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1801     EXPECT_EQ(PERMISSION_GRANTED,
1802         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1803     // create background task
1804     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1805         = std::make_shared<ContinuousTaskCallbackInfo>();
1806     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1807     continuousTaskCallbackInfo->tokenId_ = tokenID;
1808     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1809     // create a form
1810     FormInstance formInstance;
1811     formInstance.bundleName_ = "GrantTempPermission";
1812     formInstance.appIndex_ = 0;
1813     formInstance.userId_ = USER_ID;
1814     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1815     std::vector<FormInstance> formInstances;
1816     formInstances.emplace_back(formInstance);
1817     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1818     // change to background
1819     AppStateData appStateData;
1820     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1821     appStateData.accessTokenId = tokenID;
1822     appStateObserver_->OnAppStateChanged(appStateData);
1823     EXPECT_EQ(PERMISSION_GRANTED,
1824         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1825     sleep(11);
1826     EXPECT_EQ(PERMISSION_GRANTED,
1827         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1828     // remove hap
1829     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1830     ASSERT_EQ(RET_SUCCESS, ret);
1831     GTEST_LOG_(INFO) << "remove the token info";
1832 }
1833 
1834 /**
1835  * @tc.name: GrantTempPermission010
1836  * @tc.desc: Test grant temp permission switching to background and has a background task and a form, remove form
1837  * @tc.type: FUNC
1838  * @tc.require:
1839  */
HWTEST_F(PermissionManagerTest, GrantTempPermission010, TestSize.Level1)1840 HWTEST_F(PermissionManagerTest, GrantTempPermission010, TestSize.Level1)
1841 {
1842     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1843     accessTokenService_->Initialize();
1844     AccessTokenID tokenID = CreateTempHapTokenInfo();
1845     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1846         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1847     EXPECT_EQ(PERMISSION_GRANTED,
1848         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1849     // create background task
1850     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1851         = std::make_shared<ContinuousTaskCallbackInfo>();
1852     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1853     continuousTaskCallbackInfo->tokenId_ = tokenID;
1854     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1855     // create a form
1856     FormInstance formInstance;
1857     formInstance.bundleName_ = "GrantTempPermission";
1858     formInstance.appIndex_ = 0;
1859     formInstance.userId_ = USER_ID;
1860     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1861     std::vector<FormInstance> formInstances;
1862     formInstances.emplace_back(formInstance);
1863     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1864     // change to background
1865     AppStateData appStateData;
1866     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1867     appStateData.accessTokenId = tokenID;
1868     appStateObserver_->OnAppStateChanged(appStateData);
1869     EXPECT_EQ(PERMISSION_GRANTED,
1870         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1871     // form change to invisible
1872     formInstances.clear();
1873     formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1874     formInstances.emplace_back(formInstance);
1875     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances);
1876     sleep(11);
1877     EXPECT_EQ(PERMISSION_GRANTED,
1878         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1879     // remove hap
1880     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1881     ASSERT_EQ(RET_SUCCESS, ret);
1882     GTEST_LOG_(INFO) << "remove the token info";
1883 }
1884 
1885 /**
1886  * @tc.name: GrantTempPermission011
1887  * @tc.desc: Test grant temp permission switching to background and has a background task and a form, remove task
1888  * @tc.type: FUNC
1889  * @tc.require:
1890  */
HWTEST_F(PermissionManagerTest, GrantTempPermission011, TestSize.Level1)1891 HWTEST_F(PermissionManagerTest, GrantTempPermission011, TestSize.Level1)
1892 {
1893     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1894     accessTokenService_->Initialize();
1895     AccessTokenID tokenID = CreateTempHapTokenInfo();
1896     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1897         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1898     EXPECT_EQ(PERMISSION_GRANTED,
1899         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1900     // create background task
1901     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1902         = std::make_shared<ContinuousTaskCallbackInfo>();
1903     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1904     continuousTaskCallbackInfo->tokenId_ = tokenID;
1905     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1906     // create a form
1907     FormInstance formInstance;
1908     formInstance.bundleName_ = "GrantTempPermission";
1909     formInstance.appIndex_ = 0;
1910     formInstance.userId_ = USER_ID;
1911     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1912     std::vector<FormInstance> formInstances;
1913     formInstances.emplace_back(formInstance);
1914     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1915     // change to background
1916     AppStateData appStateData;
1917     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1918     appStateData.accessTokenId = tokenID;
1919     appStateObserver_->OnAppStateChanged(appStateData);
1920     EXPECT_EQ(PERMISSION_GRANTED,
1921         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1922     // remove background tast
1923     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1924     sleep(11);
1925     EXPECT_EQ(PERMISSION_GRANTED,
1926         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1927     // remove hap
1928     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1929     ASSERT_EQ(RET_SUCCESS, ret);
1930     GTEST_LOG_(INFO) << "remove the token info";
1931 }
1932 
1933 /**
1934  * @tc.name: GrantTempPermission012
1935  * @tc.desc: Test grant temp permission switching to background and has a background task and a form, remove form&task
1936  * @tc.type: FUNC
1937  * @tc.require:
1938  */
HWTEST_F(PermissionManagerTest, GrantTempPermission012, TestSize.Level1)1939 HWTEST_F(PermissionManagerTest, GrantTempPermission012, TestSize.Level1)
1940 {
1941     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1942     accessTokenService_->Initialize();
1943     AccessTokenID tokenID = CreateTempHapTokenInfo();
1944     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
1945         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
1946     EXPECT_EQ(PERMISSION_GRANTED,
1947         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1948     // create background task
1949     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
1950         = std::make_shared<ContinuousTaskCallbackInfo>();
1951     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
1952     continuousTaskCallbackInfo->tokenId_ = tokenID;
1953     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
1954     // create a form
1955     FormInstance formInstance;
1956     formInstance.bundleName_ = "GrantTempPermission";
1957     formInstance.appIndex_ = 0;
1958     formInstance.userId_ = USER_ID;
1959     formInstance.formVisiblity_ = FormVisibilityType::VISIBLE;
1960     std::vector<FormInstance> formInstances;
1961     formInstances.emplace_back(formInstance);
1962     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::VISIBLE, "#1", formInstances);
1963     // change to background
1964     AppStateData appStateData;
1965     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
1966     appStateData.accessTokenId = tokenID;
1967     appStateObserver_->OnAppStateChanged(appStateData);
1968     EXPECT_EQ(PERMISSION_GRANTED,
1969         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1970     // remove form
1971     formInstances.clear();
1972     formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
1973     formInstances.emplace_back(formInstance);
1974     formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances);
1975     sleep(11);
1976     EXPECT_EQ(PERMISSION_GRANTED,
1977         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1978     // remove background tast
1979     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
1980     sleep(11);
1981     EXPECT_EQ(PERMISSION_DENIED,
1982         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
1983     // remove hap
1984     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
1985     ASSERT_EQ(RET_SUCCESS, ret);
1986     GTEST_LOG_(INFO) << "remove the token info";
1987 }
1988 
1989 /**
1990  * @tc.name: GrantTempPermission013
1991  * @tc.desc: Test grant temp permission, Create multiple continuous task
1992  * @tc.type: FUNC
1993  * @tc.require:
1994  */
HWTEST_F(PermissionManagerTest, GrantTempPermission013, TestSize.Level1)1995 HWTEST_F(PermissionManagerTest, GrantTempPermission013, TestSize.Level1)
1996 {
1997     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
1998     accessTokenService_->Initialize();
1999     AccessTokenID tokenID = CreateTempHapTokenInfo();
2000     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2001         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
2002     EXPECT_EQ(PERMISSION_GRANTED,
2003         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2004     // create background task
2005     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
2006         = std::make_shared<ContinuousTaskCallbackInfo>();
2007     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::DATA_TRANSFER);
2008     continuousTaskCallbackInfo->tokenId_ = tokenID;
2009     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
2010 
2011     // create background task
2012     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo1
2013         = std::make_shared<ContinuousTaskCallbackInfo>();
2014     continuousTaskCallbackInfo1->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
2015     continuousTaskCallbackInfo1->tokenId_ = tokenID;
2016     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo1);
2017 
2018     // change to background
2019     AppStateData appStateData;
2020     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
2021     appStateData.accessTokenId = tokenID;
2022     appStateObserver_->OnAppStateChanged(appStateData);
2023     EXPECT_EQ(PERMISSION_GRANTED,
2024         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2025 
2026     // remove background tast
2027     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
2028     sleep(11);
2029     EXPECT_EQ(PERMISSION_GRANTED,
2030         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2031     // remove background tast
2032     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo1);
2033     sleep(11);
2034     EXPECT_EQ(PERMISSION_DENIED,
2035         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2036     // remove hap
2037     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2038     ASSERT_EQ(RET_SUCCESS, ret);
2039     GTEST_LOG_(INFO) << "remove the token info";
2040 }
2041 
2042 /**
2043  * @tc.name: GrantTempPermission014
2044  * @tc.desc: Test grant temp permission, Create multiple continuous task
2045  * @tc.type: FUNC
2046  * @tc.require:
2047  */
HWTEST_F(PermissionManagerTest, GrantTempPermission014, TestSize.Level1)2048 HWTEST_F(PermissionManagerTest, GrantTempPermission014, TestSize.Level1)
2049 {
2050     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2051     accessTokenService_->Initialize();
2052     AccessTokenID tokenID = CreateTempHapTokenInfo();
2053     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2054         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
2055     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2056         "ohos.permission.READ_PASTEBOARD", PERMISSION_ALLOW_THIS_TIME));
2057     EXPECT_EQ(PERMISSION_GRANTED,
2058         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2059     EXPECT_EQ(PERMISSION_GRANTED,
2060         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_PASTEBOARD"));
2061     // create background task
2062     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
2063         = std::make_shared<ContinuousTaskCallbackInfo>();
2064     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
2065     continuousTaskCallbackInfo->tokenId_ = tokenID;
2066     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
2067 
2068     // change to background
2069     AppStateData appStateData;
2070     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
2071     appStateData.accessTokenId = tokenID;
2072     appStateObserver_->OnAppStateChanged(appStateData);
2073     sleep(11);
2074     EXPECT_EQ(PERMISSION_GRANTED,
2075         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2076     EXPECT_EQ(PERMISSION_DENIED,
2077         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.READ_PASTEBOARD"));
2078     // remove background tast
2079     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
2080     sleep(11);
2081     EXPECT_EQ(PERMISSION_DENIED,
2082         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2083     // remove hap
2084     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2085     ASSERT_EQ(RET_SUCCESS, ret);
2086     GTEST_LOG_(INFO) << "remove the token info";
2087 }
2088 #endif
2089 /**
2090  * @tc.name: GrantTempPermission015
2091  * @tc.desc: Test grant temp permission process died
2092  * @tc.type: FUNC
2093  * @tc.require:
2094  */
HWTEST_F(PermissionManagerTest, GrantTempPermission015, TestSize.Level1)2095 HWTEST_F(PermissionManagerTest, GrantTempPermission015, TestSize.Level1)
2096 {
2097     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2098     accessTokenService_->Initialize();
2099     AccessTokenID tokenID = CreateTempHapTokenInfo();
2100     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2101         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
2102     EXPECT_EQ(PERMISSION_GRANTED,
2103         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2104     AppStateData appStateData;
2105     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_TERMINATED);
2106     appStateData.accessTokenId = tokenID;
2107     appStateObserver_->OnAppStopped(appStateData);
2108     EXPECT_EQ(PERMISSION_DENIED,
2109         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2110     // remove hap
2111     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2112     ASSERT_EQ(RET_SUCCESS, ret);
2113     GTEST_LOG_(INFO) << "remove the token info";
2114 }
2115 
2116 /**
2117  * @tc.name: GrantTempPermission016
2118  * @tc.desc: Test grant & revoke temp permission
2119  * @tc.type: FUNC
2120  * @tc.require:
2121  */
HWTEST_F(PermissionManagerTest, GrantTempPermission016, TestSize.Level1)2122 HWTEST_F(PermissionManagerTest, GrantTempPermission016, TestSize.Level1)
2123 {
2124     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2125     accessTokenService_->Initialize();
2126     AccessTokenID tokenID = CreateTempHapTokenInfo();
2127     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2128         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
2129     EXPECT_EQ(PERMISSION_GRANTED,
2130         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2131     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().RevokePermission(tokenID,
2132         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
2133     EXPECT_EQ(PERMISSION_DENIED,
2134         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2135     // remove hap
2136     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2137     ASSERT_EQ(RET_SUCCESS, ret);
2138     GTEST_LOG_(INFO) << "remove the token info";
2139 }
2140 
2141 /**
2142  * @tc.name: GrantTempPermission017
2143  * @tc.desc: Test grant temp permission not root
2144  * @tc.type: FUNC
2145  * @tc.require:
2146  */
HWTEST_F(PermissionManagerTest, GrantTempPermission017, TestSize.Level1)2147 HWTEST_F(PermissionManagerTest, GrantTempPermission017, TestSize.Level1)
2148 {
2149     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2150     accessTokenService_->Initialize();
2151     AccessTokenID tokenID = CreateTempHapTokenInfo();
2152     setuid(100);
2153     EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, PermissionManager::GetInstance().GrantPermission(tokenID,
2154         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_ALLOW_THIS_TIME));
2155     // remove hap
2156     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2157     ASSERT_EQ(RET_SUCCESS, ret);
2158     GTEST_LOG_(INFO) << "remove the token info";
2159 }
2160 
2161 /**
2162  * @tc.name: GrantTempPermission018
2163  * @tc.desc: Test tokenID not in the list
2164  * @tc.type: FUNC
2165  * @tc.require:
2166  */
HWTEST_F(PermissionManagerTest, GrantTempPermission018, TestSize.Level1)2167 HWTEST_F(PermissionManagerTest, GrantTempPermission018, TestSize.Level1)
2168 {
2169     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2170     accessTokenService_->Initialize();
2171     AccessTokenID tokenID = CreateTempHapTokenInfo();
2172     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2173         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_SYSTEM_FIXED));
2174 
2175     // change to background
2176     AppStateData appStateData;
2177     appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
2178     appStateData.accessTokenId = tokenID;
2179     appStateObserver_->OnAppStateChanged(appStateData);
2180     EXPECT_EQ(PERMISSION_GRANTED,
2181         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2182     FormInstance formInstance;
2183     formInstance.bundleName_ = "GrantTempPermission";
2184     formInstance.appIndex_ = 0;
2185     formInstance.userId_ = USER_ID;
2186     formInstance.formVisiblity_ = FormVisibilityType::INVISIBLE;
2187     std::vector<FormInstance> formInstances;
2188     formInstances.emplace_back(formInstance);
2189     EXPECT_EQ(RET_SUCCESS,
2190         formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances));
2191     EXPECT_EQ(PERMISSION_GRANTED,
2192         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2193 
2194     EXPECT_EQ(RET_SUCCESS,
2195         formStateObserver_->NotifyWhetherFormsVisible(FormVisibilityType::INVISIBLE, "#1", formInstances));
2196     EXPECT_EQ(PERMISSION_GRANTED,
2197         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2198 
2199     // remove hap
2200     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2201     ASSERT_EQ(RET_SUCCESS, ret);
2202     GTEST_LOG_(INFO) << "remove the token info";
2203 }
2204 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
2205 /**
2206  * @tc.name: GrantTempPermission019
2207  * @tc.desc: Test tokenID not in the list
2208  * @tc.type: FUNC
2209  * @tc.require:
2210  */
HWTEST_F(PermissionManagerTest, GrantTempPermission019, TestSize.Level1)2211 HWTEST_F(PermissionManagerTest, GrantTempPermission019, TestSize.Level1)
2212 {
2213     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2214     accessTokenService_->Initialize();
2215     AccessTokenID tokenID = CreateTempHapTokenInfo();
2216     EXPECT_EQ(RET_SUCCESS, PermissionManager::GetInstance().GrantPermission(tokenID,
2217         "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_SYSTEM_FIXED));
2218 
2219     TempPermissionObserver::GetInstance().ModifyAppState(tokenID, 0, false);
2220     // create background task
2221     std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
2222         = std::make_shared<ContinuousTaskCallbackInfo>();
2223     continuousTaskCallbackInfo->typeId_ = static_cast<uint32_t>(BackgroundMode::LOCATION);
2224     continuousTaskCallbackInfo->tokenId_ = tokenID;
2225     backgroundTaskObserver_->OnContinuousTaskStart(continuousTaskCallbackInfo);
2226     EXPECT_EQ(PERMISSION_GRANTED,
2227         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2228 
2229     // remove background tast
2230     backgroundTaskObserver_->OnContinuousTaskStop(continuousTaskCallbackInfo);
2231     EXPECT_EQ(PERMISSION_GRANTED,
2232         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2233 
2234     TempPermissionObserver::GetInstance().RevokeAllTempPermission(tokenID);
2235     EXPECT_EQ(PERMISSION_GRANTED,
2236         AccessTokenInfoManager::GetInstance().VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"));
2237     // remove hap
2238     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2239     ASSERT_EQ(RET_SUCCESS, ret);
2240     GTEST_LOG_(INFO) << "remove the token info";
2241 }
2242 #endif
2243 /**
2244  * @tc.name: GrantTempPermission020
2245  * @tc.desc: Test invalid permissionName
2246  * @tc.type: FUNC
2247  * @tc.require:
2248  */
HWTEST_F(PermissionManagerTest, GrantTempPermission020, TestSize.Level1)2249 HWTEST_F(PermissionManagerTest, GrantTempPermission020, TestSize.Level1)
2250 {
2251     accessTokenService_->state_ = ServiceRunningState::STATE_RUNNING;
2252     accessTokenService_->Initialize();
2253     AccessTokenID tokenID = CreateTempHapTokenInfo();
2254     EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, PermissionManager::GetInstance().GrantPermission(tokenID,
2255         "ohos.permission.MICROPHONE", PERMISSION_ALLOW_THIS_TIME));
2256     TempPermissionObserver::GetInstance().UnRegisterCallback();
2257     // remove hap
2258     int32_t ret = AccessTokenInfoManager::GetInstance().RemoveHapTokenInfo(tokenID);
2259     ASSERT_EQ(RET_SUCCESS, ret);
2260     GTEST_LOG_(INFO) << "remove the token info";
2261 }
2262 
2263 /**
2264  * @tc.name: PermissionCallbackTest001
2265  * @tc.desc: Test nullptr input for callback
2266  * @tc.type: FUNC
2267  * @tc.require:
2268  */
HWTEST_F(PermissionManagerTest, PermissionCallbackTest001, TestSize.Level1)2269 HWTEST_F(PermissionManagerTest, PermissionCallbackTest001, TestSize.Level1)
2270 {
2271     PermStateChangeScope scope;
2272     EXPECT_EQ(AccessTokenError::ERR_PARAM_INVALID, CallbackManager::GetInstance().AddCallback(scope, nullptr));
2273 }
2274 
2275 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
2276 /*
2277  * @tc.name: ContinuousTaskCallbackInfoParcel001
2278  * @tc.desc: ContinuousTaskCallbackInfo::Marshalling | Unmarshalling
2279  * @tc.type: FUNC
2280  * @tc.require:
2281  */
HWTEST_F(PermissionManagerTest, ContinuousTaskCallbackInfoParcel001, TestSize.Level1)2282 HWTEST_F(PermissionManagerTest, ContinuousTaskCallbackInfoParcel001, TestSize.Level1)
2283 {
2284     ContinuousTaskCallbackInfo info;
2285     Parcel parcel;
2286     EXPECT_EQ(true, info.Marshalling(parcel));
2287 
2288     auto p = ContinuousTaskCallbackInfo::Unmarshalling(parcel);
2289     EXPECT_NE(nullptr, p);
2290     EXPECT_EQ(info.typeId_, p->typeId_);
2291     EXPECT_EQ(info.creatorUid_, p->creatorUid_);
2292     EXPECT_EQ(info.creatorPid_, p->creatorPid_);
2293     EXPECT_EQ(info.abilityName_, p->abilityName_);
2294     EXPECT_EQ(info.isFromWebview_, p->isFromWebview_);
2295     EXPECT_EQ(info.isBatchApi_, p->isBatchApi_);
2296     EXPECT_EQ(info.typeIds_, p->typeIds_);
2297     EXPECT_EQ(info.abilityId_, p->abilityId_);
2298     EXPECT_EQ(info.tokenId_, p->tokenId_);
2299 }
2300 #endif
2301 } // namespace AccessToken
2302 } // namespace Security
2303 } // namespace OHOS
2304