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