1 /*
2 * Copyright (c) 2025 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_mock_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 AccessTokenMockTest::SetUpTestCase()
60 {
61 }
62
TearDownTestCase()63 void AccessTokenMockTest::TearDownTestCase()
64 {
65 }
66
SetUp()67 void AccessTokenMockTest::SetUp()
68 {
69 }
70
TearDown()71 void AccessTokenMockTest::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(AccessTokenMockTest, 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(AccessTokenMockTest, 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(AccessTokenMockTest, 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(AccessTokenMockTest, 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(AccessTokenMockTest, 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(AccessTokenMockTest, GetTokenType001, TestSize.Level1)
152 {
153 AccessTokenID tokenId = 123;
154 ASSERT_EQ(TOKEN_INVALID, AccessTokenKit::GetTokenType(tokenId));
155 }
156
157 /**
158 * @tc.name: GetHapTokenID001
159 * @tc.desc: GetHapTokenID with proxy is null
160 * @tc.type: FUNC
161 * @tc.require:
162 */
163 HWTEST_F(AccessTokenMockTest, GetHapTokenID001, TestSize.Level1)
164 {
165 int32_t userID = 0;
166 std::string bundleName = "test";
167 int32_t instIndex = 0;
168 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
169 ASSERT_EQ(INVALID_TOKENID, tokenId);
170 }
171
172 /**
173 * @tc.name: GetHapTokenID001
174 * @tc.desc: GetHapTokenIDEx with proxy is null
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(AccessTokenMockTest, GetHapTokenIDEx001, TestSize.Level1)
179 {
180 int32_t userID = 0;
181 std::string bundleName = "test";
182 int32_t instIndex = 0;
183 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(userID, bundleName, instIndex);
184 ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
185 }
186
187 /**
188 * @tc.name: GetHapTokenInfo001
189 * @tc.desc: GetHapTokenInfo with proxy is null
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(AccessTokenMockTest, GetHapTokenInfo001, TestSize.Level1)
194 {
195 AccessTokenID tokenId = 123;
196 HapTokenInfo tokenInfo;
197 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo));
198 }
199
200 /**
201 * @tc.name: GetNativeTokenInfo001
202 * @tc.desc: GetNativeTokenInfo with proxy is null
203 * @tc.type: FUNC
204 * @tc.require:
205 */
206 HWTEST_F(AccessTokenMockTest, GetNativeTokenInfo001, TestSize.Level1)
207 {
208 AccessTokenID tokenId = 805920561; //805920561 is a native tokenId.
209 NativeTokenInfo tokenInfo;
210 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo));
211 }
212
213 /**
214 * @tc.name: VerifyAccessToken001
215 * @tc.desc: VerifyAccessToken with proxy is null
216 * @tc.type: FUNC
217 * @tc.require:
218 */
219 HWTEST_F(AccessTokenMockTest, VerifyAccessToken001, TestSize.Level1)
220 {
221 AccessTokenID tokenId = 123;
222 std::string permission = "ohos.permission.CAMERA";
223 ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenId, permission));
224 ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenId, permission, true));
225 }
226
227 /**
228 * @tc.name: VerifyAccessToken002
229 * @tc.desc: VerifyAccessToken with proxy is null
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(AccessTokenMockTest, VerifyAccessToken002, TestSize.Level1)
234 {
235 AccessTokenID callerTokenID = 123;
236 AccessTokenID firstTokenID = 456;
237 std::string permission = "ohos.permission.CAMERA";
238 ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(callerTokenID, firstTokenID, permission));
239 ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(callerTokenID, firstTokenID, permission, true));
240 }
241
242 /**
243 * @tc.name: VerifyAccessTokenWithList001
244 * @tc.desc: VerifyAccessTokenWithList with proxy is null
245 * @tc.type: FUNC
246 * @tc.require:
247 */
248 HWTEST_F(AccessTokenMockTest, VerifyAccessTokenWithList001, TestSize.Level1)
249 {
250 AccessTokenID tokenId = 123;
251 std::vector<std::string> permissionList = {"ohos.permission.CAMERA"};
252 std::vector<int32_t> permStateList;
253 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
254 AccessTokenKit::VerifyAccessToken(tokenId, permissionList, permStateList, true));
255
256 permStateList.clear();
257 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
258 AccessTokenKit::VerifyAccessToken(tokenId, permissionList, permStateList, false));
259 }
260
261 /**
262 * @tc.name: GetDefPermission001
263 * @tc.desc: GetDefPermission with proxy is null
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(AccessTokenMockTest, GetDefPermission001, TestSize.Level1)
268 {
269 std::string permission = "ohos.permission.CAMERA";
270 PermissionDef def;
271 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetDefPermission(permission, def));
272 }
273
274 /**
275 * @tc.name: GetReqPermissions001
276 * @tc.desc: GetReqPermissions with proxy is null
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(AccessTokenMockTest, GetReqPermissions001, TestSize.Level1)
281 {
282 AccessTokenID tokenId = 123;
283 std::vector<PermissionStateFull> permList;
284 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetReqPermissions(tokenId, permList, false));
285 }
286
287 /**
288 * @tc.name: GetTokenIDByUserID001
289 * @tc.desc: GetTokenIDByUserID with proxy is null
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(AccessTokenMockTest, GetTokenIDByUserID001, TestSize.Level1)
294 {
295 int32_t userID = 1;
296 std::unordered_set<AccessTokenID> tokenIdList;
297 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetTokenIDByUserID(userID, tokenIdList));
298 }
299
300 /**
301 * @tc.name: GetPermissionFlag001
302 * @tc.desc: GetPermissionFlag with proxy is null
303 * @tc.type: FUNC
304 * @tc.require:
305 */
306 HWTEST_F(AccessTokenMockTest, GetPermissionFlag001, TestSize.Level1)
307 {
308 AccessTokenID tokenId = 123;
309 std::string permission = "ohos.permission.CAMERA";
310 uint32_t flag;
311 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetPermissionFlag(tokenId, permission, flag));
312 }
313
314 /**
315 * @tc.name: SetPermissionRequestToggleStatus001
316 * @tc.desc: SetPermissionRequestToggleStatus with proxy is null
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(AccessTokenMockTest, SetPermissionRequestToggleStatus001, TestSize.Level1)
321 {
322 int32_t userID = 123;
323 std::string permission = "ohos.permission.CAMERA";
324 uint32_t status = PermissionRequestToggleStatus::CLOSED;
325 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermissionRequestToggleStatus(permission,
326 status, userID));
327 }
328
329 /**
330 * @tc.name: GetPermissionRequestToggleStatus001
331 * @tc.desc: GetPermissionRequestToggleStatus with proxy is null
332 * @tc.type: FUNC
333 * @tc.require:
334 */
335 HWTEST_F(AccessTokenMockTest, GetPermissionRequestToggleStatus001, TestSize.Level1)
336 {
337 int32_t userID = 123;
338 std::string permission = "ohos.permission.CAMERA";
339 uint32_t status;
340 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetPermissionRequestToggleStatus(permission,
341 status, userID));
342 }
343
344 /**
345 * @tc.name: GetSelfPermissionsState001
346 * @tc.desc: GetSelfPermissionsState with proxy is null
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(AccessTokenMockTest, GetSelfPermissionsState001, TestSize.Level1)
351 {
352 std::vector<PermissionListState> permList;
353 PermissionGrantInfo info;
354 ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permList, info));
355 }
356
357 /**
358 * @tc.name: GetPermissionsStatus001
359 * @tc.desc: GetPermissionsStatus with proxy is null
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(AccessTokenMockTest, GetPermissionsStatus001, TestSize.Level1)
364 {
365 AccessTokenID tokenId = 123;
366 std::vector<PermissionListState> permsList;
367 PermissionListState perm = {
368 .permissionName = "ohos.permission.testPermDef1",
369 .state = SETTING_OPER
370 };
371 permsList.emplace_back(perm);
372 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
373 AccessTokenKit::GetPermissionsStatus(tokenId, permsList));
374 }
375
376 /**
377 * @tc.name: GrantPermission001
378 * @tc.desc: GrantPermission with proxy is null
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(AccessTokenMockTest, GrantPermission001, TestSize.Level1)
383 {
384 AccessTokenID tokenId = 123;
385 std::string permission = "ohos.permission.CAMERA";
386 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
387 AccessTokenKit::GrantPermission(tokenId, permission, PERMISSION_USER_FIXED));
388 }
389
390 /**
391 * @tc.name: RevokePermission001
392 * @tc.desc: RevokePermission with proxy is null
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(AccessTokenMockTest, RevokePermission001, TestSize.Level1)
397 {
398 AccessTokenID tokenId = 123;
399 std::string permission = "ohos.permission.CAMERA";
400 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
401 AccessTokenKit::RevokePermission(tokenId, permission, PERMISSION_USER_FIXED));
402 }
403
404 /**
405 * @tc.name: ClearUserGrantedPermissionState001
406 * @tc.desc: ClearUserGrantedPermissionState with proxy is null
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(AccessTokenMockTest, ClearUserGrantedPermissionState001, TestSize.Level1)
411 {
412 AccessTokenID tokenId = 123;
413 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ClearUserGrantedPermissionState(tokenId));
414 }
415
416 class CbCustomizeTest : public PermStateChangeCallbackCustomize {
417 public:
CbCustomizeTest(const PermStateChangeScope & scopeInfo)418 explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo)
419 : PermStateChangeCallbackCustomize(scopeInfo)
420 {
421 }
~CbCustomizeTest()422 ~CbCustomizeTest() {}
423
PermStateChangeCallback(PermStateChangeInfo & result)424 virtual void PermStateChangeCallback(PermStateChangeInfo& result)
425 {
426 }
427 };
428
429 /**
430 * @tc.name: RegisterPermStateChangeCallback001
431 * @tc.desc: RegisterPermStateChangeCallback with proxy is null
432 * @tc.type: FUNC
433 * @tc.require:
434 */
435 HWTEST_F(AccessTokenMockTest, RegisterPermStateChangeCallback001, TestSize.Level1)
436 {
437 PermStateChangeScope scopeInfo;
438 scopeInfo.permList = {"ohos.permission.CAMERA"};
439 scopeInfo.tokenIDs = {};
440 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
441 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
442 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
443 }
444
445 /**
446 * @tc.name: ReloadNativeTokenInfo001
447 * @tc.desc: ReloadNativeTokenInfo with proxy is null
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(AccessTokenMockTest, ReloadNativeTokenInfo001, TestSize.Level1)
452 {
453 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ReloadNativeTokenInfo());
454 }
455
456 /**
457 * @tc.name: GetNativeTokenId001
458 * @tc.desc: Verify the GetNativeTokenId abnormal branch return nullptr proxy.
459 * @tc.type: FUNC
460 * @tc.require: Issue Number
461 */
462 HWTEST_F(AccessTokenMockTest, GetNativeTokenId001, TestSize.Level1)
463 {
464 std::string processName = "hdcd";
465 AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName);
466 ASSERT_EQ(INVALID_TOKENID, tokenID);
467 }
468
469 #ifdef TOKEN_SYNC_ENABLE
470 /**
471 * @tc.name: GetHapTokenInfoFromRemote001
472 * @tc.desc: GetHapTokenInfoFromRemote with proxy is null
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(AccessTokenMockTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
477 {
478 AccessTokenID tokenId = 123;
479 HapTokenInfoForSync hapSync;
480 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfoFromRemote(tokenId, hapSync));
481 }
482
483 /**
484 * @tc.name: SetRemoteHapTokenInfo001
485 * @tc.desc: SetRemoteHapTokenInfo with proxy is null
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(AccessTokenMockTest, SetRemoteHapTokenInfo001, TestSize.Level1)
490 {
491 std::string device = "device";
492 HapTokenInfoForSync hapSync;
493 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetRemoteHapTokenInfo(device, hapSync));
494 }
495
496 /**
497 * @tc.name: DeleteRemoteToken001
498 * @tc.desc: DeleteRemoteToken with proxy is null
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(AccessTokenMockTest, DeleteRemoteToken001, TestSize.Level1)
503 {
504 std::string device = "device";
505 AccessTokenID tokenId = 123;
506 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteToken(device, tokenId));
507 }
508
509 /**
510 * @tc.name: GetRemoteNativeTokenID001
511 * @tc.desc: GetRemoteNativeTokenID with proxy is null
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(AccessTokenMockTest, GetRemoteNativeTokenID001, TestSize.Level1)
516 {
517 std::string device = "device";
518 AccessTokenID tokenId = 123;
519 ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetRemoteNativeTokenID(device, tokenId));
520 }
521
522 /**
523 * @tc.name: DeleteRemoteDeviceTokens001
524 * @tc.desc: DeleteRemoteDeviceTokens with proxy is null
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(AccessTokenMockTest, DeleteRemoteDeviceTokens001, TestSize.Level1)
529 {
530 std::string device = "device";
531 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteDeviceTokens(device));
532 }
533
534 /**
535 * @tc.name: RegisterTokenSyncCallback001
536 * @tc.desc: RegisterTokenSyncCallback with proxy is null
537 * @tc.type: FUNC
538 * @tc.require:
539 */
540 HWTEST_F(AccessTokenMockTest, RegisterTokenSyncCallback001, TestSize.Level1)
541 {
542 std::shared_ptr<TokenSyncKitInterface> callback = std::make_shared<TokenSyncCallbackImpl>();
543 EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterTokenSyncCallback(callback));
544 EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterTokenSyncCallback());
545 }
546 #endif
547
548 /**
549 * @tc.name: DumpTokenInfo001
550 * @tc.desc: DumpTokenInfo with proxy is null
551 * @tc.type: FUNC
552 * @tc.require:
553 */
554 HWTEST_F(AccessTokenMockTest, DumpTokenInfo001, TestSize.Level1)
555 {
556 std::string dumpInfo;
557 AtmToolsParamInfo info;
558 info.tokenId = 123;
559 AccessTokenKit::DumpTokenInfo(info, dumpInfo);
560 ASSERT_EQ("", dumpInfo);
561 }
562
563 /**
564 * @tc.name: SetPermDialogCap001
565 * @tc.desc: SetPermDialogCap with proxy is null
566 * @tc.type: FUNC
567 * @tc.require:
568 */
569 HWTEST_F(AccessTokenMockTest, SetPermDialogCap001, TestSize.Level1)
570 {
571 HapBaseInfo hapBaseInfo;
572 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true));
573 }
574
575 /**
576 * @tc.name: GetPermissionManagerInfo001
577 * @tc.desc: GetPermissionManagerInfo with proxy is null
578 * @tc.type: FUNC
579 * @tc.require:
580 */
581 HWTEST_F(AccessTokenMockTest, GetPermissionManagerInfo001, TestSize.Level1)
582 {
583 PermissionGrantInfo info;
584 AccessTokenKit::GetPermissionManagerInfo(info);
585 ASSERT_EQ(true, info.grantBundleName.empty());
586 }
587
588 /**
589 * @tc.name: GrantPermissionForSpecifiedTime001
590 * @tc.desc: GrantPermissionForSpecifiedTime with proxy is null
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(AccessTokenMockTest, GrantPermissionForSpecifiedTime001, TestSize.Level1)
595 {
596 AccessTokenID tokenId = 123;
597 std::string permission = "permission";
598 uint32_t onceTime = 1;
599 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
600 AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime));
601 }
602
603 /**
604 * @tc.name: RequestAppPermOnSettingTest001
605 * @tc.desc: RequestAppPermOnSetting with proxy is null
606 * @tc.type: FUNC
607 * @tc.require:
608 */
609 HWTEST_F(AccessTokenMockTest, RequestAppPermOnSettingTest001, TestSize.Level1)
610 {
611 AccessTokenID tokenId = 123;
612 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RequestAppPermOnSetting(tokenId));
613 }
614
615 /**
616 * @tc.name: GetKernelPermissions001
617 * @tc.desc: GetKernelPermissions with proxy is null
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(AccessTokenMockTest, GetKernelPermissions001, TestSize.Level1)
622 {
623 AccessTokenID tokenId = 123;
624 std::vector<PermissionWithValue> kernelPermList;
625 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetKernelPermissions(tokenId, kernelPermList));
626 }
627 } // namespace AccessToken
628 } // namespace Security
629 }
630