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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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.Level4)
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: GetSelfPermissionStatus001
346 * @tc.desc: GetSelfPermissionStatus with proxy is null
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(AccessTokenMockTest, GetSelfPermissionStatus001, TestSize.Level4)
351 {
352 std::string permission = "ohos.permission.CAMERA";
353 PermissionOper status;
354 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetSelfPermissionStatus(permission, status));
355 }
356
357 /**
358 * @tc.name: GetSelfPermissionsState001
359 * @tc.desc: GetSelfPermissionsState with proxy is null
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(AccessTokenMockTest, GetSelfPermissionsState001, TestSize.Level4)
364 {
365 std::vector<PermissionListState> permList;
366 PermissionGrantInfo info;
367 ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permList, info));
368 }
369
370 /**
371 * @tc.name: GetPermissionsStatus001
372 * @tc.desc: GetPermissionsStatus with proxy is null
373 * @tc.type: FUNC
374 * @tc.require:
375 */
376 HWTEST_F(AccessTokenMockTest, GetPermissionsStatus001, TestSize.Level4)
377 {
378 AccessTokenID tokenId = 123;
379 std::vector<PermissionListState> permsList;
380 PermissionListState perm = {
381 .permissionName = "ohos.permission.testPermDef1",
382 .state = SETTING_OPER
383 };
384 permsList.emplace_back(perm);
385 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
386 AccessTokenKit::GetPermissionsStatus(tokenId, permsList));
387 }
388
389 /**
390 * @tc.name: GrantPermission001
391 * @tc.desc: GrantPermission with proxy is null
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(AccessTokenMockTest, GrantPermission001, TestSize.Level4)
396 {
397 AccessTokenID tokenId = 123;
398 std::string permission = "ohos.permission.CAMERA";
399 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
400 AccessTokenKit::GrantPermission(tokenId, permission, PERMISSION_USER_FIXED));
401 }
402
403 /**
404 * @tc.name: RevokePermission001
405 * @tc.desc: RevokePermission with proxy is null
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(AccessTokenMockTest, RevokePermission001, TestSize.Level4)
410 {
411 AccessTokenID tokenId = 123;
412 std::string permission = "ohos.permission.CAMERA";
413 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
414 AccessTokenKit::RevokePermission(tokenId, permission, PERMISSION_USER_FIXED));
415 }
416
417 /**
418 * @tc.name: ClearUserGrantedPermissionState001
419 * @tc.desc: ClearUserGrantedPermissionState with proxy is null
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(AccessTokenMockTest, ClearUserGrantedPermissionState001, TestSize.Level4)
424 {
425 AccessTokenID tokenId = 123;
426 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ClearUserGrantedPermissionState(tokenId));
427 }
428
429 class CbCustomizeTest : public PermStateChangeCallbackCustomize {
430 public:
CbCustomizeTest(const PermStateChangeScope & scopeInfo)431 explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo)
432 : PermStateChangeCallbackCustomize(scopeInfo)
433 {
434 }
~CbCustomizeTest()435 ~CbCustomizeTest() {}
436
PermStateChangeCallback(PermStateChangeInfo & result)437 virtual void PermStateChangeCallback(PermStateChangeInfo& result)
438 {
439 }
440 };
441
442 /**
443 * @tc.name: RegisterPermStateChangeCallback001
444 * @tc.desc: RegisterPermStateChangeCallback with proxy is null
445 * @tc.type: FUNC
446 * @tc.require:
447 */
448 HWTEST_F(AccessTokenMockTest, RegisterPermStateChangeCallback001, TestSize.Level4)
449 {
450 PermStateChangeScope scopeInfo;
451 scopeInfo.permList = {"ohos.permission.CAMERA"};
452 scopeInfo.tokenIDs = {};
453 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
454 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
455 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
456 }
457
458 /**
459 * @tc.name: ReloadNativeTokenInfo001
460 * @tc.desc: ReloadNativeTokenInfo with proxy is null
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(AccessTokenMockTest, ReloadNativeTokenInfo001, TestSize.Level4)
465 {
466 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ReloadNativeTokenInfo());
467 }
468
469 /**
470 * @tc.name: GetNativeTokenId001
471 * @tc.desc: Verify the GetNativeTokenId abnormal branch return nullptr proxy.
472 * @tc.type: FUNC
473 * @tc.require: Issue Number
474 */
475 HWTEST_F(AccessTokenMockTest, GetNativeTokenId001, TestSize.Level4)
476 {
477 std::string processName = "hdcd";
478 AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName);
479 ASSERT_EQ(INVALID_TOKENID, tokenID);
480 }
481
482 #ifdef TOKEN_SYNC_ENABLE
483 /**
484 * @tc.name: GetHapTokenInfoFromRemote001
485 * @tc.desc: GetHapTokenInfoFromRemote with proxy is null
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(AccessTokenMockTest, GetHapTokenInfoFromRemote001, TestSize.Level4)
490 {
491 AccessTokenID tokenId = 123;
492 HapTokenInfoForSync hapSync;
493 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfoFromRemote(tokenId, hapSync));
494 }
495
496 /**
497 * @tc.name: SetRemoteHapTokenInfo001
498 * @tc.desc: SetRemoteHapTokenInfo with proxy is null
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(AccessTokenMockTest, SetRemoteHapTokenInfo001, TestSize.Level4)
503 {
504 std::string device = "device";
505 HapTokenInfoForSync hapSync;
506 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetRemoteHapTokenInfo(device, hapSync));
507 }
508
509 /**
510 * @tc.name: DeleteRemoteToken001
511 * @tc.desc: DeleteRemoteToken with proxy is null
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(AccessTokenMockTest, DeleteRemoteToken001, TestSize.Level4)
516 {
517 std::string device = "device";
518 AccessTokenID tokenId = 123;
519 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteToken(device, tokenId));
520 }
521
522 /**
523 * @tc.name: GetRemoteNativeTokenID001
524 * @tc.desc: GetRemoteNativeTokenID with proxy is null
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(AccessTokenMockTest, GetRemoteNativeTokenID001, TestSize.Level4)
529 {
530 std::string device = "device";
531 AccessTokenID tokenId = 123;
532 ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetRemoteNativeTokenID(device, tokenId));
533 }
534
535 /**
536 * @tc.name: DeleteRemoteDeviceTokens001
537 * @tc.desc: DeleteRemoteDeviceTokens with proxy is null
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541 HWTEST_F(AccessTokenMockTest, DeleteRemoteDeviceTokens001, TestSize.Level4)
542 {
543 std::string device = "device";
544 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteDeviceTokens(device));
545 }
546
547 /**
548 * @tc.name: RegisterTokenSyncCallback001
549 * @tc.desc: RegisterTokenSyncCallback with proxy is null
550 * @tc.type: FUNC
551 * @tc.require:
552 */
553 HWTEST_F(AccessTokenMockTest, RegisterTokenSyncCallback001, TestSize.Level4)
554 {
555 std::shared_ptr<TokenSyncKitInterface> callback = std::make_shared<TokenSyncCallbackImpl>();
556 EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterTokenSyncCallback(callback));
557 EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterTokenSyncCallback());
558 }
559 #endif
560
561 /**
562 * @tc.name: DumpTokenInfo001
563 * @tc.desc: DumpTokenInfo with proxy is null
564 * @tc.type: FUNC
565 * @tc.require:
566 */
567 HWTEST_F(AccessTokenMockTest, DumpTokenInfo001, TestSize.Level4)
568 {
569 std::string dumpInfo;
570 AtmToolsParamInfo info;
571 info.tokenId = 123;
572 AccessTokenKit::DumpTokenInfo(info, dumpInfo);
573 ASSERT_EQ("", dumpInfo);
574 }
575
576 /**
577 * @tc.name: SetPermDialogCap001
578 * @tc.desc: SetPermDialogCap with proxy is null
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 HWTEST_F(AccessTokenMockTest, SetPermDialogCap001, TestSize.Level4)
583 {
584 HapBaseInfo hapBaseInfo;
585 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true));
586 }
587
588 /**
589 * @tc.name: GetPermissionManagerInfo001
590 * @tc.desc: GetPermissionManagerInfo with proxy is null
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(AccessTokenMockTest, GetPermissionManagerInfo001, TestSize.Level4)
595 {
596 PermissionGrantInfo info;
597 AccessTokenKit::GetPermissionManagerInfo(info);
598 ASSERT_EQ(true, info.grantBundleName.empty());
599 }
600
601 /**
602 * @tc.name: GrantPermissionForSpecifiedTime001
603 * @tc.desc: GrantPermissionForSpecifiedTime with proxy is null
604 * @tc.type: FUNC
605 * @tc.require:
606 */
607 HWTEST_F(AccessTokenMockTest, GrantPermissionForSpecifiedTime001, TestSize.Level4)
608 {
609 AccessTokenID tokenId = 123;
610 std::string permission = "permission";
611 uint32_t onceTime = 1;
612 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL,
613 AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime));
614 }
615
616 /**
617 * @tc.name: RequestAppPermOnSettingTest001
618 * @tc.desc: RequestAppPermOnSetting with proxy is null
619 * @tc.type: FUNC
620 * @tc.require:
621 */
622 HWTEST_F(AccessTokenMockTest, RequestAppPermOnSettingTest001, TestSize.Level4)
623 {
624 AccessTokenID tokenId = 123;
625 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RequestAppPermOnSetting(tokenId));
626 }
627
628 /**
629 * @tc.name: GetKernelPermissions001
630 * @tc.desc: GetKernelPermissions with proxy is null
631 * @tc.type: FUNC
632 * @tc.require:
633 */
634 HWTEST_F(AccessTokenMockTest, GetKernelPermissions001, TestSize.Level4)
635 {
636 AccessTokenID tokenId = 123;
637 std::vector<PermissionWithValue> kernelPermList;
638 ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetKernelPermissions(tokenId, kernelPermList));
639 }
640 } // namespace AccessToken
641 } // namespace Security
642 }
643