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 int32_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(static_cast<int32_t>(res.size()), 0);
1980 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetSpecialSecCompEnhance(g_infoParmsA.bundleName, res));
1981 }
1982 #endif
1983
1984 /**
1985 * @tc.name: AddPermissionUsedRecord011
1986 * @tc.desc: Test AddPermissionUsedRecord with default normal used type
1987 * @tc.type: FUNC
1988 * @tc.require:
1989 */
1990 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord011, TestSize.Level1)
1991 {
1992 AddPermParamInfo info;
1993 info.tokenId = g_tokenIdA;
1994 info.permissionName = "ohos.permission.READ_CONTACTS";
1995 info.successCount = 1;
1996 info.failCount = 0;
1997 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
1998
1999 std::vector<PermissionUsedTypeInfo> results;
2000 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2001 results));
2002 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2003 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type); // only normal type
2004 results.clear();
2005
2006 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // repeat
2007 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2008 results));
2009 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2010 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type); // results remain
2011 }
2012
2013 /**
2014 * @tc.name: AddPermissionUsedRecord012
2015 * @tc.desc: Test AddPermissionUsedRecord with picker used type
2016 * @tc.type: FUNC
2017 * @tc.require:
2018 */
2019 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord012, TestSize.Level1)
2020 {
2021 AddPermParamInfo info;
2022 info.tokenId = g_tokenIdA;
2023 info.permissionName = "ohos.permission.READ_CONTACTS";
2024 info.successCount = 1;
2025 info.failCount = 0;
2026 info.type = PermissionUsedType::PICKER_TYPE;
2027 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2028
2029 std::vector<PermissionUsedTypeInfo> results;
2030 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2031 results));
2032 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2033 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type); // only picker type
2034 results.clear();
2035
2036 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // repeat
2037 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2038 results));
2039 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2040 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type); // results remain
2041 }
2042
2043 /**
2044 * @tc.name: AddPermissionUsedRecord013
2045 * @tc.desc: Test AddPermissionUsedRecord with security component used type
2046 * @tc.type: FUNC
2047 * @tc.require:
2048 */
2049 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord013, TestSize.Level1)
2050 {
2051 AddPermParamInfo info;
2052 info.tokenId = g_tokenIdA;
2053 info.permissionName = "ohos.permission.READ_CONTACTS";
2054 info.successCount = 1;
2055 info.failCount = 0;
2056 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2057 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2058
2059 std::vector<PermissionUsedTypeInfo> results;
2060 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2061 results));
2062 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2063 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type); // only security component type
2064 results.clear();
2065
2066 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // repeat
2067 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2068 results));
2069 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results.size());
2070 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type); // results remain
2071 }
2072
2073 /**
2074 * @tc.name: AddPermissionUsedRecord014
2075 * @tc.desc: Test AddPermissionUsedRecord with default normal and picker used type
2076 * @tc.type: FUNC
2077 * @tc.require:
2078 */
2079 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord014, TestSize.Level1)
2080 {
2081 AddPermParamInfo info;
2082 info.tokenId = g_tokenIdA;
2083 info.permissionName = "ohos.permission.READ_CONTACTS";
2084 info.successCount = 1;
2085 info.failCount = 0;
2086 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2087
2088 info.type = PermissionUsedType::PICKER_TYPE;
2089 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2090
2091 std::vector<PermissionUsedTypeInfo> results;
2092 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2093 results));
2094 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_TWO), results.size());
2095 ASSERT_EQ(NORMAL_TYPE, results[FIRST_INDEX].type); // contain normal type
2096 ASSERT_EQ(PICKER_TYPE, results[SECOND_INDEX].type); // contain picker type
2097 }
2098
2099 /**
2100 * @tc.name: AddPermissionUsedRecord015
2101 * @tc.desc: Test AddPermissionUsedRecord with default normal and security component used type
2102 * @tc.type: FUNC
2103 * @tc.require:
2104 */
2105 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord015, TestSize.Level1)
2106 {
2107 AddPermParamInfo info;
2108 info.tokenId = g_tokenIdA;
2109 info.permissionName = "ohos.permission.READ_CONTACTS";
2110 info.successCount = 1;
2111 info.failCount = 0;
2112 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2113
2114 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2115 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2116
2117 std::vector<PermissionUsedTypeInfo> results;
2118 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2119 results));
2120 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_TWO), results.size());
2121 ASSERT_EQ(NORMAL_TYPE, results[FIRST_INDEX].type); // contain normal type
2122 ASSERT_EQ(SECURITY_COMPONENT_TYPE, results[SECOND_INDEX].type); // contain security component type
2123 }
2124
2125 /**
2126 * @tc.name: AddPermissionUsedRecord016
2127 * @tc.desc: Test AddPermissionUsedRecord with picker and security component used type
2128 * @tc.type: FUNC
2129 * @tc.require:
2130 */
2131 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord016, TestSize.Level1)
2132 {
2133 AddPermParamInfo info;
2134 info.tokenId = g_tokenIdA;
2135 info.permissionName = "ohos.permission.READ_CONTACTS";
2136 info.successCount = 1;
2137 info.failCount = 0;
2138 info.type = PermissionUsedType::PICKER_TYPE;
2139 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2140
2141 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2142 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2143
2144 std::vector<PermissionUsedTypeInfo> results;
2145 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2146 results));
2147 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_TWO), results.size());
2148 ASSERT_EQ(PICKER_TYPE, results[FIRST_INDEX].type); // contain picker type
2149 ASSERT_EQ(SECURITY_COMPONENT_TYPE, results[SECOND_INDEX].type); // contain security component type
2150 }
2151
2152 /**
2153 * @tc.name: AddPermissionUsedRecord017
2154 * @tc.desc: Test AddPermissionUsedRecord with all used type
2155 * @tc.type: FUNC
2156 * @tc.require:
2157 */
2158 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord017, TestSize.Level1)
2159 {
2160 AddPermParamInfo info;
2161 info.tokenId = g_tokenIdA;
2162 info.permissionName = "ohos.permission.READ_CONTACTS";
2163 info.successCount = 1;
2164 info.failCount = 0;
2165 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add normal used type
2166
2167 info.type = PermissionUsedType::PICKER_TYPE;
2168 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add picker used type
2169
2170 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2171 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info)); // add security component used type
2172
2173 std::vector<PermissionUsedTypeInfo> results;
2174 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, "ohos.permission.READ_CONTACTS",
2175 results));
2176 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_THREE), results.size());
2177 ASSERT_EQ(NORMAL_TYPE, results[FIRST_INDEX].type); // contain normal type
2178 ASSERT_EQ(PICKER_TYPE, results[SECOND_INDEX].type); // contain picker type
2179 ASSERT_EQ(SECURITY_COMPONENT_TYPE, results[THIRD_INDEX].type); // contain security component type
2180 }
2181
2182 /**
2183 * @tc.name: AddPermissionUsedRecord018
2184 * @tc.desc: Test AddPermissionUsedRecord with invalid used type
2185 * @tc.type: FUNC
2186 * @tc.require:
2187 */
2188 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord018, TestSize.Level1)
2189 {
2190 AddPermParamInfo info;
2191 info.tokenId = g_tokenIdA;
2192 info.permissionName = "ohos.permission.READ_CONTACTS";
2193 info.successCount = 1;
2194 info.failCount = 0;
2195 info.type = PermissionUsedType::INVALID_USED_TYPE;
2196 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(info)); // add invalid used type
2197 }
2198
2199 /**
2200 * @tc.name: GetPermissionUsedTypeInfos001
2201 * @tc.desc: Test GetPermissionUsedTypeInfos with default input
2202 * @tc.type: FUNC
2203 * @tc.require:
2204 */
2205 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos001, TestSize.Level1)
2206 {
2207 AddPermParamInfo info;
2208 info.tokenId = g_tokenIdA;
2209 info.permissionName = "ohos.permission.READ_CONTACTS";
2210 info.successCount = 1;
2211 info.failCount = 0;
2212 // g_tokenIdA add normal used type
2213 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2214
2215 info.tokenId = g_tokenIdB;
2216 info.type = PermissionUsedType::PICKER_TYPE;
2217 // g_tokenIdB add picker used type
2218 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2219
2220 info.tokenId = g_tokenIdC.tokenIdExStruct.tokenID;
2221 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2222 // g_tokenIdC add security component used type
2223 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2224
2225 std::string permissionName;
2226 std::vector<PermissionUsedTypeInfo> results;
2227 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, permissionName, results));
2228 // results size may more than 3
2229 for (const PermissionUsedTypeInfo& result : results) {
2230 if (result.tokenId == g_tokenIdA) {
2231 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, result.type); // g_tokenIdA only normal type
2232 } else if (result.tokenId == g_tokenIdB) {
2233 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, result.type); // g_tokenIdB only picker type
2234 } else if (result.tokenId == g_tokenIdC.tokenIdExStruct.tokenID) {
2235 // g_tokenIdC only security component type
2236 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, result.type);
2237 }
2238 }
2239 }
2240
2241 /**
2242 * @tc.name: GetPermissionUsedTypeInfos002
2243 * @tc.desc: Test GetPermissionUsedTypeInfos with default tokenId
2244 * @tc.type: FUNC
2245 * @tc.require:
2246 */
2247 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos002, TestSize.Level1)
2248 {
2249 AddPermParamInfo info;
2250 info.tokenId = g_tokenIdA;
2251 info.permissionName = "ohos.permission.READ_CONTACTS";
2252 info.successCount = 1;
2253 info.failCount = 0;
2254 // READ_CONTACTS add normal used type
2255 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2256
2257 info.permissionName = "ohos.permission.LOCATION";
2258 info.type = PermissionUsedType::PICKER_TYPE;
2259 // LOCATION add picker used type
2260 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2261
2262 info.permissionName = "ohos.permission.MICROPHONE";
2263 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2264 // MICROPHONE add security component used type
2265 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2266
2267 std::vector<PermissionUsedTypeInfo> results1;
2268 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, "ohos.permission.READ_CONTACTS", results1));
2269 // result1 size may more than one
2270 for (const auto& result : results1) {
2271 if (g_tokenIdA == result.tokenId) {
2272 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, result.type); // g_tokenIdA only normal type
2273 }
2274 }
2275
2276 std::vector<PermissionUsedTypeInfo> results2;
2277 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, "ohos.permission.LOCATION", results2));
2278 // result2 size may more than one
2279 for (const auto& result : results2) {
2280 if (g_tokenIdA == result.tokenId) {
2281 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, result.type); // g_tokenIdA only picker type
2282 }
2283 }
2284
2285 std::vector<PermissionUsedTypeInfo> results3;
2286 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(0, "ohos.permission.MICROPHONE", results3));
2287 // result3 size may more than one
2288 for (const auto& result : results3) {
2289 if (g_tokenIdA == result.tokenId) {
2290 // g_tokenIdA only security component type
2291 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, result.type);
2292 }
2293 }
2294 }
2295
2296 /**
2297 * @tc.name: GetPermissionUsedTypeInfos003
2298 * @tc.desc: Test GetPermissionUsedTypeInfos with default permissionName
2299 * @tc.type: FUNC
2300 * @tc.require:
2301 */
2302 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos003, TestSize.Level1)
2303 {
2304 AddPermParamInfo info;
2305 info.tokenId = g_tokenIdA;
2306 info.permissionName = "ohos.permission.READ_CONTACTS";
2307 info.successCount = 1;
2308 info.failCount = 0;
2309 // g_tokenIdA add normal used type
2310 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2311
2312 info.tokenId = g_tokenIdB;
2313 info.type = PermissionUsedType::PICKER_TYPE;
2314 // g_tokenIdB add picker used type
2315 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2316
2317 info.tokenId = g_tokenIdC.tokenIdExStruct.tokenID;
2318 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
2319 // g_tokenIdC add security component used type
2320 ASSERT_EQ(RET_SUCCESS, PrivacyKit::AddPermissionUsedRecord(info));
2321
2322 std::string permissionName;
2323 std::vector<PermissionUsedTypeInfo> results1;
2324 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdA, permissionName, results1));
2325 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results1.size()); // only g_tokenIdA
2326 ASSERT_EQ(g_tokenIdA, results1[FIRST_INDEX].tokenId);
2327 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results1[FIRST_INDEX].type); // normal type
2328
2329 std::vector<PermissionUsedTypeInfo> results2;
2330 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdB, permissionName, results2));
2331 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results2.size()); // only g_tokenIdB
2332 ASSERT_EQ(g_tokenIdB, results2[FIRST_INDEX].tokenId);
2333 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results2[FIRST_INDEX].type); // picker type
2334
2335 std::vector<PermissionUsedTypeInfo> results3;
2336 ASSERT_EQ(RET_SUCCESS, PrivacyKit::GetPermissionUsedTypeInfos(g_tokenIdC.tokenIdExStruct.tokenID,
2337 permissionName, results3));
2338 ASSERT_EQ(static_cast<size_t>(RESULT_NUM_ONE), results3.size()); // only g_tokenIdC
2339 ASSERT_EQ(g_tokenIdC.tokenIdExStruct.tokenID, results3[FIRST_INDEX].tokenId);
2340 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results3[FIRST_INDEX].type); // security component type
2341 }
2342
2343 /**
2344 * @tc.name: GetPermissionUsedTypeInfos004
2345 * @tc.desc: Test GetPermissionUsedTypeInfos with invalid input param
2346 * @tc.type: FUNC
2347 * @tc.require:
2348 */
2349 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos004, TestSize.Level1)
2350 {
2351 std::vector<PermissionUsedTypeInfo> results;
2352 // tokenId invalid
2353 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::GetPermissionUsedTypeInfos(RANDOM_TOKENID,
2354 "ohos.permission.READ_CONTACTS", results));
2355
2356 std::string permissionName;
2357 for (int32_t i = 0; i < INVALID_PERMISSIONAME_LENGTH; i++) { // 257
2358 permissionName.append("a");
2359 }
2360
2361 // permissionName over length
2362 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedTypeInfos(0, permissionName, results));
2363 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PrivacyKit::GetPermissionUsedTypeInfos(0,
2364 "ohos.permission.TEST", results)); // permissionName invalid
2365 }
2366
2367 /**
2368 * @tc.name: GetPermissionUsedTypeInfos005
2369 * @tc.desc: Test GetPermissionUsedTypeInfos as normal hap or system hap without PERMISSION_USED_STATE
2370 * @tc.type: FUNC
2371 * @tc.require:
2372 */
2373 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos005, TestSize.Level1)
2374 {
2375 EXPECT_EQ(0, SetSelfTokenID(g_tokenIdA)); // g_tokenIdA is a normal hap
2376
2377 std::string permissionName;
2378 std::vector<PermissionUsedTypeInfo> results;
2379 ASSERT_EQ(PrivacyError::ERR_NOT_SYSTEM_APP, PrivacyKit::GetPermissionUsedTypeInfos(0, permissionName, results));
2380
2381 AccessTokenIDEx tokenIdEx = {0};
2382 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoParmsD, g_policyPramsD);
2383 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
2384 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // as a system hap without PERMISSION_USED_STATE
2385 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED, PrivacyKit::GetPermissionUsedTypeInfos(
2386 0, permissionName, results));
2387
2388 PrivacyKit::RemovePermissionUsedRecords(tokenIdEx.tokenIdExStruct.tokenID, "");
2389 EXPECT_EQ(0, AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID)); // delete test hap
2390 }
2391
2392 /*
2393 * @tc.name: GetPermissionUsedTypeInfos006
2394 * @tc.desc: PrivacyKit::GetPermissionUsedTypeInfos function test
2395 * @tc.type: FUNC
2396 * @tc.require:
2397 */
2398 HWTEST_F(PrivacyKitTest, GetPermissionUsedTypeInfos006, TestSize.Level1)
2399 {
2400 uint32_t count = MAX_PERMISSION_USED_TYPE_SIZE + 1;
2401
2402 // set callertoken to system app
2403 ASSERT_EQ(0, SetSelfTokenID(g_tokenIdC.tokenIDEx));
2404
2405 // add 2001 permission used type record
2406 std::vector<AccessTokenID> tokenIdList;
2407 std::string tmpBundleName = g_infoParmsC.bundleName;
2408
2409 for (uint32_t i = 0; i < count; i++) {
2410 std::string bundleName = tmpBundleName + std::to_string(i);
2411 g_infoParmsC.bundleName = bundleName;
2412 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoParmsC, g_policyPramsC);
2413 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
2414 ASSERT_NE(tokenId, INVALID_TOKENID);
2415 tokenIdList.emplace_back(tokenId);
2416
2417 AddPermParamInfo info;
2418 info.tokenId = tokenId;
2419 info.permissionName = "ohos.permission.READ_CONTACTS";
2420 info.successCount = 1;
2421 info.failCount = 0;
2422 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(info));
2423 }
2424
2425 AccessTokenID tokenId = 0;
2426 std::string permissionName;
2427 std::vector<PermissionUsedTypeInfo> results;
2428 // record over size
2429 ASSERT_EQ(PrivacyError::ERR_OVERSIZE, PrivacyKit::GetPermissionUsedTypeInfos(tokenId, permissionName, results));
2430
2431 for (const auto& id : tokenIdList) {
2432 PrivacyKit::RemovePermissionUsedRecords(id, "");
2433 ASSERT_EQ(0, AccessTokenKit::DeleteToken(id));
2434 }
2435
2436 g_infoParmsC.bundleName = tmpBundleName;
2437 }
2438
2439 /**
2440 * @tc.name: SetMutePolicyTest001
2441 * @tc.desc: Test SetMutePolicy with invalid param
2442 * @tc.type: FUNC
2443 * @tc.require:
2444 */
2445 HWTEST_F(PrivacyKitTest, SetMutePolicyTest001, TestSize.Level1)
2446 {
2447 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2448 PrivacyKit::SetMutePolicy(PolicyType::EDM - 1, CallerType::MICROPHONE, true));
2449 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2450 PrivacyKit::SetMutePolicy(PolicyType::MIXED, CallerType::MICROPHONE, true));
2451 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2452 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE - 1, true));
2453 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
2454 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::CAMERA + 1, true));
2455 }
2456
2457 /**
2458 * @tc.name: SetMutePolicyTest002
2459 * @tc.desc: Test SetMutePolicy without PERMISSION_USED_STATE
2460 * @tc.type: FUNC
2461 * @tc.require:
2462 */
2463 HWTEST_F(PrivacyKitTest, SetMutePolicyTest002, TestSize.Level1)
2464 {
2465 AccessTokenIDEx tokenIdEx = {0};
2466 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoParmsD, g_policyPramsD);
2467 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx);
2468 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // as a system hap without PERMISSION_USED_STATE
2469 ASSERT_EQ(PrivacyError::ERR_PERMISSION_DENIED,
2470 PrivacyKit::SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true));
2471 }
2472
2473 /**
2474 * @tc.name: IsAllowedUsingPermission011
2475 * @tc.desc: IsAllowedUsingPermission with valid tokenId.
2476 * @tc.type: FUNC
2477 * @tc.require:
2478 */
2479 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission011, TestSize.Level1)
2480 {
2481 std::string permissionName = "ohos.permission.MICROPHONE";
2482 std::vector<AppStateData> list;
2483 int32_t ret = AppManagerAccessClient::GetInstance().GetForegroundApplications(list);
2484 ASSERT_EQ(0, ret);
2485 if (list.empty()) {
2486 GTEST_LOG_(INFO) << "GetForegroundApplications empty ";
2487 return;
2488 }
2489 uint32_t tokenIdForeground = list[0].accessTokenId;
2490 ASSERT_EQ(true, PrivacyKit::IsAllowedUsingPermission(tokenIdForeground, permissionName));
2491 }
2492
2493 /**
2494 * @tc.name: SetHapWithFGReminder01
2495 * @tc.desc: SetHapWithFGReminder with valid tokenId.
2496 * @tc.type: FUNC
2497 * @tc.require:
2498 */
2499 HWTEST_F(PrivacyKitTest, SetHapWithFGReminder01, TestSize.Level1)
2500 {
2501 uint32_t opCode1;
2502 uint32_t opCode2;
2503 uint32_t tokenTest = 111; /// 111 is a tokenId
2504 uint32_t selfUid = getuid();
2505 setuid(ACCESS_TOKEN_UID);
2506
2507 EXPECT_EQ(true, TransferPermissionToOpcode("ohos.permission.SET_FOREGROUND_HAP_REMINDER", opCode1));
2508 EXPECT_EQ(true, TransferPermissionToOpcode("ohos.permission.PERMISSION_USED_STATS", opCode2));
2509 int32_t res = AddPermissionToKernel(tokenTest, {opCode1, opCode2}, {1, 1});
2510 ASSERT_EQ(res, 0);
2511 GTEST_LOG_(INFO) << "permissionSet OK ";
2512
2513 EXPECT_EQ(0, SetSelfTokenID(tokenTest));
2514 std::string permissionName = "ohos.permission.MICROPHONE";
2515 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
2516 int32_t ret = PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true);
2517 ASSERT_EQ(ret, 0);
2518 ASSERT_EQ(true, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
2519 ret = PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false);
2520 ASSERT_EQ(ret, 0);
2521
2522 res = RemovePermissionFromKernel(tokenTest);
2523 ASSERT_EQ(res, 0);
2524 setuid(selfUid);
2525 }
2526
2527 /**
2528 * @tc.name: SetHapWithFGReminder02
2529 * @tc.desc: SetHapWithFGReminder with valid tokenId.
2530 * @tc.type: FUNC
2531 * @tc.require:
2532 */
2533 HWTEST_F(PrivacyKitTest, SetHapWithFGReminder02, TestSize.Level1)
2534 {
2535 uint32_t opCode1;
2536 uint32_t opCode2;
2537 uint32_t tokenTest = 111; /// 111 is a tokenId
2538 uint32_t selfUid = getuid();
2539 setuid(ACCESS_TOKEN_UID);
2540
2541 EXPECT_EQ(true, TransferPermissionToOpcode("ohos.permission.SET_FOREGROUND_HAP_REMINDER", opCode1));
2542 EXPECT_EQ(true, TransferPermissionToOpcode("ohos.permission.PERMISSION_USED_STATS", opCode2));
2543 int32_t res = AddPermissionToKernel(tokenTest, {opCode1, opCode2}, {1, 1});
2544 ASSERT_EQ(res, 0);
2545
2546 EXPECT_EQ(0, SetSelfTokenID(tokenTest));
2547 int32_t ret = PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true);
2548 ASSERT_EQ(ret, 0);
2549 ret = PrivacyKit::SetHapWithFGReminder(g_tokenIdE, true);
2550 ASSERT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
2551 ret = PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false);
2552 ASSERT_EQ(ret, 0);
2553 ret = PrivacyKit::SetHapWithFGReminder(g_tokenIdE, false);
2554 ASSERT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
2555 res = RemovePermissionFromKernel(tokenTest);
2556 ASSERT_EQ(res, 0);
2557 setuid(selfUid);
2558 }
2559
2560 /**
2561 * @tc.name: SetHapWithFGReminder03
2562 * @tc.desc: SetHapWithFGReminder with native tokenId.
2563 * @tc.type: FUNC
2564 * @tc.require:
2565 */
2566 HWTEST_F(PrivacyKitTest, SetHapWithFGReminder03, TestSize.Level1)
2567 {
2568 uint32_t opCode1;
2569 uint32_t opCode2;
2570 uint32_t tokenTest = 111; /// 111 is a tokenId
2571 uint32_t selfUid = getuid();
2572 setuid(ACCESS_TOKEN_UID);
2573
2574 EXPECT_EQ(true, TransferPermissionToOpcode("ohos.permission.SET_FOREGROUND_HAP_REMINDER", opCode1));
2575 EXPECT_EQ(true, TransferPermissionToOpcode("ohos.permission.PERMISSION_USED_STATS", opCode2));
2576 int32_t res = AddPermissionToKernel(tokenTest, {opCode1, opCode2}, {1, 1});
2577 ASSERT_EQ(res, 0);
2578
2579 EXPECT_EQ(0, SetSelfTokenID(tokenTest));
2580 uint32_t nativeTokenId = 672137215; // 672137215 is a native token
2581 int32_t ret = PrivacyKit::SetHapWithFGReminder(nativeTokenId, true);
2582 ASSERT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
2583 res = RemovePermissionFromKernel(tokenTest);
2584 ASSERT_EQ(res, 0);
2585 setuid(selfUid);
2586
2587 uint32_t invalidTokenId = 0;
2588 ret = PrivacyKit::SetHapWithFGReminder(invalidTokenId, true);
2589 ASSERT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
2590 }