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 int32_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 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
337 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
338 g_InfoParms1.instIndex);
339 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
340 std::string permissionName = "ohos.permission.MICROPHONE";
341 ASSERT_EQ(PrivacyError::ERR_EDM_POLICY_CHECK_FAILED,
342 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
343
344 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
345 }
346
347 /*
348 * @tc.name: StartUsingPermissionTest004
349 * @tc.desc:
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest004, TestSize.Level1)
354 {
355 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
356 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
357
358 PermissionRecordManager::GetInstance().isMicLoad_ = true;
359 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
360 ASSERT_EQ(RET_SUCCESS,
361 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(true, PolicyType::PRIVACY));
362
363 std::vector<std::string> permList = {"ohos.permission.MICROPHONE"};
364 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
365 ASSERT_NE(nullptr, callback);
366 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
367 GetSelfTokenID(), permList, callback->AsObject()));
368
369 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
370 g_InfoParms1.instIndex);
371 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
372 std::string permissionName = "ohos.permission.MICROPHONE";
373 ASSERT_EQ(RET_SUCCESS,
374 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
375
376 usleep(500000); // 500000us = 0.5s
377 #ifndef APP_SECURITY_PRIVACY_SERVICE
378 ASSERT_EQ(PERM_INACTIVE, callback->type_);
379 #else
380 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
381 #endif
382 ASSERT_EQ(Constant::SUCCESS,
383 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName));
384 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
385 }
386
387 /*
388 * @tc.name: StartUsingPermissionTest005
389 * @tc.desc:
390 * @tc.type: FUNC
391 * @tc.require:
392 */
393 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest005, TestSize.Level1)
394 {
395 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
396 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
397
398 PermissionRecordManager::GetInstance().isMicLoad_ = true;
399 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
400 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(false, PolicyType::PRIVACY);
401 std::vector<std::string> permList = {"ohos.permission.MICROPHONE"};
402 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
403 ASSERT_NE(nullptr, callback);
404 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
405 GetSelfTokenID(), permList, callback->AsObject()));
406
407 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
408 g_InfoParms1.instIndex);
409 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
410 std::string permissionName = "ohos.permission.MICROPHONE";
411 ASSERT_EQ(RET_SUCCESS,
412 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
413
414 usleep(500000); // 500000us = 0.5s
415 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
416 ASSERT_EQ(Constant::SUCCESS,
417 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName));
418 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
419 }
420
421 /*
422 * @tc.name: StartUsingPermissionTest006
423 * @tc.desc:
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest006, TestSize.Level1)
428 {
429 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
430 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
431
432 PermissionRecordManager::GetInstance().isMicLoad_ = true;
433 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
434 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(true, PolicyType::PRIVACY);
435 std::vector<std::string> permList = {"ohos.permission.LOCATION"};
436 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
437 ASSERT_NE(nullptr, callback);
438 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
439 GetSelfTokenID(), permList, callback->AsObject()));
440
441 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
442 g_InfoParms1.instIndex);
443 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
444 std::string permissionName = "ohos.permission.LOCATION";
445 ASSERT_EQ(RET_SUCCESS,
446 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
447
448 usleep(500000); // 500000us = 0.5s
449 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
450 ASSERT_EQ(Constant::SUCCESS,
451 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName));
452 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
453 }
454
455 /*
456 * @tc.name: StartUsingPermissionTest008
457 * @tc.desc: Test multiple process start using permission
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest008, TestSize.Level1)
462 {
463 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
464
465 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
466 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
467 ASSERT_NE(nullptr, callback);
468 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
469 GetSelfTokenID(), permList, callback->AsObject()));
470
471 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
472 g_InfoParms1.instIndex);
473 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
474 std::string permissionName = "ohos.permission.CAMERA";
475 ASSERT_EQ(RET_SUCCESS,
476 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, TEST_PID_1, permissionName));
477 ASSERT_EQ(RET_SUCCESS,
478 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, TEST_PID_3, permissionName));
479 ProcessData processData;
480 processData.accessTokenId = tokenId;
481 processData.pid = TEST_PID_1;
482 appStateObserver_->OnProcessDied(processData);
483 usleep(500000); // 500000us = 0.5s
484 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
485
486 processData.pid = TEST_PID_2;
487 appStateObserver_->OnProcessDied(processData);
488 usleep(500000); // 500000us = 0.5s
489 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
490
491 processData.pid = TEST_PID_3;
492 appStateObserver_->OnProcessDied(processData);
493 usleep(500000); // 500000us = 0.5s
494 ASSERT_EQ(PERM_INACTIVE, callback->type_);
495 }
496
497 /*
498 * @tc.name: StartUsingPermissionTest011
499 * @tc.desc: Test default pid -1 start using permission and OnProcessDied
500 * @tc.type: FUNC
501 * @tc.require:
502 */
503 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest011, TestSize.Level1)
504 {
505 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
506
507 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
508 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
509 ASSERT_NE(nullptr, callback);
510 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
511 GetSelfTokenID(), permList, callback->AsObject()));
512 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
513 g_InfoParms1.instIndex);
514 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
515 std::string permissionName = "ohos.permission.CAMERA";
516 ASSERT_EQ(RET_SUCCESS,
517 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
518 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
519 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, permissionName));
520
521 // makesure callback end
522 usleep(500000); // 500000us = 0.5s
523 callback->type_ = PERM_ACTIVE_IN_FOREGROUND;
524 ProcessData processData;
525 processData.accessTokenId = tokenId;
526 processData.pid = PID;
527 appStateObserver_->OnProcessDied(processData);
528 usleep(500000);
529 ASSERT_EQ(PERM_ACTIVE_IN_FOREGROUND, callback->type_);
530 }
531
532 #ifndef APP_SECURITY_PRIVACY_SERVICE
533 /*
534 * @tc.name: ShowGlobalDialog001
535 * @tc.desc: ShowGlobalDialog function test
536 * @tc.type: FUNC
537 * @tc.require: issueI5RWXF
538 */
539 HWTEST_F(PermissionRecordManagerTest, ShowGlobalDialog001, TestSize.Level1)
540 {
541 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
542
543 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.CAMERA"));
544 sleep(3); // wait for dialog disappear
545 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog(MICROPHONE_PERMISSION_NAME));
546 sleep(3); // wait for dialog disappear
547 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.LOCATION")); // no dialog
548 }
549 #endif
550
551 /*
552 * @tc.name: AppStateChangeListener001
553 * @tc.desc: AppStateChange function test mic global switch is close
554 * @tc.type: FUNC
555 * @tc.require: issueI5RWXF
556 */
557 HWTEST_F(PermissionRecordManagerTest, AppStateChangeListener001, TestSize.Level1)
558 {
559 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
560 bool isMicLoad = PermissionRecordManager::GetInstance().isMicLoad_;
561
562 PermissionRecordManager::GetInstance().isMicLoad_ = true;
563 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
564 bool isMuteMic = AudioManagerPrivacyClient::GetInstance().GetPersistentMicMuteState();
565 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(true, PolicyType::PRIVACY);
566 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
567 g_InfoParms1.instIndex);
568 // status is inactive
569 ASSERT_EQ(0,
570 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, MICROPHONE_PERMISSION_NAME));
571 sleep(3); // wait for dialog disappear
572 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, PERM_ACTIVE_IN_BACKGROUND);
573 ASSERT_EQ(0,
574 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, MICROPHONE_PERMISSION_NAME));
575 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMutePersistent(isMuteMic, PolicyType::PRIVACY);
576 PermissionRecordManager::GetInstance().isMicLoad_ = isMicLoad;
577 }
578
579 /*
580 * @tc.name: TransferOpcodeToPermission001
581 * @tc.desc: Constant::TransferOpcodeToPermission function test return false
582 * @tc.type: FUNC
583 * @tc.require:
584 */
585 HWTEST_F(PermissionRecordManagerTest, TransferOpcodeToPermission001, TestSize.Level1)
586 {
587 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_INVALID);
588 std::string permissionName;
589 ASSERT_EQ(false, Constant::TransferOpcodeToPermission(opCode, permissionName));
590 }
591
592 /*
593 * @tc.name: AddPermissionUsedRecord001
594 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
595 * @tc.type: FUNC
596 * @tc.require:
597 */
598 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord001, TestSize.Level1)
599 {
600 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
601 g_InfoParms1.instIndex);
602 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
603
604 AddPermParamInfo info;
605 info.tokenId = tokenId;
606 info.permissionName = "com.ohos.test";
607 info.successCount = 1;
608 info.failCount = 0;
609
610 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
611 info)); // invaild permission error
612
613 info.type = PermissionUsedType::PICKER_TYPE;
614 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
615 info)); // invaild permission error
616
617 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
618 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
619 info)); // invaild permission error
620 }
621
622 /*
623 * @tc.name: AddPermissionUsedRecord002
624 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
625 * @tc.type: FUNC
626 * @tc.require:
627 */
628 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord002, TestSize.Level1)
629 {
630 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
631 g_InfoParms1.instIndex);
632 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
633
634 AddPermParamInfo info;
635 info.tokenId = tokenId;
636 info.permissionName = "com.permission.READ_MEDIA";
637 info.successCount = 0;
638 info.failCount = 0;
639 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(info));
640 }
641
642 /*
643 * @tc.name: RemovePermissionUsedRecords001
644 * @tc.desc: PermissionRecordManager::RemovePermissionUsedRecords function test
645 * @tc.type: FUNC
646 * @tc.require:
647 */
648 HWTEST_F(PermissionRecordManagerTest, RemovePermissionUsedRecords001, TestSize.Level1)
649 {
650 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
651 g_InfoParms1.instIndex);
652 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
653
654 std::string deviceID;
655 PermissionRecordManager::GetInstance().RemovePermissionUsedRecords(tokenId, deviceID); // deviceID is empty
656
657 deviceID = "what's is";
658 // deviceID is not empty, but device which deps on tokenID is empty not equals deviceID
659 PermissionRecordManager::GetInstance().RemovePermissionUsedRecords(static_cast<AccessTokenID>(123), deviceID);
660
661 deviceID = "0";
662 // deviceID is not empty, device which deps on tokenID is not empty and equals deviceID
663 PermissionRecordManager::GetInstance().RemovePermissionUsedRecords(tokenId, deviceID);
664 }
665
666 /*
667 * @tc.name: StartUsingPermission001
668 * @tc.desc: PermissionRecordManager::StartUsingPermission function test
669 * @tc.type: FUNC
670 * @tc.require:
671 */
672 HWTEST_F(PermissionRecordManagerTest, StartUsingPermission001, TestSize.Level1)
673 {
674 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
675 g_InfoParms1.instIndex);
676 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
677
678 // tokenId invaild
679 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
680 g_nativeToken, PID, "ohos.permission.READ_MEDIA"));
681
682 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
683 tokenId, PID, "ohos.permission.READ_MEDIA"));
684 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
685 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
686
687 ASSERT_EQ(Constant::SUCCESS,
688 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
689 }
690
691 /*
692 * @tc.name: StopUsingPermission001
693 * @tc.desc: PermissionRecordManager::StopUsingPermission function test
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(PermissionRecordManagerTest, StopUsingPermission001, TestSize.Level1)
698 {
699 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
700 g_InfoParms1.instIndex);
701 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
702
703 // tokenId invaild
704 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StopUsingPermission(
705 static_cast<AccessTokenID>(0), PID, "ohos.permission.READ_MEDIA"));
706
707 // permission invaild
708 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().StopUsingPermission(
709 tokenId, PID, "ohos.permission.test"));
710
711 // not start using
712 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_START_USING,
713 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
714 }
715
716 /*
717 * @tc.name: RegisterPermActiveStatusCallback003
718 * @tc.desc: PermissionRecordManager::RegisterPermActiveStatusCallback function test
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback003, TestSize.Level1)
723 {
724 std::vector<std::string> permList;
725
726 permList.emplace_back("com.ohos.TEST");
727 // GetDefPermission != Constant::SUCCESS && listRes is empty && listSrc is not empty
728 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
729 GetSelfTokenID(), permList, nullptr));
730 }
731
732 /*
733 * @tc.name: GetPermissionUsedType001
734 * @tc.desc: PermissionRecordManager::GetPermissionUsedType function test
735 * @tc.type: FUNC
736 * @tc.require:
737 */
738 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedType001, TestSize.Level1)
739 {
740 int32_t tokenId = RANDOM_TOKENID;
741 std::string permissionName = "ohos.permission.PERMISSION_RECORD_MANAGER_TEST";
742 std::vector<PermissionUsedTypeInfo> results;
743 // tokenId is not exsit
744 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST,
745 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
746
747 tokenId = 0;
748 // permissionName is not exsit
749 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
750 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
751
752 permissionName = "ohos.permission.CAMERA";
753 ASSERT_EQ(0, PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
754 }
755
756 /**
757 * @tc.name: Dlopen001
758 * @tc.desc: Open a not exist lib & not exist func
759 * @tc.type: FUNC
760 * @tc.require:
761 */
762 HWTEST_F(PermissionRecordManagerTest, Dlopen001, TestSize.Level1)
763 {
764 LibraryLoader loader1("libnotexist.z.so"); // is a not exist path
765 EXPECT_EQ(nullptr, loader1.handle_);
766
767 LibraryLoader loader2("libaccesstoken_manager_service.z.so"); // is a exist lib without create func
768 EXPECT_EQ(nullptr, loader2.instance_);
769 EXPECT_NE(nullptr, loader2.handle_);
770 }
771
772 /*
773 * @tc.name: AddDataValueToResults001
774 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults001, TestSize.Level1)
779 {
780 GenericValues value;
781 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
782 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, NORMAL_TYPE_ADD_VALUE);
783 std::vector<PermissionUsedTypeInfo> results;
784
785 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
786 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type);
787 }
788
789 /*
790 * @tc.name: AddDataValueToResults002
791 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults002, TestSize.Level1)
796 {
797 GenericValues value;
798 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
799 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, PICKER_TYPE_ADD_VALUE);
800 std::vector<PermissionUsedTypeInfo> results;
801
802 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
803 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type);
804 }
805
806 /*
807 * @tc.name: AddDataValueToResults003
808 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
809 * @tc.type: FUNC
810 * @tc.require:
811 */
812 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults003, TestSize.Level1)
813 {
814 GenericValues value;
815 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
816 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, SEC_COMPONENT_TYPE_ADD_VALUE);
817 std::vector<PermissionUsedTypeInfo> results;
818
819 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
820 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type);
821 ASSERT_EQ(0, GetFirstCallerTokenID());
822 }
823
824 /*
825 * @tc.name: SetMutePolicyTest001
826 * @tc.desc:
827 * @tc.type: FUNC
828 * @tc.require:
829 */
830 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest001, TestSize.Level1)
831 {
832 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
833 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
834 EXPECT_EQ(RET_SUCCESS,
835 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true));
836
837 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
838 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
839 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
840 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false));
841 }
842
843 /*
844 * @tc.name: SetMutePolicyTest002
845 * @tc.desc:
846 * @tc.type: FUNC
847 * @tc.require:
848 */
849 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest002, TestSize.Level1)
850 {
851 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
852 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
853 EXPECT_EQ(RET_SUCCESS,
854 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true));
855
856 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
857 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
858 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
859 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false));
860 }
861
862 /*
863 * @tc.name: SetMutePolicyTest003
864 * @tc.desc:
865 * @tc.type: FUNC
866 * @tc.require:
867 */
868 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest003, TestSize.Level1)
869 {
870 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
871 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false);
872 EXPECT_EQ(RET_SUCCESS,
873 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true));
874
875 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
876 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false);
877 EXPECT_EQ(RET_SUCCESS,
878 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false));
879 }
880
881 /*
882 * @tc.name: SetMutePolicyTest004
883 * @tc.desc:
884 * @tc.type: FUNC
885 * @tc.require:
886 */
887 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest004, TestSize.Level1)
888 {
889 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
890 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
891 EXPECT_EQ(RET_SUCCESS,
892 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true));
893
894 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
895 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
896 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED,
897 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false));
898 }
899
900 /*
901 * @tc.name: SetMutePolicyTest005
902 * @tc.desc:
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest005, TestSize.Level1)
907 {
908 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
909 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
910 EXPECT_EQ(RET_SUCCESS,
911 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true));
912
913 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
914 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
915 EXPECT_EQ(RET_SUCCESS,
916 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false));
917 }
918
919 /*
920 * @tc.name: SetMutePolicyTest006
921 * @tc.desc:
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest006, TestSize.Level1)
926 {
927 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
928 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false);
929 EXPECT_EQ(RET_SUCCESS,
930 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true));
931
932 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
933 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false);
934 EXPECT_EQ(RET_SUCCESS,
935 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false));
936 }
937
938 /*
939 * @tc.name: SetMutePolicyTest007
940 * @tc.desc:
941 * @tc.type: FUNC
942 * @tc.require:
943 */
944 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest007, TestSize.Level1)
945 {
946 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
947 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
948 EXPECT_EQ(RET_SUCCESS,
949 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::TEMPORARY, CallerType::MICROPHONE, true));
950
951 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true);
952 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
953 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED,
954 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::TEMPORARY, CallerType::MICROPHONE, false));
955 }
956
957 #ifndef APP_SECURITY_PRIVACY_SERVICE
958 /*
959 * @tc.name: SetMutePolicyTest008
960 * @tc.desc:
961 * @tc.type: FUNC
962 * @tc.require:
963 */
964 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest008, TestSize.Level1)
965 {
966 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
967 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
968 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
969 EXPECT_EQ(RET_SUCCESS,
970 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::TEMPORARY, CallerType::MICROPHONE, true));
971
972 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
973 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true);
974 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
975 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::TEMPORARY, CallerType::MICROPHONE, false));
976 }
977 #endif
978
979 /*
980 * @tc.name: SetMutePolicyTest009
981 * @tc.desc:
982 * @tc.type: FUNC
983 * @tc.require:
984 */
985 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest009, TestSize.Level1)
986 {
987 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
988 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false);
989 EXPECT_EQ(RET_SUCCESS,
990 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::TEMPORARY, CallerType::MICROPHONE, true));
991
992 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false);
993 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false);
994 EXPECT_EQ(RET_SUCCESS,
995 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::TEMPORARY, CallerType::MICROPHONE, false));
996 }
997 } // namespace AccessToken
998 } // namespace Security
999 } // namespace OHOS
1000