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