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 "privacy_kit_test.h"
17
18 #include <chrono>
19
20 #include "access_token.h"
21 #include "accesstoken_kit.h"
22 #ifdef AUDIO_FRAMEWORK_ENABLE
23 #include "audio_system_manager.h"
24 #endif
25 #include "app_manager_access_client.h"
26 #include "nativetoken_kit.h"
27 #include "on_permission_used_record_callback_stub.h"
28 #include "parameter.h"
29 #define private public
30 #include "perm_active_status_change_callback.h"
31 #include "privacy_manager_client.h"
32 #include "state_change_callback.h"
33 #undef private
34 #include "permission_map.h"
35 #include "perm_active_response_parcel.h"
36 #include "perm_active_status_change_callback_stub.h"
37 #include "perm_setproc.h"
38 #include "privacy_error.h"
39 #include "privacy_kit.h"
40 #include "privacy_test_common.h"
41 #include "state_change_callback_stub.h"
42 #include "string_ex.h"
43 #include "token_setproc.h"
44
45 using namespace testing::ext;
46 using namespace OHOS::Security::AccessToken;
47
48 const static int32_t RET_NO_ERROR = 0;
49 static AccessTokenID g_nativeToken = 0;
50 static AccessTokenID g_shellToken = 0;
51 static MockHapToken* g_mock = nullptr;
52 #ifdef AUDIO_FRAMEWORK_ENABLE
53 static bool g_isMicMute = false;
54 #endif
55 static constexpr uint32_t RANDOM_TOKENID = 123;
56 static constexpr uint32_t RANDOM_PID = 123;
57 static constexpr int32_t INVALID_PERMISSIONAME_LENGTH = 257;
58 static constexpr int32_t FIRST_INDEX = 0;
59 static constexpr int32_t SECOND_INDEX = 1;
60 static constexpr int32_t THIRD_INDEX = 2;
61 static constexpr int32_t RESULT_NUM_ONE = 1;
62 static constexpr int32_t RESULT_NUM_TWO = 2;
63 static constexpr int32_t RESULT_NUM_THREE = 3;
64 const static int32_t NOT_EXSIT_PID = 99999999;
65 const static int32_t INVALID_USER_ID = -1;
66 const static int32_t USER_ID_2 = 2;
67
68 static PermissionStateFull g_infoManagerTestStateA = {
69 .permissionName = "ohos.permission.CAMERA",
70 .isGeneral = true,
71 .resDeviceID = {"local"},
72 .grantStatus = {PermissionState::PERMISSION_GRANTED},
73 .grantFlags = {1}
74 };
75 static HapPolicyParams g_policyPramsA = {
76 .apl = APL_NORMAL,
77 .domain = "test.domain.A",
78 };
79 static HapInfoParams g_infoParmsA = {
80 .userID = 1,
81 .bundleName = "ohos.privacy_test.bundleA",
82 .instIndex = 0,
83 .appIDDesc = "privacy_test.bundleA"
84 };
85
86 static PermissionStateFull g_infoManagerTestStateB = {
87 .permissionName = "ohos.permission.MICROPHONE",
88 .isGeneral = true,
89 .resDeviceID = {"local"},
90 .grantStatus = {PermissionState::PERMISSION_GRANTED},
91 .grantFlags = {1}
92 };
93 static HapPolicyParams g_policyPramsB = {
94 .apl = APL_NORMAL,
95 .domain = "test.domain.B",
96 };
97 static HapInfoParams g_infoParmsB = {
98 .userID = 1,
99 .bundleName = "ohos.privacy_test.bundleB",
100 .instIndex = 0,
101 .appIDDesc = "privacy_test.bundleB"
102 };
103
104 static PermissionStateFull g_infoManagerTestStateC = {
105 .permissionName = "ohos.permission.PERMISSION_USED_STATS",
106 .isGeneral = true,
107 .resDeviceID = {"localC"},
108 .grantStatus = {PermissionState::PERMISSION_GRANTED},
109 .grantFlags = {1}
110 };
111 static HapInfoParams g_infoParmsC = {
112 .userID = 1,
113 .bundleName = "ohos.privacy_test.bundleC",
114 .instIndex = 0,
115 .appIDDesc = "privacy_test.bundleC",
116 .isSystemApp = true,
117 };
118 static HapPolicyParams g_policyPramsC = {
119 .apl = APL_NORMAL,
120 .domain = "test.domain.C",
121 .permList = {},
122 .permStateList = {g_infoManagerTestStateC}
123 };
124
125 static HapInfoParams g_infoParmsD = {
126 .userID = 1,
127 .bundleName = "ohos.privacy_test.bundleD",
128 .instIndex = 0,
129 .appIDDesc = "privacy_test.bundleD",
130 .isSystemApp = true,
131 };
132 static HapPolicyParams g_policyPramsD = {
133 .apl = APL_NORMAL,
134 .domain = "test.domain.C",
135 .permList = {},
136 .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB}
137 };
138
139 static HapPolicyParams g_policyPramsE = {
140 .apl = APL_NORMAL,
141 .domain = "test.domain",
142 .permList = {},
143 .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB}
144 };
145 static HapInfoParams g_infoParmsE = {
146 .userID = 1,
147 .bundleName = "ohos.privacy_test.bundleE",
148 .instIndex = 0,
149 .appIDDesc = "privacy_test.bundleE"
150 };
151
152 static HapPolicyParams g_policyPramsF = {
153 .apl = APL_NORMAL,
154 .domain = "test.domain",
155 .permList = {},
156 .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB}
157 };
158 static HapInfoParams g_infoParmsF = {
159 .userID = 1,
160 .bundleName = "ohos.privacy_test.bundleF",
161 .instIndex = 0,
162 .appIDDesc = "privacy_test.bundleF"
163 };
164
165 static HapPolicyParams g_policyPramsG = {
166 .apl = APL_NORMAL,
167 .domain = "test.domain.G",
168 };
169 static HapInfoParams g_infoParmsG = {
170 .userID = 2,
171 .bundleName = "ohos.privacy_test.bundleG",
172 .instIndex = 0,
173 .appIDDesc = "privacy_test.bundleG"
174 };
175
176 static UsedRecordDetail g_usedRecordDetail = {
177 .status = 2,
178 .timestamp = 2L,
179 .accessDuration = 2L,
180 };
181 static PermissionUsedRecord g_permissionUsedRecord = {
182 .permissionName = "ohos.permission.CAMERA",
183 .accessCount = 2,
184 .rejectCount = 2,
185 .lastAccessTime = 0L,
186 .lastRejectTime = 0L,
187 .lastAccessDuration = 0L,
188 };
189 static BundleUsedRecord g_bundleUsedRecord = {
190 .tokenId = 100,
191 .isRemote = false,
192 .deviceId = "you guess",
193 .bundleName = "com.ohos.test",
194 };
195
196 PermissionStateFull g_infoManagerTestStateD = {
197 .permissionName = "ohos.permission.MICROPHONE_BACKGROUND",
198 .isGeneral = true,
199 .resDeviceID = {"localC"},
200 .grantStatus = {PermissionState::PERMISSION_GRANTED},
201 .grantFlags = {1}
202 };
203
204 static AccessTokenID g_selfTokenId = 0;
205 static AccessTokenID g_tokenIdA = 0;
206 static AccessTokenID g_tokenIdB = 0;
207 static AccessTokenID g_tokenIdC = 0;
208 static AccessTokenID g_tokenIdE = 0;
209 static AccessTokenID g_tokenIdF = 0;
210 static AccessTokenID g_tokenIdG = 0;
211
DeleteTestToken()212 static void DeleteTestToken()
213 {
214 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
215 g_infoParmsA.userID, g_infoParmsA.bundleName, g_infoParmsA.instIndex);
216 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
217 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
218
219 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
220 g_infoParmsB.userID, g_infoParmsB.bundleName, g_infoParmsB.instIndex);
221 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
222 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
223
224 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
225 g_infoParmsC.userID, g_infoParmsC.bundleName, g_infoParmsC.instIndex);
226 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
227 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
228
229 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
230 g_infoParmsE.userID, g_infoParmsE.bundleName, g_infoParmsE.instIndex);
231 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
232 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
233
234 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
235 g_infoParmsF.userID, g_infoParmsF.bundleName, g_infoParmsF.instIndex);
236 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
237 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
238
239 tokenIdEx = PrivacyTestCommon::GetHapTokenIdFromBundle(
240 g_infoParmsG.userID, g_infoParmsG.bundleName, g_infoParmsG.instIndex);
241 PrivacyTestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
242 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID);
243 }
244
SetUpTestCase()245 void PrivacyKitTest::SetUpTestCase()
246 {
247 g_selfTokenId = GetSelfTokenID();
248 PrivacyTestCommon::SetTestEvironment(g_selfTokenId);
249
250 std::vector<std::string> reqPerm;
251 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
252 g_mock = new (std::nothrow) MockHapToken("PrivacyKitTest", reqPerm, true);
253
254 g_nativeToken = PrivacyTestCommon::GetNativeTokenIdFromProcess("privacy_service");
255 g_shellToken = PrivacyTestCommon::GetNativeTokenIdFromProcess("hdcd");
256
257 DeleteTestToken();
258 #ifdef AUDIO_FRAMEWORK_ENABLE
259 auto audioGroupManager = OHOS::AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(
260 OHOS::AudioStandard::DEFAULT_VOLUME_GROUP_ID);
261 if (audioGroupManager != nullptr) {
262 g_isMicMute = audioGroupManager->GetPersistentMicMuteState();
263 }
264 #endif
265 }
266
TearDownTestCase()267 void PrivacyKitTest::TearDownTestCase()
268 {
269 if (g_mock != nullptr) {
270 delete g_mock;
271 g_mock = nullptr;
272 }
273 SetSelfTokenID(g_selfTokenId);
274 PrivacyTestCommon::ResetTestEvironment();
275 }
276
SetUp()277 void PrivacyKitTest::SetUp()
278 {
279 #ifdef AUDIO_FRAMEWORK_ENABLE
280 auto audioGroupManager = OHOS::AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(
281 OHOS::AudioStandard::DEFAULT_VOLUME_GROUP_ID);
282 if (audioGroupManager != nullptr) {
283 audioGroupManager->SetMicrophoneMutePersistent(false, OHOS::AudioStandard::PolicyType::PRIVACY_POLCIY_TYPE);
284 }
285 #endif
286 AccessTokenIDEx tokenIdEx = {0};
287 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_infoParmsA, g_policyPramsA);
288 g_tokenIdA = tokenIdEx.tokenIdExStruct.tokenID;
289 ASSERT_NE(INVALID_TOKENID, g_tokenIdA);
290
291 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_infoParmsB, g_policyPramsB);
292 g_tokenIdB = tokenIdEx.tokenIdExStruct.tokenID;
293 ASSERT_NE(INVALID_TOKENID, g_tokenIdB);
294
295 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_infoParmsC, g_policyPramsC);
296 g_tokenIdC = tokenIdEx.tokenIdExStruct.tokenID;
297 ASSERT_NE(INVALID_TOKENID, g_tokenIdC);
298
299 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_infoParmsE, g_policyPramsE);
300 g_tokenIdE = tokenIdEx.tokenIdExStruct.tokenID;
301 ASSERT_NE(INVALID_TOKENID, g_tokenIdE);
302
303 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_infoParmsF, g_policyPramsF);
304 g_tokenIdF = tokenIdEx.tokenIdExStruct.tokenID;
305 ASSERT_NE(INVALID_TOKENID, g_tokenIdF);
306
307 tokenIdEx = PrivacyTestCommon::AllocTestHapToken(g_infoParmsG, g_policyPramsG);
308 g_tokenIdG = tokenIdEx.tokenIdExStruct.tokenID;
309 ASSERT_NE(INVALID_TOKENID, g_tokenIdG);
310 }
311
TearDown()312 void PrivacyKitTest::TearDown()
313 {
314 #ifdef AUDIO_FRAMEWORK_ENABLE
315 auto audioGroupManager = OHOS::AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(
316 OHOS::AudioStandard::DEFAULT_VOLUME_GROUP_ID);
317 if (audioGroupManager != nullptr) {
318 audioGroupManager->SetMicrophoneMutePersistent(g_isMicMute,
319 OHOS::AudioStandard::PolicyType::PRIVACY_POLCIY_TYPE);
320 }
321 #endif
322 DeleteTestToken();
323 }
324
BuildQueryRequest(AccessTokenID tokenId,const std::string & bundleName,const std::vector<std::string> & permissionList,PermissionUsedRequest & request)325 void PrivacyKitTest::BuildQueryRequest(AccessTokenID tokenId,
326 const std::string &bundleName, const std::vector<std::string> &permissionList, PermissionUsedRequest &request)
327 {
328 request.tokenId = tokenId;
329 request.isRemote = false;
330 request.deviceId = "";
331 request.bundleName = bundleName;
332 request.permissionList = permissionList;
333 request.beginTimeMillis = 0;
334 request.endTimeMillis = 0;
335 request.flag = FLAG_PERMISSION_USAGE_SUMMARY;
336 }
337
CheckPermissionUsedResult(const PermissionUsedRequest & request,const PermissionUsedResult & result,int32_t permRecordSize,int32_t totalSuccessCount,int32_t totalFailCount)338 void PrivacyKitTest::CheckPermissionUsedResult(const PermissionUsedRequest& request, const PermissionUsedResult& result,
339 int32_t permRecordSize, int32_t totalSuccessCount, int32_t totalFailCount)
340 {
341 int32_t successCount = 0;
342 int32_t failCount = 0;
343 ASSERT_EQ(request.tokenId, result.bundleRecords[0].tokenId);
344 ASSERT_EQ(request.isRemote, result.bundleRecords[0].isRemote);
345 ASSERT_EQ(request.deviceId, result.bundleRecords[0].deviceId);
346 ASSERT_EQ(request.bundleName, result.bundleRecords[0].bundleName);
347 ASSERT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
348 for (int32_t i = 0; i < permRecordSize; i++) {
349 successCount += result.bundleRecords[0].permissionRecords[i].accessCount;
350 failCount += result.bundleRecords[0].permissionRecords[i].rejectCount;
351 }
352 ASSERT_EQ(totalSuccessCount, successCount);
353 ASSERT_EQ(totalFailCount, failCount);
354 }
355
SleepUtilMinuteEnd()356 static void SleepUtilMinuteEnd()
357 {
358 std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(
359 std::chrono::system_clock::now().time_since_epoch()
360 );
361
362 int64_t timestampMs = ms.count();
363 time_t timestampS = static_cast<time_t>(timestampMs / 1000);
364 struct tm t = {0};
365 // localtime is not thread safe, localtime_r first param unit is second, timestamp unit is ms, so divided by 1000
366 localtime_r(×tampS, &t);
367 uint32_t sleepSeconds = static_cast<uint32_t>(60 - t.tm_sec);
368
369 GTEST_LOG_(INFO) << "current time is " << timestampMs << ", " << t.tm_hour << ":" << t.tm_min << ":" << t.tm_sec;
370 GTEST_LOG_(INFO) << "need to sleep " << sleepSeconds << " seconds";
371 sleep(sleepSeconds);
372 }
373
374 /**
375 * @tc.name: AddPermissionUsedRecord001
376 * @tc.desc: cannot AddPermissionUsedRecord with illegal tokenId and permission.
377 * @tc.type: FUNC
378 * @tc.require: issueI5P4IU
379 */
380 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord001, TestSize.Level0)
381 {
382 AddPermParamInfo info;
383 info.tokenId = 0;
384 info.permissionName = "ohos.permission.READ_CONTACTS";
385 info.successCount = 1;
386 info.failCount = 0;
387 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
388
389 info.tokenId = g_tokenIdA;
390 info.permissionName = "";
391 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
392
393 info.permissionName = "ohos.permission.READ_CONTACTS";
394 info.successCount = -1;
395 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
396
397 PermissionUsedRequest request;
398 PermissionUsedResult result;
399 std::vector<std::string> permissionList;
400 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
401 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
402 ASSERT_TRUE(result.bundleRecords.empty());
403 }
404
405 /**
406 * @tc.name: AddPermissionUsedRecord002
407 * @tc.desc: cannot AddPermissionUsedRecord with invalid tokenId and permission.
408 * @tc.type: FUNC
409 * @tc.require: issueI5P4IU
410 */
411 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord002, TestSize.Level0)
412 {
413 AddPermParamInfo info;
414 info.tokenId = g_tokenIdA;
415 info.permissionName = "ohos.permission.test";
416 info.successCount = 1;
417 info.failCount = 0;
418 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PrivacyKit::AddPermissionUsedRecord(info));
419
420 info.tokenId = 672137215; // 672137215 is max native tokenId: 001 01 0 000000 11111111111111111111
421 info.permissionName = "ohos.permission.CAMERA";
422 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
423
424 info.tokenId = g_tokenIdA;
425 info.permissionName = "ohos.permission.READ_CONTACTS";
426 info.successCount = 0;
427 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
428
429 PermissionUsedRequest request;
430 PermissionUsedResult result;
431 std::vector<std::string> permissionList;
432 BuildQueryRequest(g_nativeToken, "", permissionList, request);
433 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
434 ASSERT_TRUE(result.bundleRecords.empty());
435
436 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
437 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
438 ASSERT_TRUE(result.bundleRecords.empty());
439 }
440
441 /**
442 * @tc.name: AddPermissionUsedRecord003
443 * @tc.desc: cannot AddPermissionUsedRecord with native tokenId.
444 * @tc.type: FUNC
445 * @tc.require: issueI5P4IU
446 */
447 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord003, TestSize.Level0)
448 {
449 AddPermParamInfo info;
450 info.tokenId = g_nativeToken;
451 info.permissionName = "ohos.permission.READ_CONTACTS";
452 info.successCount = 1;
453 info.failCount = 0;
454 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
455
456 PermissionUsedRequest request;
457 PermissionUsedResult result;
458 std::vector<std::string> permissionList;
459 BuildQueryRequest(g_nativeToken, "", permissionList, request);
460
461 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
462 ASSERT_TRUE(result.bundleRecords.empty());
463 }
464
465 /**
466 * @tc.name: AddPermissionUsedRecord004
467 * @tc.desc: AddPermissionUsedRecord user_grant permission.
468 * @tc.type: FUNC
469 * @tc.require: issueI5P4IU
470 */
471 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord004, TestSize.Level0)
472 {
473 AddPermParamInfo info;
474 info.tokenId = g_tokenIdA;
475 info.permissionName = "ohos.permission.READ_CONTACTS";
476 info.successCount = 1;
477 info.failCount = 0;
478 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
479
480 info.permissionName = "ohos.permission.WRITE_CONTACTS";
481 info.successCount = 0;
482 info.failCount = 1;
483 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
484
485 info.permissionName = "ohos.permission.LOCATION";
486 info.successCount = 1;
487 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
488
489 PermissionUsedRequest request;
490 PermissionUsedResult result;
491 std::vector<std::string> permissionList;
492 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
493 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
494
495 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
496 CheckPermissionUsedResult(request, result, 3, 2, 2);
497 }
498
499 /**
500 * @tc.name: AddPermissionUsedRecord005
501 * @tc.desc: AddPermissionUsedRecord user_grant permission.
502 * @tc.type: FUNC
503 * @tc.require: issueI5P4IU
504 */
505 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord005, TestSize.Level0)
506 {
507 AddPermParamInfo info;
508 info.tokenId = g_tokenIdA;
509 info.permissionName = "ohos.permission.READ_CONTACTS";
510 info.successCount = 1;
511 info.failCount = 0;
512 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
513
514 info.permissionName = "ohos.permission.LOCATION";
515 info.successCount = 0;
516 info.failCount = 1;
517 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
518
519 info.tokenId = g_tokenIdB;
520 info.permissionName = "ohos.permission.READ_CONTACTS";
521 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
522
523 info.permissionName = "ohos.permission.LOCATION";
524 info.successCount = 1;
525 info.failCount = 0;
526 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
527
528 PermissionUsedRequest request;
529 PermissionUsedResult result;
530 std::vector<std::string> permissionList;
531 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
532 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
533
534 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
535 CheckPermissionUsedResult(request, result, 2, 1, 1);
536
537 BuildQueryRequest(g_tokenIdB, g_infoParmsB.bundleName, permissionList, request);
538 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
539
540 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
541 CheckPermissionUsedResult(request, result, 2, 1, 1);
542
543 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
544 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
545
546 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_UNLOCKED;
547 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
548
549 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_FOREGROUND;
550 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
551
552 request.flag = FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_BACKGROUND;
553 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
554 }
555
556 /**
557 * @tc.name: AddPermissionUsedRecord006
558 * @tc.desc: AddPermissionUsedRecord permission combine and not combine records.
559 * @tc.type: FUNC
560 * @tc.require: issueI5P4IU
561 */
562 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord006, TestSize.Level0)
563 {
564 AddPermParamInfo info;
565 info.tokenId = g_tokenIdA;
566 info.permissionName = "ohos.permission.READ_CONTACTS";
567 info.successCount = 1;
568 info.failCount = 0;
569 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // record1
570 SleepUtilMinuteEnd();
571 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // record2 not combine with record1
572
573 PermissionUsedRequest request;
574 PermissionUsedResult result1;
575 std::vector<std::string> permissionList;
576 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
577 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
578 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result1));
579 ASSERT_EQ(static_cast<uint32_t>(1), result1.bundleRecords.size());
580 ASSERT_EQ(static_cast<uint32_t>(1), result1.bundleRecords[0].permissionRecords.size());
581 // record cross minute not combine
582 ASSERT_EQ(static_cast<uint32_t>(2), result1.bundleRecords[0].permissionRecords[0].accessRecords.size());
583 CheckPermissionUsedResult(request, result1, 1, 2, 0);
584
585 // <200ms, record is dropped
586 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // record3 drop
587 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // record4 drop
588 usleep(200000); // 200000us = 200ms
589 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // record5 combine with record2
590 usleep(200000); // 200000us = 200ms
591 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // record6 combine with record2
592
593 PermissionUsedResult result2;
594 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result2));
595 ASSERT_EQ(static_cast<uint32_t>(1), result2.bundleRecords.size());
596 ASSERT_EQ(static_cast<uint32_t>(1), result2.bundleRecords[0].permissionRecords.size());
597 // records in the same minute combine to one
598 ASSERT_EQ(static_cast<uint32_t>(2), result2.bundleRecords[0].permissionRecords[0].accessRecords.size());
599 CheckPermissionUsedResult(request, result2, 1, 4, 0);
600 }
601
602 /**
603 * @tc.name: AddPermissionUsedRecord007
604 * @tc.desc: AddPermissionUsedRecord caller is normal app.
605 * @tc.type: FUNC
606 * @tc.require: issueI66BH3
607 */
608 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord007, TestSize.Level0)
609 {
610 std::vector<std::string> reqPerm;
611 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
612 MockHapToken mock("AddPermissionUsedRecord007", reqPerm, false);
613
614 AddPermParamInfo info;
615 info.tokenId = g_tokenIdA;
616 info.permissionName = "ohos.permission.READ_CONTACTS";
617 info.successCount = 1;
618 info.failCount = 0;
619 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::AddPermissionUsedRecord(info));
620 ASSERT_EQ(0, PrivacyKit::AddPermissionUsedRecord(info, true));
621 }
622
623 /**
624 * @tc.name: AddPermissionUsedRecord008
625 * @tc.desc: query permission record detail count.
626 * @tc.type: FUNC
627 * @tc.require: issueI5P4IU
628 */
629 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord008, TestSize.Level0)
630 {
631 int32_t permRecordSize = 0;
632
633 AddPermParamInfo info;
634 info.tokenId = g_tokenIdA;
635 info.permissionName = "ohos.permission.READ_CONTACTS";
636 info.successCount = 1;
637 info.failCount = 0;
638 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
639 permRecordSize++;
640
641 info.permissionName = "ohos.permission.WRITE_CONTACTS";
642 info.successCount = 0;
643 info.failCount = 2;
644 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
645 permRecordSize++;
646
647 info.permissionName = "ohos.permission.LOCATION";
648 info.successCount = 3;
649 info.failCount = 3;
650 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
651 permRecordSize++;
652
653 PermissionUsedRequest request;
654 PermissionUsedResult result;
655 std::vector<std::string> permissionList;
656 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
657 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
658 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
659
660 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
661 ASSERT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
662 for (int32_t i = 0; i < permRecordSize; i++) {
663 if (result.bundleRecords[0].permissionRecords[i].permissionName == "ohos.permission.READ_CONTACTS") {
664 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].accessRecords.size());
665 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords[0].permissionRecords[i].rejectRecords.size());
666 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[i].accessRecords[0].count);
667 } else if (result.bundleRecords[0].permissionRecords[i].permissionName == "ohos.permission.WRITE_CONTACTS") {
668 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords[0].permissionRecords[i].accessRecords.size());
669 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].rejectRecords.size());
670 ASSERT_EQ(2, result.bundleRecords[0].permissionRecords[i].rejectRecords[0].count);
671 } else if (result.bundleRecords[0].permissionRecords[i].permissionName == "ohos.permission.LOCATION") {
672 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].accessRecords.size());
673 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[i].rejectRecords.size());
674 ASSERT_EQ(3, result.bundleRecords[0].permissionRecords[i].accessRecords[0].count);
675 ASSERT_EQ(3, result.bundleRecords[0].permissionRecords[i].rejectRecords[0].count);
676 }
677 }
678 }
679
680 /**
681 * @tc.name: RemovePermissionUsedRecords001
682 * @tc.desc: cannot RemovePermissionUsedRecords with illegal tokenId.
683 * @tc.type: FUNC
684 * @tc.require: issueI5P4IU
685 */
686 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords001, TestSize.Level0)
687 {
688 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(0));
689 }
690
691 /**
692 * @tc.name: RemovePermissionUsedRecords002
693 * @tc.desc: RemovePermissionUsedRecords with invalid tokenId.
694 * @tc.type: FUNC
695 * @tc.require: issueI5P4IU
696 */
697 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords002, TestSize.Level0)
698 {
699 AddPermParamInfo info;
700 info.tokenId = g_tokenIdA;
701 info.permissionName = "ohos.permission.READ_CONTACTS";
702 info.successCount = 1;
703 info.failCount = 0;
704 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
705 PermissionUsedRequest request;
706 PermissionUsedResult result;
707 std::vector<std::string> permissionList;
708 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
709
710 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(g_tokenIdA));
711 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
712 ASSERT_TRUE(result.bundleRecords.empty());
713 }
714
715 /**
716 * @tc.name: RemovePermissionUsedRecords003
717 * @tc.desc: RemovePermissionUsedRecords caller is normal app.
718 * @tc.type: FUNC
719 * @tc.require:
720 */
721 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords003, TestSize.Level0)
722 {
723 std::vector<std::string> reqPerm;
724 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
725 MockHapToken mock("RemovePermissionUsedRecords003", reqPerm, false);
726 AccessTokenID tokenID = GetSelfTokenID();
727 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::RemovePermissionUsedRecords(tokenID));
728 }
729
730 /**
731 * @tc.name: RemovePermissionUsedRecords004
732 * @tc.desc: cannot RemovePermissionUsedRecords function test.
733 * @tc.type: FUNC
734 * @tc.require:
735 */
736 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords004, TestSize.Level0)
737 {
738 EXPECT_EQ(RET_SUCCESS, PrivacyKit::RemovePermissionUsedRecords(g_nativeToken));
739 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(g_shellToken));
740 }
741
742 /**
743 * @tc.name: GetPermissionUsedRecords001
744 * @tc.desc: cannot GetPermissionUsedRecords with invalid query time and flag.
745 * @tc.type: FUNC
746 * @tc.require: issueI5P4IU
747 */
748 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords001, TestSize.Level0)
749 {
750 AddPermParamInfo info;
751 info.tokenId = g_tokenIdA;
752 info.permissionName = "ohos.permission.READ_CONTACTS";
753 info.successCount = 1;
754 info.failCount = 0;
755 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
756 PermissionUsedRequest request;
757 PermissionUsedResult result;
758 std::vector<std::string> permissionList;
759 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
760 request.beginTimeMillis = -1;
761 request.endTimeMillis = -1;
762 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
763
764 request.beginTimeMillis = 3;
765 request.endTimeMillis = 1;
766 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
767
768 request.flag = (PermissionUsageFlag)-1;
769 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
770 }
771
772 /**
773 * @tc.name: GetPermissionUsedRecords002
774 * @tc.desc: cannot GetPermissionUsedRecords with valid query time.
775 * @tc.type: FUNC
776 * @tc.require: issueI5P4IU
777 */
778 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords002, TestSize.Level0)
779 {
780 AddPermParamInfo info;
781 info.tokenId = g_tokenIdA;
782 info.permissionName = "ohos.permission.READ_MEDIA";
783 info.successCount = 1;
784 info.failCount = 0;
785 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
786
787 info.permissionName = "ohos.permission.READ_CONTACTS";
788 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
789
790 info.permissionName = "ohos.permission.READ_CALENDAR";
791 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
792
793 PermissionUsedRequest request;
794 PermissionUsedResult result;
795 std::vector<std::string> permissionList;
796 // query by tokenId
797 BuildQueryRequest(g_tokenIdA, "", permissionList, request);
798 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
799 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
800 request.deviceId = "";
801 request.bundleName = g_infoParmsA.bundleName;
802 CheckPermissionUsedResult(request, result, 3, 3, 0);
803
804 // query by unmatched tokenId, deviceId and bundle Name
805 BuildQueryRequest(123, g_infoParmsA.bundleName, permissionList, request);
806 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
807 ASSERT_TRUE(result.bundleRecords.empty());
808
809 // query by invalid permission Name, results is empty
810 permissionList.clear();
811 permissionList.emplace_back("invalid permission");
812 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
813 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
814 ASSERT_TRUE(result.bundleRecords.empty());
815 }
816
817 /**
818 * @tc.name: GetPermissionUsedRecords003
819 * @tc.desc: can GetPermissionUsedRecords with valid query time.
820 * @tc.type: FUNC
821 * @tc.require: issueI5P4IU
822 */
823 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords003, TestSize.Level0)
824 {
825 AddPermParamInfo info;
826 info.tokenId = g_tokenIdA;
827 info.permissionName = "ohos.permission.READ_MEDIA";
828 info.successCount = 1;
829 info.failCount = 0;
830 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
831 usleep(200000); // 200000us = 200ms
832 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
833 usleep(200000); // 200000us = 200ms
834 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
835 usleep(200000); // 200000us = 200ms
836 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
837
838 PermissionUsedRequest request;
839 PermissionUsedResult result;
840 std::vector<std::string> permissionList;
841 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
842 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
843 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
844 CheckPermissionUsedResult(request, result, 1, 4, 0);
845
846 usleep(200000); // 200000us = 200ms
847 info.permissionName = "ohos.permission.READ_CONTACTS";
848 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
849
850 usleep(200000); // 200000us = 200ms
851 info.permissionName = "ohos.permission.READ_CALENDAR";
852 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
853
854 usleep(200000); // 200000us = 200ms
855 info.permissionName = "ohos.permission.WRITE_CALENDAR";
856 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
857
858 BuildQueryRequest(g_tokenIdA, g_infoParmsA.bundleName, permissionList, request);
859 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
860 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
861 CheckPermissionUsedResult(request, result, 4, 7, 0);
862 }
863
864 /**
865 * @tc.name: GetPermissionUsedRecords004
866 * @tc.desc: can GetPermissionUsedRecords with valid query time.
867 * @tc.type: FUNC
868 * @tc.require: issueI5P4IU
869 */
870 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords004, TestSize.Level0)
871 {
872 AddPermParamInfo info;
873 info.tokenId = g_tokenIdA;
874 info.permissionName = "ohos.permission.READ_CONTACTS";
875 info.successCount = 1;
876 info.failCount = 0;
877 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
878
879 info.permissionName = "ohos.permission.READ_CALENDAR";
880 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
881
882 info.tokenId = g_tokenIdB;
883 info.permissionName = "ohos.permission.READ_CONTACTS";
884 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
885
886 info.permissionName = "ohos.permission.READ_CALENDAR";
887 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
888
889 PermissionUsedRequest request;
890 PermissionUsedResult result;
891 std::vector<std::string> permissionList;
892 BuildQueryRequest(0, "", permissionList, request);
893
894 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
895 if (result.bundleRecords.size() < static_cast<uint32_t>(2)) {
896 ASSERT_TRUE(false);
897 }
898 }
899
900 /**
901 * @tc.name: GetPermissionUsedRecords005
902 * @tc.desc: GetPermissionUsedRecords005 caller is normal app.
903 * @tc.type: FUNC
904 * @tc.require: issueI66BH3
905 */
906 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords005, TestSize.Level0)
907 {
908 std::vector<std::string> reqPerm;
909 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
910 MockHapToken mock("GetPermissionUsedRecords005", reqPerm, false);
911 AccessTokenID tokenID = GetSelfTokenID();
912
913 PermissionUsedRequest request;
914 PermissionUsedResult result;
915 std::vector<std::string> permissionList;
916 // query by tokenId
917 BuildQueryRequest(tokenID, "", permissionList, request);
918 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::GetPermissionUsedRecords(request, result));
919 }
920
921 /**
922 * @tc.name: GetPermissionUsedRecords006
923 * @tc.desc: GetPermissionUsedRecords with 200ms.
924 * @tc.type: FUNC
925 * @tc.require: issueI66BH3
926 */
927 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords006, TestSize.Level0)
928 {
929 AddPermParamInfo info;
930 info.tokenId = g_tokenIdA;
931 info.permissionName = "ohos.permission.READ_MEDIA";
932 info.successCount = 0;
933 info.failCount = 1;
934 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // fail:1, success:0
935
936 PermissionUsedRequest request;
937 PermissionUsedResult result1;
938 std::vector<std::string> permissionList;
939 // query by tokenId
940 BuildQueryRequest(g_tokenIdA, "", permissionList, request);
941 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result1));
942 ASSERT_EQ(static_cast<uint32_t>(1), result1.bundleRecords.size());
943 request.deviceId = "";
944 request.bundleName = g_infoParmsA.bundleName;
945 CheckPermissionUsedResult(request, result1, 1, 0, 1);
946
947 usleep(200000); // 200000us = 200ms
948 info.permissionName = "ohos.permission.READ_CONTACTS";
949 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // fail:1, success:0
950 info.successCount = 1;
951 info.failCount = 0;
952 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info)); // fail:0, success:1
953 PermissionUsedResult result2;
954 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result2));
955 ASSERT_EQ(static_cast<uint32_t>(1), result2.bundleRecords.size());
956 CheckPermissionUsedResult(request, result2, 2, 1, 2);
957 }
958
959 /**
960 * @tc.name: GetPermissionUsedRecordsAsync001
961 * @tc.desc: cannot GetPermissionUsedRecordsAsync with invalid query time.
962 * @tc.type: FUNC
963 * @tc.require: issueI5P4IU
964 */
965 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync001, TestSize.Level0)
966 {
967 AddPermParamInfo info;
968 info.tokenId = g_tokenIdA;
969 info.permissionName = "ohos.permission.READ_CONTACTS";
970 info.successCount = 1;
971 info.failCount = 0;
972 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
973 PermissionUsedRequest request;
974 std::vector<std::string> permissionList;
975 BuildQueryRequest(g_tokenIdA, "", permissionList, request);
976 request.beginTimeMillis = -1;
977 request.endTimeMillis = -1;
978 OHOS::sptr<TestCallBack> callback(new TestCallBack());
979 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, callback));
980 }
981
982 /**
983 * @tc.name: GetPermissionUsedRecordsAsync002
984 * @tc.desc: cannot GetPermissionUsedRecordsAsync with valid query time.
985 * @tc.type: FUNC
986 * @tc.require: issueI5P4IU
987 */
988 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync002, TestSize.Level0)
989 {
990 AddPermParamInfo info;
991 info.tokenId = g_tokenIdA;
992 info.permissionName = "ohos.permission.READ_CONTACTS";
993 info.successCount = 1;
994 info.failCount = 0;
995 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
996 PermissionUsedRequest request;
997 std::vector<std::string> permissionList;
998 BuildQueryRequest(g_tokenIdA, "", permissionList, request);
999 OHOS::sptr<TestCallBack> callback(new TestCallBack());
1000 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, callback));
1001 }
1002
1003 /**
1004 * @tc.name: GetPermissionUsedRecordsAsync003
1005 * @tc.desc: cannot GetPermissionUsedRecordsAsync without permission.
1006 * @tc.type: FUNC
1007 * @tc.require: issueI5P4IU
1008 */
1009 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync003, TestSize.Level0)
1010 {
1011 std::vector<std::string> reqPerm;
1012 MockHapToken mock("GetPermissionUsedRecordsAsync003", reqPerm, true);
1013 AccessTokenID tokenID = GetSelfTokenID();
1014
1015 PermissionUsedRequest request;
1016 std::vector<std::string> permissionList;
1017 BuildQueryRequest(tokenID, "", permissionList, request);
1018 OHOS::sptr<TestCallBack> callback(new TestCallBack());
1019 ASSERT_EQ(ERR_PERMISSION_DENIED, PrivacyKit::GetPermissionUsedRecords(request, callback));
1020 }
1021
1022 /**
1023 * @tc.name: GetPermissionUsedRecordsAsync004
1024 * @tc.desc: cannot GetPermissionUsedRecordsAsync caller is normal app.
1025 * @tc.type: FUNC
1026 * @tc.require: issueI5P4IU
1027 */
1028 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync004, TestSize.Level0)
1029 {
1030 std::vector<std::string> reqPerm;
1031 MockHapToken mock("GetPermissionUsedRecordsAsync004", reqPerm, false);
1032 AccessTokenID tokenID = GetSelfTokenID();
1033
1034 PermissionUsedRequest request;
1035 std::vector<std::string> permissionList;
1036 BuildQueryRequest(tokenID, "", permissionList, request);
1037 OHOS::sptr<TestCallBack> callback(new TestCallBack());
1038 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::GetPermissionUsedRecords(request, callback));
1039 }
1040
1041 class CbCustomizeTest1 : public PermActiveStatusCustomizedCbk {
1042 public:
CbCustomizeTest1(const std::vector<std::string> & permList)1043 explicit CbCustomizeTest1(const std::vector<std::string> &permList)
1044 : PermActiveStatusCustomizedCbk(permList)
1045 {
1046 GTEST_LOG_(INFO) << "CbCustomizeTest1 create";
1047 }
1048
~CbCustomizeTest1()1049 ~CbCustomizeTest1()
1050 {}
1051
ActiveStatusChangeCallback(ActiveChangeResponse & result)1052 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
1053 {
1054 type_ = result.type;
1055 GTEST_LOG_(INFO) << "CbCustomizeTest1 ActiveChangeResponse";
1056 GTEST_LOG_(INFO) << "CbCustomizeTest1 tokenid " << result.tokenID;
1057 GTEST_LOG_(INFO) << "CbCustomizeTest1 permissionName " << result.permissionName;
1058 GTEST_LOG_(INFO) << "CbCustomizeTest1 deviceId " << result.deviceId;
1059 GTEST_LOG_(INFO) << "CbCustomizeTest1 type " << result.type;
1060 }
1061
1062 ActiveChangeType type_ = PERM_INACTIVE;
1063 };
1064
1065 class CbCustomizeTest2 : public PermActiveStatusCustomizedCbk {
1066 public:
CbCustomizeTest2(const std::vector<std::string> & permList)1067 explicit CbCustomizeTest2(const std::vector<std::string> &permList)
1068 : PermActiveStatusCustomizedCbk(permList)
1069 {
1070 GTEST_LOG_(INFO) << "CbCustomizeTest2 create";
1071 }
1072
~CbCustomizeTest2()1073 ~CbCustomizeTest2()
1074 {}
1075
ActiveStatusChangeCallback(ActiveChangeResponse & result)1076 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
1077 {
1078 type_ = result.type;
1079 GTEST_LOG_(INFO) << "CbCustomizeTest2 ActiveChangeResponse";
1080 GTEST_LOG_(INFO) << "CbCustomizeTest2 tokenid " << result.tokenID;
1081 GTEST_LOG_(INFO) << "CbCustomizeTest2 permissionName " << result.permissionName;
1082 GTEST_LOG_(INFO) << "CbCustomizeTest2 deviceId " << result.deviceId;
1083 GTEST_LOG_(INFO) << "CbCustomizeTest2 type " << result.type;
1084 }
1085
1086 ActiveChangeType type_;
1087 };
1088
1089 /**
1090 * @tc.name: RegisterPermActiveStatusCallback001
1091 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
1092 * @tc.type: FUNC
1093 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1094 */
1095 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback001, TestSize.Level0)
1096 {
1097 std::vector<std::string> permList = {"ohos.permission.READ_MEDIA"};
1098
1099 auto callbackPtr = std::make_shared<CbCustomizeTest1>(permList);
1100 callbackPtr->type_ = PERM_TEMPORARY_CALL;
1101
1102 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1103 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.READ_MEDIA"));
1104
1105 usleep(1000000); // 1000000us = 1s
1106 EXPECT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
1107
1108 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.READ_MEDIA"));
1109
1110 usleep(1000000); // 1000000us = 1s
1111 EXPECT_EQ(PERM_INACTIVE, callbackPtr->type_);
1112
1113 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1114 callbackPtr->type_ = PERM_TEMPORARY_CALL;
1115
1116 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.READ_MEDIA"));
1117 EXPECT_NE(PERM_INACTIVE, callbackPtr->type_);
1118 EXPECT_NE(PERM_ACTIVE_IN_FOREGROUND, callbackPtr->type_);
1119 EXPECT_NE(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
1120
1121 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.READ_MEDIA"));
1122 ASSERT_NE(PERM_INACTIVE, callbackPtr->type_);
1123 ASSERT_NE(PERM_ACTIVE_IN_FOREGROUND, callbackPtr->type_);
1124 ASSERT_NE(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
1125 }
1126
1127 class CbCustomizeTest3 : public PermActiveStatusCustomizedCbk {
1128 public:
CbCustomizeTest3(const std::vector<std::string> & permList)1129 explicit CbCustomizeTest3(const std::vector<std::string> &permList)
1130 : PermActiveStatusCustomizedCbk(permList)
1131 {}
~CbCustomizeTest3()1132 ~CbCustomizeTest3()
1133 {}
ActiveStatusChangeCallback(ActiveChangeResponse & result)1134 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
1135 {
1136 type_ = result.type;
1137 }
1138 ActiveChangeType type_ = PERM_INACTIVE;
1139 };
1140
1141 class CbCustomizeTest4 : public StateCustomizedCbk {
1142 public:
CbCustomizeTest4()1143 CbCustomizeTest4()
1144 {}
1145
~CbCustomizeTest4()1146 ~CbCustomizeTest4()
1147 {}
1148
StateChangeNotify(AccessTokenID tokenId,bool isShow)1149 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
1150 {}
1151 };
1152
1153 /**
1154 * @tc.name: RegisterPermActiveStatusCallback002
1155 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
1156 * @tc.type: FUNC
1157 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1158 */
1159 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback002, TestSize.Level0)
1160 {
1161 std::vector<std::string> permList1 = {"ohos.permission.READ_CONTACTS"};
1162 auto callbackPtr1 = std::make_shared<CbCustomizeTest1>(permList1);
1163 callbackPtr1->type_ = PERM_TEMPORARY_CALL;
1164
1165 std::vector<std::string> permList2 = {"ohos.permission.READ_MEDIA"};
1166 auto callbackPtr2 = std::make_shared<CbCustomizeTest2>(permList2);
1167 callbackPtr2->type_ = PERM_TEMPORARY_CALL;
1168
1169 std::vector<std::string> permList3 = {};
1170 auto callbackPtr3 = std::make_shared<CbCustomizeTest2>(permList3);
1171 callbackPtr3->type_ = PERM_TEMPORARY_CALL;
1172
1173 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
1174 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr2));
1175 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr3));
1176
1177 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.READ_CONTACTS"));
1178
1179 usleep(1000000); // 1000000us = 1s
1180 EXPECT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr1->type_);
1181 EXPECT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr3->type_);
1182
1183 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.READ_CONTACTS"));
1184
1185 usleep(1000000); // 1000000us = 1s
1186 EXPECT_EQ(PERM_INACTIVE, callbackPtr1->type_);
1187 EXPECT_EQ(PERM_INACTIVE, callbackPtr3->type_);
1188
1189 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.READ_MEDIA"));
1190
1191 usleep(1000000); // 1000000us = 1s
1192 EXPECT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr2->type_);
1193 EXPECT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr3->type_);
1194
1195 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.READ_MEDIA"));
1196
1197 usleep(1000000); // 1000000us = 1s
1198 EXPECT_EQ(PERM_INACTIVE, callbackPtr2->type_);
1199 EXPECT_EQ(PERM_INACTIVE, callbackPtr3->type_);
1200
1201 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1202 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr2));
1203 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr3));
1204 }
1205
1206 /**
1207 * @tc.name: RegisterPermActiveStatusCallback003
1208 * @tc.desc: Register callback with permList which contains 1025 permissions.
1209 * @tc.type: FUNC
1210 * @tc.require: issueI5NT1X
1211 */
1212 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback003, TestSize.Level0)
1213 {
1214 std::vector<std::string> permList;
1215 for (int32_t i = 0; i < 1024; i++) { // 1024 is the limitation
1216 permList.emplace_back("ohos.permission.CAMERA");
1217 }
1218 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList);
1219 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
1220 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1221
1222 permList.emplace_back("ohos.permission.MICROPHONE");
1223 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1224 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1225 }
1226
1227 /**
1228 * @tc.name: RegisterPermActiveStatusCallback004
1229 * @tc.desc: Register callback 201 times.
1230 * @tc.type: FUNC
1231 * @tc.require: issueI5NT1X
1232 */
1233 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback004, TestSize.Level0)
1234 {
1235 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1236 std::vector<std::shared_ptr<CbCustomizeTest3>> callbackList;
1237
1238 for (int32_t i = 0; i <= 200; i++) { // 200 is the max size
1239 if (i == 200) { // 200 is the max size
1240 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1241 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
1242 PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1243 break;
1244 }
1245 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1246 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1247 callbackList.emplace_back(callbackPtr);
1248 }
1249 for (int32_t i = 0; i < 200; i++) { // release 200 callback
1250 auto callbackPtr = callbackList[i];
1251 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1252 }
1253 callbackList.clear();
1254 }
1255
1256 /**
1257 * @tc.name: RegisterPermActiveStatusCallback005
1258 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
1259 * @tc.type: FUNC
1260 * @tc.require: issueI5NT1X
1261 */
1262 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback005, TestSize.Level0)
1263 {
1264 std::vector<std::string> permList = {"ohos.permission.INVALD"};
1265
1266 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1267 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1268
1269 std::vector<std::string> permList1 = {"ohos.permission.INVALD", "ohos.permission.CAMERA"};
1270 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList1);
1271 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
1272 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1273 }
1274
1275 /**
1276 * @tc.name: RegisterPermActiveStatusCallback006
1277 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid callback.
1278 * @tc.type: FUNC
1279 * @tc.require: issueI5NT1X
1280 */
1281 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback006, TestSize.Level0)
1282 {
1283 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1284 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1285 ASSERT_EQ(PrivacyError::ERR_CALLBACK_NOT_EXIST, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1286 }
1287
1288 /**
1289 * @tc.name: RegisterPermActiveStatusCallback007
1290 * @tc.desc: RegisterPermActiveStatusCallback with valid permission repeatedly.
1291 * @tc.type: FUNC
1292 * @tc.require: issueI5NT1X
1293 */
1294 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback007, TestSize.Level0)
1295 {
1296 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1297 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1298 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1299 ASSERT_EQ(PrivacyError::ERR_CALLBACK_ALREADY_EXIST, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1300 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1301 ASSERT_EQ(PrivacyError::ERR_CALLBACK_NOT_EXIST, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1302 }
1303
1304 /**
1305 * @tc.name: RegisterPermActiveStatusCallback008
1306 * @tc.desc: register and startusing three permission.
1307 * @tc.type: FUNC
1308 * @tc.require: issueI5SZHG
1309 */
1310 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback008, TestSize.Level0)
1311 {
1312 std::vector<std::string> permList = {
1313 "ohos.permission.CAMERA",
1314 "ohos.permission.MICROPHONE",
1315 "ohos.permission.LOCATION"
1316 };
1317 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
1318 int32_t res = PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr);
1319 ASSERT_EQ(RET_NO_ERROR, res);
1320 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA");
1321 ASSERT_EQ(RET_NO_ERROR, res);
1322 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE");
1323 ASSERT_EQ(RET_NO_ERROR, res);
1324 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.LOCATION");
1325 ASSERT_EQ(RET_NO_ERROR, res);
1326 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA");
1327 ASSERT_EQ(RET_NO_ERROR, res);
1328 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE");
1329 ASSERT_EQ(RET_NO_ERROR, res);
1330 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.LOCATION");
1331 ASSERT_EQ(RET_NO_ERROR, res);
1332 res = PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr);
1333 ASSERT_EQ(RET_NO_ERROR, res);
1334 }
1335
1336 /**
1337 * @tc.name: RegisterPermActiveStatusCallback009
1338 * @tc.desc: PrivacyManagerClient::RegisterPermActiveStatusCallback function test
1339 * @tc.type: FUNC
1340 * @tc.require: issueI61A6M
1341 */
1342 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback009, TestSize.Level0)
1343 {
1344 std::shared_ptr<PermActiveStatusCustomizedCbk> callback = nullptr;
1345 ASSERT_EQ(nullptr, callback);
1346 PrivacyManagerClient::GetInstance().RegisterPermActiveStatusCallback(callback); // callback is null
1347 }
1348
1349 /**
1350 * @tc.name: RegisterPermActiveStatusCallback010
1351 * @tc.desc: RegisterPermActiveStatusCallback caller is normal app.
1352 * @tc.type: FUNC
1353 * @tc.require: issueI66BH3
1354 */
1355 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback010, TestSize.Level0)
1356 {
1357 std::vector<std::string> reqPerm;
1358 MockHapToken mock("RegisterPermActiveStatusCallback010", reqPerm, false);
1359
1360 std::vector<std::string> permList1 = {"ohos.permission.CAMERA"};
1361 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList1);
1362 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1363 }
1364
1365 /**
1366 * @tc.name: RegisterPermActiveStatusCallback011
1367 * @tc.desc: UnRegisterPermActiveStatusCallback caller is normal app.
1368 * @tc.type: FUNC
1369 * @tc.require: issueI66BH3
1370 */
1371 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback011, TestSize.Level0)
1372 {
1373 std::vector<std::string> permList1 = {"ohos.permission.CAMERA"};
1374 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList1);
1375 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
1376 {
1377 std::vector<std::string> reqPerm;
1378 MockHapToken mockTmp("RegisterPermActiveStatusCallback011_1", reqPerm, false);
1379 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1380 }
1381 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
1382 }
1383
1384 class CbCustomizeTest5 : public PermActiveStatusCustomizedCbk {
1385 public:
CbCustomizeTest5(const std::vector<std::string> & permList)1386 explicit CbCustomizeTest5(const std::vector<std::string> &permList)
1387 : PermActiveStatusCustomizedCbk(permList)
1388 {}
~CbCustomizeTest5()1389 ~CbCustomizeTest5()
1390 {}
1391
1392 // change callingTokenID_ and usedType_ to result
ActiveStatusChangeCallback(ActiveChangeResponse & result)1393 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
1394 {
1395 callingTokenID_ = result.callingTokenID;
1396 usedType_ = result.usedType;
1397 pid_ = result.pid;
1398 }
1399
1400 AccessTokenID callingTokenID_ = INVALID_TOKENID;
1401 PermissionUsedType usedType_ = INVALID_USED_TYPE;
1402 int32_t pid_ = NOT_EXSIT_PID;
1403 };
1404
1405 /**
1406 * @tc.name: RegisterPermActiveStatusCallback012
1407 * @tc.desc: detect callback modify private member.
1408 * @tc.type: FUNC
1409 * @tc.require: issueI66BH3
1410 */
1411 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback012, TestSize.Level0)
1412 {
1413 std::vector<std::string> permList = {"ohos.permission.READ_CALL_LOG"};
1414 auto callbackPtr = std::make_shared<CbCustomizeTest5>(permList);
1415 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
1416
1417 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.READ_CALL_LOG"));
1418
1419 usleep(1000000); // 1000000us = 1s
1420 ASSERT_NE(INVALID_TOKENID, callbackPtr->callingTokenID_);
1421 ASSERT_NE(INVALID_USED_TYPE, callbackPtr->usedType_);
1422 ASSERT_NE(NOT_EXSIT_PID, callbackPtr->pid_);
1423
1424 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.READ_CALL_LOG"));
1425 usleep(1000000); // 1000000us = 1s
1426
1427 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(
1428 g_tokenIdE, "ohos.permission.READ_CALL_LOG", NOT_EXSIT_PID));
1429 usleep(1000000); // 1000000us = 1s
1430
1431 ASSERT_EQ(NOT_EXSIT_PID, callbackPtr->pid_);
1432
1433 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(
1434 g_tokenIdE, "ohos.permission.READ_CALL_LOG", NOT_EXSIT_PID));
1435
1436 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
1437 }
1438
1439 /**
1440 * @tc.name: IsAllowedUsingPermission001
1441 * @tc.desc: IsAllowedUsingPermission with invalid tokenId or permission.
1442 * @tc.type: FUNC
1443 * @tc.require: issueI5RWX3 issueI5RWX8
1444 */
1445 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission001, TestSize.Level0)
1446 {
1447 std::string permissionName = "ohos.permission.CAMERA";
1448 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1449 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(0, permissionName));
1450 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, ""));
1451 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(0, ""));
1452 }
1453
1454 /**
1455 * @tc.name: IsAllowedUsingPermission002
1456 * @tc.desc: IsAllowedUsingPermission with no permission.
1457 * @tc.type: FUNC
1458 * @tc.require: issueI5RWX3 issueI5RWX8
1459 */
1460 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission002, TestSize.Level0)
1461 {
1462 std::vector<std::string> reqPerm;
1463 MockHapToken mock("IsAllowedUsingPermission002", reqPerm, true);
1464 std::string permissionName = "ohos.permission.CAMERA";
1465 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1466 }
1467
1468 /**
1469 * @tc.name: IsAllowedUsingPermission003
1470 * @tc.desc: IsAllowedUsingPermission with no permission.
1471 * @tc.type: FUNC
1472 * @tc.require: issueI5RWX3 issueI5RWX8
1473 */
1474 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission003, TestSize.Level0)
1475 {
1476 std::vector<std::string> reqPerm;
1477 MockHapToken mock("IsAllowedUsingPermission003", reqPerm, true);
1478
1479 std::string permissionName = "ohos.permission.CAMERA";
1480 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1481 }
1482
1483
1484 /**
1485 * @tc.name: IsAllowedUsingPermission004
1486 * @tc.desc: IsAllowedUsingPermission with valid tokenId.
1487 * @tc.type: FUNC
1488 * @tc.require:
1489 */
1490 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission004, TestSize.Level0)
1491 {
1492 std::string permissionName = "ohos.permission.MICROPHONE";
1493 std::vector<AppStateData> list;
1494 int32_t ret = AppManagerAccessClient::GetInstance().GetForegroundApplications(list);
1495 ASSERT_EQ(0, ret);
1496 if (list.empty()) {
1497 GTEST_LOG_(INFO) << "GetForegroundApplications empty ";
1498 } else {
1499 uint32_t tokenIdForeground = list[0].accessTokenId;
1500 ASSERT_EQ(true, PrivacyKit::IsAllowedUsingPermission(tokenIdForeground, permissionName));
1501 }
1502 }
1503
1504 /**
1505 * @tc.name: IsAllowedUsingPermission005
1506 * @tc.desc: IsAllowedUsingPermission with valid pid.
1507 * @tc.type: FUNC
1508 * @tc.require:
1509 */
1510 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission005, TestSize.Level0)
1511 {
1512 std::vector<AppStateData> list;
1513 ASSERT_EQ(0, AppManagerAccessClient::GetInstance().GetForegroundApplications(list));
1514 if (list.empty()) {
1515 GTEST_LOG_(INFO) << "GetForegroundApplications empty ";
1516 } else {
1517 uint32_t tokenIdForeground = list[0].accessTokenId;
1518 int32_t pidForground = list[0].pid;
1519 std::string permissionName = "ohos.permission.MICROPHONE";
1520 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(tokenIdForeground, permissionName, NOT_EXSIT_PID));
1521 ASSERT_EQ(true, PrivacyKit::IsAllowedUsingPermission(tokenIdForeground, permissionName, pidForground));
1522
1523 permissionName = "ohos.permission.CAMERA";
1524 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(tokenIdForeground, permissionName, NOT_EXSIT_PID));
1525 ASSERT_EQ(true, PrivacyKit::IsAllowedUsingPermission(tokenIdForeground, permissionName, pidForground));
1526 }
1527 }
1528
1529 /**
1530 * @tc.name: IsAllowedUsingPermission006
1531 * @tc.desc: IsAllowedUsingPermission with MICROPHONE_BACKGROUND permission.
1532 * @tc.type: FUNC
1533 * @tc.require:
1534 */
1535 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission006, TestSize.Level0)
1536 {
1537 std::string permissionName = "ohos.permission.MICROPHONE";
1538 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1539
1540 HapInfoParams info = {
1541 .userID = 1,
1542 .bundleName = "ohos.privacy_test.microphone",
1543 .instIndex = 0,
1544 .appIDDesc = "privacy_test.microphone"
1545 };
1546
1547 HapPolicyParams policy = {
1548 .apl = APL_NORMAL,
1549 .domain = "test.domain",
1550 .permList = {},
1551 .permStateList = {g_infoManagerTestStateD}
1552 };
1553
1554 AccessTokenIDEx tokenIdEx = PrivacyTestCommon::AllocTestHapToken(info, policy);
1555 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
1556 ASSERT_NE(0, tokenId); // hap MICROPHONE_BACKGROUND permission
1557 ASSERT_EQ(true, PrivacyKit::IsAllowedUsingPermission(tokenId, permissionName)); // background hap
1558
1559 {
1560 MockNativeToken mock("audio_server");
1561
1562 // callkit set hap to foreground with MICROPHONE_BACKGROUND
1563 EXPECT_EQ(0, PrivacyKit::SetHapWithFGReminder(tokenId, true));
1564 EXPECT_EQ(true, PrivacyKit::IsAllowedUsingPermission(tokenId, permissionName));
1565
1566 // callkit set g_tokenIdE to foreground without MICROPHONE_BACKGROUND
1567 EXPECT_EQ(0, PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true));
1568 EXPECT_EQ(true, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
1569
1570 EXPECT_EQ(0, PrivacyKit::SetHapWithFGReminder(tokenId, false));
1571 EXPECT_EQ(0, PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false));
1572 }
1573
1574 ASSERT_EQ(0, PrivacyTestCommon::DeleteTestHapToken(tokenId));
1575 }
1576
1577 /**
1578 * @tc.name: StartUsingPermission001
1579 * @tc.desc: StartUsingPermission with invalid tokenId or permission or usedType.
1580 * @tc.type: FUNC
1581 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1582 */
1583 HWTEST_F(PrivacyKitTest, StartUsingPermission001, TestSize.Level0)
1584 {
1585 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA"));
1586 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "permissionName"));
1587 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(
1588 g_tokenIdE, "ohos.permission.READ_CALL_LOG", -1, PermissionUsedType::INVALID_USED_TYPE));
1589 }
1590
1591 /**
1592 * @tc.name: StartUsingPermission002
1593 * @tc.desc: StartUsingPermission is called twice with same permission.
1594 * @tc.type: FUNC
1595 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1596 */
1597 HWTEST_F(PrivacyKitTest, StartUsingPermission002, TestSize.Level0)
1598 {
1599 std::string permissionName = "ohos.permission.CAMERA";
1600 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1601 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
1602 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1603 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1604 }
1605
1606 /**
1607 * @tc.name: StopUsingPermission003
1608 * @tc.desc: Add record when StopUsingPermission is called.
1609 * @tc.type: FUNC
1610 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1611 */
1612 HWTEST_F(PrivacyKitTest, StartUsingPermission003, TestSize.Level0)
1613 {
1614 std::string permissionName = "ohos.permission.READ_CONTACTS";
1615 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1616 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdE, permissionName, 1, 0));
1617
1618 usleep(1000000); // 1000000us = 1s
1619 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1620
1621 PermissionUsedRequest request;
1622 PermissionUsedResult result;
1623 std::vector<std::string> permissionList;
1624 BuildQueryRequest(g_tokenIdE, g_infoParmsE.bundleName, permissionList, request);
1625 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
1626 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
1627 ASSERT_EQ(g_tokenIdE, result.bundleRecords[0].tokenId);
1628 ASSERT_EQ(g_infoParmsE.bundleName, result.bundleRecords[0].bundleName);
1629 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
1630 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[0].accessCount);
1631 }
1632
1633 /**
1634 * @tc.name: StartUsingPermission004
1635 * @tc.desc: StartUsingPermission basic functional verification
1636 * @tc.type: FUNC
1637 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1638 */
1639 HWTEST_F(PrivacyKitTest, StartUsingPermission004, TestSize.Level0)
1640 {
1641 std::string permissionName = "ohos.permission.CAMERA";
1642 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1643 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1644 }
1645
1646 /**
1647 * @tc.name: StartUsingPermission005
1648 * @tc.desc: StartUsingPermission with invalid tokenId or permission.
1649 * @tc.type: FUNC
1650 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1651 */
1652 HWTEST_F(PrivacyKitTest, StartUsingPermission005, TestSize.Level0)
1653 {
1654 std::string permissionName = "ohos.permission.UtTestInvalidPermission";
1655 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1656 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA"));
1657 ASSERT_EQ(
1658 PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(g_nativeToken, "ohos.permission.CAMERA"));
1659 }
1660
1661 /**
1662 * @tc.name: StartUsingPermission006
1663 * @tc.desc: StartUsingPermission with invalid tokenId or permission or callback or usedType.
1664 * @tc.type: FUNC
1665 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1666 */
1667 HWTEST_F(PrivacyKitTest, StartUsingPermission006, TestSize.Level0)
1668 {
1669 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1670 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1671 PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA", callbackPtr));
1672 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1673 PrivacyKit::StartUsingPermission(g_tokenIdE, "", callbackPtr));
1674 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1675 PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", nullptr));
1676 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(
1677 g_tokenIdE, "ohos.permission.READ_CALL_LOG", callbackPtr, -1, PermissionUsedType::INVALID_USED_TYPE));
1678 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1679 PrivacyKit::StartUsingPermission(g_tokenIdE, "permissionName", callbackPtr));
1680 }
1681
1682 /**
1683 * @tc.name: StartUsingPermission007
1684 * @tc.desc: StartUsingPermission is called twice with same callback.
1685 * @tc.type: FUNC
1686 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1687 */
1688 HWTEST_F(PrivacyKitTest, StartUsingPermission007, TestSize.Level0)
1689 {
1690 std::string permissionName = "ohos.permission.CAMERA";
1691 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1692 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1693 ASSERT_EQ(PrivacyError::ERR_CALLBACK_ALREADY_EXIST,
1694 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1695 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1696 }
1697
1698 /**
1699 * @tc.name: StartUsingPermission008
1700 * @tc.desc: PrivacyKit:: function test input invalid
1701 * @tc.type: FUNC
1702 * @tc.require: issueI61A6M
1703 */
1704 HWTEST_F(PrivacyKitTest, StartUsingPermission008, TestSize.Level0)
1705 {
1706 AccessTokenID tokenId = 0;
1707 std::string permissionName;
1708 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(tokenId, permissionName));
1709 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(tokenId, permissionName));
1710 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(tokenId));
1711 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(tokenId, permissionName));
1712 }
1713
1714 /**
1715 * @tc.name: StartUsingPermission009
1716 * @tc.desc: StartUsingPermission basic functional verification
1717 * @tc.type: FUNC
1718 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1719 */
1720 HWTEST_F(PrivacyKitTest, StartUsingPermission009, TestSize.Level0)
1721 {
1722 std::string permissionName = "ohos.permission.CAMERA";
1723 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1724 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1725 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdF, permissionName, callbackPtr));
1726 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1727 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdF, permissionName));
1728 }
1729
1730 /**
1731 * @tc.name: StartUsingPermission010
1732 * @tc.desc: StartUsingPermission caller is normal app.
1733 * @tc.type: FUNC
1734 * @tc.require: issueI66BH3
1735 */
1736 HWTEST_F(PrivacyKitTest, StartUsingPermission010, TestSize.Level0)
1737 {
1738 std::vector<std::string> reqPerm;
1739 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
1740 MockHapToken mock("StartUsingPermission010", reqPerm, false);
1741
1742 std::string permissionName = "ohos.permission.CAMERA";
1743 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1744 }
1745
1746 /**
1747 * @tc.name: StartUsingPermission011
1748 * @tc.desc: StartUsingPermission with differet tokenId and pid.
1749 * @tc.type: FUNC
1750 * @tc.require:
1751 */
1752 HWTEST_F(PrivacyKitTest, StartUsingPermission011, TestSize.Level0)
1753 {
1754 std::string permissionName = "ohos.permission.CAMERA";
1755 int32_t pid1 = 1001;
1756 int32_t pid2 = 1002;
1757 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, pid1));
1758 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(g_tokenIdF, permissionName, pid2));
1759
1760 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName, pid1));
1761 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(g_tokenIdF, permissionName, pid2));
1762 }
1763
1764 /**
1765 * @tc.name: StartUsingPermission012
1766 * @tc.desc: StartUsingPermission with same tokenId and differet pid.
1767 * @tc.type: FUNC
1768 * @tc.require:
1769 */
1770 HWTEST_F(PrivacyKitTest, StartUsingPermission012, TestSize.Level0)
1771 {
1772 std::string permissionName = "ohos.permission.CAMERA";
1773 int32_t pid1 = 1001;
1774 int32_t pid2 = 1002;
1775 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, pid1));
1776 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, pid2));
1777
1778 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName, pid1));
1779 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName, pid2));
1780 }
1781
1782 /**
1783 * @tc.name: StartUsingPermission013
1784 * @tc.desc: StartUsingPermission with same tokenId and pid.
1785 * @tc.type: FUNC
1786 * @tc.require:
1787 */
1788 HWTEST_F(PrivacyKitTest, StartUsingPermission013, TestSize.Level0)
1789 {
1790 std::string permissionName = "ohos.permission.CAMERA";
1791 int32_t pid1 = 1001;
1792 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, pid1));
1793 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
1794 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, pid1));
1795
1796 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName, pid1));
1797 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_START_USING,
1798 PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName, pid1));
1799 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_START_USING,
1800 PrivacyKit::StopUsingPermission(g_tokenIdF, permissionName, pid1));
1801 }
1802
1803 /**
1804 * @tc.name: StartUsingPermission014
1805 * @tc.desc: StartUsingPermission caller is normal app.
1806 * @tc.type: FUNC
1807 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1808 */
1809 HWTEST_F(PrivacyKitTest, StartUsingPermission014, TestSize.Level0)
1810 {
1811 std::vector<std::string> reqPerm;
1812 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
1813 MockHapToken mock("StartUsingPermission014", reqPerm, false);
1814
1815 std::string permissionName = "ohos.permission.CAMERA";
1816 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1817 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP,
1818 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1819 }
1820
1821 /**
1822 * @tc.name: StartUsingPermission015
1823 * @tc.desc: StartUsingPermission function test.
1824 * @tc.type: FUNC
1825 * @tc.require:
1826 */
1827 HWTEST_F(PrivacyKitTest, StartUsingPermission015, TestSize.Level0)
1828 {
1829 std::string permissionName = "ohos.permission.CAMERA";
1830 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1831
1832 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID,
1833 PrivacyKit::StartUsingPermission(g_nativeToken, permissionName, callbackPtr));
1834
1835 permissionName = "ohos.permission.MICROPHONE";
1836 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID,
1837 PrivacyKit::StartUsingPermission(g_nativeToken, permissionName, callbackPtr));
1838
1839 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID,
1840 PrivacyKit::StartUsingPermission(g_shellToken, permissionName, callbackPtr));
1841 }
1842
1843 /**
1844 * @tc.name: StartUsingPermission016
1845 * @tc.desc: StartUsingPermission caller is shell.
1846 * @tc.type: FUNC
1847 * @tc.require:
1848 */
1849 HWTEST_F(PrivacyKitTest, StartUsingPermission016, TestSize.Level0)
1850 {
1851 std::string permissionName = "ohos.permission.CAMERA";
1852
1853 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(g_nativeToken, permissionName));
1854
1855 permissionName = "ohos.permission.MICROPHONE";
1856 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(g_nativeToken, permissionName));
1857
1858 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(g_shellToken, permissionName));
1859 }
1860
1861 /**
1862 * @tc.name: StopUsingPermission001
1863 * @tc.desc: StopUsingPermission with invalid tokenId or permission.
1864 * @tc.type: FUNC
1865 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1866 */
1867 HWTEST_F(PrivacyKitTest, StopUsingPermission001, TestSize.Level0)
1868 {
1869 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, "ohos.permission.CAMERA"));
1870 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, "permissionName"));
1871 }
1872
1873 /**
1874 * @tc.name: StopUsingPermission002
1875 * @tc.desc: StopUsingPermission cancel permissions that you haven't started using
1876 * @tc.type: FUNC
1877 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1878 */
1879 HWTEST_F(PrivacyKitTest, StopUsingPermission002, TestSize.Level0)
1880 {
1881 std::string permissionName = "ohos.permission.CAMERA";
1882 ASSERT_EQ(
1883 PrivacyError::ERR_PERMISSION_NOT_START_USING, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1884 }
1885
1886 /**
1887 * @tc.name: StopUsingPermission003
1888 * @tc.desc: StopUsingPermission invalid tokenid, permission
1889 * @tc.type: FUNC
1890 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1891 */
1892 HWTEST_F(PrivacyKitTest, StopUsingPermission003, TestSize.Level0)
1893 {
1894 std::string permissionName = "ohos.permission.CAMERA";
1895 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1896 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
1897 PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.uttestpermission"));
1898 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, permissionName));
1899 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1900 }
1901
1902 /**
1903 * @tc.name: StopUsingPermission004
1904 * @tc.desc: StopUsingPermission stop a use repeatedly
1905 * @tc.type: FUNC
1906 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1907 */
1908 HWTEST_F(PrivacyKitTest, StopUsingPermission004, TestSize.Level0)
1909 {
1910 std::string permissionName = "ohos.permission.CAMERA";
1911 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1912 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1913 ASSERT_EQ(
1914 PrivacyError::ERR_PERMISSION_NOT_START_USING, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1915 }
1916
1917 /**
1918 * @tc.name: StopUsingPermission005
1919 * @tc.desc: stop use with native token
1920 * @tc.type: FUNC
1921 * @tc.require: issueI5SZHG
1922 */
1923 HWTEST_F(PrivacyKitTest, StopUsingPermission005, TestSize.Level0)
1924 {
1925 ASSERT_EQ(
1926 PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(g_nativeToken, "ohos.permission.CAMERA"));
1927 }
1928
1929 /**
1930 * @tc.name: StopUsingPermission006
1931 * @tc.desc: StopUsingPermission caller is normal app.
1932 * @tc.type: FUNC
1933 * @tc.require: issueI66BH3
1934 */
1935 HWTEST_F(PrivacyKitTest, StopUsingPermission006, TestSize.Level0)
1936 {
1937 std::vector<std::string> reqPerm;
1938 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
1939 MockHapToken mock("StopUsingPermission006", reqPerm, false);
1940
1941 std::string permissionName = "ohos.permission.CAMERA";
1942 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1943 }
1944
1945 /**
1946 * @tc.name: StopUsingPermission007
1947 * @tc.desc: Add record when StopUsingPermission is called.
1948 * @tc.type: FUNC
1949 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1950 */
1951 HWTEST_F(PrivacyKitTest, StopUsingPermission007, TestSize.Level0)
1952 {
1953 std::string permissionName = "ohos.permission.READ_CONTACTS";
1954 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1955 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1956 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdE, permissionName, 1, 0));
1957
1958 usleep(1000000); // 1000000us = 1s
1959 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1960
1961 PermissionUsedRequest request;
1962 PermissionUsedResult result;
1963 std::vector<std::string> permissionList;
1964 BuildQueryRequest(g_tokenIdE, g_infoParmsE.bundleName, permissionList, request);
1965 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
1966 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
1967 ASSERT_EQ(g_tokenIdE, result.bundleRecords[0].tokenId);
1968 ASSERT_EQ(g_infoParmsE.bundleName, result.bundleRecords[0].bundleName);
1969 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
1970 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[0].accessCount);
1971 }
1972
1973 /**
1974 * @tc.name: StopUsingPermission008
1975 * @tc.desc: StopUsingPermission test with shell tokenid.
1976 * @tc.type: FUNC
1977 * @tc.require:
1978 */
1979 HWTEST_F(PrivacyKitTest, StopUsingPermission008, TestSize.Level0)
1980 {
1981 std::string permissionName = "ohos.permission.CAMERA";
1982
1983 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(g_nativeToken, permissionName));
1984
1985 permissionName = "ohos.permission.MICROPHONE";
1986 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(g_nativeToken, permissionName));
1987
1988 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(g_shellToken, permissionName));
1989 }
1990
1991 /**
1992 * @tc.name: StopUsingPermission009
1993 * @tc.desc: StopUsingPermission test with different pid.
1994 * @tc.type: FUNC
1995 * @tc.require:
1996 */
1997 HWTEST_F(PrivacyKitTest, StopUsingPermission009, TestSize.Level0)
1998 {
1999 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
2000 ASSERT_EQ(0, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", callbackPtr));
2001 ASSERT_EQ(0, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
2002 ASSERT_EQ(0, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", callbackPtr, RANDOM_PID));
2003 ASSERT_EQ(0, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
2004
2005 ASSERT_EQ(0, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE"));
2006 ASSERT_EQ(0, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE"));
2007 ASSERT_EQ(0, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE", RANDOM_PID));
2008 ASSERT_EQ(0, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE", RANDOM_PID));
2009
2010 ASSERT_EQ(0, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
2011 ASSERT_EQ(0, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
2012 ASSERT_EQ(0, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", RANDOM_PID));
2013 ASSERT_EQ(0, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", RANDOM_PID));
2014 }
2015
2016 class TestCallBack1 : public StateChangeCallbackStub {
2017 public:
2018 TestCallBack1() = default;
2019 virtual ~TestCallBack1() = default;
2020
StateChangeNotify(AccessTokenID tokenId,bool isShowing)2021 void StateChangeNotify(AccessTokenID tokenId, bool isShowing)
2022 {
2023 GTEST_LOG_(INFO) << "StateChangeNotify, tokenId is " << tokenId << ", isShowing is " << isShowing;
2024 }
2025 };
2026
2027 /**
2028 * @tc.name: OnRemoteRequest001
2029 * @tc.desc: StateChangeCallbackStub::OnRemoteRequest function test
2030 * @tc.type: FUNC
2031 * @tc.require: issueI61A6M
2032 */
2033 HWTEST_F(PrivacyKitTest, OnRemoteRequest001, TestSize.Level0)
2034 {
2035 AccessTokenID tokenId = 123; // 123 is random input
2036 bool isShowing = false;
2037
2038 TestCallBack1 callback;
2039 OHOS::MessageParcel data;
2040 ASSERT_EQ(true, data.WriteInterfaceToken(IStateChangeCallback::GetDescriptor()));
2041 ASSERT_EQ(true, data.WriteUint32(tokenId));
2042 ASSERT_EQ(true, data.WriteBool(isShowing));
2043
2044 OHOS::MessageParcel reply;
2045 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
2046 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(IStateChangeCallback::STATE_CHANGE_CALLBACK),
2047 data, reply, option)); // descriptor true + msgCode true
2048
2049 ASSERT_EQ(true, data.WriteInterfaceToken(IStateChangeCallback::GetDescriptor()));
2050 ASSERT_EQ(true, data.WriteUint32(tokenId));
2051 ASSERT_EQ(true, data.WriteBool(isShowing));
2052 uint32_t code = 10;
2053 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
2054
2055 std::string descriptor = "I don't know";
2056 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
2057 ASSERT_EQ(true, data.WriteUint32(tokenId));
2058 ASSERT_EQ(true, data.WriteBool(isShowing));
2059 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(IStateChangeCallback::STATE_CHANGE_CALLBACK),
2060 data, reply, option)); // descriptor flase + msgCode true
2061 }
2062
2063 class TestCallBack2 : public OnPermissionUsedRecordCallbackStub {
2064 public:
2065 TestCallBack2() = default;
2066 virtual ~TestCallBack2() = default;
2067
OnQueried(OHOS::ErrCode code,PermissionUsedResult & result)2068 void OnQueried(OHOS::ErrCode code, PermissionUsedResult& result)
2069 {
2070 GTEST_LOG_(INFO) << "OnQueried, code is " << code;
2071 }
2072 };
2073
2074 /**
2075 * @tc.name: OnRemoteRequest002
2076 * @tc.desc: OnPermissionUsedRecordCallbackStub::OnRemoteRequest function test
2077 * @tc.type: FUNC
2078 * @tc.require: issueI61A6M
2079 */
2080 HWTEST_F(PrivacyKitTest, OnRemoteRequest002, TestSize.Level0)
2081 {
2082 g_permissionUsedRecord.accessRecords.emplace_back(g_usedRecordDetail);
2083 g_bundleUsedRecord.permissionRecords.emplace_back(g_permissionUsedRecord);
2084
2085 int32_t errCode = 123; // 123 is random input
2086 PermissionUsedResultParcel resultParcel;
2087 resultParcel.result = {
2088 .beginTimeMillis = 0L,
2089 .endTimeMillis = 0L,
2090 };
2091 resultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord);
2092
2093 TestCallBack2 callback;
2094 OHOS::MessageParcel data;
2095 std::string descriptor = "I don't know";
2096 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
2097 ASSERT_EQ(true, data.ReadInt32(errCode));
2098 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
2099
2100 OHOS::MessageParcel reply;
2101 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
2102 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(PrivacyPermissionRecordInterfaceCode::ON_QUERIED),
2103 data, reply, option)); // descriptor false
2104
2105 ASSERT_EQ(true, data.WriteInterfaceToken(OnPermissionUsedRecordCallback::GetDescriptor()));
2106 ASSERT_EQ(true, data.ReadInt32(errCode));
2107 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
2108 uint32_t code = 10;
2109 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
2110
2111 ASSERT_EQ(true, data.WriteInterfaceToken(OnPermissionUsedRecordCallback::GetDescriptor()));
2112 ASSERT_EQ(true, data.ReadInt32(errCode));
2113 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
2114 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(PrivacyPermissionRecordInterfaceCode::ON_QUERIED),
2115 data, reply, option)); // descriptor flase + msgCode true + error != 0
2116 }
2117
2118 class TestCallBack3 : public PermActiveStatusChangeCallbackStub {
2119 public:
2120 TestCallBack3() = default;
2121 virtual ~TestCallBack3() = default;
2122
ActiveStatusChangeCallback(ActiveChangeResponse & result)2123 void ActiveStatusChangeCallback(ActiveChangeResponse& result)
2124 {
2125 GTEST_LOG_(INFO) << "ActiveStatusChangeCallback, result is " << result.type;
2126 }
2127 };
2128
2129 /**
2130 * @tc.name: OnRemoteRequest003
2131 * @tc.desc: PermActiveStatusChangeCallbackStub::OnRemoteRequest function test
2132 * @tc.type: FUNC
2133 * @tc.require: issueI61A6M
2134 */
2135 HWTEST_F(PrivacyKitTest, OnRemoteRequest003, TestSize.Level0)
2136 {
2137 ActiveChangeResponse response = {
2138 .tokenID = 123,
2139 .permissionName = "ohos.permission.CAMERA",
2140 .deviceId = "I don't know",
2141 .type = ActiveChangeType::PERM_INACTIVE
2142 };
2143
2144 ActiveChangeResponseParcel responseParcel;
2145 responseParcel.changeResponse = response;
2146
2147 TestCallBack3 callback;
2148 OHOS::MessageParcel data;
2149 std::string descriptor = "I don't know";
2150 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
2151 ASSERT_EQ(true, data.WriteParcelable(&responseParcel));
2152
2153 OHOS::MessageParcel reply;
2154 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
2155 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(
2156 PrivacyActiveChangeInterfaceCode::PERM_ACTIVE_STATUS_CHANGE), data, reply, option)); // descriptor false
2157
2158 ASSERT_EQ(true, data.WriteInterfaceToken(IPermActiveStatusCallback::GetDescriptor()));
2159 ASSERT_EQ(true, data.WriteParcelable(&responseParcel));
2160 uint32_t code = 10;
2161 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
2162 }
2163
2164 /**
2165 * @tc.name: ActiveStatusChangeCallback001
2166 * @tc.desc: PermActiveStatusChangeCallback::ActiveStatusChangeCallback function test
2167 * @tc.type: FUNC
2168 * @tc.require: issueI61A6M
2169 */
2170 HWTEST_F(PrivacyKitTest, ActiveStatusChangeCallback001, TestSize.Level0)
2171 {
2172 ActiveChangeResponse response = {
2173 .tokenID = 123,
2174 .permissionName = "ohos.permission.CAMERA",
2175 .deviceId = "I don't know",
2176 .type = ActiveChangeType::PERM_INACTIVE
2177 };
2178 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
2179 std::shared_ptr<PermActiveStatusCustomizedCbk> callbackPtr = std::make_shared<CbCustomizeTest1>(permList);
2180 OHOS::sptr<PermActiveStatusChangeCallback> callback = new (
2181 std::nothrow) PermActiveStatusChangeCallback(callbackPtr);
2182 ASSERT_NE(nullptr, callback);
2183 callback->ActiveStatusChangeCallback(response); // customizedCallback_ is null
2184 }
2185
2186 /**
2187 * @tc.name: StateChangeNotify001
2188 * @tc.desc: StateChangeCallback::StateChangeNotify function test
2189 * @tc.type: FUNC
2190 * @tc.require: issueI61A6M
2191 */
2192 HWTEST_F(PrivacyKitTest, StateChangeNotify001, TestSize.Level0)
2193 {
2194 AccessTokenID tokenId = 123; // 123 is random input
2195 bool isShowing = false;
2196 std::shared_ptr<StateCustomizedCbk> callbackPtr = std::make_shared<CbCustomizeTest4>();
2197 OHOS::sptr<StateChangeCallback> callback = new (std::nothrow) StateChangeCallback(callbackPtr);
2198 ASSERT_NE(nullptr, callback);
2199 callback->StateChangeNotify(tokenId, isShowing); // customizedCallback_ is null
2200 }
2201
2202 /**
2203 * @tc.name: InitProxy001
2204 * @tc.desc: PrivacyManagerClient::InitProxy function test
2205 * @tc.type: FUNC
2206 * @tc.require: issueI61A6M
2207 */
2208 HWTEST_F(PrivacyKitTest, InitProxy001, TestSize.Level0)
2209 {
2210 ASSERT_NE(nullptr, PrivacyManagerClient::GetInstance().proxy_);
2211 OHOS::sptr<IPrivacyManager> proxy = PrivacyManagerClient::GetInstance().proxy_; // backup
2212 PrivacyManagerClient::GetInstance().proxy_ = nullptr;
2213 ASSERT_EQ(nullptr, PrivacyManagerClient::GetInstance().proxy_);
2214 PrivacyManagerClient::GetInstance().InitProxy(); // proxy_ is null
2215 PrivacyManagerClient::GetInstance().proxy_ = proxy; // recovery
2216 }
2217
2218 /**
2219 * @tc.name: AddPermissionUsedRecord011
2220 * @tc.desc: Test AddPermissionUsedRecord with default normal used type
2221 * @tc.type: FUNC
2222 * @tc.require:
2223 */
2224 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord011, TestSize.Level0)
2225 {
2226 AddPermParamInfo info;
2227 info.tokenId = g_tokenIdA;
2228 info.permissionName = "ohos.permission.READ_CONTACTS";
2229 info.successCount = 1;
2230 info.failCount = 0;
2231 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2232
2233 std::vector<PermissionUsedTypeInfo> results;
2234 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2235 results));
2236 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2237 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type); // only normal type
2238 results.clear();
2239
2240 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // repeat
2241 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2242 results));
2243 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2244 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type); // results remain
2245 }
2246
2247 /**
2248 * @tc.name: AddPermissionUsedRecord012
2249 * @tc.desc: Test AddPermissionUsedRecord with picker used type
2250 * @tc.type: FUNC
2251 * @tc.require:
2252 */
2253 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord012, TestSize.Level0)
2254 {
2255 AddPermParamInfo info;
2256 info.tokenId = g_tokenIdA;
2257 info.permissionName = "ohos.permission.READ_CONTACTS";
2258 info.successCount = 1;
2259 info.failCount = 0;
2260 info.type = PermissionUsedType::PICKER_TYPE;
2261 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2262
2263 std::vector<PermissionUsedTypeInfo> results;
2264 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2265 results));
2266 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2267 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type); // only picker type
2268 results.clear();
2269
2270 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // repeat
2271 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2272 results));
2273 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2274 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type); // results remain
2275 }
2276
2277 /**
2278 * @tc.name: AddPermissionUsedRecord013
2279 * @tc.desc: Test AddPermissionUsedRecord with security component used type
2280 * @tc.type: FUNC
2281 * @tc.require:
2282 */
2283 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord013, TestSize.Level0)
2284 {
2285 AddPermParamInfo info;
2286 info.tokenId = g_tokenIdA;
2287 info.permissionName = "ohos.permission.READ_CONTACTS";
2288 info.successCount = 1;
2289 info.failCount = 0;
2290 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2291 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2292
2293 std::vector<PermissionUsedTypeInfo> results;
2294 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2295 results));
2296 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2297 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type); // only security component type
2298 results.clear();
2299
2300 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // repeat
2301 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2302 results));
2303 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2304 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type); // results remain
2305 }
2306
2307 /**
2308 * @tc.name: AddPermissionUsedRecord014
2309 * @tc.desc: Test AddPermissionUsedRecord with default normal and picker used type
2310 * @tc.type: FUNC
2311 * @tc.require:
2312 */
2313 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord014, TestSize.Level0)
2314 {
2315 AddPermParamInfo info;
2316 info.tokenId = g_tokenIdA;
2317 info.permissionName = "ohos.permission.READ_CONTACTS";
2318 info.successCount = 1;
2319 info.failCount = 0;
2320 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2321
2322 info.type = PermissionUsedType::PICKER_TYPE;
2323 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2324
2325 std::vector<PermissionUsedTypeInfo> results;
2326 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2327 results));
2328 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_TWO), results.size());
2329 ASSERT_EQ(NORMAL_TYPE, results[FIRST_INDEX].type); // contain normal type
2330 ASSERT_EQ(PICKER_TYPE, results[SECOND_INDEX].type); // contain picker type
2331 }
2332
2333 /**
2334 * @tc.name: AddPermissionUsedRecord015
2335 * @tc.desc: Test AddPermissionUsedRecord with default normal and security component used type
2336 * @tc.type: FUNC
2337 * @tc.require:
2338 */
2339 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord015, TestSize.Level0)
2340 {
2341 AddPermParamInfo info;
2342 info.tokenId = g_tokenIdA;
2343 info.permissionName = "ohos.permission.READ_CONTACTS";
2344 info.successCount = 1;
2345 info.failCount = 0;
2346 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2347
2348 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2349 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2350
2351 std::vector<PermissionUsedTypeInfo> results;
2352 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2353 results));
2354 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_TWO), results.size());
2355 ASSERT_EQ(NORMAL_TYPE, results[FIRST_INDEX].type); // contain normal type
2356 ASSERT_EQ(SECURITY_COMPONENT_TYPE, results[SECOND_INDEX].type); // contain security component type
2357 }
2358
2359 /**
2360 * @tc.name: AddPermissionUsedRecord016
2361 * @tc.desc: Test AddPermissionUsedRecord with picker and security component used type
2362 * @tc.type: FUNC
2363 * @tc.require:
2364 */
2365 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord016, TestSize.Level0)
2366 {
2367 AddPermParamInfo info;
2368 info.tokenId = g_tokenIdA;
2369 info.permissionName = "ohos.permission.READ_CONTACTS";
2370 info.successCount = 1;
2371 info.failCount = 0;
2372 info.type = PermissionUsedType::PICKER_TYPE;
2373 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2374
2375 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2376 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2377
2378 std::vector<PermissionUsedTypeInfo> results;
2379 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2380 results));
2381 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_TWO), results.size());
2382 ASSERT_EQ(PICKER_TYPE, results[FIRST_INDEX].type); // contain picker type
2383 ASSERT_EQ(SECURITY_COMPONENT_TYPE, results[SECOND_INDEX].type); // contain security component type
2384 }
2385
2386 /**
2387 * @tc.name: AddPermissionUsedRecord017
2388 * @tc.desc: Test AddPermissionUsedRecord with all used type
2389 * @tc.type: FUNC
2390 * @tc.require:
2391 */
2392 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord017, TestSize.Level0)
2393 {
2394 AddPermParamInfo info;
2395 info.tokenId = g_tokenIdA;
2396 info.permissionName = "ohos.permission.READ_CONTACTS";
2397 info.successCount = 1;
2398 info.failCount = 0;
2399 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2400
2401 info.type = PermissionUsedType::PICKER_TYPE;
2402 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2403
2404 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2405 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2406
2407 std::vector<PermissionUsedTypeInfo> results;
2408 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2409 results));
2410 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_THREE), results.size());
2411 ASSERT_EQ(NORMAL_TYPE, results[FIRST_INDEX].type); // contain normal type
2412 ASSERT_EQ(PICKER_TYPE, results[SECOND_INDEX].type); // contain picker type
2413 ASSERT_EQ(SECURITY_COMPONENT_TYPE, results[THIRD_INDEX].type); // contain security component type
2414 }
2415
2416 /**
2417 * @tc.name: AddPermissionUsedRecord018
2418 * @tc.desc: Test AddPermissionUsedRecord with invalid used type
2419 * @tc.type: FUNC
2420 * @tc.require:
2421 */
2422 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord018, TestSize.Level0)
2423 {
2424 AddPermParamInfo info;
2425 info.tokenId = g_tokenIdA;
2426 info.permissionName = "ohos.permission.READ_CONTACTS";
2427 info.successCount = 1;
2428 info.failCount = 0;
2429 info.type = PermissionUsedType::INVALID_USED_TYPE;
2430 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info)); // add invalid used type
2431 }
2432
2433 /**
2434 * @tc.name: AddPermissionUsedRecord019
2435 * @tc.desc: Test AddPermissionUsedRecord with shell token
2436 * @tc.type: FUNC
2437 * @tc.require:
2438 */
2439 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord019, TestSize.Level0)
2440 {
2441 AddPermParamInfo info;
2442 info.tokenId = g_nativeToken;
2443 info.permissionName = "ohos.permission.CAMERA";
2444 info.successCount = 1;
2445 info.failCount = 0;
2446 info.type = NORMAL_TYPE;
2447 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
2448
2449 info.permissionName = "ohos.permission.MICROPHONE";
2450 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
2451
2452 info.tokenId = g_shellToken;
2453 EXPECT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info));
2454 }
2455
2456 /**
2457 * @tc.name: AddPermissionUsedRecord020
2458 * @tc.desc: Test AddPermissionUsedRecord failed twice in 200ms
2459 * @tc.type: FUNC
2460 * @tc.require:
2461 */
2462 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord020, TestSize.Level0)
2463 {
2464 MockNativeToken mock("accesstoken_service"); // accesstoken_service without PERMISSION_USED_STATS
2465 AddPermParamInfo info;
2466 info.tokenId = g_nativeToken;
2467 info.permissionName = "ohos.permission.CAMERA";
2468 info.successCount = 1;
2469 info.failCount = 0;
2470 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, PrivacyKit::AddPermissionUsedRecord(info));
2471 EXPECT_EQ(PrivacyError::ERR_PERMISSION_DENIED, PrivacyKit::AddPermissionUsedRecord(info));
2472 }
2473
2474 /**
2475 * @tc.name: GetPermissionUsedTypeInfos001
2476 * @tc.desc: Test GetPermissionUsedTypeInfos with default input
2477 * @tc.type: FUNC
2478 * @tc.require:
2479 */
2480 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos001, TestSize.Level0)
2481 {
2482 AddPermParamInfo info;
2483 info.tokenId = g_tokenIdA;
2484 info.permissionName = "ohos.permission.READ_CONTACTS";
2485 info.successCount = 1;
2486 info.failCount = 0;
2487 // g_tokenIdA add normal used type
2488 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2489
2490 info.tokenId = g_tokenIdB;
2491 info.type = PermissionUsedType::PICKER_TYPE;
2492 // g_tokenIdB add picker used type
2493 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2494
2495 info.tokenId = g_tokenIdC;
2496 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2497 // g_tokenIdC add security component used type
2498 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2499
2500 std::string permissionName;
2501 std::vector<PermissionUsedTypeInfo> results;
2502 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, permissionName, results));
2503 // results size may more than 3
2504 for (const PermissionUsedTypeInfo& result : results) {
2505 if (result.tokenId == g_tokenIdA) {
2506 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, result.type); // g_tokenIdA only normal type
2507 } else if (result.tokenId == g_tokenIdB) {
2508 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, result.type); // g_tokenIdB only picker type
2509 } else if (result.tokenId == g_tokenIdC) {
2510 // g_tokenIdC only security component type
2511 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, result.type);
2512 }
2513 }
2514 }
2515
2516 /**
2517 * @tc.name: GetPermissionUsedTypeInfos002
2518 * @tc.desc: Test GetPermissionUsedTypeInfos with default tokenId
2519 * @tc.type: FUNC
2520 * @tc.require:
2521 */
2522 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos002, TestSize.Level0)
2523 {
2524 AddPermParamInfo info;
2525 info.tokenId = g_tokenIdA;
2526 info.permissionName = "ohos.permission.READ_CONTACTS";
2527 info.successCount = 1;
2528 info.failCount = 0;
2529 // READ_CONTACTS add normal used type
2530 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2531
2532 info.permissionName = "ohos.permission.LOCATION";
2533 info.type = PermissionUsedType::PICKER_TYPE;
2534 // LOCATION add picker used type
2535 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2536
2537 info.permissionName = "ohos.permission.MICROPHONE";
2538 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2539 // MICROPHONE add security component used type
2540 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2541
2542 std::vector<PermissionUsedTypeInfo> results1;
2543 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, "ohos.permission.READ_CONTACTS", results1));
2544 // result1 size may more than one
2545 for (const auto& result : results1) {
2546 if (g_tokenIdA == result.tokenId) {
2547 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, result.type); // g_tokenIdA only normal type
2548 }
2549 }
2550
2551 std::vector<PermissionUsedTypeInfo> results2;
2552 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, "ohos.permission.LOCATION", results2));
2553 // result2 size may more than one
2554 for (const auto& result : results2) {
2555 if (g_tokenIdA == result.tokenId) {
2556 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, result.type); // g_tokenIdA only picker type
2557 }
2558 }
2559
2560 std::vector<PermissionUsedTypeInfo> results3;
2561 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, "ohos.permission.MICROPHONE", results3));
2562 // result3 size may more than one
2563 for (const auto& result : results3) {
2564 if (g_tokenIdA == result.tokenId) {
2565 // g_tokenIdA only security component type
2566 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, result.type);
2567 }
2568 }
2569 }
2570
2571 /**
2572 * @tc.name: GetPermissionUsedTypeInfos003
2573 * @tc.desc: Test GetPermissionUsedTypeInfos with default permissionName
2574 * @tc.type: FUNC
2575 * @tc.require:
2576 */
2577 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos003, TestSize.Level0)
2578 {
2579 AddPermParamInfo info;
2580 info.tokenId = g_tokenIdA;
2581 info.permissionName = "ohos.permission.READ_CONTACTS";
2582 info.successCount = 1;
2583 info.failCount = 0;
2584 // g_tokenIdA add normal used type
2585 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2586
2587 info.tokenId = g_tokenIdB;
2588 info.type = PermissionUsedType::PICKER_TYPE;
2589 // g_tokenIdB add picker used type
2590 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2591
2592 info.tokenId = g_tokenIdC;
2593 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2594 // g_tokenIdC add security component used type
2595 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2596
2597 std::string permissionName;
2598 std::vector<PermissionUsedTypeInfo> results1;
2599 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, permissionName, results1));
2600 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results1.size()); // only g_tokenIdA
2601 ASSERT_EQ(g_tokenIdA, results1[FIRST_INDEX].tokenId);
2602 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results1[FIRST_INDEX].type); // normal type
2603
2604 std::vector<PermissionUsedTypeInfo> results2;
2605 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdB, permissionName, results2));
2606 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results2.size()); // only g_tokenIdB
2607 ASSERT_EQ(g_tokenIdB, results2[FIRST_INDEX].tokenId);
2608 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results2[FIRST_INDEX].type); // picker type
2609
2610 std::vector<PermissionUsedTypeInfo> results3;
2611 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdC, permissionName, results3));
2612 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results3.size()); // only g_tokenIdC
2613 ASSERT_EQ(g_tokenIdC, results3[FIRST_INDEX].tokenId);
2614 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results3[FIRST_INDEX].type); // security component type
2615 }
2616
2617 /**
2618 * @tc.name: GetPermissionUsedTypeInfos004
2619 * @tc.desc: Test GetPermissionUsedTypeInfos with invalid input param
2620 * @tc.type: FUNC
2621 * @tc.require:
2622 */
2623 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos004, TestSize.Level0)
2624 {
2625 std::vector<PermissionUsedTypeInfo> results;
2626 // tokenId invalid
2627 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::GetPermissionUsedTypeInfos(RANDOM_TOKENID,
2628 "ohos.permission.READ_CONTACTS", results));
2629
2630 std::string permissionName;
2631 for (int32_t i = 0; i < INVALID_PERMISSIONAME_LENGTH; i++) { // 257
2632 permissionName.append("a");
2633 }
2634
2635 // permissionName over length
2636 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedTypeInfos(0, permissionName, results));
2637 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PrivacyKit::GetPermissionUsedTypeInfos(0,
2638 "ohos.permission.TEST", results)); // permissionName invalid
2639 }
2640
2641 /**
2642 * @tc.name: GetPermissionUsedTypeInfos005
2643 * @tc.desc: Test GetPermissionUsedTypeInfos as normal hap or system hap without PERMISSION_USED_STATE
2644 * @tc.type: FUNC
2645 * @tc.require:
2646 */
2647 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos005, TestSize.Level0)
2648 {
2649 std::vector<std::string> reqPerm;
2650 std::string permissionName;
2651 std::vector<PermissionUsedTypeInfo> results;
2652
2653 {
2654 // as a normal hap without PERMISSION_USED_STATE
2655 MockHapToken mock("GetPermissionUsedTypeInfos005", reqPerm, false);
2656 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::GetPermissionUsedTypeInfos(0, permissionName, results));
2657 }
2658
2659 {
2660 // as a system hap without PERMISSION_USED_STATE
2661 MockHapToken mock("GetPermissionUsedTypeInfos005", reqPerm, true);
2662 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, PrivacyKit::GetPermissionUsedTypeInfos(
2663 0, permissionName, results));
2664 }
2665 }
2666
2667 /**
2668 * @tc.name: SetMutePolicyTest001
2669 * @tc.desc: Test SetMutePolicy with invalid param
2670 * @tc.type: FUNC
2671 * @tc.require:
2672 */
2673 HWTEST_F(PrivacyKitTest, SetMutePolicyTest001, TestSize.Level0)
2674 {
2675 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2676 PrivacyKit::SetMutePolicy(PolicyType::EDM - 1, CallerType::MICROPHONE, true, RANDOM_TOKENID));
2677 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2678 PrivacyKit::SetMutePolicy(PolicyType::MIXED, CallerType::MICROPHONE, true, RANDOM_TOKENID));
2679 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2680 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE - 1, true, RANDOM_TOKENID));
2681 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2682 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::CAMERA + 1, true, RANDOM_TOKENID));
2683 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2684 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::CAMERA, true, 0));
2685 }
2686
2687 /**
2688 * @tc.name: SetMutePolicyTest002
2689 * @tc.desc: Test SetMutePolicy without SET_MUTE_POLICY
2690 * @tc.type: FUNC
2691 * @tc.require:
2692 */
2693 HWTEST_F(PrivacyKitTest, SetMutePolicyTest002, TestSize.Level0)
2694 {
2695 MockNativeToken mock("accesstoken_service"); // as a sa without SET_MUTE_POLICY
2696 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
2697 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, RANDOM_TOKENID));
2698 }
2699
2700 /**
2701 * @tc.name: SetMutePolicyTest003
2702 * @tc.desc: Test SetMutePolicy with not edm
2703 * @tc.type: FUNC
2704 * @tc.require:
2705 */
2706 HWTEST_F(PrivacyKitTest, SetMutePolicyTest003, TestSize.Level0)
2707 {
2708 MockNativeToken mock("audio_server"); // as a system service with SET_MUTE_POLICY
2709
2710 ASSERT_EQ(PrivacyError::ERR_FIRST_CALLER_NOT_EDM,
2711 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, RANDOM_TOKENID));
2712 }
2713
2714 /**
2715 * @tc.name: SetMutePolicyTest004
2716 * @tc.desc: Test SetMutePolicy with not permission
2717 * @tc.type: FUNC
2718 * @tc.require:
2719 */
2720 HWTEST_F(PrivacyKitTest, SetMutePolicyTest004, TestSize.Level0)
2721 {
2722 std::vector<std::string> reqPerm;
2723 MockHapToken mock("SetMutePolicyTest004", reqPerm, true); // as a system hap
2724 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
2725 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, RANDOM_TOKENID));
2726 }
2727
2728 /**
2729 * @tc.name: SetMutePolicyTest005
2730 * @tc.desc: hdcd without SET_MUTE_POLICY permission
2731 * @tc.type: FUNC
2732 * @tc.require:
2733 */
2734 HWTEST_F(PrivacyKitTest, SetMutePolicyTest005, TestSize.Level0)
2735 {
2736 MockNativeToken mock("hdcd");
2737 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
2738 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, RANDOM_TOKENID));
2739 }
2740
2741 /**
2742 * @tc.name: SetHapWithFGReminder01
2743 * @tc.desc: SetHapWithFGReminder with valid tokenId.
2744 * @tc.type: FUNC
2745 * @tc.require:
2746 */
2747 HWTEST_F(PrivacyKitTest, SetHapWithFGReminder01, TestSize.Level0)
2748 {
2749 MockNativeToken mock("audio_server");
2750
2751 std::string permissionName = "ohos.permission.MICROPHONE";
2752 EXPECT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
2753 EXPECT_EQ(RET_SUCCESS, PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true));
2754 EXPECT_EQ(true, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
2755 EXPECT_EQ(RET_SUCCESS, PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false));
2756 }
2757
2758 /**
2759 * @tc.name: SetHapWithFGReminder02
2760 * @tc.desc: SetHapWithFGReminder with valid tokenId.
2761 * @tc.type: FUNC
2762 * @tc.require:
2763 */
2764 HWTEST_F(PrivacyKitTest, SetHapWithFGReminder02, TestSize.Level0)
2765 {
2766 MockNativeToken mock("audio_server");
2767
2768 EXPECT_EQ(RET_SUCCESS, PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true));
2769 EXPECT_EQ(PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true), PrivacyError::ERR_PARAM_INVALID);
2770 EXPECT_EQ(PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false), 0);
2771 EXPECT_EQ(PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false), PrivacyError::ERR_PARAM_INVALID);
2772 }
2773
2774 /**
2775 * @tc.name: SetHapWithFGReminder03
2776 * @tc.desc: SetHapWithFGReminder with native tokenId.
2777 * @tc.type: FUNC
2778 * @tc.require:
2779 */
2780 HWTEST_F(PrivacyKitTest, SetHapWithFGReminder03, TestSize.Level0)
2781 {
2782 MockNativeToken mock("audio_server");
2783
2784 uint32_t nativeTokenId = 672137215; // 672137215 is a native token
2785 EXPECT_EQ(PrivacyKit::SetHapWithFGReminder(nativeTokenId, true), PrivacyError::ERR_PARAM_INVALID);
2786
2787 uint32_t invalidTokenId = 0;
2788 EXPECT_EQ(PrivacyKit::SetHapWithFGReminder(invalidTokenId, true), PrivacyError::ERR_PARAM_INVALID);
2789 }
2790
2791 /**
2792 * @tc.name: SetPermissionUsedRecordToggleStatus001
2793 * @tc.desc: SetPermissionUsedRecordToggleStatus and GetPermissionUsedRecordToggleStatus with invalid userID.
2794 * @tc.type: FUNC
2795 * @tc.require:
2796 */
2797 HWTEST_F(PrivacyKitTest, SetPermissionUsedRecordToggleStatus001, TestSize.Level0)
2798 {
2799 bool status = true;
2800 int32_t resSet = PrivacyKit::SetPermissionUsedRecordToggleStatus(INVALID_USER_ID, status);
2801 int32_t resGet = PrivacyKit::GetPermissionUsedRecordToggleStatus(INVALID_USER_ID, status);
2802 EXPECT_EQ(resSet, PrivacyError::ERR_PARAM_INVALID);
2803 EXPECT_EQ(resGet, PrivacyError::ERR_PARAM_INVALID);
2804 }
2805
2806 /**
2807 * @tc.name: SetPermissionUsedRecordToggleStatus002
2808 * @tc.desc: SetPermissionUsedRecordToggleStatus with true status and false status.
2809 * @tc.type: FUNC
2810 * @tc.require:
2811 */
2812 HWTEST_F(PrivacyKitTest, SetPermissionUsedRecordToggleStatus002, TestSize.Level0)
2813 {
2814 std::vector<std::string> reqPerm;
2815 reqPerm.emplace_back("ohos.permission.ERR_PERMISSION_DENIED");
2816 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
2817 MockHapToken mock("SetPermissionUsedRecordToggleStatus002", reqPerm, true);
2818
2819 int32_t permRecordSize = 0;
2820 bool status = true;
2821
2822 EXPECT_EQ(RET_SUCCESS, PrivacyKit::SetPermissionUsedRecordToggleStatus(USER_ID_2, true));
2823 EXPECT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedRecordToggleStatus(USER_ID_2, status));
2824 EXPECT_TRUE(status);
2825
2826 AddPermParamInfo info;
2827 info.tokenId = g_tokenIdG;
2828 info.permissionName = "ohos.permission.READ_CONTACTS";
2829 info.successCount = 1;
2830 info.failCount = 0;
2831 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2832 permRecordSize++;
2833
2834 info.permissionName = "ohos.permission.WRITE_CONTACTS";
2835 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2836 permRecordSize++;
2837
2838 PermissionUsedRequest request;
2839 PermissionUsedResult result;
2840 std::vector<std::string> permissionList;
2841 BuildQueryRequest(g_tokenIdG, g_infoParmsG.bundleName, permissionList, request);
2842
2843 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
2844 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
2845 EXPECT_EQ(1, static_cast<int32_t>(result.bundleRecords.size()));
2846 EXPECT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
2847
2848 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::SetPermissionUsedRecordToggleStatus(USER_ID_2, false));
2849 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
2850 EXPECT_EQ(0, static_cast<int32_t>(result.bundleRecords.size()));
2851
2852 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2853 info.permissionName = "ohos.permission.READ_CONTACTS";
2854 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2855
2856 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
2857 EXPECT_EQ(0, static_cast<int32_t>(result.bundleRecords.size()));
2858
2859 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::SetPermissionUsedRecordToggleStatus(USER_ID_2, true));
2860 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(info.tokenId));
2861 }
2862
2863 /**
2864 * @tc.name: SetPermissionUsedRecordToggleStatus003
2865 * @tc.desc: SetPermissionUsedRecordToggleStatus with false status and true status.
2866 * @tc.type: FUNC
2867 * @tc.require:
2868 */
2869 HWTEST_F(PrivacyKitTest, SetPermissionUsedRecordToggleStatus003, TestSize.Level0)
2870 {
2871 std::vector<std::string> reqPerm;
2872 reqPerm.emplace_back("ohos.permission.ERR_PERMISSION_DENIED");
2873 reqPerm.emplace_back("ohos.permission.PERMISSION_USED_STATS");
2874 MockHapToken mock("SetPermissionUsedRecordToggleStatus003", reqPerm, true);
2875
2876 int32_t permRecordSize = 0;
2877 bool status = true;
2878
2879 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::SetPermissionUsedRecordToggleStatus(USER_ID_2, false));
2880 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecordToggleStatus(USER_ID_2, status));
2881 EXPECT_FALSE(status);
2882
2883 AddPermParamInfo info;
2884 info.tokenId = g_tokenIdG;
2885 info.permissionName = "ohos.permission.READ_CONTACTS";
2886 info.successCount = 1;
2887 info.failCount = 0;
2888 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2889
2890 info.permissionName = "ohos.permission.WRITE_CONTACTS";
2891 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2892
2893 PermissionUsedRequest request;
2894 PermissionUsedResult result;
2895 std::vector<std::string> permissionList;
2896 BuildQueryRequest(g_tokenIdG, g_infoParmsG.bundleName, permissionList, request);
2897 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
2898
2899 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
2900 EXPECT_TRUE(result.bundleRecords.empty());
2901
2902 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::SetPermissionUsedRecordToggleStatus(USER_ID_2, true));
2903 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecordToggleStatus(USER_ID_2, status));
2904 EXPECT_TRUE(status);
2905
2906 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2907 permRecordSize++;
2908
2909 info.permissionName = "ohos.permission.READ_CONTACTS";
2910 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2911 permRecordSize++;
2912
2913 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
2914 EXPECT_EQ(1, static_cast<int32_t>(result.bundleRecords.size()));
2915 EXPECT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
2916
2917 EXPECT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(info.tokenId));
2918 }
2919