1 /*
2 * Copyright (c) 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 "register_perm_state_change_callback_test.h"
17 #include <thread>
18
19 #include "access_token.h"
20 #include "access_token_error.h"
21 #include "accesstoken_common_log.h"
22 #include "accesstoken_service_ipc_interface_code.h"
23 #include "hap_token_info.h"
24 #include "nativetoken_kit.h"
25 #include "permission_grant_info.h"
26 #include "permission_state_change_info_parcel.h"
27 #include "string_ex.h"
28 #include "tokenid_kit.h"
29 #include "token_setproc.h"
30 #include "accesstoken_manager_client.h"
31 #include "test_common.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace Security {
37 namespace AccessToken {
38 namespace {
39 static MockHapToken* g_mock = nullptr;
40 HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms();
41 uint64_t g_selfShellTokenId;
42 static const uint32_t TOKENIDS_LIST_SIZE_MAX_TEST = 1024;
43 static const uint32_t PERMS_LIST_SIZE_MAX_TEST = 1024;
44 static const uint32_t MAX_CALLBACK_MAP_SIZE = 200;
45 PermissionStateFull g_infoManagerTestStateA = {
46 .permissionName = "ohos.permission.CAMERA",
47 .isGeneral = true,
48 .resDeviceID = {"local2"},
49 .grantStatus = {PERMISSION_DENIED},
50 .grantFlags = {1}
51 };
52 }
53
SetUpTestCase()54 void RegisterPermStateChangeCallbackTest::SetUpTestCase()
55 {
56 g_selfShellTokenId = GetSelfTokenID();
57 TestCommon::SetTestEvironment(g_selfShellTokenId);
58 std::vector<std::string> reqPerm;
59 reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS");
60 g_mock = new (std::nothrow) MockHapToken("RegisterPermStateChangeCallbackTest", reqPerm, true);
61 }
62
TearDownTestCase()63 void RegisterPermStateChangeCallbackTest::TearDownTestCase()
64 {
65 if (g_mock != nullptr) {
66 delete g_mock;
67 g_mock = nullptr;
68 }
69 EXPECT_EQ(0, SetSelfTokenID(g_selfShellTokenId));
70 TestCommon::ResetTestEvironment();
71 }
72
SetUp()73 void RegisterPermStateChangeCallbackTest::SetUp()
74 {
75 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
76 }
77
TearDown()78 void RegisterPermStateChangeCallbackTest::TearDown()
79 {
80 }
81
82 class CbCustomizeTest : public PermStateChangeCallbackCustomize {
83 public:
CbCustomizeTest(const PermStateChangeScope & scopeInfo)84 explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo)
85 : PermStateChangeCallbackCustomize(scopeInfo)
86 {
87 }
88
~CbCustomizeTest()89 ~CbCustomizeTest()
90 {}
91
PermStateChangeCallback(PermStateChangeInfo & result)92 virtual void PermStateChangeCallback(PermStateChangeInfo& result)
93 {
94 ready_ = true;
95 int32_t status = (result.permStateChangeType == 1) ? PERMISSION_GRANTED : PERMISSION_DENIED;
96 ASSERT_EQ(status, AccessTokenKit::VerifyAccessToken(result.tokenID, result.permissionName));
97 }
98
99 bool ready_;
100 };
101
102 /**
103 * @tc.name: RegisterPermStateChangeCallbackFuncTest001
104 * @tc.desc: RegisterPermStateChangeCallback permList
105 * @tc.type: FUNC
106 * @tc.require: issueI5NT1X
107 */
108 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest001, TestSize.Level1)
109 {
110 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest001");
111 PermStateChangeScope scopeInfo;
112 scopeInfo.permList = {"ohos.permission.CAMERA"};
113 scopeInfo.tokenIDs = {};
114 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
115 callbackPtr->ready_ = false;
116
117 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
118
119 static HapPolicyParams infoManagerTestPolicyPrams1 = {
120 .apl = APL_NORMAL,
121 .domain = "test.domain2",
122 .permStateList = {g_infoManagerTestStateA}
123 };
124
125 AccessTokenIDEx tokenIdEx = {0};
126 ASSERT_EQ(
127 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
128 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
129 ASSERT_NE(tokenID, INVALID_TOKENID);
130
131 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
132
133 ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false));
134 usleep(500000); // 500000us = 0.5s
135 EXPECT_EQ(true, callbackPtr->ready_);
136
137 callbackPtr->ready_ = false;
138
139 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
140 usleep(500000); // 500000us = 0.5s
141 EXPECT_EQ(true, callbackPtr->ready_);
142
143 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
144
145 callbackPtr->ready_ = false;
146
147 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
148 usleep(500000); // 500000us = 0.5s
149 ASSERT_EQ(false, callbackPtr->ready_);
150
151 callbackPtr->ready_ = false;
152
153 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
154 usleep(500000); // 500000us = 0.5s
155 ASSERT_EQ(false, callbackPtr->ready_);
156
157 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
158 }
159
160 /**
161 * @tc.name: RegisterPermStateChangeCallbackFuncTest002
162 * @tc.desc: RegisterPermStateChangeCallback permList
163 * @tc.type: FUNC
164 * @tc.require: issueI5NT1X
165 */
166 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest002, TestSize.Level1)
167 {
168 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest002");
169 PermStateChangeScope scopeInfo;
170 scopeInfo.permList = {"ohos.permission.APPROXIMATELY_LOCATION"};
171 scopeInfo.tokenIDs = {};
172 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
173 callbackPtr->ready_ = false;
174
175 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
176
177 static PermissionStateFull infoManagerTestStateA = {
178 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
179 .isGeneral = true,
180 .resDeviceID = {"local2"},
181 .grantStatus = {PERMISSION_GRANTED},
182 .grantFlags = {1}
183 };
184 static PermissionStateFull infoManagerTestStateB = {
185 .permissionName = "ohos.permission.CAMERA",
186 .isGeneral = true,
187 .resDeviceID = {"local2"},
188 .grantStatus = {PERMISSION_GRANTED},
189 .grantFlags = {1}
190 };
191 static HapPolicyParams infoManagerTestPolicyPrams2 = {
192 .apl = APL_SYSTEM_BASIC,
193 .domain = "test.domain2",
194 .permStateList = {infoManagerTestStateA, infoManagerTestStateB}
195 };
196
197 AccessTokenIDEx tokenIdEx = {0};
198 ASSERT_EQ(
199 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams2, tokenIdEx));
200 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
201 ASSERT_NE(tokenID, INVALID_TOKENID);
202
203 res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false);
204 ASSERT_EQ(PERMISSION_DENIED, res);
205
206 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
207 ASSERT_EQ(RET_SUCCESS, res);
208 usleep(500000); // 500000us = 0.5s
209 EXPECT_EQ(false, callbackPtr->ready_);
210
211 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
212
213 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
214 ASSERT_EQ(RET_SUCCESS, res);
215 }
216
217 /**
218 * @tc.name: RegisterPermStateChangeCallbackFuncTest003
219 * @tc.desc: RegisterPermStateChangeCallback permList
220 * @tc.type: FUNC
221 * @tc.require: issueI5NT1X
222 */
223 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest003, TestSize.Level1)
224 {
225 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest003");
226 PermStateChangeScope scopeInfo;
227 scopeInfo.permList = {};
228 scopeInfo.tokenIDs = {};
229 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
230 callbackPtr->ready_ = false;
231
232 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
233
234 HapPolicyParams infoManagerTestPolicyPrams3 = {
235 .apl = APL_SYSTEM_CORE,
236 .domain = "test.domain2",
237 .permStateList = {g_infoManagerTestStateA}
238 };
239
240 AccessTokenIDEx tokenIdEx = {0};
241 ASSERT_EQ(
242 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams3, tokenIdEx));
243 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
244 ASSERT_NE(tokenID, INVALID_TOKENID);
245
246 callbackPtr->ready_ = false;
247 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
248 ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false));
249 usleep(500000); // 500000us = 0.5s
250 EXPECT_EQ(true, callbackPtr->ready_);
251
252 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
253
254 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
255 }
256
257 /**
258 * @tc.name: RegisterPermStateChangeCallbackFuncTest004
259 * @tc.desc: RegisterPermStateChangeCallback permList
260 * @tc.type: FUNC
261 * @tc.require: issueI5NT1X
262 */
263 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest004, TestSize.Level1)
264 {
265 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest004");
266
267 static HapPolicyParams infoManagerTestPolicyPrams5 = {
268 .apl = APL_NORMAL,
269 .domain = "test.domain2",
270 .permStateList = {g_infoManagerTestStateA}
271 };
272
273 AccessTokenIDEx tokenIdEx = {0};
274 ASSERT_EQ(
275 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams5, tokenIdEx));
276 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
277 ASSERT_NE(tokenID, INVALID_TOKENID);
278
279 PermStateChangeScope scopeInfo;
280 scopeInfo.permList = {"ohos.permission.CAMERA"};
281 scopeInfo.tokenIDs = {tokenID, 0};
282 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
283 callbackPtr->ready_ = false;
284
285 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
286
287 callbackPtr->ready_ = false;
288 ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false));
289 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
290 usleep(500000); // 500000us = 0.5s
291 EXPECT_EQ(true, callbackPtr->ready_);
292
293 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
294
295 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
296 }
297
298
299 /**
300 * @tc.name: RegisterPermStateChangeCallbackFuncTest005
301 * @tc.desc: RegisterPermStateChangeCallback caller is normal app.
302 * @tc.type: FUNC
303 * @tc.require: issueI66BH3
304 */
305 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest005, TestSize.Level0)
306 {
307 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest005");
308 std::vector<std::string> reqPerm;
309 reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS");
310 MockHapToken mock("RegisterPermStateChangeCallbackFuncTest005", reqPerm, false);
311
312 PermStateChangeScope scopeInfo;
313 scopeInfo.permList = {"ohos.permission.CAMERA"};
314 scopeInfo.tokenIDs = {};
315 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
316 callbackPtr->ready_ = false;
317
318 ASSERT_EQ(ERR_NOT_SYSTEM_APP, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
319 }
320
321 /**
322 * @tc.name: RegisterPermStateChangeCallbackFuncTest006
323 * @tc.desc: RegisterPermStateChangeCallback caller is system app.
324 * @tc.type: FUNC
325 * @tc.require: issueI66BH3
326 */
327 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest006, TestSize.Level0)
328 {
329 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest006");
330 std::vector<std::string> reqPerm;
331 reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS");
332 MockHapToken mock("RegisterPermStateChangeCallbackFuncTest006", reqPerm, true);
333
334 PermStateChangeScope scopeInfo;
335 scopeInfo.permList = {"ohos.permission.CAMERA"};
336 scopeInfo.tokenIDs = {};
337 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
338 callbackPtr->ready_ = false;
339
340 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
341 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
342 }
343
344 /**
345 * @tc.name: RegisterPermStateChangeCallbackAbnormalTest001
346 * @tc.desc: RegisterPermStateChangeCallback with invalid tokenId
347 * @tc.type: FUNC
348 * @tc.require: issueI5NT1X
349 */
350 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbnormalTest001, TestSize.Level1)
351 {
352 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackAbnormalTest001");
353 PermStateChangeScope scopeInfo;
354 scopeInfo.permList = {"ohos.permission.CAMERA"};
355 scopeInfo.tokenIDs = {555555}; // 555555为模拟的tokenid
356 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
357 callbackPtr->ready_ = false;
358
359 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
360
361 PermissionStateFull infoManagerTestStateA = {
362 .permissionName = "ohos.permission.CAMERA",
363 .isGeneral = true,
364 .resDeviceID = {"local2"},
365 .grantStatus = {PERMISSION_GRANTED},
366 .grantFlags = {1}
367 };
368 HapPolicyParams infoManagerTestPolicyPrams4 = {
369 .apl = APL_NORMAL,
370 .domain = "test.domain2",
371 .permStateList = {infoManagerTestStateA}
372 };
373
374 AccessTokenIDEx tokenIdEx = {0};
375 ASSERT_EQ(
376 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams4, tokenIdEx));
377 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
378 ASSERT_NE(tokenID, INVALID_TOKENID);
379
380 callbackPtr->ready_ = false;
381 ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false));
382 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
383 ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false));
384 usleep(500000); // 500000us = 0.5s
385 EXPECT_EQ(false, callbackPtr->ready_);
386
387 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
388 }
389
390 /**
391 * @tc.name: RegisterPermStateChangeCallbackAbnormalTest002
392 * @tc.desc: RegisterPermStateChangeCallback with invaild permission
393 * @tc.type: FUNC
394 * @tc.require: issueI5NT1X
395 */
396 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbnormalTest002, TestSize.Level1)
397 {
398 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackAbnormalTest002");
399 PermStateChangeScope scopeInfo;
400 scopeInfo.permList = {"ohos.permission.INVALID"};
401 scopeInfo.tokenIDs = {};
402 auto callbackPtr1 = std::make_shared<CbCustomizeTest>(scopeInfo);
403 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1));
404
405 static PermissionStateFull infoManagerTestState = {
406 .permissionName = "ohos.permission.CAMERA",
407 .isGeneral = true,
408 .resDeviceID = {"local2"},
409 .grantStatus = {PERMISSION_DENIED},
410 .grantFlags = {1}
411 };
412 static HapPolicyParams infoManagerTestPolicyPrams6 = {
413 .apl = APL_SYSTEM_BASIC,
414 .domain = "test.domain2",
415 .permStateList = {infoManagerTestState}
416 };
417
418 AccessTokenIDEx tokenIdEx = {0};
419 ASSERT_EQ(
420 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams6, tokenIdEx));
421 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
422
423 scopeInfo.tokenIDs = {tokenIdEx.tokenIdExStruct.tokenID};
424 scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"};
425 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
426 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
427
428 int32_t res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2);
429 ASSERT_EQ(RET_SUCCESS, res);
430 usleep(500000); // 500000us = 0.5s
431 EXPECT_EQ(true, callbackPtr->ready_);
432
433 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
434
435 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
436 ASSERT_EQ(RET_SUCCESS, res);
437 }
438
439 /**
440 * @tc.name: RegisterPermStateChangeCallbackAbnormalTest003
441 * @tc.desc: RegisterPermStateChangeCallback with nullptr
442 * @tc.type: FUNC
443 * @tc.require: issueI5NT1X
444 */
445 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbnormalTest003, TestSize.Level1)
446 {
447 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackAbnormalTest003");
448 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(nullptr);
449 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
450 }
451
452 /**
453 * @tc.name: RegisterPermStateChangeCallbackSpecTest001
454 * @tc.desc: RegisterPermStateChangeCallback with permList, whose size is PERMS_LIST_SIZE_MAX_TEST
455 * @tc.type: FUNC
456 * @tc.require: issueI5NT1X
457 */
458 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpecTest001, TestSize.Level1)
459 {
460 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackSpecTest001");
461 PermStateChangeScope scopeInfo;
462 scopeInfo.permList = {};
463 scopeInfo.tokenIDs = {};
464 for (int32_t i = 0; i <= PERMS_LIST_SIZE_MAX_TEST; i++) {
465 scopeInfo.permList.emplace_back("ohos.permission.APPROXIMATELY_LOCATION");
466 if (i == PERMS_LIST_SIZE_MAX_TEST) {
467 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
468 ASSERT_EQ(
469 AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
470 break;
471 }
472 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
473 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
474 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
475 }
476 }
477
478 /**
479 * @tc.name: RegisterPermStateChangeCallbackSpecTest002
480 * @tc.desc: RegisterPermStateChangeCallback with tokenList, whose token size is oversize
481 * @tc.type: FUNC
482 * @tc.require: issueI5NT1X
483 */
484 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpecTest002, TestSize.Level1)
485 {
486 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackSpecTest002");
487 PermStateChangeScope scopeInfo;
488 scopeInfo.permList = {};
489 scopeInfo.tokenIDs = {};
490 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
491 callbackPtr->ready_ = false;
492
493 static HapPolicyParams infoManagerTestPolicyPrams8 = {
494 .apl = APL_NORMAL,
495 .domain = "test.domain",
496 .permStateList = {}
497 };
498
499 AccessTokenIDEx tokenIdEx = {0};
500 ASSERT_EQ(
501 RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams8, tokenIdEx));
502 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
503
504 for (int32_t i = 0; i <= TOKENIDS_LIST_SIZE_MAX_TEST; i++) {
505 scopeInfo.tokenIDs.emplace_back(tokenIdEx.tokenIdExStruct.tokenID);
506 if (i == TOKENIDS_LIST_SIZE_MAX_TEST) {
507 auto callbackPtr1 = std::make_shared<CbCustomizeTest>(scopeInfo);
508 ASSERT_EQ(
509 AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1));
510 break;
511 }
512 auto callbackPtr1 = std::make_shared<CbCustomizeTest>(scopeInfo);
513 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1));
514 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr1));
515 }
516
517 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
518 }
519
520 /**
521 * @tc.name: RegisterPermStateChangeCallbackSpecTest003
522 * @tc.desc: RegisterPermStateChangeCallback
523 * @tc.type: FUNC
524 * @tc.require: issueI5NT1X
525 */
526 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpecTest003, TestSize.Level1)
527 {
528 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackSpecTest003");
529 PermStateChangeScope scopeInfo;
530 scopeInfo.permList = {};
531 scopeInfo.tokenIDs = {};
532 std::vector<std::shared_ptr<CbCustomizeTest>> callbackList;
533
534 for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // 200 is the max size
535 if (i == MAX_CALLBACK_MAP_SIZE) { // 200 is the max size
536 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
537 ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION,
538 AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
539 break;
540 }
541 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
542 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr));
543 callbackList.emplace_back(callbackPtr);
544 }
545 for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // release 200 callback
546 auto callbackPtr = callbackList[i];
547 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
548 }
549 callbackList.clear();
550 }
551
552 /**
553 * @tc.name: RegisterPermStateChangeCallbackSpecTest004
554 * @tc.desc: ClearUserGrantedPermissionState notify.
555 * @tc.type: FUNC
556 * @tc.require: issueI5NT1X
557 */
558 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpecTest004, TestSize.Level1)
559 {
560 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackSpecTest004");
561 PermStateChangeScope scopeInfo;
562
563 static HapPolicyParams infoManagerTestPolicyPrams13 = {
564 .apl = APL_SYSTEM_BASIC,
565 .domain = "test.domain2",
566 .permStateList = {g_infoManagerTestStateA}
567 };
568
569 AccessTokenIDEx tokenIdEx = {0};
570 ASSERT_EQ(RET_SUCCESS,
571 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams13, tokenIdEx));
572 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
573
574 scopeInfo.tokenIDs = {tokenIdEx.tokenIdExStruct.tokenID};
575 scopeInfo.permList = {"ohos.permission.CAMERA"};
576 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
577 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
578 ASSERT_EQ(RET_SUCCESS, res);
579
580 res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2);
581 EXPECT_EQ(RET_SUCCESS, res);
582 usleep(500000); // 500000us = 0.5s
583 EXPECT_EQ(true, callbackPtr->ready_);
584
585 callbackPtr->ready_ = false;
586 {
587 std::vector<std::string> reqPerm;
588 reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS");
589 MockHapToken mock("RegisterPermStateChangeCallbackSpecTest004", reqPerm);
590 EXPECT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenIdEx.tokenIdExStruct.tokenID));
591 }
592 usleep(500000); // 500000us = 0.5s
593 EXPECT_EQ(true, callbackPtr->ready_);
594
595 callbackPtr->ready_ = false;
596 res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2);
597 EXPECT_EQ(RET_SUCCESS, res);
598 usleep(500000); // 500000us = 0.5s
599 EXPECT_EQ(true, callbackPtr->ready_);
600
601 callbackPtr->ready_ = false;
602 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
603 usleep(500000); // 500000us = 0.5s
604 EXPECT_EQ(true, callbackPtr->ready_);
605
606 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr));
607 }
608
609 /**
610 * @tc.name: RegisterPermStateChangeCallbackSpecTest005
611 * @tc.desc: ClearUserGrantedPermissionState notify.
612 * @tc.type: FUNC
613 * @tc.require: issueI5NT1X
614 */
615 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpecTest005, TestSize.Level1)
616 {
617 LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackSpecTest005");
618 PermStateChangeScope scopeInfo;
619 static PermissionStateFull infoManagerTestStateA = {
620 .permissionName = "ohos.permission.READ_MEDIA",
621 .isGeneral = true,
622 .resDeviceID = {"local2"},
623 .grantStatus = {PERMISSION_DENIED},
624 .grantFlags = {1}
625 };
626 static HapPolicyParams infoManagerTestPolicyPrams14 = {
627 .apl = APL_SYSTEM_BASIC,
628 .domain = "testA.domain2",
629 .permStateList = {infoManagerTestStateA}
630 };
631
632 AccessTokenIDEx tokenIdEx = {0};
633 ASSERT_EQ(RET_SUCCESS,
634 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams14, tokenIdEx));
635 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
636
637 scopeInfo.tokenIDs = {tokenIdEx.tokenIdExStruct.tokenID};
638 scopeInfo.permList = {"ohos.permission.READ_MEDIA"};
639 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
640 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
641 ASSERT_EQ(RET_SUCCESS, res);
642
643 res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID,
644 "ohos.permission.READ_MEDIA", PERMISSION_SYSTEM_FIXED);
645 EXPECT_EQ(RET_SUCCESS, res);
646 usleep(500000); // 500000us = 0.5s
647 EXPECT_EQ(true, callbackPtr->ready_);
648
649 callbackPtr->ready_ = false;
650 {
651 std::vector<std::string> reqPerm;
652 reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS");
653 MockHapToken mock("RegisterPermStateChangeCallbackSpecTest004", reqPerm);
654 EXPECT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenIdEx.tokenIdExStruct.tokenID));
655 }
656 usleep(500000); // 500000us = 0.5s
657 EXPECT_EQ(false, callbackPtr->ready_);
658
659 callbackPtr->ready_ = false;
660 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
661 usleep(500000); // 500000us = 0.5s
662 EXPECT_EQ(true, callbackPtr->ready_);
663
664 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
665 ASSERT_EQ(RET_SUCCESS, res);
666 }
667
668 /**
669 * @tc.name: RegisterSelfPermStateChangeCallback001
670 * @tc.desc: RegisterSelfPermStateChangeCallback permList
671 * @tc.type: FUNC
672 * @tc.require: issueI5NT1X
673 */
674 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback001, TestSize.Level1)
675 {
676 static HapPolicyParams infoManagerTestPolicyPrams1 = {
677 .apl = APL_NORMAL,
678 .domain = "test.domain2",
679 .permStateList = {g_infoManagerTestStateA}
680 };
681 AccessTokenIDEx tokenIdEx = {0};
682 ASSERT_EQ(RET_SUCCESS,
683 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
684 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
685 ASSERT_NE(INVALID_TOKENID, tokenID);
686
687 PermStateChangeScope scopeInfo;
688 scopeInfo.permList = {"ohos.permission.CAMERA"};
689 scopeInfo.tokenIDs = {tokenID};
690 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
691 callbackPtr->ready_ = false;
692
693 SetSelfTokenID(tokenID);
694 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
695 ASSERT_EQ(RET_SUCCESS, res);
696 SetSelfTokenID(g_selfShellTokenId);
697
698 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
699 ASSERT_EQ(RET_SUCCESS, res);
700
701 res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false);
702 ASSERT_EQ(PERMISSION_GRANTED, res);
703 usleep(500000); // 500000us = 0.5s
704 EXPECT_EQ(true, callbackPtr->ready_);
705
706 callbackPtr->ready_ = false;
707
708 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
709 ASSERT_EQ(RET_SUCCESS, res);
710 usleep(500000); // 500000us = 0.5s
711 EXPECT_EQ(true, callbackPtr->ready_);
712
713 SetSelfTokenID(tokenID);
714 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
715 ASSERT_EQ(RET_SUCCESS, res);
716 SetSelfTokenID(g_selfShellTokenId);
717
718 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
719 }
720
721 /**
722 * @tc.name: RegisterSelfPermStateChangeCallback002
723 * @tc.desc: RegisterSelfPermStateChangeCallback permList
724 * @tc.type: FUNC
725 * @tc.require: issueI5NT1X
726 */
727 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback002, TestSize.Level1)
728 {
729 static HapPolicyParams infoManagerTestPolicyPrams1 = {
730 .apl = APL_NORMAL,
731 .domain = "test.domain2",
732 .permStateList = {g_infoManagerTestStateA}
733 };
734 AccessTokenIDEx tokenIdEx = {0};
735 ASSERT_EQ(RET_SUCCESS,
736 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
737 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
738 ASSERT_NE(INVALID_TOKENID, tokenID);
739
740 PermStateChangeScope scopeInfo;
741 scopeInfo.permList = {"ohos.permission.CAMERA"};
742 scopeInfo.tokenIDs = {tokenID};
743 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
744 callbackPtr->ready_ = false;
745
746 SetSelfTokenID(tokenID);
747 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr));
748 SetSelfTokenID(g_selfShellTokenId);
749
750 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
751 usleep(500000); // 500000us = 0.5s
752 EXPECT_EQ(true, callbackPtr->ready_);
753
754 callbackPtr->ready_ = false;
755
756 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
757 usleep(500000); // 500000us = 0.5s
758 EXPECT_EQ(true, callbackPtr->ready_);
759
760 callbackPtr->ready_ = false;
761
762 SetSelfTokenID(tokenID);
763 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr));
764 SetSelfTokenID(g_selfShellTokenId);
765
766 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
767 }
768
769 /**
770 * @tc.name: RegisterSelfPermStateChangeCallback003
771 * @tc.desc: RegisterSelfPermStateChangeCallback permList
772 * @tc.type: FUNC
773 * @tc.require: issueI5NT1X
774 */
775 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback003, TestSize.Level1)
776 {
777 static HapPolicyParams infoManagerTestPolicyPrams1 = {
778 .apl = APL_NORMAL,
779 .domain = "test.domain2",
780 .permStateList = {g_infoManagerTestStateA}
781 };
782 AccessTokenIDEx tokenIdEx = {0};
783 ASSERT_EQ(RET_SUCCESS,
784 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
785 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
786 ASSERT_NE(INVALID_TOKENID, tokenID);
787
788 PermStateChangeScope scopeInfo;
789 scopeInfo.permList = {};
790 scopeInfo.tokenIDs = {tokenID};
791 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
792 callbackPtr->ready_ = false;
793
794 SetSelfTokenID(tokenID);
795 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
796 ASSERT_EQ(RET_SUCCESS, res);
797 SetSelfTokenID(g_selfShellTokenId);
798
799 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
800 ASSERT_EQ(RET_SUCCESS, res);
801
802 res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false);
803 ASSERT_EQ(PERMISSION_GRANTED, res);
804 usleep(500000); // 500000us = 0.5s
805 EXPECT_EQ(true, callbackPtr->ready_);
806
807 callbackPtr->ready_ = false;
808
809 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
810 ASSERT_EQ(RET_SUCCESS, res);
811 usleep(500000); // 500000us = 0.5s
812 EXPECT_EQ(true, callbackPtr->ready_);
813
814 SetSelfTokenID(tokenID);
815 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
816 ASSERT_EQ(RET_SUCCESS, res);
817 SetSelfTokenID(g_selfShellTokenId);
818
819 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
820 }
821
822 /**
823 * @tc.name: RegisterSelfPermStateChangeCallback004
824 * @tc.desc: RegisterSelfPermStateChangeCallback permList
825 * @tc.type: FUNC
826 * @tc.require: issueI5NT1X
827 */
828 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback004, TestSize.Level1)
829 {
830 PermissionStateFull infoManagerTestStateB = {
831 .permissionName = "ohos.permission.MICROPHONE",
832 .isGeneral = true,
833 .resDeviceID = {"local2"},
834 .grantStatus = {PERMISSION_DENIED},
835 .grantFlags = {1}
836 };
837 HapPolicyParams infoManagerTestPolicyPrams1 = {
838 .apl = APL_NORMAL,
839 .domain = "test.domain2",
840 .permStateList = {g_infoManagerTestStateA, infoManagerTestStateB}
841 };
842 AccessTokenIDEx tokenIdEx = {0};
843 ASSERT_EQ(RET_SUCCESS,
844 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
845 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
846 ASSERT_NE(INVALID_TOKENID, tokenID);
847
848 PermStateChangeScope scopeInfo;
849 scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.MICROPHONE"};
850 scopeInfo.tokenIDs = {tokenID};
851 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
852 callbackPtr->ready_ = false;
853
854 SetSelfTokenID(tokenID);
855 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr));
856 SetSelfTokenID(g_selfShellTokenId);
857
858 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
859 usleep(500000); // 500000us = 0.5s
860 EXPECT_EQ(true, callbackPtr->ready_);
861
862 callbackPtr->ready_ = false;
863 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
864 usleep(500000); // 500000us = 0.5s
865 EXPECT_EQ(true, callbackPtr->ready_);
866
867 callbackPtr->ready_ = false;
868 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.MICROPHONE", 2));
869 usleep(500000); // 500000us = 0.5s
870 EXPECT_EQ(true, callbackPtr->ready_);
871
872 callbackPtr->ready_ = false;
873 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.MICROPHONE", 2));
874 usleep(500000); // 500000us = 0.5s
875 EXPECT_EQ(true, callbackPtr->ready_);
876
877 SetSelfTokenID(tokenID);
878 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr));
879 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
880 }
881
882 /**
883 * @tc.name: RegisterSelfPermStateChangeCallback005
884 * @tc.desc: RegisterSelfPermStateChangeCallback permList
885 * @tc.type: FUNC
886 * @tc.require: issueI5NT1X
887 */
888 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback005, TestSize.Level1)
889 {
890 static PermissionStateFull infoManagerTestStateA = {
891 .permissionName = "ohos.permission.CAMERA",
892 .isGeneral = true,
893 .resDeviceID = {"local2"},
894 .grantStatus = {PERMISSION_DENIED},
895 .grantFlags = {1}
896 };
897 static HapPolicyParams infoManagerTestPolicyPrams1 = {
898 .apl = APL_NORMAL,
899 .domain = "test.domain2",
900 .permStateList = {g_infoManagerTestStateA}
901 };
902 AccessTokenIDEx tokenIdEx = {0};
903 ASSERT_EQ(RET_SUCCESS,
904 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
905 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
906 ASSERT_NE(INVALID_TOKENID, tokenID);
907
908 PermStateChangeScope scopeInfo;
909 scopeInfo.permList = {"ohos.permission.INVALID"};
910 scopeInfo.tokenIDs = {tokenID};
911 auto callbackPtr1 = std::make_shared<CbCustomizeTest>(scopeInfo);
912 callbackPtr1->ready_ = false;
913
914 SetSelfTokenID(tokenID);
915 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1);
916 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
917
918 scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"};
919 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
920 res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
921 ASSERT_EQ(RET_SUCCESS, res);
922 SetSelfTokenID(g_selfShellTokenId);
923
924 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
925 ASSERT_EQ(RET_SUCCESS, res);
926
927 res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false);
928 ASSERT_EQ(PERMISSION_GRANTED, res);
929 usleep(500000); // 500000us = 0.5s
930 EXPECT_EQ(true, callbackPtr->ready_);
931
932 callbackPtr->ready_ = false;
933
934 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
935 ASSERT_EQ(RET_SUCCESS, res);
936 usleep(500000); // 500000us = 0.5s
937 EXPECT_EQ(true, callbackPtr->ready_);
938
939 SetSelfTokenID(tokenID);
940 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
941 ASSERT_EQ(RET_SUCCESS, res);
942
943 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
944 }
945
946 /**
947 * @tc.name: RegisterSelfPermStateChangeCallback006
948 * @tc.desc: RegisterSelfPermStateChangeCallback with permList, whose size is oversize
949 * @tc.type: FUNC
950 * @tc.require: issueI5NT1X
951 */
952 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback006, TestSize.Level1)
953 {
954 static PermissionStateFull infoManagerTestStateA = {
955 .permissionName = "ohos.permission.GET_BUNDLE_INFO",
956 .isGeneral = true,
957 .resDeviceID = {"local2"},
958 .grantStatus = {PERMISSION_DENIED},
959 .grantFlags = {1}
960 };
961 static HapPolicyParams infoManagerTestPolicyPrams1 = {
962 .apl = APL_NORMAL,
963 .domain = "test.domain2",
964 .permList = {},
965 .permStateList = {infoManagerTestStateA}
966 };
967 AccessTokenIDEx tokenIdEx = {0};
968 ASSERT_EQ(RET_SUCCESS,
969 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
970 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
971 ASSERT_NE(INVALID_TOKENID, tokenID);
972 SetSelfTokenID(tokenID);
973
974 PermStateChangeScope scopeInfo;
975 scopeInfo.permList = {};
976 scopeInfo.tokenIDs = {GetSelfTokenID()};
977 for (int32_t i = 0; i <= PERMS_LIST_SIZE_MAX_TEST; i++) { // 1025 is a invalid size
978 scopeInfo.permList.emplace_back("ohos.permission.MICROPHONE");
979 if (i == PERMS_LIST_SIZE_MAX_TEST) { // 1025 is a invalid size
980 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
981 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
982 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
983 break;
984 }
985 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
986 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr));
987 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr));
988 }
989 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
990 }
991
992 /**
993 * @tc.name: RegisterSelfPermStateChangeCallback007
994 * @tc.desc: RegisterSelfPermStateChangeCallback without set TokenID.
995 * @tc.type: FUNC
996 * @tc.require: issueI5NT1X
997 */
998 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback007, TestSize.Level1)
999 {
1000 static HapPolicyParams infoManagerTestPolicyPrams1 = {
1001 .apl = APL_NORMAL,
1002 .domain = "test.domain2",
1003 .permList = {},
1004 .permStateList = {g_infoManagerTestStateA}
1005 };
1006 AccessTokenIDEx tokenIdEx = {0};
1007 ASSERT_EQ(RET_SUCCESS,
1008 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
1009 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1010 ASSERT_NE(INVALID_TOKENID, tokenID);
1011
1012 PermStateChangeScope scopeInfo;
1013 scopeInfo.permList = {"ohos.permission.CAMERA"};
1014 scopeInfo.tokenIDs = {tokenID};
1015 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
1016 callbackPtr->ready_ = false;
1017
1018 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
1019 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
1020
1021 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1022 }
1023
1024 /**
1025 * @tc.name: RegisterSelfPermStateChangeCallback008
1026 * @tc.desc: RegisterSelfPermStateChangeCallback with none or two tokenIDs.
1027 * @tc.type: FUNC
1028 * @tc.require: issueI5NT1X
1029 */
1030 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback008, TestSize.Level1)
1031 {
1032 static HapPolicyParams infoManagerTestPolicyPrams1 = {
1033 .apl = APL_NORMAL,
1034 .domain = "test.domain2",
1035 .permStateList = {g_infoManagerTestStateA}
1036 };
1037 AccessTokenIDEx tokenIdEx = {0};
1038 ASSERT_EQ(RET_SUCCESS,
1039 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
1040 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1041 ASSERT_NE(INVALID_TOKENID, tokenID);
1042
1043 HapInfoParams infoManagerTestInfoParms2 = {
1044 .userID = 1,
1045 .bundleName = "accesstoken_test_2",
1046 .instIndex = 0,
1047 .appIDDesc = "test2",
1048 .apiVersion = TestCommon::DEFAULT_API_VERSION
1049 };
1050
1051 ASSERT_EQ(RET_SUCCESS,
1052 TestCommon::AllocTestHapToken(infoManagerTestInfoParms2, infoManagerTestPolicyPrams1, tokenIdEx));
1053 AccessTokenID tokenID2 = tokenIdEx.tokenIdExStruct.tokenID;
1054 ASSERT_NE(INVALID_TOKENID, tokenID2);
1055
1056 PermStateChangeScope scopeInfo;
1057 scopeInfo.permList = {"ohos.permission.CAMERA"};
1058 scopeInfo.tokenIDs = {};
1059 auto callbackPtr1 = std::make_shared<CbCustomizeTest>(scopeInfo);
1060 callbackPtr1->ready_ = false;
1061
1062 // tokenIDs size si 0,
1063 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1);
1064 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
1065
1066 scopeInfo.tokenIDs = {tokenID, tokenID2};
1067 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
1068 callbackPtr->ready_ = false;
1069
1070 // tokenIDs size != 1
1071 res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
1072 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
1073
1074 SetSelfTokenID(g_selfShellTokenId);
1075 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1076 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID2));
1077 }
1078
1079 /**
1080 * @tc.name: RegisterSelfPermStateChangeCallback009
1081 * @tc.desc: RegisterSelfPermStateChangeCallback
1082 * @tc.type: FUNC
1083 * @tc.require: issueI5NT1X
1084 */
1085 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback009, TestSize.Level1)
1086 {
1087 static HapPolicyParams infoManagerTestPolicyPrams1 = {
1088 .apl = APL_NORMAL,
1089 .domain = "test.domain2",
1090 .permList = {},
1091 .permStateList = {g_infoManagerTestStateA}
1092 };
1093 AccessTokenIDEx tokenIdEx = {0};
1094 ASSERT_EQ(RET_SUCCESS,
1095 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
1096 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1097 ASSERT_NE(INVALID_TOKENID, tokenID);
1098 SetSelfTokenID(tokenID);
1099
1100 PermStateChangeScope scopeInfo;
1101 scopeInfo.permList = {};
1102 scopeInfo.tokenIDs = {tokenID};
1103 std::vector<std::shared_ptr<CbCustomizeTest>> callbackList;
1104
1105 for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // 200 is the max size
1106 if (i == MAX_CALLBACK_MAP_SIZE) { // 200 is the max size
1107 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
1108 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
1109 ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res);
1110 break;
1111 }
1112 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
1113 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr));
1114 callbackList.emplace_back(callbackPtr);
1115 }
1116 for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // release 200 callback
1117 auto callbackPtr = callbackList[i];
1118 int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
1119 ASSERT_EQ(RET_SUCCESS, res);
1120 }
1121 callbackList.clear();
1122
1123 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1124 }
1125
1126 /**
1127 * @tc.name: RegisterSelfPermStateChangeCallback010
1128 * @tc.desc: RegisterSelfPermStateChangeCallback with nullptr
1129 * @tc.type: FUNC
1130 * @tc.require: issueI5NT1X
1131 */
1132 HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback010, TestSize.Level1)
1133 {
1134 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(nullptr);
1135 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
1136 }
1137 } // namespace AccessToken
1138 } // namespace Security
1139 } // namespace OHOS
1140