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