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