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 "accesstoken_kit_test.h"
17 #include <thread>
18 #include "access_token_error.h"
19 #include "permission_grant_info.h"
20 
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 namespace Security {
25 namespace AccessToken {
26 namespace {
27 static constexpr int32_t DEFAULT_API_VERSION = 8;
28 HapInfoParams g_infoManagerTestInfoParms = {
29     .userID = 1,
30     .bundleName = "accesstoken_test",
31     .instIndex = 0,
32     .appIDDesc = "test1",
33     .apiVersion = DEFAULT_API_VERSION
34 };
35 HapPolicyParams g_infoManagerTestPolicyPrams = {
36     .apl = APL_NORMAL,
37     .domain = "test.domain",
38 };
39 #ifdef TOKEN_SYNC_ENABLE
40 static const int32_t FAKE_SYNC_RET = 0xabcdef;
41 class TokenSyncCallbackImpl : public TokenSyncKitInterface {
GetRemoteHapTokenInfo(const std::string & deviceID,AccessTokenID tokenID) const42     int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override
43     {
44         return FAKE_SYNC_RET;
45     };
46 
DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const47     int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override
48     {
49         return FAKE_SYNC_RET;
50     };
51 
UpdateRemoteHapTokenInfo(const HapTokenInfoForSync & tokenInfo) const52     int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override
53     {
54         return FAKE_SYNC_RET;
55     };
56 };
57 #endif
58 }
SetUpTestCase()59 void AccessTokenKitTest::SetUpTestCase()
60 {
61 }
62 
TearDownTestCase()63 void AccessTokenKitTest::TearDownTestCase()
64 {
65 }
66 
SetUp()67 void AccessTokenKitTest::SetUp()
68 {
69 }
70 
TearDown()71 void AccessTokenKitTest::TearDown()
72 {
73 }
74 
75 /**
76  * @tc.name: InitHapToken001
77  * @tc.desc: InitHapToken with proxy is null
78  * @tc.type: FUNC
79  * @tc.require:
80  */
81 HWTEST_F(AccessTokenKitTest, InitHapToken001, TestSize.Level1)
82 {
83     AccessTokenIDEx tokenIdEx = {0};
84     int32_t ret = AccessTokenKit::InitHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx);
85     ASSERT_EQ(ret, AccessTokenError::ERR_SERVICE_ABNORMAL);
86 }
87 
88 /**
89  * @tc.name: AllocHapToken001
90  * @tc.desc: AllocHapToken with proxy is null
91  * @tc.type: FUNC
92  * @tc.require:
93  */
94 HWTEST_F(AccessTokenKitTest, AllocHapToken001, TestSize.Level1)
95 {
96     AccessTokenIDEx tokenIdEx = {0};
97     tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
98     ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
99 }
100 
101 /**
102  * @tc.name: AllocLocalTokenID001
103  * @tc.desc: AllocLocalTokenID with proxy is null
104  * @tc.type: FUNC
105  * @tc.require:
106  */
107 HWTEST_F(AccessTokenKitTest, AllocLocalTokenID001, TestSize.Level1)
108 {
109     std::string remoteDevice = "remote device";
110     AccessTokenID tokenId = 123;
111     AccessTokenID localTokenId = AccessTokenKit::AllocLocalTokenID(remoteDevice, tokenId);
112     ASSERT_EQ(INVALID_TOKENID, localTokenId);
113 }
114 
115 /**
116  * @tc.name: UpdateHapToken001
117  * @tc.desc: UpdateHapToken with proxy is null
118  * @tc.type: FUNC
119  * @tc.require:
120  */
121 HWTEST_F(AccessTokenKitTest, UpdateHapToken001, TestSize.Level1)
122 {
123     AccessTokenIDEx tokenIdEx = {0};
124     tokenIdEx.tokenIdExStruct.tokenID = 123;
125     UpdateHapInfoParams info;
126     info.appIDDesc = "appId desc";
127     info.apiVersion = 9;
128     info.isSystemApp = false;
129     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
130         AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams));
131 }
132 
133 /**
134  * @tc.name: DeleteToken001
135  * @tc.desc: DeleteToken with proxy is null
136  * @tc.type: FUNC
137  * @tc.require:
138  */
139 HWTEST_F(AccessTokenKitTest, DeleteToken001, TestSize.Level1)
140 {
141     AccessTokenID tokenId = 123;
142     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteToken(tokenId));
143 }
144 
145 /**
146  * @tc.name: GetTokenType001
147  * @tc.desc: GetTokenType with proxy is null
148  * @tc.type: FUNC
149  * @tc.require:
150  */
151 HWTEST_F(AccessTokenKitTest, GetTokenType001, TestSize.Level1)
152 {
153     AccessTokenID tokenId = 123;
154     ASSERT_EQ(TOKEN_INVALID, AccessTokenKit::GetTokenType(tokenId));
155 }
156 
157 /**
158  * @tc.name: CheckNativeDCap001
159  * @tc.desc: CheckNativeDCap with proxy is null
160  * @tc.type: FUNC
161  * @tc.require:
162  */
163 HWTEST_F(AccessTokenKitTest, CheckNativeDCap001, TestSize.Level1)
164 {
165     AccessTokenID tokenId = 123;
166     const std::string dcap = "AT_CAP";
167     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::CheckNativeDCap(tokenId, dcap));
168 }
169 
170 /**
171  * @tc.name: GetHapTokenID001
172  * @tc.desc: GetHapTokenID with proxy is null
173  * @tc.type: FUNC
174  * @tc.require:
175  */
176 HWTEST_F(AccessTokenKitTest, GetHapTokenID001, TestSize.Level1)
177 {
178     int32_t userID = 0;
179     std::string bundleName = "test";
180     int32_t instIndex = 0;
181     AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
182     ASSERT_EQ(INVALID_TOKENID, tokenId);
183 }
184 
185 /**
186  * @tc.name: GetHapTokenID001
187  * @tc.desc: GetHapTokenIDEx with proxy is null
188  * @tc.type: FUNC
189  * @tc.require:
190  */
191 HWTEST_F(AccessTokenKitTest, GetHapTokenIDEx001, TestSize.Level1)
192 {
193     int32_t userID = 0;
194     std::string bundleName = "test";
195     int32_t instIndex = 0;
196     AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(userID, bundleName, instIndex);
197     ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
198 }
199 
200 /**
201  * @tc.name: GetHapTokenInfo001
202  * @tc.desc: GetHapTokenInfo with proxy is null
203  * @tc.type: FUNC
204  * @tc.require:
205  */
206 HWTEST_F(AccessTokenKitTest, GetHapTokenInfo001, TestSize.Level1)
207 {
208     AccessTokenID tokenId = 123;
209     HapTokenInfo tokenInfo;
210     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo));
211 }
212 
213 /**
214  * @tc.name: GetNativeTokenInfo001
215  * @tc.desc: GetNativeTokenInfo with proxy is null
216  * @tc.type: FUNC
217  * @tc.require:
218  */
219 HWTEST_F(AccessTokenKitTest, GetNativeTokenInfo001, TestSize.Level1)
220 {
221     AccessTokenID tokenId = 805920561; //805920561 is a native tokenId.
222     NativeTokenInfo tokenInfo;
223     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo));
224 }
225 
226 /**
227  * @tc.name: VerifyAccessToken001
228  * @tc.desc: VerifyAccessToken with proxy is null
229  * @tc.type: FUNC
230  * @tc.require:
231  */
232 HWTEST_F(AccessTokenKitTest, VerifyAccessToken001, TestSize.Level1)
233 {
234     AccessTokenID tokenId = 123;
235     std::string permission = "ohos.permission.CAMERA";
236     ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenId, permission));
237     ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenId, permission, true));
238 }
239 
240 /**
241  * @tc.name: VerifyAccessToken002
242  * @tc.desc: VerifyAccessToken with proxy is null
243  * @tc.type: FUNC
244  * @tc.require:
245  */
246 HWTEST_F(AccessTokenKitTest, VerifyAccessToken002, TestSize.Level1)
247 {
248     AccessTokenID callerTokenID = 123;
249     AccessTokenID firstTokenID = 456;
250     std::string permission = "ohos.permission.CAMERA";
251     ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(callerTokenID, firstTokenID, permission));
252     ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(callerTokenID, firstTokenID, permission, true));
253 }
254 
255 /**
256  * @tc.name: GetDefPermission001
257  * @tc.desc: GetDefPermission with proxy is null
258  * @tc.type: FUNC
259  * @tc.require:
260  */
261 HWTEST_F(AccessTokenKitTest, GetDefPermission001, TestSize.Level1)
262 {
263     std::string permission = "ohos.permission.CAMERA";
264     PermissionDef def;
265     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetDefPermission(permission, def));
266 }
267 
268 /**
269  * @tc.name: GetDefPermissions001
270  * @tc.desc: GetDefPermissions with proxy is null
271  * @tc.type: FUNC
272  * @tc.require:
273  */
274 HWTEST_F(AccessTokenKitTest, GetDefPermissions001, TestSize.Level1)
275 {
276     AccessTokenID tokenId = 123;
277     std::vector<PermissionDef> permList;
278     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetDefPermissions(tokenId, permList));
279 }
280 
281 /**
282  * @tc.name: GetReqPermissions001
283  * @tc.desc: GetReqPermissions with proxy is null
284  * @tc.type: FUNC
285  * @tc.require:
286  */
287 HWTEST_F(AccessTokenKitTest, GetReqPermissions001, TestSize.Level1)
288 {
289     AccessTokenID tokenId = 123;
290     std::vector<PermissionStateFull> permList;
291     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetReqPermissions(tokenId, permList, false));
292 }
293 
294 /**
295  * @tc.name: GetPermissionFlag001
296  * @tc.desc: GetPermissionFlag with proxy is null
297  * @tc.type: FUNC
298  * @tc.require:
299  */
300 HWTEST_F(AccessTokenKitTest, GetPermissionFlag001, TestSize.Level1)
301 {
302     AccessTokenID tokenId = 123;
303     std::string permission = "ohos.permission.CAMERA";
304     uint32_t flag;
305     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetPermissionFlag(tokenId, permission, flag));
306 }
307 
308 /**
309  * @tc.name: SetPermissionRequestToggleStatus001
310  * @tc.desc: SetPermissionRequestToggleStatus with proxy is null
311  * @tc.type: FUNC
312  * @tc.require:
313  */
314 HWTEST_F(AccessTokenKitTest, SetPermissionRequestToggleStatus001, TestSize.Level1)
315 {
316     int32_t userID = 123;
317     std::string permission = "ohos.permission.CAMERA";
318     uint32_t status = PermissionRequestToggleStatus::CLOSED;
319     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermissionRequestToggleStatus(permission,
320         status, userID));
321 }
322 
323 /**
324  * @tc.name: GetPermissionRequestToggleStatus001
325  * @tc.desc: GetPermissionRequestToggleStatus with proxy is null
326  * @tc.type: FUNC
327  * @tc.require:
328  */
329 HWTEST_F(AccessTokenKitTest, GetPermissionRequestToggleStatus001, TestSize.Level1)
330 {
331     int32_t userID = 123;
332     std::string permission = "ohos.permission.CAMERA";
333     uint32_t status;
334     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetPermissionRequestToggleStatus(permission,
335         status, userID));
336 }
337 
338 /**
339  * @tc.name: GetSelfPermissionsState001
340  * @tc.desc: GetSelfPermissionsState with proxy is null
341  * @tc.type: FUNC
342  * @tc.require:
343  */
344 HWTEST_F(AccessTokenKitTest, GetSelfPermissionsState001, TestSize.Level1)
345 {
346     std::vector<PermissionListState> permList;
347     PermissionGrantInfo info;
348     ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permList, info));
349 }
350 
351 /**
352  * @tc.name: GetPermissionsStatus001
353  * @tc.desc: GetPermissionsStatus with proxy is null
354  * @tc.type: FUNC
355  * @tc.require:
356  */
357 HWTEST_F(AccessTokenKitTest, GetPermissionsStatus001, TestSize.Level1)
358 {
359     AccessTokenID tokenId = 123;
360     std::vector<PermissionListState> permsList;
361     PermissionListState perm = {
362         .permissionName = "ohos.permission.testPermDef1",
363         .state = SETTING_OPER
364     };
365     permsList.emplace_back(perm);
366     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
367         AccessTokenKit::GetPermissionsStatus(tokenId, permsList));
368 }
369 
370 /**
371  * @tc.name: GrantPermission001
372  * @tc.desc: GrantPermission with proxy is null
373  * @tc.type: FUNC
374  * @tc.require:
375  */
376 HWTEST_F(AccessTokenKitTest, GrantPermission001, TestSize.Level1)
377 {
378     AccessTokenID tokenId = 123;
379     std::string permission = "ohos.permission.CAMERA";
380     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
381         AccessTokenKit::GrantPermission(tokenId, permission, PERMISSION_USER_FIXED));
382 }
383 
384 /**
385  * @tc.name: RevokePermission001
386  * @tc.desc: RevokePermission with proxy is null
387  * @tc.type: FUNC
388  * @tc.require:
389  */
390 HWTEST_F(AccessTokenKitTest, RevokePermission001, TestSize.Level1)
391 {
392     AccessTokenID tokenId = 123;
393     std::string permission = "ohos.permission.CAMERA";
394     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
395         AccessTokenKit::RevokePermission(tokenId, permission, PERMISSION_USER_FIXED));
396 }
397 
398 /**
399  * @tc.name: ClearUserGrantedPermissionState001
400  * @tc.desc: ClearUserGrantedPermissionState with proxy is null
401  * @tc.type: FUNC
402  * @tc.require:
403  */
404 HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState001, TestSize.Level1)
405 {
406     AccessTokenID tokenId = 123;
407     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ClearUserGrantedPermissionState(tokenId));
408 }
409 
410 class CbCustomizeTest : public PermStateChangeCallbackCustomize {
411 public:
CbCustomizeTest(const PermStateChangeScope & scopeInfo)412     explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo)
413         : PermStateChangeCallbackCustomize(scopeInfo)
414     {
415     }
~CbCustomizeTest()416     ~CbCustomizeTest() {}
417 
PermStateChangeCallback(PermStateChangeInfo & result)418     virtual void PermStateChangeCallback(PermStateChangeInfo& result)
419     {
420     }
421 };
422 
423 /**
424  * @tc.name: RegisterPermStateChangeCallback001
425  * @tc.desc: RegisterPermStateChangeCallback with proxy is null
426  * @tc.type: FUNC
427  * @tc.require:
428  */
429 HWTEST_F(AccessTokenKitTest, RegisterPermStateChangeCallback001, TestSize.Level1)
430 {
431     PermStateChangeScope scopeInfo;
432     scopeInfo.permList = {"ohos.permission.CAMERA"};
433     scopeInfo.tokenIDs = {};
434     auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
435     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
436     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
437 }
438 
439 /**
440  * @tc.name: ReloadNativeTokenInfo001
441  * @tc.desc: ReloadNativeTokenInfo with proxy is null
442  * @tc.type: FUNC
443  * @tc.require:
444  */
445 HWTEST_F(AccessTokenKitTest, ReloadNativeTokenInfo001, TestSize.Level1)
446 {
447     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ReloadNativeTokenInfo());
448 }
449 
450 /**
451  * @tc.name: GetNativeTokenId001
452  * @tc.desc: Verify the GetNativeTokenId abnormal branch return nullptr proxy.
453  * @tc.type: FUNC
454  * @tc.require: Issue Number
455  */
456 HWTEST_F(AccessTokenKitTest, GetNativeTokenId001, TestSize.Level1)
457 {
458     std::string processName = "hdcd";
459     AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName);
460     ASSERT_EQ(INVALID_TOKENID, tokenID);
461 }
462 
463 #ifdef TOKEN_SYNC_ENABLE
464 /**
465  * @tc.name: GetHapTokenInfoFromRemote001
466  * @tc.desc: GetHapTokenInfoFromRemote with proxy is null
467  * @tc.type: FUNC
468  * @tc.require:
469  */
470 HWTEST_F(AccessTokenKitTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
471 {
472     AccessTokenID tokenId = 123;
473     HapTokenInfoForSync hapSync;
474     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfoFromRemote(tokenId, hapSync));
475 }
476 
477 /**
478  * @tc.name: SetRemoteHapTokenInfo001
479  * @tc.desc: SetRemoteHapTokenInfo with proxy is null
480  * @tc.type: FUNC
481  * @tc.require:
482  */
483 HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo001, TestSize.Level1)
484 {
485     std::string device = "device";
486     HapTokenInfoForSync hapSync;
487     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetRemoteHapTokenInfo(device, hapSync));
488 }
489 
490 /**
491  * @tc.name: DeleteRemoteToken001
492  * @tc.desc: DeleteRemoteToken with proxy is null
493  * @tc.type: FUNC
494  * @tc.require:
495  */
496 HWTEST_F(AccessTokenKitTest, DeleteRemoteToken001, TestSize.Level1)
497 {
498     std::string device = "device";
499     AccessTokenID tokenId = 123;
500     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteToken(device, tokenId));
501 }
502 
503 /**
504  * @tc.name: GetRemoteNativeTokenID001
505  * @tc.desc: GetRemoteNativeTokenID with proxy is null
506  * @tc.type: FUNC
507  * @tc.require:
508  */
509 HWTEST_F(AccessTokenKitTest, GetRemoteNativeTokenID001, TestSize.Level1)
510 {
511     std::string device = "device";
512     AccessTokenID tokenId = 123;
513     ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetRemoteNativeTokenID(device, tokenId));
514 }
515 
516 /**
517  * @tc.name: DeleteRemoteDeviceTokens001
518  * @tc.desc: DeleteRemoteDeviceTokens with proxy is null
519  * @tc.type: FUNC
520  * @tc.require:
521  */
522 HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceTokens001, TestSize.Level1)
523 {
524     std::string device = "device";
525     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteDeviceTokens(device));
526 }
527 
528 /**
529  * @tc.name: RegisterTokenSyncCallback001
530  * @tc.desc: RegisterTokenSyncCallback with proxy is null
531  * @tc.type: FUNC
532  * @tc.require:
533  */
534 HWTEST_F(AccessTokenKitTest, RegisterTokenSyncCallback001, TestSize.Level1)
535 {
536     std::shared_ptr<TokenSyncKitInterface> callback = std::make_shared<TokenSyncCallbackImpl>();
537     EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterTokenSyncCallback(callback));
538     EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterTokenSyncCallback());
539 }
540 #endif
541 
542 /**
543  * @tc.name: DumpTokenInfo001
544  * @tc.desc: DumpTokenInfo with proxy is null
545  * @tc.type: FUNC
546  * @tc.require:
547  */
548 HWTEST_F(AccessTokenKitTest, DumpTokenInfo001, TestSize.Level1)
549 {
550     std::string dumpInfo;
551     AtmToolsParamInfo info;
552     info.tokenId = 123;
553     AccessTokenKit::DumpTokenInfo(info, dumpInfo);
554     ASSERT_EQ("", dumpInfo);
555 }
556 
557 /**
558  * @tc.name: SetPermDialogCap001
559  * @tc.desc: SetPermDialogCap with proxy is null
560  * @tc.type: FUNC
561  * @tc.require:
562  */
563 HWTEST_F(AccessTokenKitTest, SetPermDialogCap001, TestSize.Level1)
564 {
565     HapBaseInfo hapBaseInfo;
566     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true));
567 }
568 
569 /**
570  * @tc.name: GetPermissionManagerInfo001
571  * @tc.desc: GetPermissionManagerInfo with proxy is null
572  * @tc.type: FUNC
573  * @tc.require:
574  */
575 HWTEST_F(AccessTokenKitTest, GetPermissionManagerInfo001, TestSize.Level1)
576 {
577     PermissionGrantInfo info;
578     AccessTokenKit::GetPermissionManagerInfo(info);
579     ASSERT_EQ(true, info.grantBundleName.empty());
580 }
581 
582 /**
583  * @tc.name: GrantPermissionForSpecifiedTime001
584  * @tc.desc: GrantPermissionForSpecifiedTime with proxy is null
585  * @tc.type: FUNC
586  * @tc.require:
587  */
588 HWTEST_F(AccessTokenKitTest, GrantPermissionForSpecifiedTime001, TestSize.Level1)
589 {
590     AccessTokenID tokenId = 123;
591     std::string permission = "permission";
592     uint32_t onceTime = 1;
593     ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
594         AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime));
595 }
596 }  // namespace AccessToken
597 }  // namespace Security
598 }
599