1 /*
2 * Copyright (c) 2022-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 <cstdint>
17 #include <gtest/gtest.h>
18 #include <string>
19
20 #include "access_token.h"
21 #include "accesstoken_kit.h"
22 #include "active_change_response_info.h"
23 #include "audio_manager_adapter.h"
24 #include "constant.h"
25 #include "data_translator.h"
26 #include "permission_record.h"
27 #define private public
28 #include "active_status_callback_manager.h"
29 #include "libraryloader.h"
30 #include "permission_record_manager.h"
31 #include "permission_used_record_db.h"
32 #include "privacy_manager_service.h"
33 #include "privacy_manager_proxy_death_param.h"
34 #include "proxy_death_callback_stub.h"
35 #undef private
36 #include "parameter.h"
37 #include "perm_active_status_change_callback_stub.h"
38 #include "privacy_error.h"
39 #include "privacy_field_const.h"
40 #include "privacy_kit.h"
41 #include "privacy_test_common.h"
42 #include "state_change_callback.h"
43 #include "time_util.h"
44 #include "token_setproc.h"
45
46 using namespace testing;
47 using namespace testing::ext;
48 using namespace OHOS;
49
50 namespace OHOS {
51 namespace Security {
52 namespace AccessToken {
53 namespace {
54 static int32_t PID = -1;
55 static int32_t TEST_PID_1 = 1;
56 static int32_t TEST_PID_2 = 2;
57 static int32_t TEST_PID_3 = 3;
58 static constexpr int32_t CALLER_PID = 11;
59 static constexpr int32_t CALLER_PID2 = 12;
60 static AccessTokenID g_selfTokenId = 0;
61 static AccessTokenID g_nativeToken = 0;
62 static bool g_isMicEdmMute = false;
63 static bool g_isMicMixMute = false;
64 static bool g_isMicMute = false;
65 static constexpr int32_t TEST_USER_ID_10 = 10;
66 static constexpr int32_t TEST_INVALID_USER_ID = -1;
67 static constexpr int32_t TEST_INVALID_USER_ID_20000 = 20000;
68 static constexpr uint32_t MAX_CALLBACK_SIZE = 1024;
69 static constexpr uint32_t RANDOM_TOKENID = 123;
70 static constexpr int32_t FIRST_INDEX = 0;
71 static const int32_t NORMAL_TYPE_ADD_VALUE = 1;
72 static const int32_t PICKER_TYPE_ADD_VALUE = 2;
73 static const int32_t SEC_COMPONENT_TYPE_ADD_VALUE = 4;
74 static const int32_t VALUE_MAX_LEN = 32;
75 const static uint32_t TEST_MAX_PERMISSION_USED_TYPE_SIZE = 20;
76 static const char* EDM_MIC_MUTE_KEY = "persist.edm.mic_disable";
77 static MockNativeToken* g_mock = nullptr;
78 static PermissionStateFull g_testState1 = {
79 .permissionName = "ohos.permission.CAMERA",
80 .isGeneral = true,
81 .resDeviceID = {"local"},
82 .grantStatus = {PermissionState::PERMISSION_GRANTED},
83 .grantFlags = {1}
84 };
85
86 static PermissionStateFull g_testState2 = {
87 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
88 .isGeneral = true,
89 .resDeviceID = {"local"},
90 .grantStatus = {PermissionState::PERMISSION_GRANTED},
91 .grantFlags = {1}
92 };
93
94 static PermissionStateFull g_testState3 = {
95 .permissionName = "ohos.permission.MANAGE_AUDIO_CONFIG",
96 .isGeneral = true,
97 .resDeviceID = {"local"},
98 .grantStatus = {PermissionState::PERMISSION_GRANTED},
99 .grantFlags = {1}
100 };
101
102 static HapPolicyParams g_PolicyPrams1 = {
103 .apl = APL_NORMAL,
104 .domain = "test.domain.A",
105 .permList = {},
106 .permStateList = {g_testState1, g_testState2, g_testState3}
107 };
108
109 static HapInfoParams g_InfoParms1 = {
110 .userID = 1,
111 .bundleName = "ohos.privacy_test.bundleA",
112 .instIndex = 0,
113 .appIDDesc = "privacy_test.bundleA"
114 };
115
116 static HapPolicyParams g_PolicyPrams2 = {
117 .apl = APL_NORMAL,
118 .domain = "test.domain.B",
119 .permList = {},
120 .permStateList = {g_testState1}
121 };
122
123 static HapInfoParams g_InfoParms2 = {
124 .userID = 1,
125 .bundleName = "ohos.privacy_test.bundleB",
126 .instIndex = 0,
127 .appIDDesc = "privacy_test.bundleB"
128 };
129 }
130 class PermissionRecordManagerTest : public testing::Test {
131 public:
132 static void SetUpTestCase();
133
134 static void TearDownTestCase();
135
136 void SetUp();
137
138 void TearDown();
139
140 std::shared_ptr<PrivacyAppStateObserver> appStateObserver_ = nullptr;
141 };
142
SetUpTestCase()143 void PermissionRecordManagerTest::SetUpTestCase()
144 {
145 g_selfTokenId = GetSelfTokenID();
146 PrivacyTestCommon::SetTestEvironment(g_selfTokenId);
147 g_mock = new (std::nothrow) MockNativeToken("privacy_service");
148
149 DelayedSingleton<PrivacyManagerService>::GetInstance()->Initialize();
150 PermissionRecordManager::GetInstance().Init();
151
152 g_nativeToken = PrivacyTestCommon::GetNativeTokenIdFromProcess("privacy_service");
153 g_isMicEdmMute = PermissionRecordManager::GetInstance().isMicEdmMute_;
154 g_isMicMixMute = PermissionRecordManager::GetInstance().isMicMixMute_;
155 PermissionRecordManager::GetInstance().isMicEdmMute_ = false;
156 PermissionRecordManager::GetInstance().isMicMixMute_ = false;
157 g_isMicMute = AudioManagerAdapter::GetInstance().GetPersistentMicMuteState();
158 }
159
TearDownTestCase()160 void PermissionRecordManagerTest::TearDownTestCase()
161 {
162 PermissionRecordManager::GetInstance().isMicEdmMute_ = g_isMicEdmMute;
163 PermissionRecordManager::GetInstance().isMicMixMute_ = g_isMicMixMute;
164 PrivacyTestCommon::ResetTestEvironment();
165 if (g_mock != nullptr) {
166 delete g_mock;
167 g_mock = nullptr;
168 }
169 }
170
SetUp()171 void PermissionRecordManagerTest::SetUp()
172 {
173 PermissionRecordManager::GetInstance().Init();
174 PermissionRecordManager::GetInstance().Register();
175
176 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_InfoParms1, g_PolicyPrams1);
177 ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID);
178 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_InfoParms2, g_PolicyPrams2);
179 ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID);
180 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
181 RANDOM_TOKENID);
182 if (appStateObserver_ != nullptr) {
183 return;
184 }
185 appStateObserver_ = std::make_shared<PrivacyAppStateObserver>();
186 }
187
TearDown()188 void PermissionRecordManagerTest::TearDown()
189 {
190 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, g_isMicMute,
191 RANDOM_TOKENID);
192 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
193 g_InfoParms1.instIndex);
194 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
195 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
196 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms2.userID, g_InfoParms2.bundleName,
197 g_InfoParms2.instIndex);
198 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
199 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
200 appStateObserver_ = nullptr;
201 }
202
203 class PermissionRecordManagerTestCb1 : public StateCustomizedCbk {
204 public:
PermissionRecordManagerTestCb1()205 PermissionRecordManagerTestCb1()
206 {}
207
~PermissionRecordManagerTestCb1()208 ~PermissionRecordManagerTestCb1()
209 {}
210
StateChangeNotify(AccessTokenID tokenId,bool isShow)211 void StateChangeNotify(AccessTokenID tokenId, bool isShow)
212 {
213 GTEST_LOG_(INFO) << "PermissionRecordManagerTestCb1 isShow" << isShow;
214 isShow_ = isShow;
215 }
216
Stop()217 void Stop()
218 {}
219
220 bool isShow_ = true;
221 };
222
MakeInfo(AccessTokenID tokenId,int32_t pid,const std::string & permission,PermissionUsedType type=PermissionUsedType::NORMAL_TYPE)223 static PermissionUsedTypeInfo MakeInfo(AccessTokenID tokenId, int32_t pid, const std::string &permission,
224 PermissionUsedType type = PermissionUsedType::NORMAL_TYPE)
225 {
226 PermissionUsedTypeInfo info = {
227 .tokenId = tokenId,
228 .pid = pid,
229 .permissionName = permission,
230 .type = type
231 };
232 return info;
233 }
234
235 /**
236 * @tc.name: RegisterPermActiveStatusCallback001
237 * @tc.desc: RegisterPermActiveStatusCallback with invalid parameter.
238 * @tc.type: FUNC
239 * @tc.require: issueI5RWX8
240 */
241 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback001, TestSize.Level0)
242 {
243 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
244 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
245 GetSelfTokenID(), permList, nullptr));
246 }
247
248
249 class PermActiveStatusChangeCallback : public PermActiveStatusChangeCallbackStub {
250 public:
251 PermActiveStatusChangeCallback() = default;
252 virtual ~PermActiveStatusChangeCallback() = default;
253
AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient> & deathRecipient)254 bool AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient>& deathRecipient) override
255 {
256 return true;
257 }
258
ActiveStatusChangeCallback(ActiveChangeResponse & result)259 void ActiveStatusChangeCallback(ActiveChangeResponse& result) override
260 {
261 type_ = result.type;
262 GTEST_LOG_(INFO) << "ActiveStatusChange tokenid " << result.tokenID <<
263 ", permission " << result.permissionName << ", type " << result.type;
264 }
265
266 ActiveChangeType type_ = PERM_INACTIVE;
267 };
268
269 /**
270 * @tc.name: RegisterPermActiveStatusCallback002
271 * @tc.desc: RegisterPermActiveStatusCallback with exceed limitation.
272 * @tc.type: FUNC
273 * @tc.require: issueI5RWX8
274 */
275 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback002, TestSize.Level0)
276 {
277 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
278 std::vector<sptr<PermActiveStatusChangeCallback>> callbacks;
279
280 for (size_t i = 0; i < MAX_CALLBACK_SIZE; ++i) {
281 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
282 ASSERT_NE(nullptr, callback);
283 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
284 GetSelfTokenID(), permList, callback->AsObject()));
285 callbacks.emplace_back(callback);
286 }
287
288 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
289 ASSERT_NE(nullptr, callback);
290 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
291 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
292 GetSelfTokenID(), permList, callback->AsObject()));
293
294 for (size_t i = 0; i < callbacks.size(); ++i) {
295 ASSERT_EQ(RET_SUCCESS,
296 PermissionRecordManager::GetInstance().UnRegisterPermActiveStatusCallback(callbacks[i]->AsObject()));
297 }
298 }
299
300 /**
301 * @tc.name: UnRegisterPermActiveStatusCallback001
302 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid parameter.
303 * @tc.type: FUNC
304 * @tc.require: issueI5RWX8
305 */
306 HWTEST_F(PermissionRecordManagerTest, UnRegisterPermActiveStatusCallback001, TestSize.Level0)
307 {
308 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
309 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
310 GetSelfTokenID(), permList, nullptr));
311 }
312
313 /*
314 * @tc.name: StartUsingPermissionTest001
315 * @tc.desc: StartUsingPermission function test with invaild tokenId.
316 * @tc.type: FUNC
317 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
318 */
319 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest001, TestSize.Level0)
320 {
321 std::string permissionName = "ohos.permission.CAMERA";
322 auto callbackPtr = std::make_shared<PermissionRecordManagerTestCb1>();
323 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
324 ASSERT_NE(nullptr, callbackPtr);
325 ASSERT_NE(nullptr, callbackWrap);
326 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
327 MakeInfo(0, PID, permissionName), callbackWrap->AsObject(), CALLER_PID));
328 }
329
330 /*
331 * @tc.name: StartUsingPermissionTest002
332 * @tc.desc: StartUsingPermission function test with invaild permissionName.
333 * @tc.type: FUNC
334 * @tc.require: issueI5RWXF
335 */
336 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest002, TestSize.Level0)
337 {
338 auto callbackPtr = std::make_shared<PermissionRecordManagerTestCb1>();
339 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
340 ASSERT_NE(nullptr, callbackPtr);
341 ASSERT_NE(nullptr, callbackWrap);
342 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
343 g_InfoParms1.instIndex);
344 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
345 ASSERT_NE(INVALID_TOKENID, tokenId);
346 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
347 MakeInfo(tokenId, PID, "ohos.permission.LOCATION"), callbackWrap->AsObject(), CALLER_PID));
348
349 // tokenId invaild
350 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
351 MakeInfo(g_nativeToken, PID, "ohos.permission.CAMERA"), nullptr, CALLER_PID));
352
353 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
354 MakeInfo(tokenId, PID, "ohos.permission.CAMERA"), nullptr, CALLER_PID));
355 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
356 PermissionRecordManager::GetInstance().StartUsingPermission(
357 MakeInfo(tokenId, PID, "ohos.permission.CAMERA"), nullptr, CALLER_PID));
358
359 ASSERT_EQ(Constant::SUCCESS,
360 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.CAMERA", CALLER_PID));
361 }
362
363 /*
364 * @tc.name: StartUsingPermissionTest003
365 * @tc.desc:
366 * @tc.type: FUNC
367 * @tc.require:
368 */
369 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest003, TestSize.Level0)
370 {
371 char value[VALUE_MAX_LEN] = {0};
372 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
373 GTEST_LOG_(INFO) << "value:" << value;
374
375 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
376 SetParameter(EDM_MIC_MUTE_KEY, "true");
377
378 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
379 g_InfoParms1.instIndex);
380 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
381 ASSERT_NE(INVALID_TOKENID, tokenId);
382 std::string permissionName = "ohos.permission.MICROPHONE";
383 ASSERT_EQ(PrivacyError::ERR_EDM_POLICY_CHECK_FAILED,
384 PermissionRecordManager::GetInstance().StartUsingPermission(
385 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
386 std::string str = isMute ? "true" : "false";
387 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
388 }
389
390 /*
391 * @tc.name: StartUsingPermissionTest004
392 * @tc.desc:
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest004, TestSize.Level0)
397 {
398 char value[VALUE_MAX_LEN] = {0};
399 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
400 GTEST_LOG_(INFO) << "value:" << value;
401
402 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
403 SetParameter(EDM_MIC_MUTE_KEY, "false");
404
405 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
406 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
407
408 std::vector<std::string> permList = {"ohos.permission.READ_MEDIA"};
409 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
410 ASSERT_NE(nullptr, callback);
411 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
412 GetSelfTokenID(), permList, callback->AsObject()));
413
414 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
415 g_InfoParms1.instIndex);
416 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
417 ASSERT_NE(INVALID_TOKENID, tokenId);
418 std::string permissionName = "ohos.permission.READ_MEDIA";
419 ASSERT_EQ(RET_SUCCESS,
420 PermissionRecordManager::GetInstance().StartUsingPermission(
421 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
422
423 usleep(1000000); // 1000000us = 1s
424 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
425 ASSERT_EQ(Constant::SUCCESS,
426 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName, CALLER_PID));
427 std::string str = isMute ? "true" : "false";
428 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
429 }
430
431 /*
432 * @tc.name: StartUsingPermissionTest005
433 * @tc.desc:
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest005, TestSize.Level0)
438 {
439 char value[VALUE_MAX_LEN] = {0};
440 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
441 GTEST_LOG_(INFO) << "value:" << value;
442
443 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
444 SetParameter(EDM_MIC_MUTE_KEY, "false");
445
446 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
447 RANDOM_TOKENID);
448 std::vector<std::string> permList = {"ohos.permission.READ_MEDIA"};
449 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
450 ASSERT_NE(nullptr, callback);
451 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
452 GetSelfTokenID(), permList, callback->AsObject()));
453
454 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
455 g_InfoParms1.instIndex);
456 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
457 ASSERT_NE(INVALID_TOKENID, tokenId);
458 std::string permissionName = "ohos.permission.READ_MEDIA";
459 ASSERT_EQ(RET_SUCCESS,
460 PermissionRecordManager::GetInstance().StartUsingPermission(
461 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
462
463 usleep(1000000); // 1000000us = 1s
464 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
465 ASSERT_EQ(Constant::SUCCESS,
466 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName, CALLER_PID));
467
468 std::string str = isMute ? "true" : "false";
469 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
470 }
471
472 /*
473 * @tc.name: StartUsingPermissionTest006
474 * @tc.desc:
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest006, TestSize.Level0)
479 {
480 char value[VALUE_MAX_LEN] = {0};
481 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
482 GTEST_LOG_(INFO) << "value:" << value;
483
484 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
485 SetParameter(EDM_MIC_MUTE_KEY, "true");
486
487 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
488 RANDOM_TOKENID);
489 std::vector<std::string> permList = {"ohos.permission.LOCATION"};
490 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
491 ASSERT_NE(nullptr, callback);
492 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
493 GetSelfTokenID(), permList, callback->AsObject()));
494
495 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
496 g_InfoParms1.instIndex);
497 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
498 ASSERT_NE(INVALID_TOKENID, tokenId);
499 std::string permissionName = "ohos.permission.LOCATION";
500 ASSERT_EQ(RET_SUCCESS,
501 PermissionRecordManager::GetInstance().StartUsingPermission(
502 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
503
504 usleep(500000); // 500000us = 0.5s
505 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
506 ASSERT_EQ(Constant::SUCCESS,
507 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName, CALLER_PID));
508
509 std::string str = isMute ? "true" : "false";
510 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
511 }
512
513 /*
514 * @tc.name: StartUsingPermissionTest007
515 * @tc.desc: PermissionRecordManager::StartUsingPermission function test
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest007, TestSize.Level0)
520 {
521 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
522 g_InfoParms1.instIndex);
523 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
524 ASSERT_NE(INVALID_TOKENID, tokenId);
525
526 // tokenId invaild
527 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
528 MakeInfo(g_nativeToken, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
529
530 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
531 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
532 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
533 PermissionRecordManager::GetInstance().StartUsingPermission(
534 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
535
536 ASSERT_EQ(Constant::SUCCESS,
537 PermissionRecordManager::GetInstance().StopUsingPermission(
538 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID));
539 }
540
541 /*
542 * @tc.name: StartUsingPermissionTest008
543 * @tc.desc: Test multiple process start using permission
544 * @tc.type: FUNC
545 * @tc.require:
546 */
547 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest008, TestSize.Level0)
548 {
549 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
550 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
551 ASSERT_NE(nullptr, callback);
552 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
553 GetSelfTokenID(), permList, callback->AsObject()));
554
555 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
556 g_InfoParms1.instIndex);
557 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
558 ASSERT_NE(INVALID_TOKENID, tokenId);
559 std::string permissionName = "ohos.permission.CAMERA";
560 ASSERT_EQ(RET_SUCCESS,
561 PermissionRecordManager::GetInstance().StartUsingPermission(
562 MakeInfo(tokenId, TEST_PID_1, permissionName), CALLER_PID));
563 ASSERT_EQ(RET_SUCCESS,
564 PermissionRecordManager::GetInstance().StartUsingPermission(
565 MakeInfo(tokenId, TEST_PID_3, permissionName), CALLER_PID));
566 ProcessData processData;
567 processData.accessTokenId = tokenId;
568 processData.pid = TEST_PID_1;
569 appStateObserver_->OnProcessDied(processData);
570 usleep(500000); // 500000us = 0.5s
571 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
572
573 processData.pid = TEST_PID_2;
574 appStateObserver_->OnProcessDied(processData);
575 usleep(500000); // 500000us = 0.5s
576 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
577
578 processData.pid = TEST_PID_3;
579 appStateObserver_->OnProcessDied(processData);
580 usleep(500000); // 500000us = 0.5s
581 ASSERT_EQ(PERM_INACTIVE, callback->type_);
582 }
583
584 /*
585 * @tc.name: StartUsingPermissionTest009
586 * @tc.desc: Test multiple process start using permission
587 * @tc.type: FUNC
588 * @tc.require:
589 */
590 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest009, TestSize.Level0)
591 {
592 auto callbackPtr1 = std::make_shared<PermissionRecordManagerTestCb1>();
593 auto callbackWrap1 = new (std::nothrow) StateChangeCallback(callbackPtr1);
594 ASSERT_NE(nullptr, callbackPtr1);
595 ASSERT_NE(nullptr, callbackWrap1);
596
597 auto callbackPtr2 = std::make_shared<PermissionRecordManagerTestCb1>();
598 auto callbackWrap2 = new (std::nothrow) StateChangeCallback(callbackPtr2);
599 ASSERT_NE(nullptr, callbackPtr2);
600 ASSERT_NE(nullptr, callbackWrap2);
601
602 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
603 g_InfoParms1.instIndex);
604 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
605 ASSERT_NE(INVALID_TOKENID, tokenId);
606 std::string permissionName = "ohos.permission.CAMERA";
607
608 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
609 MakeInfo(tokenId, TEST_PID_1, permissionName), callbackWrap1->AsObject(), CALLER_PID));
610 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
611 PermissionRecordManager::GetInstance().StartUsingPermission(MakeInfo(tokenId, TEST_PID_2, permissionName),
612 callbackWrap2->AsObject(), CALLER_PID));
613 }
614
615 /*
616 * @tc.name: StartUsingPermissionTest010
617 * @tc.desc: Test multiple process start using permission
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest010, TestSize.Level0)
622 {
623 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
624 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
625 ASSERT_NE(nullptr, callback);
626 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
627 GetSelfTokenID(), permList, callback->AsObject()));
628
629 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
630 g_InfoParms1.instIndex);
631 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
632 ASSERT_NE(INVALID_TOKENID, tokenId);
633 std::string permissionName = "ohos.permission.CAMERA";
634 ASSERT_EQ(RET_SUCCESS,
635 PermissionRecordManager::GetInstance().StartUsingPermission(
636 MakeInfo(tokenId, TEST_PID_1, permissionName), CALLER_PID));
637 ASSERT_EQ(RET_SUCCESS,
638 PermissionRecordManager::GetInstance().StartUsingPermission(
639 MakeInfo(tokenId, TEST_PID_2, permissionName), CALLER_PID));
640
641 ASSERT_EQ(Constant::SUCCESS,
642 PermissionRecordManager::GetInstance().StopUsingPermission(
643 tokenId, TEST_PID_2, "ohos.permission.CAMERA", CALLER_PID));
644 usleep(500000); // 500000us = 0.5s
645 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
646
647 ASSERT_EQ(Constant::SUCCESS,
648 PermissionRecordManager::GetInstance().StopUsingPermission(
649 tokenId, TEST_PID_1, "ohos.permission.CAMERA", CALLER_PID));
650 usleep(500000); // 500000us = 0.5s
651 ASSERT_EQ(PERM_INACTIVE, callback->type_);
652 }
653
654 /*
655 * @tc.name: StartUsingPermissionTest011
656 * @tc.desc: Test default pid -1 start using permission and OnProcessDied
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest011, TestSize.Level0)
661 {
662 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
663 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
664 ASSERT_NE(nullptr, callback);
665 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
666 GetSelfTokenID(), permList, callback->AsObject()));
667 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
668 g_InfoParms1.instIndex);
669 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
670 ASSERT_NE(INVALID_TOKENID, tokenId);
671 std::string permissionName = "ohos.permission.CAMERA";
672 ASSERT_EQ(RET_SUCCESS,
673 PermissionRecordManager::GetInstance().StartUsingPermission(
674 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
675 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
676 PermissionRecordManager::GetInstance().StartUsingPermission(
677 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
678
679 // makesure callback end
680 usleep(500000); // 500000us = 0.5s
681 callback->type_ = PERM_TEMPORARY_CALL;
682 ProcessData processData;
683 processData.accessTokenId = tokenId;
684 processData.pid = 100; // random pid
685 appStateObserver_->OnProcessDied(processData);
686 usleep(500000);
687 ASSERT_EQ(PERM_TEMPORARY_CALL, callback->type_);
688 }
689
690 #ifndef APP_SECURITY_PRIVACY_SERVICE
691 /*
692 * @tc.name: ShowGlobalDialog001
693 * @tc.desc: ShowGlobalDialog function test
694 * @tc.type: FUNC
695 * @tc.require: issueI5RWXF
696 */
697 HWTEST_F(PermissionRecordManagerTest, ShowGlobalDialog001, TestSize.Level0)
698 {
699 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.CAMERA"));
700 sleep(3); // wait for dialog disappear
701 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.MICROPHONE"));
702 sleep(3); // wait for dialog disappear
703 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.LOCATION")); // no dialog
704 }
705 #endif
706
707 /*
708 * @tc.name: AppStateChangeListener001
709 * @tc.desc: AppStateChange function test mic global switch is close
710 * @tc.type: FUNC
711 * @tc.require: issueI5RWXF
712 */
713 HWTEST_F(PermissionRecordManagerTest, AppStateChangeListener001, TestSize.Level0)
714 {
715 char value[VALUE_MAX_LEN] = {0};
716 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
717 GTEST_LOG_(INFO) << "value:" << value;
718
719 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
720 SetParameter(EDM_MIC_MUTE_KEY, std::to_string(false).c_str());
721
722 bool isMuteMic = AudioManagerAdapter::GetInstance().GetPersistentMicMuteState();
723 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
724 RANDOM_TOKENID);
725 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
726 g_InfoParms1.instIndex);
727 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
728 ASSERT_NE(INVALID_TOKENID, tokenId);
729 // status is inactive
730 ASSERT_EQ(RET_SUCCESS,
731 PermissionRecordManager::GetInstance().StartUsingPermission(
732 MakeInfo(tokenId, PID, "ohos.permission.MICROPHONE"), CALLER_PID));
733 sleep(3); // wait for dialog disappear
734 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, PERM_ACTIVE_IN_BACKGROUND);
735 ASSERT_EQ(RET_SUCCESS,
736 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID,
737 "ohos.permission.MICROPHONE", CALLER_PID));
738 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, isMuteMic,
739 RANDOM_TOKENID);
740 std::string str = isMute ? "true" : "false";
741 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
742 }
743
744 /*
745 * @tc.name: TransferOpcodeToPermission001
746 * @tc.desc: Constant::TransferOpcodeToPermission function test return false
747 * @tc.type: FUNC
748 * @tc.require:
749 */
750 HWTEST_F(PermissionRecordManagerTest, TransferOpcodeToPermission001, TestSize.Level0)
751 {
752 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_INVALID);
753 std::string permissionName;
754 ASSERT_EQ(false, Constant::TransferOpcodeToPermission(opCode, permissionName));
755 }
756
757 /*
758 * @tc.name: AddPermissionUsedRecord001
759 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
760 * @tc.type: FUNC
761 * @tc.require:
762 */
763 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord001, TestSize.Level0)
764 {
765 MockNativeToken mock("audio_server"); // native process with have add permission
766 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
767 g_InfoParms1.instIndex);
768 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
769 ASSERT_NE(INVALID_TOKENID, tokenId);
770
771 AddPermParamInfo info;
772 info.tokenId = tokenId;
773 info.permissionName = "com.ohos.test";
774 info.successCount = 1;
775 info.failCount = 0;
776
777 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
778 info)); // invaild permission error
779
780 info.type = PermissionUsedType::PICKER_TYPE;
781 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
782 info)); // invaild permission error
783
784 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
785 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
786 info)); // invaild permission error
787 }
788
789 /*
790 * @tc.name: AddPermissionUsedRecord002
791 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord002, TestSize.Level0)
796 {
797 MockNativeToken mock("audio_server"); // native process with have permission
798 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
799 g_InfoParms1.instIndex);
800 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
801 ASSERT_NE(INVALID_TOKENID, tokenId);
802
803 AddPermParamInfo info;
804 info.tokenId = tokenId;
805 info.permissionName = "com.permission.READ_MEDIA";
806 info.successCount = 0;
807 info.failCount = 0;
808 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(info));
809 }
810
811 /*
812 * @tc.name:SetPermissionUsedRecordToggleStatus001
813 * @tc.desc: PermissionRecordManager::SetPermissionUsedRecordToggleStatus function test
814 * @tc.type: FUNC
815 * @tc.require:
816 */
817 HWTEST_F(PermissionRecordManagerTest, SetPermissionUsedRecordToggleStatus001, TestSize.Level0)
818 {
819 int32_t ret = PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(
820 TEST_INVALID_USER_ID, true);
821 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
822
823 ret = PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(
824 TEST_INVALID_USER_ID_20000, true);
825 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
826 }
827
828 /*
829 * @tc.name:GetPermissionUsedRecordToggleStatus001
830 * @tc.desc: PermissionRecordManager::GetPermissionUsedRecordToggleStatus function test
831 * @tc.type: FUNC
832 * @tc.require:
833 */
834 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedRecordToggleStatus001, TestSize.Level0)
835 {
836 bool status = true;
837 int32_t ret = PermissionRecordManager::GetInstance().GetPermissionUsedRecordToggleStatus(
838 TEST_INVALID_USER_ID, status);
839 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
840
841 ret = PermissionRecordManager::GetInstance().GetPermissionUsedRecordToggleStatus(
842 TEST_INVALID_USER_ID_20000, status);
843 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
844 }
845
846 /*
847 * @tc.name:UpdatePermUsedRecToggleStatusMap001
848 * @tc.desc: PermissionRecordManager::test UpdatePermUsedRecToggleStatusMap and CheckPermissionUsedRecordToggleStatus
849 * @tc.type: FUNC
850 * @tc.require:
851 */
852 HWTEST_F(PermissionRecordManagerTest, UpdatePermUsedRecToggleStatusMap001, TestSize.Level0)
853 {
854 bool checkStatus = PermissionRecordManager::GetInstance().CheckPermissionUsedRecordToggleStatus(TEST_USER_ID_10);
855 EXPECT_TRUE(checkStatus);
856
857 bool ret = PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMap(TEST_USER_ID_10, false);
858 checkStatus = PermissionRecordManager::GetInstance().CheckPermissionUsedRecordToggleStatus(TEST_USER_ID_10);
859 EXPECT_TRUE(ret);
860 EXPECT_FALSE(checkStatus);
861
862 ret = PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMap(TEST_USER_ID_10, false);
863 EXPECT_FALSE(ret);
864
865 ret = PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMap(TEST_USER_ID_10, true);
866 checkStatus = PermissionRecordManager::GetInstance().CheckPermissionUsedRecordToggleStatus(TEST_USER_ID_10);
867 EXPECT_TRUE(ret);
868 EXPECT_TRUE(checkStatus);
869 }
870
871 /*
872 * @tc.name: StopUsingPermission001
873 * @tc.desc: PermissionRecordManager::StopUsingPermission function test
874 * @tc.type: FUNC
875 * @tc.require:
876 */
877 HWTEST_F(PermissionRecordManagerTest, StopUsingPermission001, TestSize.Level0)
878 {
879 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
880 g_InfoParms1.instIndex);
881 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
882 ASSERT_NE(INVALID_TOKENID, tokenId);
883
884 // tokenId invaild
885 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StopUsingPermission(
886 static_cast<AccessTokenID>(0), PID, "ohos.permission.READ_MEDIA", CALLER_PID));
887
888 // permission invaild
889 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().StopUsingPermission(
890 tokenId, PID, "ohos.permission.test", CALLER_PID));
891
892 // not start using
893 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_START_USING,
894 PermissionRecordManager::GetInstance().StopUsingPermission(
895 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID));
896 }
897
898 /*
899 * @tc.name: RegisterPermActiveStatusCallback003
900 * @tc.desc: PermissionRecordManager::RegisterPermActiveStatusCallback function test
901 * @tc.type: FUNC
902 * @tc.require:
903 */
904 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback003, TestSize.Level0)
905 {
906 std::vector<std::string> permList;
907
908 permList.emplace_back("com.ohos.TEST");
909 // GetDefPermission != Constant::SUCCESS && listRes is empty && listSrc is not empty
910 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
911 GetSelfTokenID(), permList, nullptr));
912 }
913
914 /*
915 * @tc.name: GetPermissionUsedTypeInfos001
916 * @tc.desc: PermissionRecordManager::GetPermissionUsedTypeInfos001 function test
917 * @tc.type: FUNC
918 * @tc.require:
919 */
920 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedTypeInfos001, TestSize.Level0)
921 {
922 uint32_t tokenId = RANDOM_TOKENID;
923 std::string permissionName = "ohos.permission.PERMISSION_RECORD_MANAGER_TEST";
924 std::vector<PermissionUsedTypeInfo> results;
925 // tokenId is not exsit
926 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST,
927 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
928
929 tokenId = 0;
930 // permissionName is not exsit
931 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
932 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
933
934 permissionName = "ohos.permission.CAMERA";
935 ASSERT_EQ(0, PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
936 }
937
938 /*
939 * @tc.name: GetPermissionUsedTypeInfos002
940 * @tc.desc: PrivacyKit::GetPermissionUsedTypeInfos function test
941 * @tc.type: FUNC
942 * @tc.require:
943 */
944 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedType002, TestSize.Level0)
945 {
946 MockNativeToken mock("audio_server"); // set self tokenID to audio_service with PERMISSION_USED_STATS
947 // add 21 permission used type record
948 std::vector<AccessTokenID> tokenIdList;
949 uint32_t count = TEST_MAX_PERMISSION_USED_TYPE_SIZE + 1;
950 for (uint32_t i = 0; i < count; i++) {
951 HapInfoParams infoParms = g_InfoParms1;
952 HapPolicyParams policyPrams = g_PolicyPrams1;
953 infoParms.bundleName = infoParms.bundleName + std::to_string(i);
954
955 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::AllocTestHapToken(infoParms, policyPrams);
956 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
957 EXPECT_NE(INVALID_TOKENID, tokenId);
958 tokenIdList.emplace_back(tokenId);
959
960 AddPermParamInfo info;
961 info.tokenId = tokenId;
962 info.permissionName = "ohos.permission.READ_MESSAGES";
963 info.successCount = 1;
964 info.failCount = 0;
965 EXPECT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
966 }
967
968 AccessTokenID tokenId = 0;
969 std::string permissionName = "ohos.permission.READ_MESSAGES";
970 std::vector<PermissionUsedTypeInfo> results;
971 // record over size
972 EXPECT_EQ(PrivacyError::ERR_OVERSIZE,
973 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
974
975 for (const auto& id : tokenIdList) {
976 EXPECT_EQ(RET_SUCCESS, PrivacyKit::RemovePermissionUsedRecords(id));
977 EXPECT_EQ(RET_SUCCESS, PrivacyTestCommon::DeleteTestHapToken(id));
978 }
979 }
980
981 /*
982 * @tc.name: AddDataValueToResults001
983 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
984 * @tc.type: FUNC
985 * @tc.require:
986 */
987 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults001, TestSize.Level0)
988 {
989 GenericValues value;
990 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
991 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, NORMAL_TYPE_ADD_VALUE);
992 std::vector<PermissionUsedTypeInfo> results;
993
994 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
995 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type);
996 }
997
998 /*
999 * @tc.name: AddDataValueToResults002
1000 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults002, TestSize.Level0)
1005 {
1006 GenericValues value;
1007 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
1008 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, PICKER_TYPE_ADD_VALUE);
1009 std::vector<PermissionUsedTypeInfo> results;
1010
1011 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
1012 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type);
1013 }
1014
1015 /*
1016 * @tc.name: AddDataValueToResults003
1017 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
1018 * @tc.type: FUNC
1019 * @tc.require:
1020 */
1021 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults003, TestSize.Level0)
1022 {
1023 GenericValues value;
1024 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
1025 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, SEC_COMPONENT_TYPE_ADD_VALUE);
1026 std::vector<PermissionUsedTypeInfo> results;
1027
1028 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
1029 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type);
1030 ASSERT_EQ(0, GetFirstCallerTokenID());
1031 }
1032
1033 /*
1034 * @tc.name: SetMutePolicyTest001
1035 * @tc.desc:
1036 * @tc.type: FUNC
1037 * @tc.require:
1038 */
1039 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest001, TestSize.Level0)
1040 {
1041 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1042 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1043 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1044 RANDOM_TOKENID);
1045 EXPECT_EQ(RET_SUCCESS,
1046 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
1047
1048 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1049 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1050 RANDOM_TOKENID);
1051 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
1052 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
1053 }
1054
1055 /*
1056 * @tc.name: SetMutePolicyTest002
1057 * @tc.desc:
1058 * @tc.type: FUNC
1059 * @tc.require:
1060 */
1061 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest002, TestSize.Level0)
1062 {
1063 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1064 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1065 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1066 RANDOM_TOKENID);
1067 EXPECT_EQ(RET_SUCCESS,
1068 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
1069
1070 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1071 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1072 RANDOM_TOKENID);
1073 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
1074 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
1075 }
1076
1077 /*
1078 * @tc.name: SetMutePolicyTest003
1079 * @tc.desc:
1080 * @tc.type: FUNC
1081 * @tc.require:
1082 */
1083 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest003, TestSize.Level0)
1084 {
1085 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1086 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1087 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1088 RANDOM_TOKENID);
1089 EXPECT_EQ(RET_SUCCESS,
1090 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
1091
1092 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1093 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1094 RANDOM_TOKENID);
1095 EXPECT_EQ(RET_SUCCESS,
1096 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
1097 }
1098
1099 /*
1100 * @tc.name: SetMutePolicyTest004
1101 * @tc.desc:
1102 * @tc.type: FUNC
1103 * @tc.require:
1104 */
1105 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest004, TestSize.Level0)
1106 {
1107 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1108 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1109 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1110 RANDOM_TOKENID);
1111 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1112 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1113
1114 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1115 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1116 RANDOM_TOKENID);
1117 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED,
1118 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1119 RANDOM_TOKENID));
1120 }
1121
1122 /*
1123 * @tc.name: SetMutePolicyTest005
1124 * @tc.desc:
1125 * @tc.type: FUNC
1126 * @tc.require:
1127 */
1128 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest005, TestSize.Level0)
1129 {
1130 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1131 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1132 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1133 RANDOM_TOKENID);
1134 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1135 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1136
1137 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1138 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1139 RANDOM_TOKENID);
1140 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1141 PolicyType::PRIVACY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1142 }
1143
1144 /*
1145 * @tc.name: SetMutePolicyTest006
1146 * @tc.desc:
1147 * @tc.type: FUNC
1148 * @tc.require:
1149 */
1150 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest006, TestSize.Level0)
1151 {
1152 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1153 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1154 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1155 RANDOM_TOKENID);
1156 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1157 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1158
1159 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1160 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1161 RANDOM_TOKENID);
1162 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1163 PolicyType::PRIVACY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1164 }
1165
1166 /*
1167 * @tc.name: SetMutePolicyTest007
1168 * @tc.desc:
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest007, TestSize.Level0)
1173 {
1174 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1175 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1176 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1177 RANDOM_TOKENID);
1178 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1179 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1180
1181 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1182 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1183 RANDOM_TOKENID);
1184 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED, PermissionRecordManager::GetInstance().SetMutePolicy(
1185 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1186 }
1187
1188 #ifndef APP_SECURITY_PRIVACY_SERVICE
1189 /*
1190 * @tc.name: SetMutePolicyTest008
1191 * @tc.desc:
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest008, TestSize.Level0)
1196 {
1197 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1198 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1199 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1200 RANDOM_TOKENID);
1201 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1202 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1203
1204 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1205 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1206 RANDOM_TOKENID);
1207 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED, PermissionRecordManager::GetInstance().SetMutePolicy(
1208 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1209 }
1210 #endif
1211
1212 /*
1213 * @tc.name: SetMutePolicyTest009
1214 * @tc.desc:
1215 * @tc.type: FUNC
1216 * @tc.require:
1217 */
1218 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest009, TestSize.Level0)
1219 {
1220 uint32_t tokenID = PrivacyTestCommon::GetNativeTokenIdFromProcess("edm");
1221 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1222 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1223 RANDOM_TOKENID);
1224 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1225 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1226
1227 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1228 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1229 RANDOM_TOKENID);
1230 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1231 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1232 }
1233
1234 class DiedProxyMaker {
1235 public:
DiedProxyMaker()1236 DiedProxyMaker()
1237 {
1238 handler_ = std::make_shared<ProxyDeathHandler>();
1239 }
1240
AddRecipient(int callerPid)1241 void AddRecipient(int callerPid)
1242 {
1243 std::shared_ptr<ProxyDeathParam> param = std::make_shared<PrivacyManagerProxyDeathParam>(callerPid);
1244 auto anonyStub = sptr<ProxyDeathCallBackStub>::MakeSptr();
1245 handler_->AddProxyStub(anonyStub, param);
1246 }
1247
TestDie(int32_t callerPid)1248 void TestDie(int32_t callerPid)
1249 {
1250 auto map = handler_->proxyStubAndRecipientMap_;
1251 auto param = reinterpret_cast<ProxyDeathParam*>(new (std::nothrow) PrivacyManagerProxyDeathParam(callerPid));
1252 for (auto iter = map.begin(); iter != map.end(); ++iter) {
1253 if (iter->second.second->IsEqual(param)) {
1254 iter->second.first->OnRemoteDied(iter->first);
1255 }
1256 }
1257 }
1258
1259 std::shared_ptr<ProxyDeathHandler> handler_ = nullptr;
1260 };
1261
1262 /*
1263 * @tc.name: PermissionRecordManagerTest
1264 * @tc.desc: ProxyDeathTest test
1265 * @tc.type: FUNC
1266 * @tc.require:
1267 */
1268 HWTEST_F(PermissionRecordManagerTest, ProxyDeathTest001, TestSize.Level0)
1269 {
1270 DiedProxyMaker init;
1271 init.AddRecipient(CALLER_PID);
1272 init.TestDie(CALLER_PID);
1273 ASSERT_EQ(0, PermissionRecordManager::GetInstance().startRecordList_.size());
1274
1275 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
1276 g_InfoParms1.instIndex);
1277 AccessTokenID tokenId1 = tokenIdEx.tokenIdExStruct.tokenID;
1278 ASSERT_NE(INVALID_TOKENID, tokenId1);
1279 std::string permissionName = "ohos.permission.CAMERA";
1280 ASSERT_EQ(RET_SUCCESS,
1281 PermissionRecordManager::GetInstance().StartUsingPermission(
1282 MakeInfo(tokenId1, TEST_PID_1, permissionName), CALLER_PID));
1283
1284 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
1285 g_InfoParms1.instIndex);
1286 AccessTokenID tokenId2 = tokenIdEx.tokenIdExStruct.tokenID;
1287 ASSERT_NE(INVALID_TOKENID, tokenId2);
1288 ASSERT_EQ(RET_SUCCESS,
1289 PermissionRecordManager::GetInstance().StartUsingPermission(
1290 MakeInfo(tokenId2, TEST_PID_2, permissionName), CALLER_PID));
1291 ASSERT_EQ(2, PermissionRecordManager::GetInstance().startRecordList_.size());
1292
1293 DiedProxyMaker maker;
1294 maker.AddRecipient(CALLER_PID);
1295 maker.TestDie(CALLER_PID);
1296 ASSERT_EQ(0, PermissionRecordManager::GetInstance().startRecordList_.size());
1297 }
1298
1299 /*
1300 * @tc.name: PermissionRecordManagerTest
1301 * @tc.desc: ProxyDeathTest test
1302 * @tc.type: FUNC
1303 * @tc.require:
1304 */
1305 HWTEST_F(PermissionRecordManagerTest, ProxyDeathTest002, TestSize.Level0)
1306 {
1307 DiedProxyMaker init;
1308 init.AddRecipient(CALLER_PID);
1309 init.TestDie(CALLER_PID);
1310 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
1311 g_InfoParms1.instIndex);
1312 AccessTokenID tokenId1 = tokenIdEx.tokenIdExStruct.tokenID;
1313 ASSERT_NE(INVALID_TOKENID, tokenId1);
1314 std::string permissionName = "ohos.permission.CAMERA";
1315 ASSERT_EQ(RET_SUCCESS,
1316 PermissionRecordManager::GetInstance().StartUsingPermission(
1317 MakeInfo(tokenId1, TEST_PID_1, permissionName), CALLER_PID));
1318
1319 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
1320 g_InfoParms1.instIndex);
1321 AccessTokenID tokenId2 = tokenIdEx.tokenIdExStruct.tokenID;
1322 ASSERT_NE(INVALID_TOKENID, tokenId2);
1323 ASSERT_EQ(RET_SUCCESS,
1324 PermissionRecordManager::GetInstance().StartUsingPermission(
1325 MakeInfo(tokenId2, TEST_PID_2, permissionName), CALLER_PID2));
1326 ASSERT_EQ(2, PermissionRecordManager::GetInstance().startRecordList_.size());
1327
1328 DiedProxyMaker maker;
1329 maker.AddRecipient(CALLER_PID);
1330 maker.TestDie(CALLER_PID);
1331 ASSERT_EQ(1, PermissionRecordManager::GetInstance().startRecordList_.size());
1332
1333 ASSERT_EQ(RET_SUCCESS,
1334 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId2, TEST_PID_2, permissionName, CALLER_PID2));
1335 }
1336
1337 /*
1338 * @tc.name: PermissionRecordManagerTest
1339 * @tc.desc: HasCallerInStartList test
1340 * @tc.type: FUNC
1341 * @tc.require:
1342 */
1343 HWTEST_F(PermissionRecordManagerTest, HasCallerInStartList001, TestSize.Level0)
1344 {
1345 DiedProxyMaker init;
1346 init.AddRecipient(CALLER_PID);
1347 init.TestDie(CALLER_PID);
1348 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
1349 g_InfoParms1.instIndex);
1350 AccessTokenID tokenId1 = tokenIdEx.tokenIdExStruct.tokenID;
1351 ASSERT_NE(INVALID_TOKENID, tokenId1);
1352 std::string permissionName = "ohos.permission.CAMERA";
1353 ASSERT_EQ(RET_SUCCESS,
1354 PermissionRecordManager::GetInstance().StartUsingPermission(
1355 MakeInfo(tokenId1, TEST_PID_1, permissionName), CALLER_PID));
1356 ASSERT_TRUE(PermissionRecordManager::GetInstance().HasCallerInStartList(CALLER_PID));
1357 ASSERT_FALSE(PermissionRecordManager::GetInstance().HasCallerInStartList(CALLER_PID2));
1358 ASSERT_EQ(RET_SUCCESS,
1359 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId1, TEST_PID_1, permissionName, CALLER_PID));
1360 ASSERT_FALSE(PermissionRecordManager::GetInstance().HasCallerInStartList(CALLER_PID));
1361 }
1362 } // namespace AccessToken
1363 } // namespace Security
1364 } // namespace OHOS
1365