1 /*
2 * Copyright (c) 2022-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 <cstdint>
17 #include <gtest/gtest.h>
18
19 #include "ability_manager_access_loader.h"
20 #include "access_token.h"
21 #include "accesstoken_kit.h"
22 #include "accesstoken_log.h"
23 #include "audio_manager_privacy_client.h"
24 #include "camera_manager_privacy_client.h"
25 #include "constant.h"
26 #include "data_translator.h"
27 #include "permission_record.h"
28 #define private public
29 #include "active_status_callback_manager.h"
30 #include "libraryloader.h"
31 #include "permission_record_manager.h"
32 #include "permission_used_record_db.h"
33 #include "privacy_manager_service.h"
34 #undef private
35 #include "perm_active_status_change_callback_stub.h"
36 #include "privacy_error.h"
37 #include "privacy_field_const.h"
38 #include "privacy_kit.h"
39 #include "state_change_callback.h"
40 #include "time_util.h"
41 #include "token_setproc.h"
42
43 using namespace testing;
44 using namespace testing::ext;
45 using namespace OHOS;
46
47 namespace OHOS {
48 namespace Security {
49 namespace AccessToken {
50 namespace {
51 static int32_t PID = -1;
52 static int32_t TEST_PID_1 = 1;
53 static int32_t TEST_PID_2 = 2;
54 static int32_t TEST_PID_3 = 3;
55 static AccessTokenID g_selfTokenId = 0;
56 static AccessTokenID g_nativeToken = 0;
57 static bool g_isMicEdmMute = false;
58 static bool g_isMicMixMute = false;
59 static bool g_isMicMute = false;
60 constexpr const char* MICROPHONE_PERMISSION_NAME = "ohos.permission.MICROPHONE";
61 static constexpr uint32_t MAX_CALLBACK_SIZE = 1024;
62 static constexpr uint32_t RANDOM_TOKENID = 123;
63 static constexpr int32_t FIRST_INDEX = 0;
64 static const int32_t NORMAL_TYPE_ADD_VALUE = 1;
65 static const int32_t PICKER_TYPE_ADD_VALUE = 2;
66 static const int32_t SEC_COMPONENT_TYPE_ADD_VALUE = 4;
67 static PermissionStateFull g_testState1 = {
68 .permissionName = "ohos.permission.CAMERA",
69 .isGeneral = true,
70 .resDeviceID = {"local"},
71 .grantStatus = {PermissionState::PERMISSION_GRANTED},
72 .grantFlags = {1}
73 };
74
75 static PermissionStateFull g_testState2 = {
76 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
77 .isGeneral = true,
78 .resDeviceID = {"local"},
79 .grantStatus = {PermissionState::PERMISSION_GRANTED},
80 .grantFlags = {1}
81 };
82 static PermissionStateFull g_testState3 = {
83 .permissionName = "ohos.permission.MANAGE_AUDIO_CONFIG",
84 .isGeneral = true,
85 .resDeviceID = {"local"},
86 .grantStatus = {PermissionState::PERMISSION_GRANTED},
87 .grantFlags = {1}
88 };
89
90 static HapPolicyParams g_PolicyPrams1 = {
91 .apl = APL_NORMAL,
92 .domain = "test.domain.A",
93 .permList = {},
94 .permStateList = {g_testState1, g_testState2, g_testState3}
95 };
96
97 static HapInfoParams g_InfoParms1 = {
98 .userID = 1,
99 .bundleName = "ohos.privacy_test.bundleA",
100 .instIndex = 0,
101 .appIDDesc = "privacy_test.bundleA"
102 };
103
104 static HapPolicyParams g_PolicyPrams2 = {
105 .apl = APL_NORMAL,
106 .domain = "test.domain.B",
107 .permList = {},
108 .permStateList = {g_testState1}
109 };
110
111 static HapInfoParams g_InfoParms2 = {
112 .userID = 1,
113 .bundleName = "ohos.privacy_test.bundleB",
114 .instIndex = 0,
115 .appIDDesc = "privacy_test.bundleB"
116 };
117 }
118 class PermissionRecordManagerTest : public testing::Test {
119 public:
120 static void SetUpTestCase();
121
122 static void TearDownTestCase();
123
124 void SetUp();
125
126 void TearDown();
127
128 std::shared_ptr<PrivacyAppStateObserver> appStateObserver_ = nullptr;
129 };
130
SetUpTestCase()131 void PermissionRecordManagerTest::SetUpTestCase()
132 {
133 DelayedSingleton<PrivacyManagerService>::GetInstance()->Initialize();
134 PermissionRecordManager::GetInstance().Init();
135
136 g_selfTokenId = GetSelfTokenID();
137 g_nativeToken = AccessTokenKit::GetNativeTokenId("privacy_service");
138 g_isMicEdmMute = PermissionRecordManager::GetInstance().isMicEdmMute_;
139 g_isMicMixMute = PermissionRecordManager::GetInstance().isMicMixMute_;
140 PermissionRecordManager::GetInstance().isMicEdmMute_ = false;
141 PermissionRecordManager::GetInstance().isMicMixMute_ = false;
142 g_isMicMute = AudioManagerPrivacyClient::GetInstance().GetPersistentMicMuteState();
143 }
144
TearDownTestCase()145 void PermissionRecordManagerTest::TearDownTestCase()
146 {
147 PermissionRecordManager::GetInstance().isMicEdmMute_ = g_isMicEdmMute;
148 PermissionRecordManager::GetInstance().isMicMixMute_ = g_isMicMixMute;
149 }
150
SetUp()151 void PermissionRecordManagerTest::SetUp()
152 {
153 PermissionRecordManager::GetInstance().Init();
154 PermissionRecordManager::GetInstance().Register();
155
156 AccessTokenKit::AllocHapToken(g_InfoParms1, g_PolicyPrams1);
157 AccessTokenKit::AllocHapToken(g_InfoParms2, g_PolicyPrams2);
158 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(false, PolicyType::PRIVACY);
159 if (appStateObserver_ != nullptr) {
160 return;
161 }
162 appStateObserver_ = std::make_shared<PrivacyAppStateObserver>();
163 }
164
TearDown()165 void PermissionRecordManagerTest::TearDown()
166 {
167 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(g_isMicMute, PolicyType::PRIVACY);
168 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
169 g_InfoParms1.instIndex);
170 AccessTokenKit::DeleteToken(tokenId);
171 PrivacyKit::RemovePermissionUsedRecords(tokenId, "");
172 tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
173 g_InfoParms2.instIndex);
174 AccessTokenKit::DeleteToken(tokenId);
175 PrivacyKit::RemovePermissionUsedRecords(tokenId, "");
176 appStateObserver_ = nullptr;
177 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
178 }
179
180 class PermissionRecordManagerTestCb1 : public StateCustomizedCbk {
181 public:
PermissionRecordManagerTestCb1()182 PermissionRecordManagerTestCb1()
183 {}
184
~PermissionRecordManagerTestCb1()185 ~PermissionRecordManagerTestCb1()
186 {}
187
StateChangeNotify(AccessTokenID tokenId,bool isShow)188 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
189 {}
190
Stop()191 void Stop()
192 {}
193 };
194
195 /**
196 * @tc.name: RegisterPermActiveStatusCallback001
197 * @tc.desc: RegisterPermActiveStatusCallback with invalid parameter.
198 * @tc.type: FUNC
199 * @tc.require: issueI5RWX8
200 */
201 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback001, TestSize.Level1)
202 {
203 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
204 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
205 GetSelfTokenID(), permList, nullptr));
206 }
207
208
209 class PermActiveStatusChangeCallback : public PermActiveStatusChangeCallbackStub {
210 public:
211 PermActiveStatusChangeCallback() = default;
212 virtual ~PermActiveStatusChangeCallback() = default;
213
ActiveStatusChangeCallback(ActiveChangeResponse & result)214 void ActiveStatusChangeCallback(ActiveChangeResponse& result)
215 {
216 type_ = result.type;
217 GTEST_LOG_(INFO) << "PermActiveStatusChangeCallback ActiveChangeResponse";
218 GTEST_LOG_(INFO) << "PermActiveStatusChangeCallback tokenid " << result.tokenID;
219 GTEST_LOG_(INFO) << "PermActiveStatusChangeCallback permissionName " << result.permissionName;
220 GTEST_LOG_(INFO) << "PermActiveStatusChangeCallback deviceId " << result.deviceId;
221 GTEST_LOG_(INFO) << "PermActiveStatusChangeCallback type " << result.type;
222 }
223
224 ActiveChangeType type_ = PERM_INACTIVE;
225 };
226
227 /**
228 * @tc.name: RegisterPermActiveStatusCallback002
229 * @tc.desc: RegisterPermActiveStatusCallback with exceed limitation.
230 * @tc.type: FUNC
231 * @tc.require: issueI5RWX8
232 */
233 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback002, TestSize.Level1)
234 {
235 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
236 std::vector<sptr<PermActiveStatusChangeCallback>> callbacks;
237
238 for (size_t i = 0; i < MAX_CALLBACK_SIZE; ++i) {
239 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
240 ASSERT_NE(nullptr, callback);
241 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
242 GetSelfTokenID(), permList, callback->AsObject()));
243 callbacks.emplace_back(callback);
244 }
245
246 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
247 ASSERT_NE(nullptr, callback);
248 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
249 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
250 GetSelfTokenID(), permList, callback->AsObject()));
251
252 for (size_t i = 0; i < callbacks.size(); ++i) {
253 ASSERT_EQ(RET_SUCCESS,
254 PermissionRecordManager::GetInstance().UnRegisterPermActiveStatusCallback(callbacks[i]->AsObject()));
255 }
256 }
257
258 /**
259 * @tc.name: UnRegisterPermActiveStatusCallback001
260 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid parameter.
261 * @tc.type: FUNC
262 * @tc.require: issueI5RWX8
263 */
264 HWTEST_F(PermissionRecordManagerTest, UnRegisterPermActiveStatusCallback001, TestSize.Level1)
265 {
266 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
267 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
268 GetSelfTokenID(), permList, nullptr));
269 }
270
271 /*
272 * @tc.name: StartUsingPermissionTest001
273 * @tc.desc: StartUsingPermission function test with invaild tokenId.
274 * @tc.type: FUNC
275 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
276 */
277 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest001, TestSize.Level1)
278 {
279 std::string permissionName = "ohos.permission.CAMERA";
280 auto callbackPtr = std::make_shared<PermissionRecordManagerTestCb1>();
281 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
282 ASSERT_NE(nullptr, callbackPtr);
283 ASSERT_NE(nullptr, callbackWrap);
284 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
285 g_InfoParms1.instIndex);
286 ASSERT_NE(INVALID_TOKENID, tokenId);
287 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
288 0, PID, permissionName, callbackWrap->AsObject()));
289 }
290
291 /*
292 * @tc.name: StartUsingPermissionTest002
293 * @tc.desc: StartUsingPermission function test with invaild permissionName.
294 * @tc.type: FUNC
295 * @tc.require: issueI5RWXF
296 */
297 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest002, TestSize.Level1)
298 {
299 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
300
301 auto callbackPtr = std::make_shared<PermissionRecordManagerTestCb1>();
302 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
303 ASSERT_NE(nullptr, callbackPtr);
304 ASSERT_NE(nullptr, callbackWrap);
305 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
306 g_InfoParms1.instIndex);
307 ASSERT_NE(INVALID_TOKENID, tokenId);
308 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
309 tokenId, PID, "ohos.permission.LOCATION", callbackWrap->AsObject()));
310
311 // tokenId invaild
312 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
313 g_nativeToken, PID, "ohos.permission.CAMERA", nullptr));
314
315 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
316 tokenId, PID, "ohos.permission.CAMERA", nullptr));
317 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
318 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, "ohos.permission.CAMERA", nullptr));
319
320 ASSERT_EQ(Constant::SUCCESS,
321 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.CAMERA"));
322 }
323
324 /*
325 * @tc.name: StartUsingPermissionTest003
326 * @tc.desc:
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest003, TestSize.Level1)
331 {
332 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
333 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
334
335 PermissionRecordManager::GetInstance().isMicLoad_ = true;
336 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
337 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
338 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
339 g_InfoParms1.instIndex);
340 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
341 std::string permissionName = "ohos.permission.MICROPHONE";
342 ASSERT_EQ(PrivacyError::ERR_EDM_POLICY_CHECK_FAILED,
343 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
344
345 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
346 }
347
348 /*
349 * @tc.name: StartUsingPermissionTest004
350 * @tc.desc:
351 * @tc.type: FUNC
352 * @tc.require:
353 */
354 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest004, TestSize.Level1)
355 {
356 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
357 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
358
359 PermissionRecordManager::GetInstance().isMicLoad_ = true;
360 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
361 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
362 ASSERT_EQ(RET_SUCCESS,
363 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(true, PolicyType::PRIVACY));
364
365 std::vector<std::string> permList = {"ohos.permission.MICROPHONE"};
366 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
367 ASSERT_NE(nullptr, callback);
368 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
369 GetSelfTokenID(), permList, callback->AsObject()));
370
371 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
372 g_InfoParms1.instIndex);
373 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
374 std::string permissionName = "ohos.permission.MICROPHONE";
375 ASSERT_EQ(RET_SUCCESS,
376 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
377
378 usleep(500000); // 500000us = 0.5s
379 #ifndef APP_SECURITY_PRIVACY_SERVICE
380 ASSERT_EQ(PERM_INACTIVE, callback->type_);
381 #else
382 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
383 #endif
384 ASSERT_EQ(Constant::SUCCESS,
385 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName));
386 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
387 }
388
389 /*
390 * @tc.name: StartUsingPermissionTest005
391 * @tc.desc:
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest005, TestSize.Level1)
396 {
397 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
398 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
399
400 PermissionRecordManager::GetInstance().isMicLoad_ = true;
401 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
402 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
403 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(false, PolicyType::PRIVACY);
404 std::vector<std::string> permList = {"ohos.permission.MICROPHONE"};
405 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
406 ASSERT_NE(nullptr, callback);
407 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
408 GetSelfTokenID(), permList, callback->AsObject()));
409
410 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
411 g_InfoParms1.instIndex);
412 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
413 std::string permissionName = "ohos.permission.MICROPHONE";
414 ASSERT_EQ(RET_SUCCESS,
415 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
416
417 usleep(500000); // 500000us = 0.5s
418 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
419 ASSERT_EQ(Constant::SUCCESS,
420 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName));
421 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
422 }
423
424 /*
425 * @tc.name: StartUsingPermissionTest006
426 * @tc.desc:
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest006, TestSize.Level1)
431 {
432 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
433 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
434
435 PermissionRecordManager::GetInstance().isMicLoad_ = true;
436 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
437 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
438 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(true, PolicyType::PRIVACY);
439 std::vector<std::string> permList = {"ohos.permission.LOCATION"};
440 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
441 ASSERT_NE(nullptr, callback);
442 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
443 GetSelfTokenID(), permList, callback->AsObject()));
444
445 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
446 g_InfoParms1.instIndex);
447 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
448 std::string permissionName = "ohos.permission.LOCATION";
449 ASSERT_EQ(RET_SUCCESS,
450 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
451
452 usleep(500000); // 500000us = 0.5s
453 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
454 ASSERT_EQ(Constant::SUCCESS,
455 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName));
456 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
457 }
458
459 /*
460 * @tc.name: StartUsingPermissionTest008
461 * @tc.desc: Test multiple process start using permission
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest008, TestSize.Level1)
466 {
467 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
468
469 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
470 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
471 ASSERT_NE(nullptr, callback);
472 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
473 GetSelfTokenID(), permList, callback->AsObject()));
474
475 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
476 g_InfoParms1.instIndex);
477 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
478 std::string permissionName = "ohos.permission.CAMERA";
479 ASSERT_EQ(RET_SUCCESS,
480 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, TEST_PID_1, permissionName));
481 ASSERT_EQ(RET_SUCCESS,
482 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, TEST_PID_3, permissionName));
483 ProcessData processData;
484 processData.accessTokenId = tokenId;
485 processData.pid = TEST_PID_1;
486 appStateObserver_->OnProcessDied(processData);
487 usleep(500000); // 500000us = 0.5s
488 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
489
490 processData.pid = TEST_PID_2;
491 appStateObserver_->OnProcessDied(processData);
492 usleep(500000); // 500000us = 0.5s
493 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
494
495 processData.pid = TEST_PID_3;
496 appStateObserver_->OnProcessDied(processData);
497 usleep(500000); // 500000us = 0.5s
498 ASSERT_EQ(PERM_INACTIVE, callback->type_);
499 }
500
501 /*
502 * @tc.name: StartUsingPermissionTest011
503 * @tc.desc: Test default pid -1 start using permission and OnProcessDied
504 * @tc.type: FUNC
505 * @tc.require:
506 */
507 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest011, TestSize.Level1)
508 {
509 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
510
511 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
512 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
513 ASSERT_NE(nullptr, callback);
514 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
515 GetSelfTokenID(), permList, callback->AsObject()));
516 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
517 g_InfoParms1.instIndex);
518 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
519 std::string permissionName = "ohos.permission.CAMERA";
520 ASSERT_EQ(RET_SUCCESS,
521 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
522 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
523 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
524
525 // makesure callback end
526 usleep(500000); // 500000us = 0.5s
527 callback->type_ = PERM_ACTIVE_IN_FOREGROUND;
528 ProcessData processData;
529 processData.accessTokenId = tokenId;
530 processData.pid = PID;
531 appStateObserver_->OnProcessDied(processData);
532 usleep(500000);
533 ASSERT_EQ(PERM_ACTIVE_IN_FOREGROUND, callback->type_);
534 }
535
536 #ifndef APP_SECURITY_PRIVACY_SERVICE
537 /*
538 * @tc.name: ShowGlobalDialog001
539 * @tc.desc: ShowGlobalDialog function test
540 * @tc.type: FUNC
541 * @tc.require: issueI5RWXF
542 */
543 HWTEST_F(PermissionRecordManagerTest, ShowGlobalDialog001, TestSize.Level1)
544 {
545 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
546
547 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.CAMERA"));
548 sleep(3); // wait for dialog disappear
549 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog(MICROPHONE_PERMISSION_NAME));
550 sleep(3); // wait for dialog disappear
551 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.LOCATION")); // no dialog
552 }
553 #endif
554
555 /*
556 * @tc.name: AppStateChangeListener001
557 * @tc.desc: AppStateChange function test mic global switch is close
558 * @tc.type: FUNC
559 * @tc.require: issueI5RWXF
560 */
561 HWTEST_F(PermissionRecordManagerTest, AppStateChangeListener001, TestSize.Level1)
562 {
563 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
564 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
565
566 PermissionRecordManager::GetInstance().isMicLoad_ = true;
567 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
568 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
569 bool isMuteMic = AudioManagerPrivacyClient::GetInstance().GetPersistentMicMuteState();
570 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(true, PolicyType::PRIVACY);
571 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
572 g_InfoParms1.instIndex);
573 // status is inactive
574 ASSERT_EQ(0,
575 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, MICROPHONE_PERMISSION_NAME));
576 sleep(3); // wait for dialog disappear
577 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, PERM_ACTIVE_IN_BACKGROUND);
578 ASSERT_EQ(0,
579 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, MICROPHONE_PERMISSION_NAME));
580 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(isMuteMic, PolicyType::PRIVACY);
581 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
582 }
583
584 /*
585 * @tc.name: TransferOpcodeToPermission001
586 * @tc.desc: Constant::TransferOpcodeToPermission function test return false
587 * @tc.type: FUNC
588 * @tc.require:
589 */
590 HWTEST_F(PermissionRecordManagerTest, TransferOpcodeToPermission001, TestSize.Level1)
591 {
592 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_INVALID);
593 std::string permissionName;
594 ASSERT_EQ(false, Constant::TransferOpcodeToPermission(opCode, permissionName));
595 }
596
597 /*
598 * @tc.name: AddPermissionUsedRecord001
599 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
600 * @tc.type: FUNC
601 * @tc.require:
602 */
603 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord001, TestSize.Level1)
604 {
605 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
606 g_InfoParms1.instIndex);
607 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
608
609 AddPermParamInfo info;
610 info.tokenId = tokenId;
611 info.permissionName = "com.ohos.test";
612 info.successCount = 1;
613 info.failCount = 0;
614
615 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
616 info)); // invaild permission error
617
618 info.type = PermissionUsedType::PICKER_TYPE;
619 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
620 info)); // invaild permission error
621
622 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
623 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
624 info)); // invaild permission error
625 }
626
627 /*
628 * @tc.name: AddPermissionUsedRecord002
629 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
630 * @tc.type: FUNC
631 * @tc.require:
632 */
633 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord002, TestSize.Level1)
634 {
635 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
636 g_InfoParms1.instIndex);
637 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
638
639 AddPermParamInfo info;
640 info.tokenId = tokenId;
641 info.permissionName = "com.permission.READ_MEDIA";
642 info.successCount = 0;
643 info.failCount = 0;
644 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(info));
645 }
646
647 /*
648 * @tc.name: RemovePermissionUsedRecords001
649 * @tc.desc: PermissionRecordManager::RemovePermissionUsedRecords function test
650 * @tc.type: FUNC
651 * @tc.require:
652 */
653 HWTEST_F(PermissionRecordManagerTest, RemovePermissionUsedRecords001, TestSize.Level1)
654 {
655 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
656 g_InfoParms1.instIndex);
657 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
658
659 std::string deviceID;
660 PermissionRecordManager::GetInstance().RemovePermissionUsedRecords(tokenId, deviceID); // deviceID is empty
661
662 deviceID = "what's is";
663 // deviceID is not empty, but device which deps on tokenID is empty not equals deviceID
664 PermissionRecordManager::GetInstance().RemovePermissionUsedRecords(static_cast<AccessTokenID>(123), deviceID);
665
666 deviceID = "0";
667 // deviceID is not empty, device which deps on tokenID is not empty and equals deviceID
668 PermissionRecordManager::GetInstance().RemovePermissionUsedRecords(tokenId, deviceID);
669 }
670
671 /*
672 * @tc.name: StartUsingPermission001
673 * @tc.desc: PermissionRecordManager::StartUsingPermission function test
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(PermissionRecordManagerTest, StartUsingPermission001, TestSize.Level1)
678 {
679 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
680 g_InfoParms1.instIndex);
681 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
682
683 // tokenId invaild
684 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
685 g_nativeToken, PID, "ohos.permission.READ_MEDIA"));
686
687 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
688 tokenId, PID, "ohos.permission.READ_MEDIA"));
689 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
690 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
691
692 ASSERT_EQ(Constant::SUCCESS,
693 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
694 }
695
696 /*
697 * @tc.name: StopUsingPermission001
698 * @tc.desc: PermissionRecordManager::StopUsingPermission function test
699 * @tc.type: FUNC
700 * @tc.require:
701 */
702 HWTEST_F(PermissionRecordManagerTest, StopUsingPermission001, TestSize.Level1)
703 {
704 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
705 g_InfoParms1.instIndex);
706 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
707
708 // tokenId invaild
709 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StopUsingPermission(
710 static_cast<AccessTokenID>(0), PID, "ohos.permission.READ_MEDIA"));
711
712 // permission invaild
713 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().StopUsingPermission(
714 tokenId, PID, "ohos.permission.test"));
715
716 // not start using
717 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_START_USING,
718 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
719 }
720
721 /*
722 * @tc.name: RegisterPermActiveStatusCallback003
723 * @tc.desc: PermissionRecordManager::RegisterPermActiveStatusCallback function test
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback003, TestSize.Level1)
728 {
729 std::vector<std::string> permList;
730
731 permList.emplace_back("com.ohos.TEST");
732 // GetDefPermission != Constant::SUCCESS && listRes is empty && listSrc is not empty
733 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
734 GetSelfTokenID(), permList, nullptr));
735 }
736
737 /*
738 * @tc.name: GetPermissionUsedType001
739 * @tc.desc: PermissionRecordManager::GetPermissionUsedType function test
740 * @tc.type: FUNC
741 * @tc.require:
742 */
743 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedType001, TestSize.Level1)
744 {
745 uint32_t tokenId = RANDOM_TOKENID;
746 std::string permissionName = "ohos.permission.PERMISSION_RECORD_MANAGER_TEST";
747 std::vector<PermissionUsedTypeInfo> results;
748 // tokenId is not exsit
749 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST,
750 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
751
752 tokenId = 0;
753 // permissionName is not exsit
754 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
755 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
756
757 permissionName = "ohos.permission.CAMERA";
758 ASSERT_EQ(0, PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
759 }
760
761 /**
762 * @tc.name: Dlopen001
763 * @tc.desc: Open a not exist lib & not exist func
764 * @tc.type: FUNC
765 * @tc.require:
766 */
767 HWTEST_F(PermissionRecordManagerTest, Dlopen001, TestSize.Level1)
768 {
769 LibraryLoader loader1("libnotexist.z.so"); // is a not exist path
770 EXPECT_EQ(nullptr, loader1.handle_);
771
772 LibraryLoader loader2("libaccesstoken_manager_service.z.so"); // is a exist lib without create func
773 EXPECT_EQ(nullptr, loader2.instance_);
774 EXPECT_NE(nullptr, loader2.handle_);
775 }
776
777 /*
778 * @tc.name: AddDataValueToResults001
779 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults001, TestSize.Level1)
784 {
785 GenericValues value;
786 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
787 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, NORMAL_TYPE_ADD_VALUE);
788 std::vector<PermissionUsedTypeInfo> results;
789
790 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
791 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type);
792 }
793
794 /*
795 * @tc.name: AddDataValueToResults002
796 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
797 * @tc.type: FUNC
798 * @tc.require:
799 */
800 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults002, TestSize.Level1)
801 {
802 GenericValues value;
803 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
804 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, PICKER_TYPE_ADD_VALUE);
805 std::vector<PermissionUsedTypeInfo> results;
806
807 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
808 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type);
809 }
810
811 /*
812 * @tc.name: AddDataValueToResults003
813 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
814 * @tc.type: FUNC
815 * @tc.require:
816 */
817 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults003, TestSize.Level1)
818 {
819 GenericValues value;
820 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
821 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, SEC_COMPONENT_TYPE_ADD_VALUE);
822 std::vector<PermissionUsedTypeInfo> results;
823
824 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
825 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type);
826 ASSERT_EQ(0, GetFirstCallerTokenID());
827 }
828
829 /*
830 * @tc.name: SetMutePolicyTest001
831 * @tc.desc:
832 * @tc.type: FUNC
833 * @tc.require:
834 */
835 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest001, TestSize.Level1)
836 {
837 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
838 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
839 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
840 RANDOM_TOKENID);
841 EXPECT_EQ(RET_SUCCESS,
842 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
843
844 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
845 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
846 RANDOM_TOKENID);
847 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
848 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
849 }
850
851 /*
852 * @tc.name: SetMutePolicyTest002
853 * @tc.desc:
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest002, TestSize.Level1)
858 {
859 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
860 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
861 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
862 RANDOM_TOKENID);
863 EXPECT_EQ(RET_SUCCESS,
864 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
865
866 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
867 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
868 RANDOM_TOKENID);
869 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
870 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
871 }
872
873 /*
874 * @tc.name: SetMutePolicyTest003
875 * @tc.desc:
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest003, TestSize.Level1)
880 {
881 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
882 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
883 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
884 RANDOM_TOKENID);
885 EXPECT_EQ(RET_SUCCESS,
886 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
887
888 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
889 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
890 RANDOM_TOKENID);
891 EXPECT_EQ(RET_SUCCESS,
892 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
893 }
894
895 /*
896 * @tc.name: SetMutePolicyTest004
897 * @tc.desc:
898 * @tc.type: FUNC
899 * @tc.require:
900 */
901 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest004, TestSize.Level1)
902 {
903 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
904 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
905 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
906 RANDOM_TOKENID);
907 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
908 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
909
910 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
911 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
912 RANDOM_TOKENID);
913 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED,
914 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
915 RANDOM_TOKENID));
916 }
917
918 /*
919 * @tc.name: SetMutePolicyTest005
920 * @tc.desc:
921 * @tc.type: FUNC
922 * @tc.require:
923 */
924 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest005, TestSize.Level1)
925 {
926 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
927 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
928 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
929 RANDOM_TOKENID);
930 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
931 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
932
933 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
934 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
935 RANDOM_TOKENID);
936 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
937 PolicyType::PRIVACY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
938 }
939
940 /*
941 * @tc.name: SetMutePolicyTest006
942 * @tc.desc:
943 * @tc.type: FUNC
944 * @tc.require:
945 */
946 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest006, TestSize.Level1)
947 {
948 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
949 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
950 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
951 RANDOM_TOKENID);
952 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
953 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
954
955 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
956 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
957 RANDOM_TOKENID);
958 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
959 PolicyType::PRIVACY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
960 }
961
962 /*
963 * @tc.name: SetMutePolicyTest007
964 * @tc.desc:
965 * @tc.type: FUNC
966 * @tc.require:
967 */
968 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest007, TestSize.Level1)
969 {
970 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
971 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
972 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
973 RANDOM_TOKENID);
974 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
975 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
976
977 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
978 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
979 RANDOM_TOKENID);
980 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED, PermissionRecordManager::GetInstance().SetMutePolicy(
981 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
982 }
983
984 #ifndef APP_SECURITY_PRIVACY_SERVICE
985 /*
986 * @tc.name: SetMutePolicyTest008
987 * @tc.desc:
988 * @tc.type: FUNC
989 * @tc.require:
990 */
991 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest008, TestSize.Level1)
992 {
993 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
994 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
995 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
996 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
997 RANDOM_TOKENID);
998 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
999 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1000
1001 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1002 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1003 RANDOM_TOKENID);
1004 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED, PermissionRecordManager::GetInstance().SetMutePolicy(
1005 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1006 }
1007 #endif
1008
1009 /*
1010 * @tc.name: SetMutePolicyTest009
1011 * @tc.desc:
1012 * @tc.type: FUNC
1013 * @tc.require:
1014 */
1015 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest009, TestSize.Level1)
1016 {
1017 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1018 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1019 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1020 RANDOM_TOKENID);
1021 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1022 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1023
1024 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1025 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1026 RANDOM_TOKENID);
1027 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1028 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1029 }
1030 } // namespace AccessToken
1031 } // namespace Security
1032 } // namespace OHOS
1033