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 <gtest/gtest.h>
17 #include <memory>
18
19 #include "accesstoken_kit.h"
20 #include "constant.h"
21 #include "iprivacy_manager.h"
22 #include "on_permission_used_record_callback_stub.h"
23 #define private public
24 #include "permission_record_manager.h"
25 #include "privacy_manager_service.h"
26 #undef private
27 #include "perm_active_status_change_callback_stub.h"
28 #include "perm_active_status_change_callback.h"
29 #include "privacy_error.h"
30 #include "privacy_field_const.h"
31 #include "privacy_test_common.h"
32 #include "proxy_death_callback_stub.h"
33 #include "state_change_callback.h"
34 #include "string_ex.h"
35 #include "token_setproc.h"
36
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace Security {
41 namespace AccessToken {
42 namespace {
43 static AccessTokenID g_selfTokenId = 0;
44 static constexpr int32_t PERMISSION_USAGE_RECORDS_MAX_NUM = 10;
45 constexpr const char* CAMERA_PERMISSION_NAME = "ohos.permission.CAMERA";
46 constexpr const char* MICROPHONE_PERMISSION_NAME = "ohos.permission.MICROPHONE";
47 constexpr const char* LOCATION_PERMISSION_NAME = "ohos.permission.LOCATION";
48 static const uint32_t PERM_LIST_SIZE_MAX = 1024;
49 static constexpr int32_t COMMON_EVENT_SERVICE_ID = 3299;
50 static constexpr int32_t SCREENLOCK_SERVICE_ID = 3704;
51 static constexpr int32_t INVALID_CODE = 999;
52 static PermissionStateFull g_testState = {
53 .permissionName = "ohos.permission.CAMERA",
54 .isGeneral = true,
55 .resDeviceID = {"local"},
56 .grantStatus = {PermissionState::PERMISSION_GRANTED},
57 .grantFlags = {1}
58 };
59
60 static HapPolicyParams g_PolicyPrams1 = {
61 .apl = APL_NORMAL,
62 .domain = "test.domain.A",
63 .permList = {},
64 .permStateList = {g_testState}
65 };
66
67 static HapInfoParams g_InfoParms1 = {
68 .userID = 1,
69 .bundleName = "ohos.privacy_test.bundleA",
70 .instIndex = 0,
71 .appIDDesc = "privacy_test.bundleA",
72 .isSystemApp = true
73 };
74 }
75
76 class PrivacyManagerServiceTest : public testing::Test {
77 public:
78 static void SetUpTestCase();
79
80 static void TearDownTestCase();
81
82 void SetUp();
83
84 void TearDown();
85 std::shared_ptr<PrivacyManagerService> privacyManagerService_;
86 };
87
SetUpTestCase()88 void PrivacyManagerServiceTest::SetUpTestCase()
89 {
90 g_selfTokenId = GetSelfTokenID();
91 PrivacyTestCommon::SetTestEvironment(g_selfTokenId);
92 }
93
TearDownTestCase()94 void PrivacyManagerServiceTest::TearDownTestCase()
95 {
96 PrivacyTestCommon::ResetTestEvironment();
97 }
98
SetUp()99 void PrivacyManagerServiceTest::SetUp()
100 {
101 privacyManagerService_ = DelayedSingleton<PrivacyManagerService>::GetInstance();
102 PermissionRecordManager::GetInstance().Register();
103 EXPECT_NE(nullptr, privacyManagerService_);
104
105 PrivacyTestCommon::AllocTestHapToken(g_InfoParms1, g_PolicyPrams1);
106 }
107
TearDown()108 void PrivacyManagerServiceTest::TearDown()
109 {
110 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(g_InfoParms1.userID, g_InfoParms1.bundleName,
111 g_InfoParms1.instIndex);
112 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
113 privacyManagerService_->RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
114
115 privacyManagerService_ = nullptr;
116 }
117
118 /**
119 * @tc.name: Dump001
120 * @tc.desc: Dump record info.
121 * @tc.type: FUNC
122 * @tc.require: issueI4V02P
123 */
124 HWTEST_F(PrivacyManagerServiceTest, Dump001, TestSize.Level0)
125 {
126 int32_t fd = -1;
127 std::vector<std::u16string> args;
128
129 // fd is 0
130 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
131
132 fd = 1; // 1: std output
133
134 // hidumper
135 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
136
137 // hidumper -h
138 args.emplace_back(Str8ToStr16("-h"));
139 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
140
141 args.clear();
142 // hidumper -t
143 args.emplace_back(Str8ToStr16("-t"));
144 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
145
146 args.clear();
147 // hidumper -t
148 args.emplace_back(Str8ToStr16("-t"));
149 args.emplace_back(Str8ToStr16("-1")); // illegal tokenId
150 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
151
152 args.clear();
153 // hidumper -t
154 args.emplace_back(Str8ToStr16("-s"));
155 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
156
157 args.clear();
158 // hidumper -t
159 args.emplace_back(Str8ToStr16("-t"));
160 args.emplace_back(Str8ToStr16("123")); // 123: invalid tokenId
161 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
162 }
163
164 /**
165 * @tc.name: Dump002
166 * @tc.desc: Dump record info.
167 * @tc.type: FUNC
168 * @tc.require: issueI4V02P
169 */
170 HWTEST_F(PrivacyManagerServiceTest, Dump002, TestSize.Level0)
171 {
172 int32_t fd = 1; // 1: std output
173 std::vector<std::u16string> args;
174 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_InfoParms1, g_PolicyPrams1);
175
176 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
177 args.emplace_back(Str8ToStr16("-t"));
178 std::string tokenIdStr = std::to_string(tokenId);
179 args.emplace_back(Str8ToStr16(tokenIdStr));
180
181 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
182
183 AddPermParamInfoParcel infoParcel;
184 infoParcel.info.tokenId = tokenId;
185 infoParcel.info.permissionName = "ohos.permission.READ_CONTACTS";
186 infoParcel.info.successCount = 1;
187 infoParcel.info.failCount = 0;
188
189 for (int32_t i = 0; i < PERMISSION_USAGE_RECORDS_MAX_NUM; i++) {
190 privacyManagerService_->AddPermissionUsedRecord(infoParcel);
191 }
192
193 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
194
195 privacyManagerService_->AddPermissionUsedRecord(infoParcel);
196 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
197 }
198
199 /*
200 * @tc.name: IsAllowedUsingPermission001
201 * @tc.desc: IsAllowedUsingPermission function test permissionName branch
202 * @tc.type: FUNC
203 * @tc.require: issueI5UPRK
204 */
205 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermission001, TestSize.Level0)
206 {
207 MockNativeToken mock("privacy_service");
208
209 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
210 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
211
212 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
213 ASSERT_NE(INVALID_TOKENID, tokenId);
214 ASSERT_EQ(false, PermissionRecordManager::GetInstance().IsAllowedUsingPermission(
215 tokenId, MICROPHONE_PERMISSION_NAME, -1));
216 ASSERT_EQ(false, PermissionRecordManager::GetInstance().IsAllowedUsingPermission(
217 tokenId, LOCATION_PERMISSION_NAME, -1));
218 ASSERT_EQ(false, PermissionRecordManager::GetInstance().IsAllowedUsingPermission(
219 tokenId, CAMERA_PERMISSION_NAME, -1));
220 }
221
222 /*
223 * @tc.name: IsAllowedUsingPermission002
224 * @tc.desc: IsAllowedUsingPermission function test invalid tokenId and permission
225 * @tc.type: FUNC
226 * @tc.require: issueI5UPRK
227 */
228 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermission002, TestSize.Level0)
229 {
230 AccessTokenID tokenId = PrivacyTestCommon::GetNativeTokenIdFromProcess("privacy_service");
231 // invalid tokenId
232 bool isAllowed = true;
233 privacyManagerService_->IsAllowedUsingPermission(0, CAMERA_PERMISSION_NAME, -1, isAllowed);
234 ASSERT_EQ(false, isAllowed);
235
236 // native tokenId
237 privacyManagerService_->IsAllowedUsingPermission(tokenId, CAMERA_PERMISSION_NAME, -1, isAllowed);
238 ASSERT_EQ(false, isAllowed);
239
240 // invalid permission
241 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
242 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
243 tokenId = tokenIdEx.tokenIdExStruct.tokenID;
244 ASSERT_NE(INVALID_TOKENID, tokenId);
245 privacyManagerService_->IsAllowedUsingPermission(tokenId, "test", -1, isAllowed);
246 ASSERT_EQ(false, isAllowed);
247 }
248
249 /*
250 * @tc.name: IsAllowedUsingPermission003
251 * @tc.desc: test camera with screen off
252 * @tc.type: FUNC
253 * @tc.require: issueI5UPRK
254 */
255 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermission003, TestSize.Level0)
256 {
257 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
258 g_InfoParms1.userID, g_InfoParms1.bundleName, g_InfoParms1.instIndex);
259
260 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
261 ASSERT_NE(INVALID_TOKENID, tokenId);
262 bool isAllowed = true;
263 privacyManagerService_->IsAllowedUsingPermission(tokenId, CAMERA_PERMISSION_NAME, -1, isAllowed);
264 ASSERT_EQ(false, isAllowed);
265 }
266
267 /**
268 * @tc.name: AddPermissionUsedRecordInner001
269 * @tc.desc: AddPermissionUsedRecordInner test.
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(PrivacyManagerServiceTest, AddPermissionUsedRecordInner001, TestSize.Level0)
274 {
275 AccessTokenID tokenID = 123; // 123 is invalid tokenID
276 std::string permissionName = "ohos.permission.test"; // is invalid permission
277 int32_t successCount = 1; // number 1
278 int32_t failCount = 1; // number 1
279
280 AddPermParamInfoParcel infoParcel;
281 infoParcel.info.tokenId = tokenID;
282 infoParcel.info.permissionName = permissionName;
283 infoParcel.info.successCount = successCount;
284 infoParcel.info.failCount = failCount;
285
286 // callingTokenID is native token hdcd with need permission, but input tokenID is not a real hap
287 int32_t ret = privacyManagerService_->AddPermissionUsedRecord(infoParcel);
288
289 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
290 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
291 }
292
293 /**
294 * @tc.name: AddPermissionUsedRecordInner002
295 * @tc.desc: AddPermissionUsedRecordInner test.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(PrivacyManagerServiceTest, AddPermissionUsedRecordInner002, TestSize.Level0)
300 {
301 AccessTokenID tokenID = 123; // 123 is invalid tokenID
302 std::string permissionName = "ohos.permission.test"; // is invalid permission
303 int32_t successCount = 1; // number 1
304 int32_t failCount = 1; // number 1
305
306 std::vector<std::string> reqPerm;
307 MockHapToken mock("AddPermissionUsedRecordInner002", reqPerm, false); // set self tokenID to normal app
308
309 AddPermParamInfoParcel infoParcel;
310 infoParcel.info.tokenId = tokenID;
311 infoParcel.info.permissionName = permissionName;
312 infoParcel.info.successCount = successCount;
313 infoParcel.info.failCount = failCount;
314
315 // callingTokenID is normal hap without need permission
316 int32_t ret = privacyManagerService_->AddPermissionUsedRecord(infoParcel);
317
318 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
319 }
320
321 /**
322 * @tc.name: AddPermissionUsedRecordInner003
323 * @tc.desc: AddPermissionUsedRecordInner test.
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(PrivacyManagerServiceTest, AddPermissionUsedRecordInner003, TestSize.Level0)
328 {
329 AccessTokenID tokenID = 123; // 123 is invalid tokenID
330 std::string permissionName = "ohos.permission.test"; // is invalid permission
331 int32_t successCount = 1; // number 1
332 int32_t failCount = 1; // number 1
333
334 std::vector<std::string> reqPerm;
335 MockHapToken mock("AddPermissionUsedRecordInner003", reqPerm, true); // set self tokenID to system app
336
337 AddPermParamInfoParcel infoParcel;
338 infoParcel.info.tokenId = tokenID;
339 infoParcel.info.permissionName = permissionName;
340 infoParcel.info.successCount = successCount;
341 infoParcel.info.failCount = failCount;
342
343 // callingTokenID is normal hap without need permission
344 int32_t ret = privacyManagerService_->AddPermissionUsedRecord(infoParcel);
345
346 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
347 }
348
349 /**
350 * @tc.name: AddPermissionUsedRecordAsyncInner001
351 * @tc.desc: AddPermissionUsedRecordAsyncInner test.
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(PrivacyManagerServiceTest, AddPermissionUsedRecordAsyncInner001, TestSize.Level0)
356 {
357 AccessTokenID tokenID = 123; // 123 is invalid tokenID
358 std::string permissionName = "ohos.permission.test"; // is invalid permission
359 int32_t successCount = 1; // number 1
360 int32_t failCount = 1; // number 1
361
362 AddPermParamInfoParcel infoParcel;
363 infoParcel.info.tokenId = tokenID;
364 infoParcel.info.permissionName = permissionName;
365 infoParcel.info.successCount = successCount;
366 infoParcel.info.failCount = failCount;
367
368 // callingTokenID is native token hdcd with need permission, but input tokenID is not a real hap
369 int32_t ret = privacyManagerService_->AddPermissionUsedRecordAsync(infoParcel);
370
371 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
372 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
373 }
374
375 /**
376 * @tc.name: AddPermissionUsedRecordAsyncInner002
377 * @tc.desc: AddPermissionUsedRecordAsyncInner test.
378 * @tc.type: FUNC
379 * @tc.require:
380 */
381 HWTEST_F(PrivacyManagerServiceTest, AddPermissionUsedRecordAsyncInner002, TestSize.Level0)
382 {
383 AccessTokenID tokenID = 123; // 123 is invalid tokenID
384 std::string permissionName = "ohos.permission.test"; // is invalid permission
385 int32_t successCount = 1; // number 1
386 int32_t failCount = 1; // number 1
387
388 std::vector<std::string> reqPerm;
389 MockHapToken mock("AddPermissionUsedRecordAsyncInner002", reqPerm, false); // set self tokenID to normal app
390
391 AddPermParamInfoParcel infoParcel;
392 infoParcel.info.tokenId = tokenID;
393 infoParcel.info.permissionName = permissionName;
394 infoParcel.info.successCount = successCount;
395 infoParcel.info.failCount = failCount;
396
397 // callingTokenID is normal hap without need permission
398 int32_t ret = privacyManagerService_->AddPermissionUsedRecordAsync(infoParcel);
399
400 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
401 }
402
403 /**
404 * @tc.name: AddPermissionUsedRecordAsyncInner003
405 * @tc.desc: AddPermissionUsedRecordAsyncInner test.
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(PrivacyManagerServiceTest, AddPermissionUsedRecordAsyncInner003, TestSize.Level0)
410 {
411 AccessTokenID tokenID = 123; // 123 is invalid tokenID
412 std::string permissionName = "ohos.permission.test"; // is invalid permission
413 int32_t successCount = 1; // number 1
414 int32_t failCount = 1; // number 1
415
416 std::vector<std::string> reqPerm;
417 MockHapToken mock("AddPermissionUsedRecordAsyncInner003", reqPerm, true); // set self tokenID to system app
418
419 AddPermParamInfoParcel infoParcel;
420 infoParcel.info.tokenId = tokenID;
421 infoParcel.info.permissionName = permissionName;
422 infoParcel.info.successCount = successCount;
423 infoParcel.info.failCount = failCount;
424
425 // callingTokenID is normal hap without need permission
426 int32_t ret = privacyManagerService_->AddPermissionUsedRecordAsync(infoParcel);
427
428 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
429 }
430
431 /**
432 * @tc.name: SetPermissionUsedRecordToggleStatusInner001
433 * @tc.desc: SetPermissionUsedRecordToggleStatusInner test.
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(PrivacyManagerServiceTest, SetPermissionUsedRecordToggleStatusInner001, TestSize.Level0)
438 {
439 int32_t userID = 1;
440 bool status = true;
441
442 int32_t ret = privacyManagerService_->SetPermissionUsedRecordToggleStatus(userID, status);
443 ASSERT_EQ(RET_SUCCESS, ret);
444 }
445
446 /**
447 * @tc.name: SetPermissionUsedRecordToggleStatusInner002
448 * @tc.desc: SetPermissionUsedRecordToggleStatusInner test.
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(PrivacyManagerServiceTest, SetPermissionUsedRecordToggleStatusInner002, TestSize.Level0)
453 {
454 int32_t userID = 1;
455 bool status = true;
456
457 std::vector<std::string> reqPerm;
458 MockHapToken mock("SetPermissionUsedRecordToggleStatusInner002", reqPerm, false); // set self tokenID to normal app
459
460 int32_t ret = privacyManagerService_->SetPermissionUsedRecordToggleStatus(userID, status);
461 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
462 }
463
464 /**
465 * @tc.name: SetPermissionUsedRecordToggleStatusInner003
466 * @tc.desc: SetPermissionUsedRecordToggleStatusInner test.
467 * @tc.type: FUNC
468 * @tc.require:
469 */
470 HWTEST_F(PrivacyManagerServiceTest, SetPermissionUsedRecordToggleStatusInner003, TestSize.Level0)
471 {
472 int32_t userID = 1;
473 bool status = true;
474
475 std::vector<std::string> reqPerm;
476 MockHapToken mock("SetPermissionUsedRecordToggleStatusInner003", reqPerm, true); // set self tokenID to system app
477
478 int32_t ret = privacyManagerService_->SetPermissionUsedRecordToggleStatus(userID, status);
479 ASSERT_EQ(RET_SUCCESS, ret);
480 }
481
482 /**
483 * @tc.name: GetPermissionUsedRecordToggleStatusInner001
484 * @tc.desc: GetPermissionUsedRecordToggleStatusInner test.
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordToggleStatusInner001, TestSize.Level0)
489 {
490 int32_t userID = 1;
491 bool status = true;
492
493 int32_t ret = privacyManagerService_->GetPermissionUsedRecordToggleStatus(userID, status);
494 ASSERT_EQ(RET_SUCCESS, ret);
495 }
496
497 /**
498 * @tc.name: GetPermissionUsedRecordToggleStatusInner002
499 * @tc.desc: GetPermissionUsedRecordToggleStatusInner test.
500 * @tc.type: FUNC
501 * @tc.require:
502 */
503 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordToggleStatusInner002, TestSize.Level0)
504 {
505 int32_t userID = 1;
506 bool status = true;
507
508 std::vector<std::string> reqPerm;
509 MockHapToken mock("GetPermissionUsedRecordToggleStatusInner002", reqPerm, false); // set self tokenID to normal app
510
511 int32_t ret = privacyManagerService_->GetPermissionUsedRecordToggleStatus(userID, status);
512 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
513 }
514
515 /**
516 * @tc.name: GetPermissionUsedRecordToggleStatusInner003
517 * @tc.desc: GetPermissionUsedRecordToggleStatusInner test.
518 * @tc.type: FUNC
519 * @tc.require:
520 */
521 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordToggleStatusInner003, TestSize.Level0)
522 {
523 int32_t userID = 1;
524 bool status = true;
525
526 std::vector<std::string> reqPerm;
527 MockHapToken mock("GetPermissionUsedRecordToggleStatusInner003", reqPerm, true); // set self tokenID to system app
528
529 int32_t ret = privacyManagerService_->GetPermissionUsedRecordToggleStatus(userID, status);
530 ASSERT_EQ(RET_SUCCESS, ret);
531 }
532
533 /**
534 * @tc.name: StartUsingPermissionInner001
535 * @tc.desc: StartUsingPermissionInner test.
536 * @tc.type: FUNC
537 * @tc.require:
538 */
539 HWTEST_F(PrivacyManagerServiceTest, StartUsingPermissionInner001, TestSize.Level0)
540 {
541 AccessTokenID tokenID = 123; // 123 is invalid tokenID
542 std::string permissionName = "ohos.permission.test"; // is invalid permission
543 int32_t pid = 456; // 456 is random input
544
545 PermissionUsedTypeInfoParcel parcel;
546 parcel.info.tokenId = tokenID;
547 parcel.info.pid = pid;
548 parcel.info.permissionName = permissionName;
549
550 // callingTokenID is native token hdcd with need permission, but input tokenID & perm are invalid
551 int32_t ret = privacyManagerService_->StartUsingPermission(parcel, nullptr);
552 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
553 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
554 }
555
556 /**
557 * @tc.name: StartUsingPermissionInner002
558 * @tc.desc: StartUsingPermissionInner test.
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(PrivacyManagerServiceTest, StartUsingPermissionInner002, TestSize.Level0)
563 {
564 AccessTokenID tokenID = 123; // 123 is invalid tokenID
565 std::string permissionName = "ohos.permission.test"; // is invalid permission
566
567 std::vector<std::string> reqPerm;
568 MockHapToken mock("StartUsingPermissionInner002", reqPerm, false); // set self tokenID to normal app
569
570 PermissionUsedTypeInfoParcel parcel;
571 parcel.info.tokenId = tokenID;
572 parcel.info.pid = -1;
573 parcel.info.permissionName = permissionName;
574 // callingTokenID is normal hap without need permission
575 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, privacyManagerService_->StartUsingPermission(parcel, nullptr));
576 }
577
578 /**
579 * @tc.name: StartUsingPermissionInner003
580 * @tc.desc: StartUsingPermissionInner test.
581 * @tc.type: FUNC
582 * @tc.require:
583 */
584 HWTEST_F(PrivacyManagerServiceTest, StartUsingPermissionInner003, TestSize.Level0)
585 {
586 AccessTokenID tokenID = 123; // 123 is invalid tokenID
587 std::string permissionName = "ohos.permission.test"; // is invalid permission
588
589 std::vector<std::string> reqPerm;
590 MockHapToken mock("StartUsingPermissionInner003", reqPerm, true); // set self tokenID to system app
591
592 PermissionUsedTypeInfoParcel parcel;
593 parcel.info.tokenId = tokenID;
594 parcel.info.pid = -1;
595 parcel.info.permissionName = permissionName;
596 // callingTokenID is system hap without need permission
597 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, privacyManagerService_->StartUsingPermission(parcel, nullptr));
598 }
599
600 /**
601 * @tc.name: StartUsingPermissionCallbackInner001
602 * @tc.desc: StartUsingPermissionCallbackInner test.
603 * @tc.type: FUNC
604 * @tc.require:
605 */
606 HWTEST_F(PrivacyManagerServiceTest, StartUsingPermissionCallbackInner001, TestSize.Level0)
607 {
608 AccessTokenID tokenID = 123; // 123 is invalid tokenID
609 std::string permissionName = "ohos.permission.test"; // is invalid permission
610 int32_t pid = 111;
611
612 std::vector<std::string> reqPerm;
613 MockHapToken mock("StartUsingPermissionCallbackInner001", reqPerm, true); // set self tokenID to system app
614
615 PermissionUsedTypeInfoParcel parcel;
616 parcel.info.tokenId = tokenID;
617 parcel.info.pid = pid;
618 parcel.info.permissionName = permissionName;
619 // callingTokenID has no request permission
620 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
621 privacyManagerService_->StartUsingPermissionCallback(parcel, nullptr, nullptr));
622 }
623
624 /**
625 * @tc.name: StartUsingPermissionCallbackInner002
626 * @tc.desc: StartUsingPermissionCallbackInner test.
627 * @tc.type: FUNC
628 * @tc.require:
629 */
630 HWTEST_F(PrivacyManagerServiceTest, StartUsingPermissionCallbackInner002, TestSize.Level0)
631 {
632 AccessTokenID tokenID = 123; // 123 is invalid tokenID
633 std::string permissionName = "ohos.permission.test"; // is invalid permission
634 int32_t pid = 11;
635
636 PermissionUsedTypeInfoParcel parcel;
637 parcel.info.tokenId = tokenID;
638 parcel.info.pid = pid;
639 parcel.info.permissionName = permissionName;
640
641 // callingTokenID is native token hdcd with request permission
642 int32_t ret = privacyManagerService_->StartUsingPermissionCallback(parcel, nullptr, nullptr);
643 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
644 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
645 }
646
647 /**
648 * @tc.name: StartUsingPermissionCallbackInner003
649 * @tc.desc: StartUsingPermissionCallbackInner test.
650 * @tc.type: FUNC
651 * @tc.require:
652 */
653 HWTEST_F(PrivacyManagerServiceTest, StartUsingPermissionCallbackInner003, TestSize.Level0)
654 {
655 AccessTokenID tokenID = 123; // 123 is invalid tokenID
656 std::string permissionName = "ohos.permission.test"; // is invalid permission
657 int32_t pid = 11;
658
659 std::vector<std::string> reqPerm;
660 MockHapToken mock("StartUsingPermissionCallbackInner003", reqPerm, false); // set self tokenID to normal app
661
662 PermissionUsedTypeInfoParcel parcel;
663 parcel.info.tokenId = tokenID;
664 parcel.info.pid = pid;
665 parcel.info.permissionName = permissionName;
666
667 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP,
668 privacyManagerService_->StartUsingPermissionCallback(parcel, nullptr, nullptr));
669 }
670
671 /**
672 * @tc.name: StopUsingPermissionInner001
673 * @tc.desc: StopUsingPermissionInner test.
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(PrivacyManagerServiceTest, StopUsingPermissionInner001, TestSize.Level0)
678 {
679 AccessTokenID tokenID = 123; // 123 is invalid tokenID
680 std::string permissionName = "ohos.permission.test"; // is invalid permission
681 int32_t pid = 11;
682
683 // callingTokenID is native token hdcd with need permission, but input tokenID is not a real hap
684 int32_t ret = privacyManagerService_->StopUsingPermission(tokenID, pid, permissionName);
685 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
686 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
687 }
688
689 /**
690 * @tc.name: StopUsingPermissionInner002
691 * @tc.desc: StopUsingPermissionInner test.
692 * @tc.type: FUNC
693 * @tc.require:
694 */
695 HWTEST_F(PrivacyManagerServiceTest, StopUsingPermissionInner002, TestSize.Level0)
696 {
697 AccessTokenID tokenID = 123; // 123 is invalid tokenID
698 std::string permissionName = "ohos.permission.test"; // is invalid permission
699 int32_t pid = 11;
700
701 std::vector<std::string> reqPerm;
702 MockHapToken mock("StopUsingPermissionInner002", reqPerm, false); // set self tokenID to normal app
703
704 // callingTokenID is normal hap without need permission
705 int32_t ret = privacyManagerService_->StopUsingPermission(tokenID, pid, permissionName);
706 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
707 }
708
709 /**
710 * @tc.name: StopUsingPermissionInner003
711 * @tc.desc: StopUsingPermissionInner test.
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(PrivacyManagerServiceTest, StopUsingPermissionInner003, TestSize.Level0)
716 {
717 AccessTokenID tokenID = 123; // 123 is invalid tokenID
718 std::string permissionName = "ohos.permission.test"; // is invalid permission
719 int32_t pid = 11;
720
721 std::vector<std::string> reqPerm;
722 MockHapToken mock("StopUsingPermissionInner003", reqPerm, true); // set self tokenID to system app
723
724 // callingTokenID is system hap without need permission
725 int32_t ret = privacyManagerService_->StopUsingPermission(tokenID, pid, permissionName);
726 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
727 }
728
729 /**
730 * @tc.name: RemovePermissionUsedRecordsInner001
731 * @tc.desc: RemovePermissionUsedRecordsInner test.
732 * @tc.type: FUNC
733 * @tc.require:
734 */
735 HWTEST_F(PrivacyManagerServiceTest, RemovePermissionUsedRecordsInner001, TestSize.Level0)
736 {
737 AccessTokenID tokenID = 123; // 123 is invalid tokenID
738
739 // callingTokenID is native token hdcd with need permission, but input tokenID is not a real hap
740 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->RemovePermissionUsedRecords(tokenID));
741 }
742
743 /**
744 * @tc.name: RemovePermissionUsedRecordsInner002
745 * @tc.desc: RemovePermissionUsedRecordsInner test.
746 * @tc.type: FUNC
747 * @tc.require:
748 */
749 HWTEST_F(PrivacyManagerServiceTest, RemovePermissionUsedRecordsInner002, TestSize.Level0)
750 {
751 AccessTokenID tokenID = 123; // 123 is invalid tokenID
752
753 MockNativeToken mock("device_manager"); // set self tokenID to native device_manager
754 AccessTokenID nativeTokenID = GetSelfTokenID();
755 ASSERT_NE(nativeTokenID, static_cast<AccessTokenID>(0));
756
757 // native token device_manager don't have request permission
758 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, privacyManagerService_->RemovePermissionUsedRecords(tokenID));
759 }
760
761 /**
762 * @tc.name: RemovePermissionUsedRecordsInner003
763 * @tc.desc: RemovePermissionUsedRecordsInner test.
764 * @tc.type: FUNC
765 * @tc.require:
766 */
767 HWTEST_F(PrivacyManagerServiceTest, RemovePermissionUsedRecordsInner003, TestSize.Level0)
768 {
769 AccessTokenID tokenID = 123; // 123 is invalid tokenID
770
771 std::vector<std::string> reqPerm;
772 MockHapToken mock("RemovePermissionUsedRecordsInner003", reqPerm, false); // set self tokenID to normal app
773
774 // native token device_manager don't have request permission
775 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, privacyManagerService_->RemovePermissionUsedRecords(tokenID));
776 }
777
778 /**
779 * @tc.name: RemovePermissionUsedRecordsInner004
780 * @tc.desc: RemovePermissionUsedRecordsInner test.
781 * @tc.type: FUNC
782 * @tc.require:
783 */
784 HWTEST_F(PrivacyManagerServiceTest, RemovePermissionUsedRecordsInner004, TestSize.Level0)
785 {
786 AccessTokenID tokenID = 123; // 123 is invalid tokenID
787
788 std::vector<std::string> reqPerm = {"ohos.permission.PERMISSION_USED_STATS"};
789 MockHapToken mock("RemovePermissionUsedRecordsInner004", reqPerm, true); // set self tokenID to system app
790 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->RemovePermissionUsedRecords(tokenID));
791 }
792
793 /**
794 * @tc.name: GetPermissionUsedRecordsInner001
795 * @tc.desc: GetPermissionUsedRecordsInner test.
796 * @tc.type: FUNC
797 * @tc.require:
798 */
799 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordsInner001, TestSize.Level0)
800 {
801 PermissionUsedRequestParcel request;
802 request.request.isRemote = true;
803 PermissionUsedResultParcel resultParcel;
804
805 // callingTokenID is native token hdcd with need permission
806 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->GetPermissionUsedRecords(request, resultParcel));
807 }
808
809 /**
810 * @tc.name: GetPermissionUsedRecordsInner002
811 * @tc.desc: GetPermissionUsedRecordsInner test.
812 * @tc.type: FUNC
813 * @tc.require:
814 */
815 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordsInner002, TestSize.Level0)
816 {
817 PermissionUsedRequestParcel request;
818 request.request.isRemote = true;
819 PermissionUsedResultParcel resultParcel;
820
821 std::vector<std::string> reqPerm;
822 MockHapToken mock("GetPermissionUsedRecordsInner002", reqPerm, false); // set self tokenID to normal app
823
824 // callingTokenID is normal hap without need permission
825 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP,
826 privacyManagerService_->GetPermissionUsedRecords(request, resultParcel));
827 }
828
829 /**
830 * @tc.name: GetPermissionUsedRecordsInner003
831 * @tc.desc: GetPermissionUsedRecordsInner test.
832 * @tc.type: FUNC
833 * @tc.require:
834 */
835 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordsInner003, TestSize.Level0)
836 {
837 PermissionUsedRequestParcel request;
838 request.request.isRemote = true;
839 PermissionUsedResultParcel resultParcel;
840
841 std::vector<std::string> reqPerm;
842 MockHapToken mock("GetPermissionUsedRecordsInner003", reqPerm, true); // set self tokenID to system app
843
844 // callingTokenID is system hap without need permission
845 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
846 privacyManagerService_->GetPermissionUsedRecords(request, resultParcel));
847 }
848
849 /**
850 * @tc.name: GetPermissionUsedRecordsAsyncInner001
851 * @tc.desc: GetPermissionUsedRecordsAsyncInner test.
852 * @tc.type: FUNC
853 * @tc.require:
854 */
855 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordsAsyncInner001, TestSize.Level0)
856 {
857 PermissionUsedRequestParcel request;
858 request.request.isRemote = true;
859
860 int32_t ret = privacyManagerService_->GetPermissionUsedRecordsAsync(request, nullptr);
861 // callingTokenID is native token hdcd with need permission
862 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
863 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
864 }
865
866 /**
867 * @tc.name: GetPermissionUsedRecordsAsyncInner002
868 * @tc.desc: GetPermissionUsedRecordsAsyncInner test.
869 * @tc.type: FUNC
870 * @tc.require:
871 */
872 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordsAsyncInner002, TestSize.Level0)
873 {
874 PermissionUsedRequestParcel request;
875 request.request.isRemote = true;
876
877 std::vector<std::string> reqPerm;
878 MockHapToken mock("GetPermissionUsedRecordsAsyncInner002", reqPerm, false); // set self tokenID to normal app
879
880 int32_t ret = privacyManagerService_->GetPermissionUsedRecordsAsync(request, nullptr);
881 // callingTokenID is normal hap without need permission
882 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
883 }
884
885 /**
886 * @tc.name: GetPermissionUsedRecordsAsyncInner003
887 * @tc.desc: GetPermissionUsedRecordsAsyncInner test.
888 * @tc.type: FUNC
889 * @tc.require:
890 */
891 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedRecordsAsyncInner003, TestSize.Level0)
892 {
893 PermissionUsedRequestParcel request;
894 request.request.isRemote = true;
895
896 std::vector<std::string> reqPerm;
897 MockHapToken mock("GetPermissionUsedRecordsAsyncInner003", reqPerm, true); // set self tokenID to system app
898
899 int32_t ret = privacyManagerService_->GetPermissionUsedRecordsAsync(request, nullptr);
900 // callingTokenID is system hap without need permission
901 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
902 }
903
904 /**
905 * @tc.name: RegisterPermActiveStatusCallbackInner001
906 * @tc.desc: RegisterPermActiveStatusCallbackInner test.
907 * @tc.type: FUNC
908 * @tc.require:
909 */
910 HWTEST_F(PrivacyManagerServiceTest, RegisterPermActiveStatusCallbackInner001, TestSize.Level0)
911 {
912 std::vector<std::string> permList(PERM_LIST_SIZE_MAX + 1);
913
914 // permList size oversize
915 ASSERT_EQ(PrivacyError::ERR_OVERSIZE,
916 privacyManagerService_->RegisterPermActiveStatusCallback(permList, nullptr));
917 }
918
919 /**
920 * @tc.name: RegisterPermActiveStatusCallbackInner002
921 * @tc.desc: RegisterPermActiveStatusCallbackInner test.
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(PrivacyManagerServiceTest, RegisterPermActiveStatusCallbackInner002, TestSize.Level0)
926 {
927 std::vector<std::string> permList = {};
928
929 std::vector<std::string> reqPerm;
930 MockHapToken mock("RegisterPermActiveStatusCallbackInner002", reqPerm, false); // set self tokenID to normal app
931
932 // callingTokenID is normal hap without need permission
933 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP,
934 privacyManagerService_->RegisterPermActiveStatusCallback(permList, nullptr));
935 }
936
937 /**
938 * @tc.name: RegisterPermActiveStatusCallbackInner003
939 * @tc.desc: RegisterPermActiveStatusCallbackInner test.
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 HWTEST_F(PrivacyManagerServiceTest, RegisterPermActiveStatusCallbackInner003, TestSize.Level0)
944 {
945 std::vector<std::string> permList = {};
946
947 std::vector<std::string> reqPerm;
948 MockHapToken mock("RegisterPermActiveStatusCallbackInner003", reqPerm, true); // set self tokenID to system app
949
950 // callingTokenID is system hap without need permission
951 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
952 privacyManagerService_->RegisterPermActiveStatusCallback(permList, nullptr));
953 }
954
955 /**
956 * @tc.name: RegisterPermActiveStatusCallbackInner004
957 * @tc.desc: RegisterPermActiveStatusCallbackInner test.
958 * @tc.type: FUNC
959 * @tc.require:
960 */
961 HWTEST_F(PrivacyManagerServiceTest, RegisterPermActiveStatusCallbackInner004, TestSize.Level0)
962 {
963 std::vector<std::string> permList;
964
965 // systemapp with need permission
966 int32_t ret = privacyManagerService_->RegisterPermActiveStatusCallback(permList, nullptr);
967 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
968 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
969 }
970
971 /**
972 * @tc.name: UnRegisterPermActiveStatusCallbackInner001
973 * @tc.desc: UnRegisterPermActiveStatusCallbackInner test.
974 * @tc.type: FUNC
975 * @tc.require:
976 */
977 HWTEST_F(PrivacyManagerServiceTest, UnRegisterPermActiveStatusCallbackInner001, TestSize.Level0)
978 {
979 // systemapp with need permission
980 int32_t ret = privacyManagerService_->UnRegisterPermActiveStatusCallback(nullptr);
981 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
982 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
983 }
984
985 /**
986 * @tc.name: UnRegisterPermActiveStatusCallbackInner002
987 * @tc.desc: UnRegisterPermActiveStatusCallbackInner test.
988 * @tc.type: FUNC
989 * @tc.require:
990 */
991 HWTEST_F(PrivacyManagerServiceTest, UnRegisterPermActiveStatusCallbackInner002, TestSize.Level0)
992 {
993 std::vector<std::string> reqPerm;
994 MockHapToken mock("UnRegisterPermActiveStatusCallbackInner002", reqPerm, false); // set self tokenID to normal app
995
996 // callingTokenID is normal hap without need permission
997 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP,
998 privacyManagerService_->UnRegisterPermActiveStatusCallback(nullptr));
999 }
1000
1001 /**
1002 * @tc.name: UnRegisterPermActiveStatusCallbackInner003
1003 * @tc.desc: UnRegisterPermActiveStatusCallbackInner test.
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(PrivacyManagerServiceTest, UnRegisterPermActiveStatusCallbackInner003, TestSize.Level0)
1008 {
1009 std::vector<std::string> reqPerm;
1010 MockHapToken mock("UnRegisterPermActiveStatusCallbackInner003", reqPerm, true); // set self tokenID to system app
1011
1012 // callingTokenID is system hap without need permission
1013 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
1014 privacyManagerService_->UnRegisterPermActiveStatusCallback(nullptr));
1015 }
1016
1017 /**
1018 * @tc.name: IsAllowedUsingPermissionInner001
1019 * @tc.desc: IsAllowedUsingPermissionInner test.
1020 * @tc.type: FUNC
1021 * @tc.require:
1022 */
1023 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermissionInner001, TestSize.Level0)
1024 {
1025 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1026 std::string permissionName = "ohos.permission.test"; // is invalid permission
1027 int32_t pid = 11;
1028 bool isAllowed = true;
1029
1030 // callingTokenID is native token hdcd with need permission, but tokenID is invalid
1031 int32_t result = privacyManagerService_->IsAllowedUsingPermission(tokenID, permissionName, pid, isAllowed);
1032 ASSERT_EQ(result, RET_SUCCESS);
1033 ASSERT_EQ(false, isAllowed);
1034 }
1035
1036 /**
1037 * @tc.name: IsAllowedUsingPermissionInner002
1038 * @tc.desc: IsAllowedUsingPermissionInner test.
1039 * @tc.type: FUNC
1040 * @tc.require:
1041 */
1042 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermissionInner002, TestSize.Level0)
1043 {
1044 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1045 std::string permissionName = "ohos.permission.test"; // is invalid permission
1046 int32_t pid = 11;
1047 bool isAllowed = false;
1048
1049 std::vector<std::string> reqPerm;
1050 MockHapToken mock("IsAllowedUsingPermissionInner002", reqPerm, false); // set self tokenID to normal app
1051
1052 // callingTokenID is normal hap without need permission
1053 int32_t result = privacyManagerService_->IsAllowedUsingPermission(tokenID, permissionName, pid, isAllowed);
1054 ASSERT_EQ(result, PrivacyError::ERR_NOT_SYSTEM_APP);
1055 }
1056
1057 /**
1058 * @tc.name: IsAllowedUsingPermissionInner003
1059 * @tc.desc: IsAllowedUsingPermissionInner test.
1060 * @tc.type: FUNC
1061 * @tc.require:
1062 */
1063 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermissionInner003, TestSize.Level0)
1064 {
1065 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1066 std::string permissionName = "ohos.permission.test"; // is invalid permission
1067 int32_t pid = 11;
1068 bool isAllowed = false;
1069
1070 std::vector<std::string> reqPerm;
1071 MockHapToken mock("IsAllowedUsingPermissionInner003", reqPerm, true); // set self tokenID to system app
1072
1073 // callingTokenID is normal hap without need permission
1074 int32_t result = privacyManagerService_->IsAllowedUsingPermission(tokenID, permissionName, pid, isAllowed);
1075 ASSERT_EQ(result, PrivacyError::ERR_PERMISSION_DENIED);
1076 }
1077
1078 /**
1079 * @tc.name: GetPermissionUsedTypeInfosInner001
1080 * @tc.desc: GetPermissionUsedTypeInfosInner test.
1081 * @tc.type: FUNC
1082 * @tc.require:
1083 */
1084 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedTypeInfosInner001, TestSize.Level0)
1085 {
1086 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1087 std::string permissionName = "ohos.permission.test"; // is invalid permission
1088 std::vector<PermissionUsedTypeInfoParcel> resultsParcel;
1089
1090 // systemapp with need permission
1091 int32_t ret = privacyManagerService_->GetPermissionUsedTypeInfos(tokenID, permissionName, resultsParcel);
1092 EXPECT_NE(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
1093 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
1094 }
1095
1096 /**
1097 * @tc.name: GetPermissionUsedTypeInfosInner002
1098 * @tc.desc: GetPermissionUsedTypeInfosInner test.
1099 * @tc.type: FUNC
1100 * @tc.require:
1101 */
1102 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedTypeInfosInner002, TestSize.Level0)
1103 {
1104 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1105 std::string permissionName = "ohos.permission.test"; // is invalid permission
1106 std::vector<PermissionUsedTypeInfoParcel> resultsParcel;
1107
1108 std::vector<std::string> reqPerm;
1109 MockHapToken mock("GetPermissionUsedTypeInfosInner002", reqPerm, false); // set self tokenID to normal app
1110
1111 int32_t ret = privacyManagerService_->GetPermissionUsedTypeInfos(tokenID, permissionName, resultsParcel);
1112 EXPECT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, ret);
1113 }
1114
1115 /**
1116 * @tc.name: GetPermissionUsedTypeInfosInner003
1117 * @tc.desc: GetPermissionUsedTypeInfosInner test.
1118 * @tc.type: FUNC
1119 * @tc.require:
1120 */
1121 HWTEST_F(PrivacyManagerServiceTest, GetPermissionUsedTypeInfosInner003, TestSize.Level0)
1122 {
1123 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1124 std::string permissionName = "ohos.permission.test"; // is invalid permission
1125 std::vector<PermissionUsedTypeInfoParcel> resultsParcel;
1126
1127 std::vector<std::string> reqPerm;
1128 MockHapToken mock("GetPermissionUsedTypeInfosInner003", reqPerm, true); // set self tokenID to system app
1129
1130 int32_t ret = privacyManagerService_->GetPermissionUsedTypeInfos(tokenID, permissionName, resultsParcel);
1131 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
1132 }
1133
1134 /**
1135 * @tc.name: SetMutePolicyInner001
1136 * @tc.desc: SetMutePolicyInner test.
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(PrivacyManagerServiceTest, SetMutePolicyInner001, TestSize.Level0)
1141 {
1142 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1143 uint32_t policyType = 0;
1144 uint32_t callerType = 0;
1145 bool isMute = false;
1146
1147 std::vector<std::string> reqPerm;
1148 MockHapToken mock("SetMutePolicyInner001", reqPerm, true); // set self tokenID to system app
1149
1150 int32_t ret = privacyManagerService_->SetMutePolicy(policyType, callerType, isMute, tokenID);
1151 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
1152 }
1153
1154 /**
1155 * @tc.name: SetMutePolicyInner002
1156 * @tc.desc: SetMutePolicyInner test.
1157 * @tc.type: FUNC
1158 * @tc.require:
1159 */
1160 HWTEST_F(PrivacyManagerServiceTest, SetMutePolicyInner002, TestSize.Level0)
1161 {
1162 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1163 uint32_t policyType = 0;
1164 uint32_t callerType = 0;
1165 bool isMute = false;
1166
1167 MockNativeToken mock("audio_server");
1168
1169 int32_t ret = privacyManagerService_->SetMutePolicy(policyType, callerType, isMute, tokenID);
1170 EXPECT_NE(PrivacyError::ERR_PERMISSION_DENIED, ret);
1171 }
1172
1173 /**
1174 * @tc.name: SetMutePolicyInner003
1175 * @tc.desc: SetMutePolicyInner test.
1176 * @tc.type: FUNC
1177 * @tc.require:
1178 */
1179 HWTEST_F(PrivacyManagerServiceTest, SetMutePolicyInner003, TestSize.Level0)
1180 {
1181 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1182 uint32_t policyType = 0;
1183 uint32_t callerType = 0;
1184 bool isMute = false;
1185
1186 MockNativeToken mock("accesstoken_service");
1187
1188 int32_t ret = privacyManagerService_->SetMutePolicy(policyType, callerType, isMute, tokenID);
1189 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
1190 }
1191
1192 /**
1193 * @tc.name: SetMutePolicyInner004
1194 * @tc.desc: SetMutePolicyInner test.
1195 * @tc.type: FUNC
1196 * @tc.require:
1197 */
1198 HWTEST_F(PrivacyManagerServiceTest, SetMutePolicyInner004, TestSize.Level0)
1199 {
1200 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1201 uint32_t policyType = 0;
1202 uint32_t callerType = 0;
1203 bool isMute = false;
1204
1205 MockNativeToken mock("hdcd");
1206
1207 int32_t ret = privacyManagerService_->SetMutePolicy(policyType, callerType, isMute, tokenID);
1208 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
1209 }
1210
1211 /**
1212 * @tc.name: SetHapWithFGReminderInner001
1213 * @tc.desc: SetHapWithFGReminderInner test.
1214 * @tc.type: FUNC
1215 * @tc.require:
1216 */
1217 HWTEST_F(PrivacyManagerServiceTest, SetHapWithFGReminderInner001, TestSize.Level0)
1218 {
1219 AccessTokenID tokenID = 123; // 123 is invalid tokenID
1220 bool isAllowed = true;
1221
1222 std::vector<std::string> reqPerm;
1223 MockHapToken mock("SetHapWithFGReminderInner001", reqPerm, true); // set self tokenID to system app
1224
1225 // systemapp with need permission
1226 int32_t ret = privacyManagerService_->SetHapWithFGReminder(tokenID, isAllowed);
1227 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, ret);
1228 }
1229
1230 /**
1231 * @tc.name: GetProxyDeathHandle001
1232 * @tc.desc: GetProxyDeathHandle test.
1233 * @tc.type: FUNC
1234 * @tc.require:
1235 */
1236 HWTEST_F(PrivacyManagerServiceTest, GetProxyDeathHandle001, TestSize.Level0)
1237 {
1238 auto handler1 = privacyManagerService_->GetProxyDeathHandler();
1239 ASSERT_NE(nullptr, handler1);
1240 auto handler2 = privacyManagerService_->GetProxyDeathHandler();
1241 ASSERT_NE(nullptr, handler2);
1242
1243 privacyManagerService_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "123");
1244 privacyManagerService_->OnAddSystemAbility(SCREENLOCK_SERVICE_ID, "123");
1245 privacyManagerService_->OnAddSystemAbility(INVALID_CODE, "123");
1246 }
1247 } // namespace AccessToken
1248 } // namespace Security
1249 } // namespace OHOS
1250