1 /*
2 * Copyright (c) 2023 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 "un_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 uint64_t g_selfShellTokenId;
41 HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms();
42 }
43
SetUpTestCase()44 void UnRegisterPermStateChangeCallbackTest::SetUpTestCase()
45 {
46 g_selfShellTokenId = GetSelfTokenID();
47 TestCommon::SetTestEvironment(g_selfShellTokenId);
48 std::vector<std::string> reqPerm;
49 reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS");
50 g_mock = new (std::nothrow) MockHapToken("UnRegisterPermStateChangeCallbackTest", reqPerm, true);
51 }
52
TearDownTestCase()53 void UnRegisterPermStateChangeCallbackTest::TearDownTestCase()
54 {
55 if (g_mock != nullptr) {
56 delete g_mock;
57 g_mock = nullptr;
58 }
59 SetSelfTokenID(g_selfShellTokenId);
60 TestCommon::ResetTestEvironment();
61 }
62
SetUp()63 void UnRegisterPermStateChangeCallbackTest::SetUp()
64 {
65 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
66 }
67
TearDown()68 void UnRegisterPermStateChangeCallbackTest::TearDown()
69 {
70 }
71
72 class CbCustomizeTest : public PermStateChangeCallbackCustomize {
73 public:
CbCustomizeTest(const PermStateChangeScope & scopeInfo)74 explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo)
75 : PermStateChangeCallbackCustomize(scopeInfo)
76 {
77 }
78
~CbCustomizeTest()79 ~CbCustomizeTest()
80 {}
81
PermStateChangeCallback(PermStateChangeInfo & result)82 virtual void PermStateChangeCallback(PermStateChangeInfo& result)
83 {
84 ready_ = true;
85 int32_t status = (result.permStateChangeType == 1) ? PERMISSION_GRANTED : PERMISSION_DENIED;
86 ASSERT_EQ(status, AccessTokenKit::VerifyAccessToken(result.tokenID, result.permissionName));
87 }
88
89 bool ready_;
90 };
91
92 /**
93 * @tc.name: UnRegisterPermStateChangeCallbackAbnormalTest001
94 * @tc.desc: UnRegisterPermStateChangeCallback with invalid input.
95 * @tc.type: FUNC
96 * @tc.require: issueI5NT1X
97 */
98 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterPermStateChangeCallbackAbnormalTest001, TestSize.Level1)
99 {
100 LOGI(ATM_DOMAIN, ATM_TAG, "UnRegisterPermStateChangeCallbackAbnormalTest001");
101 PermStateChangeScope scopeInfo;
102 scopeInfo.permList = {};
103 scopeInfo.tokenIDs = {};
104 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
105 callbackPtr->ready_ = false;
106
107 int32_t res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
108 ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res);
109 }
110
111 /**
112 * @tc.name: UnRegisterPermStateChangeCallbackSpecTest001
113 * @tc.desc: UnRegisterPermStateChangeCallback repeatedly.
114 * @tc.type: FUNC
115 * @tc.require: issueI5NT1X
116 */
117 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterPermStateChangeCallbackSpecTest001, TestSize.Level1)
118 {
119 LOGI(ATM_DOMAIN, ATM_TAG, "UnRegisterPermStateChangeCallbackSpecTest001");
120 PermStateChangeScope scopeInfo;
121 scopeInfo.permList = {};
122 scopeInfo.tokenIDs = {};
123 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
124 callbackPtr->ready_ = false;
125
126 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
127 ASSERT_EQ(RET_SUCCESS, res);
128 res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
129 ASSERT_EQ(AccessTokenError::ERR_CALLBACK_ALREADY_EXIST, res);
130 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
131 ASSERT_EQ(RET_SUCCESS, res);
132 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
133 ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res);
134 }
135
136 /**
137 * @tc.name: UnRegisterPermStateChangeCallbackFuncTest001
138 * @tc.desc: UnRegisterPermStateChangeCallback caller is normal app.
139 * @tc.type: FUNC
140 * @tc.require: issueI66BH3
141 */
142 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterPermStateChangeCallbackFuncTest001, TestSize.Level0)
143 {
144 LOGI(ATM_DOMAIN, ATM_TAG, "UnRegisterPermStateChangeCallbackFuncTest001");
145 PermStateChangeScope scopeInfo;
146 scopeInfo.permList = {};
147 scopeInfo.tokenIDs = {};
148 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
149 callbackPtr->ready_ = false;
150
151 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
152 ASSERT_EQ(RET_SUCCESS, res);
153
154 {
155 std::vector<std::string> reqPerm;
156 reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS");
157 MockHapToken mock("UnRegisterPermStateChangeCallbackFuncTest001", reqPerm, false);
158
159 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
160 ASSERT_EQ(ERR_NOT_SYSTEM_APP, res);
161 }
162
163 res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
164 ASSERT_EQ(RET_SUCCESS, res);
165 }
166
167 /**
168 * @tc.name: UnRegisterSelfPermStateChangeCallback001
169 * @tc.desc: UnRegisterSelfPermStateChangeCallback with invalid input.
170 * @tc.type: FUNC
171 * @tc.require: issueI5NT1X
172 */
173 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback001, TestSize.Level1)
174 {
175 static PermissionStateFull infoManagerTestStateA = {
176 .permissionName = "ohos.permission.CAMERA",
177 .isGeneral = true,
178 .resDeviceID = {"local2"},
179 .grantStatus = {PERMISSION_DENIED},
180 .grantFlags = {1}
181 };
182 static HapPolicyParams infoManagerTestPolicyPrams1 = {
183 .apl = APL_NORMAL,
184 .domain = "test.domain2",
185 .permStateList = {infoManagerTestStateA}
186 };
187 AccessTokenIDEx tokenIdEx = {0};
188 ASSERT_EQ(RET_SUCCESS,
189 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
190 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
191 ASSERT_NE(INVALID_TOKENID, tokenID);
192
193 PermStateChangeScope scopeInfo;
194 scopeInfo.permList = {};
195 scopeInfo.tokenIDs = {tokenID};
196 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
197 callbackPtr->ready_ = false;
198
199 SetSelfTokenID(tokenID);
200 int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
201 ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res);
202
203 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
204 SetSelfTokenID(g_selfShellTokenId);
205 }
206
207 /**
208 * @tc.name: UnRegisterSelfPermStateChangeCallback002
209 * @tc.desc: UnRegisterSelfPermStateChangeCallback repeatedly.
210 * @tc.type: FUNC
211 * @tc.require: issueI5NT1X
212 */
213 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback002, TestSize.Level1)
214 {
215 static PermissionStateFull infoManagerTestStateA = {
216 .permissionName = "ohos.permission.CAMERA",
217 .isGeneral = true,
218 .resDeviceID = {"local2"},
219 .grantStatus = {PERMISSION_DENIED},
220 .grantFlags = {1}
221 };
222 static HapPolicyParams infoManagerTestPolicyPrams1 = {
223 .apl = APL_NORMAL,
224 .domain = "test.domain2",
225 .permStateList = {infoManagerTestStateA}
226 };
227 AccessTokenIDEx tokenIdEx = {0};
228 ASSERT_EQ(RET_SUCCESS,
229 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
230 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
231 ASSERT_NE(INVALID_TOKENID, tokenID);
232
233 PermStateChangeScope scopeInfo;
234 scopeInfo.permList = {};
235 scopeInfo.tokenIDs = {tokenID};
236 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
237 callbackPtr->ready_ = false;
238
239 SetSelfTokenID(tokenID);
240 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
241 ASSERT_EQ(RET_SUCCESS, res);
242 res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
243 ASSERT_EQ(AccessTokenError::ERR_CALLBACK_ALREADY_EXIST, res);
244 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
245 ASSERT_EQ(RET_SUCCESS, res);
246 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
247 ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res);
248 SetSelfTokenID(g_selfShellTokenId);
249
250 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
251 }
252
253 /**
254 * @tc.name: UnRegisterSelfPermStateChangeCallback003
255 * @tc.desc: UnRegisterSelfPermStateChangeCallback permList
256 * @tc.type: FUNC
257 * @tc.require: issueI5NT1X
258 */
259 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback003, TestSize.Level1)
260 {
261 static PermissionStateFull infoManagerTestStateA = {
262 .permissionName = "ohos.permission.CAMERA",
263 .isGeneral = true,
264 .resDeviceID = {"local2"},
265 .grantStatus = {PERMISSION_DENIED},
266 .grantFlags = {1}
267 };
268 static HapPolicyParams infoManagerTestPolicyPrams1 = {
269 .apl = APL_NORMAL,
270 .domain = "test.domain2",
271 .permStateList = {infoManagerTestStateA}
272 };
273 AccessTokenIDEx tokenIdEx = {0};
274 ASSERT_EQ(RET_SUCCESS,
275 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
276 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
277 ASSERT_NE(INVALID_TOKENID, tokenID);
278
279 PermStateChangeScope scopeInfo;
280 scopeInfo.permList = {"ohos.permission.CAMERA"};
281 scopeInfo.tokenIDs = {tokenID};
282 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
283 callbackPtr->ready_ = false;
284
285 SetSelfTokenID(tokenID);
286 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
287 ASSERT_EQ(RET_SUCCESS, res);
288
289 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
290 ASSERT_EQ(RET_SUCCESS, res);
291 SetSelfTokenID(g_selfShellTokenId);
292
293 callbackPtr->ready_ = false;
294
295 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
296 ASSERT_EQ(RET_SUCCESS, res);
297 usleep(500000); // 500000us = 0.5s
298 ASSERT_EQ(false, callbackPtr->ready_);
299
300 callbackPtr->ready_ = false;
301
302 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
303 ASSERT_EQ(RET_SUCCESS, res);
304 usleep(500000); // 500000us = 0.5s
305 ASSERT_EQ(false, callbackPtr->ready_);
306
307 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
308 }
309
310 /**
311 * @tc.name: UnRegisterSelfPermStateChangeCallback004
312 * @tc.desc: UnRegisterSelfPermStateChangeCallback permList
313 * @tc.type: FUNC
314 * @tc.require: issueI5NT1X
315 */
316 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback004, TestSize.Level1)
317 {
318 static PermissionStateFull infoManagerTestStateA = {
319 .permissionName = "ohos.permission.CAMERA",
320 .isGeneral = true,
321 .resDeviceID = {"local2"},
322 .grantStatus = {PERMISSION_DENIED},
323 .grantFlags = {1}
324 };
325 static PermissionStateFull infoManagerTestStateB = {
326 .permissionName = "ohos.permission.GET_BUNDLE_INFO",
327 .isGeneral = true,
328 .resDeviceID = {"local2"},
329 .grantStatus = {PERMISSION_DENIED},
330 .grantFlags = {1}
331 };
332 static HapPolicyParams infoManagerTestPolicyPrams1 = {
333 .apl = APL_NORMAL,
334 .domain = "test.domain2",
335 .permStateList = {infoManagerTestStateA, infoManagerTestStateB}
336 };
337 AccessTokenIDEx tokenIdEx = {0};
338 ASSERT_EQ(RET_SUCCESS,
339 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
340 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
341 ASSERT_NE(INVALID_TOKENID, tokenID);
342
343 PermStateChangeScope scopeInfo;
344 scopeInfo.permList = {"ohos.permission.CAMERA"};
345 scopeInfo.tokenIDs = {tokenID};
346 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
347 callbackPtr->ready_ = false;
348
349 SetSelfTokenID(tokenID);
350 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
351 ASSERT_EQ(RET_SUCCESS, res);
352
353 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
354 ASSERT_EQ(RET_SUCCESS, res);
355 SetSelfTokenID(g_selfShellTokenId);
356
357 callbackPtr->ready_ = false;
358
359 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
360 ASSERT_EQ(RET_SUCCESS, res);
361 usleep(500000); // 500000us = 0.5s
362 ASSERT_EQ(false, callbackPtr->ready_);
363
364 callbackPtr->ready_ = false;
365
366 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
367 ASSERT_EQ(RET_SUCCESS, res);
368 usleep(500000); // 500000us = 0.5s
369 ASSERT_EQ(false, callbackPtr->ready_);
370
371 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
372 }
373
374 /**
375 * @tc.name: UnRegisterSelfPermStateChangeCallback005
376 * @tc.desc: UnRegisterSelfPermStateChangeCallback permList
377 * @tc.type: FUNC
378 * @tc.require: issueI5NT1X
379 */
380 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback005, TestSize.Level1)
381 {
382 static PermissionStateFull infoManagerTestStateA = {
383 .permissionName = "ohos.permission.CAMERA",
384 .isGeneral = true,
385 .resDeviceID = {"local2"},
386 .grantStatus = {PERMISSION_DENIED},
387 .grantFlags = {1}
388 };
389 static HapPolicyParams infoManagerTestPolicyPrams1 = {
390 .apl = APL_NORMAL,
391 .domain = "test.domain2",
392 .permStateList = {infoManagerTestStateA}
393 };
394 AccessTokenIDEx tokenIdEx = {0};
395 ASSERT_EQ(RET_SUCCESS,
396 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
397 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
398 ASSERT_NE(INVALID_TOKENID, tokenID);
399
400 PermStateChangeScope scopeInfo;
401 scopeInfo.permList = {};
402 scopeInfo.tokenIDs = {tokenID};
403 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
404 callbackPtr->ready_ = false;
405
406 SetSelfTokenID(tokenID);
407 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
408 ASSERT_EQ(RET_SUCCESS, res);
409 SetSelfTokenID(g_selfShellTokenId);
410
411 SetSelfTokenID(tokenID);
412 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
413 ASSERT_EQ(RET_SUCCESS, res);
414 SetSelfTokenID(g_selfShellTokenId);
415
416 callbackPtr->ready_ = false;
417
418 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
419 ASSERT_EQ(RET_SUCCESS, res);
420 usleep(500000); // 500000us = 0.5s
421 ASSERT_EQ(false, callbackPtr->ready_);
422
423 callbackPtr->ready_ = false;
424
425 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
426 ASSERT_EQ(RET_SUCCESS, res);
427 usleep(500000); // 500000us = 0.5s
428 ASSERT_EQ(false, callbackPtr->ready_);
429
430 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
431 }
432
433 /**
434 * @tc.name: UnRegisterSelfPermStateChangeCallback006
435 * @tc.desc: UnRegisterSelfPermStateChangeCallback permList
436 * @tc.type: FUNC
437 * @tc.require: issueI5NT1X
438 */
439 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback006, TestSize.Level1)
440 {
441 static PermissionStateFull infoManagerTestStateA = {
442 .permissionName = "ohos.permission.CAMERA",
443 .isGeneral = true,
444 .resDeviceID = {"local2"},
445 .grantStatus = {PERMISSION_DENIED},
446 .grantFlags = {1}
447 };
448 static PermissionStateFull infoManagerTestStateB = {
449 .permissionName = "ohos.permission.DISTRIBUTED_DATASYNC",
450 .isGeneral = true,
451 .resDeviceID = {"local2"},
452 .grantStatus = {PERMISSION_DENIED},
453 .grantFlags = {1}
454 };
455 static HapPolicyParams infoManagerTestPolicyPrams1 = {
456 .apl = APL_NORMAL,
457 .domain = "test.domain2",
458 .permStateList = {infoManagerTestStateA, infoManagerTestStateB}
459 };
460 AccessTokenIDEx tokenIdEx = {0};
461 ASSERT_EQ(RET_SUCCESS,
462 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
463 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
464 ASSERT_NE(INVALID_TOKENID, tokenID);
465
466 PermStateChangeScope scopeInfo;
467 scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.DISTRIBUTED_DATASYNC"};
468 scopeInfo.tokenIDs = {tokenID};
469 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
470 callbackPtr->ready_ = false;
471
472 SetSelfTokenID(tokenID);
473 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr));
474
475 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr));
476 SetSelfTokenID(g_selfShellTokenId);
477
478 callbackPtr->ready_ = false;
479
480 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
481 usleep(500000); // 500000us = 0.5s
482 ASSERT_EQ(false, callbackPtr->ready_);
483
484 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2));
485 usleep(500000); // 500000us = 0.5s
486 ASSERT_EQ(false, callbackPtr->ready_);
487
488 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.DISTRIBUTED_DATASYNC", 2));
489 usleep(500000); // 500000us = 0.5s
490 ASSERT_EQ(false, callbackPtr->ready_);
491
492 ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.DISTRIBUTED_DATASYNC", 2));
493 usleep(500000); // 500000us = 0.5s
494 ASSERT_EQ(false, callbackPtr->ready_);
495
496 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
497 }
498
499 /**
500 * @tc.name: UnRegisterSelfPermStateChangeCallback007
501 * @tc.desc: UnRegisterSelfPermStateChangeCallback permList
502 * @tc.type: FUNC
503 * @tc.require: issueI5NT1X
504 */
505 HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback007, TestSize.Level1)
506 {
507 static PermissionStateFull infoManagerTestStateA = {
508 .permissionName = "ohos.permission.CAMERA",
509 .isGeneral = true,
510 .resDeviceID = {"local2"},
511 .grantStatus = {PERMISSION_DENIED},
512 .grantFlags = {1}
513 };
514 static HapPolicyParams infoManagerTestPolicyPrams1 = {
515 .apl = APL_NORMAL,
516 .domain = "test.domain2",
517 .permStateList = {infoManagerTestStateA}
518 };
519 AccessTokenIDEx tokenIdEx = {0};
520 ASSERT_EQ(RET_SUCCESS,
521 TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx));
522 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
523 ASSERT_NE(INVALID_TOKENID, tokenID);
524
525 PermStateChangeScope scopeInfo;
526 scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"};
527 scopeInfo.tokenIDs = {tokenID};
528 auto callbackPtr = std::make_shared<CbCustomizeTest>(scopeInfo);
529 callbackPtr->ready_ = false;
530
531 SetSelfTokenID(tokenID);
532 int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr);
533 ASSERT_EQ(RET_SUCCESS, res);
534
535 res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr);
536 ASSERT_EQ(RET_SUCCESS, res);
537 SetSelfTokenID(g_selfShellTokenId);
538
539 callbackPtr->ready_ = false;
540
541 res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
542 ASSERT_EQ(RET_SUCCESS, res);
543 usleep(500000); // 500000us = 0.5s
544 ASSERT_EQ(false, callbackPtr->ready_);
545
546 callbackPtr->ready_ = false;
547
548 res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2);
549 ASSERT_EQ(RET_SUCCESS, res);
550 usleep(500000); // 500000us = 0.5s
551 ASSERT_EQ(false, callbackPtr->ready_);
552
553 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
554 }
555 } // namespace AccessToken
556 } // namespace Security
557 } // namespace OHOS