1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "privacy_kit_test.h"
17
18 #include "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "on_permission_used_record_callback_stub.h"
21 #include "parameter.h"
22 #define private public
23 #include "perm_active_status_change_callback.h"
24 #include "privacy_manager_client.h"
25 #include "state_change_callback.h"
26 #undef private
27 #include "perm_active_response_parcel.h"
28 #include "perm_active_status_change_callback_stub.h"
29 #include "privacy_error.h"
30 #include "privacy_kit.h"
31 #include "state_change_callback_stub.h"
32 #include "string_ex.h"
33 #include "token_setproc.h"
34
35 using namespace testing::ext;
36 using namespace OHOS::Security::AccessToken;
37
38 const static int32_t RET_NO_ERROR = 0;
39
40 static HapPolicyParams g_policyPramsA = {
41 .apl = APL_NORMAL,
42 .domain = "test.domain.A",
43 };
44
45 static HapInfoParams g_infoParmsA = {
46 .userID = 1,
47 .bundleName = "ohos.privacy_test.bundleA",
48 .instIndex = 0,
49 .appIDDesc = "privacy_test.bundleA"
50 };
51
52 static HapPolicyParams g_policyPramsB = {
53 .apl = APL_NORMAL,
54 .domain = "test.domain.B",
55 };
56
57 static HapInfoParams g_infoParmsB = {
58 .userID = 1,
59 .bundleName = "ohos.privacy_test.bundleB",
60 .instIndex = 0,
61 .appIDDesc = "privacy_test.bundleB"
62 };
63
64 static PermissionStateFull g_infoManagerTestStateA = {
65 .permissionName = "ohos.permission.CAMERA",
66 .isGeneral = true,
67 .resDeviceID = {"local"},
68 .grantStatus = {PermissionState::PERMISSION_GRANTED},
69 .grantFlags = {1}
70 };
71
72 static PermissionStateFull g_infoManagerTestStateB = {
73 .permissionName = "ohos.permission.MICROPHONE",
74 .isGeneral = true,
75 .resDeviceID = {"local"},
76 .grantStatus = {PermissionState::PERMISSION_GRANTED},
77 .grantFlags = {1}
78 };
79 static HapPolicyParams g_policyPramsE = {
80 .apl = APL_NORMAL,
81 .domain = "test.domain",
82 .permList = {},
83 .permStateList = {g_infoManagerTestStateA, g_infoManagerTestStateB}
84 };
85 static HapInfoParams g_infoParmsE = {
86 .userID = 1,
87 .bundleName = "ohos.privacy_test.bundleE",
88 .instIndex = 0,
89 .appIDDesc = "privacy_test.bundleE"
90 };
91 static UsedRecordDetail g_usedRecordDetail = {
92 .status = 2,
93 .timestamp = 2L,
94 .accessDuration = 2L,
95 };
96 static PermissionUsedRecord g_permissionUsedRecord = {
97 .permissionName = "ohos.permission.CAMERA",
98 .accessCount = 2,
99 .rejectCount = 2,
100 .lastAccessTime = 0L,
101 .lastRejectTime = 0L,
102 .lastAccessDuration = 0L,
103 };
104 static BundleUsedRecord g_bundleUsedRecord = {
105 .tokenId = 100,
106 .isRemote = false,
107 .deviceId = "you guess",
108 .bundleName = "com.ohos.camera",
109 };
110
111 static AccessTokenID g_selfTokenId = 0;
112 static AccessTokenID g_tokenIdA = 0;
113 static AccessTokenID g_tokenIdB = 0;
114 static AccessTokenID g_tokenIdE = 0;
115
116
DeleteTestToken()117 static void DeleteTestToken()
118 {
119 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsA.userID,
120 g_infoParmsA.bundleName,
121 g_infoParmsA.instIndex);
122 AccessTokenKit::DeleteToken(tokenId);
123
124 tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsB.userID,
125 g_infoParmsB.bundleName,
126 g_infoParmsB.instIndex);
127 AccessTokenKit::DeleteToken(tokenId);
128
129 tokenId = AccessTokenKit::GetHapTokenID(g_infoParmsE.userID,
130 g_infoParmsE.bundleName,
131 g_infoParmsE.instIndex);
132 AccessTokenKit::DeleteToken(tokenId);
133 }
134
SetUpTestCase()135 void PrivacyKitTest::SetUpTestCase()
136 {
137 DeleteTestToken();
138 g_selfTokenId = GetSelfTokenID();
139 }
140
TearDownTestCase()141 void PrivacyKitTest::TearDownTestCase()
142 {
143 }
144
SetUp()145 void PrivacyKitTest::SetUp()
146 {
147 AccessTokenKit::AllocHapToken(g_infoParmsA, g_policyPramsA);
148 AccessTokenKit::AllocHapToken(g_infoParmsB, g_policyPramsB);
149 AccessTokenKit::AllocHapToken(g_infoParmsE, g_policyPramsE);
150
151 g_tokenIdA = AccessTokenKit::GetHapTokenID(g_infoParmsA.userID, g_infoParmsA.bundleName, g_infoParmsA.instIndex);
152 g_tokenIdB = AccessTokenKit::GetHapTokenID(g_infoParmsB.userID, g_infoParmsB.bundleName, g_infoParmsB.instIndex);
153 g_tokenIdE = AccessTokenKit::GetHapTokenID(g_infoParmsE.userID, g_infoParmsE.bundleName, g_infoParmsE.instIndex);
154
155 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(100, "com.ohos.permissionmanager", 0); // 100 is userID
156 SetSelfTokenID(tokenId);
157 }
158
TearDown()159 void PrivacyKitTest::TearDown()
160 {
161 SetSelfTokenID(g_selfTokenId);
162 DeleteTestToken();
163 }
164
GetLocalDeviceUdid()165 std::string PrivacyKitTest::GetLocalDeviceUdid()
166 {
167 const int32_t DEVICE_UUID_LENGTH = 65;
168 char udid[DEVICE_UUID_LENGTH] = {0};
169 GetDevUdid(udid, DEVICE_UUID_LENGTH);
170 return udid;
171 }
172
BuildQueryRequest(AccessTokenID tokenId,const std::string & deviceId,const std::string & bundleName,const std::vector<std::string> & permissionList,PermissionUsedRequest & request)173 void PrivacyKitTest::BuildQueryRequest(AccessTokenID tokenId, const std::string &deviceId,
174 const std::string &bundleName, const std::vector<std::string> &permissionList, PermissionUsedRequest &request)
175 {
176 request.tokenId = tokenId;
177 request.isRemote = false;
178 request.deviceId = deviceId;
179 request.bundleName = bundleName;
180 request.permissionList = permissionList;
181 request.beginTimeMillis = 0;
182 request.endTimeMillis = 0;
183 request.flag = FLAG_PERMISSION_USAGE_SUMMARY;
184 }
185
CheckPermissionUsedResult(const PermissionUsedRequest & request,const PermissionUsedResult & result,int32_t permRecordSize,int32_t totalSuccessCount,int32_t totalFailCount)186 void PrivacyKitTest::CheckPermissionUsedResult(const PermissionUsedRequest& request, const PermissionUsedResult& result,
187 int32_t permRecordSize, int32_t totalSuccessCount, int32_t totalFailCount)
188 {
189 int32_t successCount = 0;
190 int32_t failCount = 0;
191 ASSERT_EQ(request.tokenId, result.bundleRecords[0].tokenId);
192 ASSERT_EQ(request.isRemote, result.bundleRecords[0].isRemote);
193 ASSERT_EQ(request.deviceId, result.bundleRecords[0].deviceId);
194 ASSERT_EQ(request.bundleName, result.bundleRecords[0].bundleName);
195 ASSERT_EQ(permRecordSize, static_cast<int32_t>(result.bundleRecords[0].permissionRecords.size()));
196 for (int32_t i = 0; i < permRecordSize; i++) {
197 successCount += result.bundleRecords[0].permissionRecords[i].accessCount;
198 failCount += result.bundleRecords[0].permissionRecords[i].rejectCount;
199 }
200 ASSERT_EQ(totalSuccessCount, successCount);
201 ASSERT_EQ(totalFailCount, failCount);
202 }
203
SetTokenID(std::vector<HapInfoParams> & g_InfoParms_List,std::vector<AccessTokenID> & g_TokenId_List,int32_t number)204 static void SetTokenID(std::vector<HapInfoParams>& g_InfoParms_List,
205 std::vector<AccessTokenID>& g_TokenId_List, int32_t number)
206 {
207 SetSelfTokenID(g_selfTokenId);
208 for (int32_t i = 0; i < number; i++) {
209 HapInfoParams g_InfoParmsTmp = {
210 .userID = i,
211 .bundleName = "ohos.privacy_test.bundle" + std::to_string(i),
212 .instIndex = i,
213 .appIDDesc = "privacy_test.bundle" + std::to_string(i)
214 };
215 g_InfoParms_List.push_back(g_InfoParmsTmp);
216 HapPolicyParams g_PolicyPramsTmp = {
217 .apl = APL_NORMAL,
218 .domain = "test.domain." + std::to_string(i)
219 };
220 AccessTokenKit::AllocHapToken(g_InfoParmsTmp, g_PolicyPramsTmp);
221 AccessTokenID g_TokenId_Tmp = AccessTokenKit::GetHapTokenID(g_InfoParmsTmp.userID,
222 g_InfoParmsTmp.bundleName,
223 g_InfoParmsTmp.instIndex);
224 g_TokenId_List.push_back(g_TokenId_Tmp);
225 }
226 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(100, "com.ohos.permissionmanager", 0);
227 SetSelfTokenID(tokenId);
228 }
229
DeleteTokenID(std::vector<HapInfoParams> & g_InfoParms_List)230 static void DeleteTokenID(std::vector<HapInfoParams>& g_InfoParms_List)
231 {
232 SetSelfTokenID(g_selfTokenId);
233 for (size_t i = 0; i < g_InfoParms_List.size(); i++) {
234 AccessTokenID g_TokenId_Tmp = AccessTokenKit::GetHapTokenID(g_InfoParms_List[i].userID,
235 g_InfoParms_List[i].bundleName,
236 g_InfoParms_List[i].instIndex);
237 AccessTokenKit::DeleteToken(g_TokenId_Tmp);
238 }
239 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(100, "com.ohos.permissionmanager", 0);
240 SetSelfTokenID(tokenId);
241 }
242
243 /**
244 * @tc.name: AddPermissionUsedRecord001
245 * @tc.desc: cannot AddPermissionUsedRecord with illegal tokenId and permission.
246 * @tc.type: FUNC
247 * @tc.require: issueI5P4IU
248 */
249 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord001, TestSize.Level1)
250 {
251 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(
252 0, "ohos.permission.READ_CONTACTS", 1, 0));
253 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "", 1, 0));
254 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::AddPermissionUsedRecord(
255 g_tokenIdA, "ohos.permission.READ_CONTACTS", -1, 0));
256
257 PermissionUsedRequest request;
258 PermissionUsedResult result;
259 std::vector<std::string> permissionList;
260 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
261 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
262 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
263 }
264
265 /**
266 * @tc.name: AddPermissionUsedRecord002
267 * @tc.desc: cannot AddPermissionUsedRecord with invalid tokenId and permission.
268 * @tc.type: FUNC
269 * @tc.require: issueI5P4IU
270 */
271 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord002, TestSize.Level1)
272 {
273 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
274 PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.test", 1, 0));
275 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST,
276 PrivacyKit::AddPermissionUsedRecord(123, "ohos.permission.CAMERA", 1, 0));
277 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
278 PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CONTACTS", 0, 0));
279
280 PermissionUsedRequest request;
281 PermissionUsedResult result;
282 std::vector<std::string> permissionList;
283 BuildQueryRequest(123, "", "", permissionList, request);
284 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
285 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
286
287 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
288 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
289 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
290 }
291
292 /**
293 * @tc.name: AddPermissionUsedRecord003
294 * @tc.desc: cannot AddPermissionUsedRecord with native tokenId.
295 * @tc.type: FUNC
296 * @tc.require: issueI5P4IU
297 */
298 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord003, TestSize.Level1)
299 {
300 const char **dcaps = new const char *[2];
301 dcaps[0] = "AT_CAP";
302 dcaps[1] = "ST_CAP";
303 uint64_t tokenId;
304 const char **acls = new const char *[2];
305 acls[0] = "ohos.permission.test1";
306 acls[1] = "ohos.permission.test2";
307 const char **perms = new const char *[2];
308 perms[0] = "ohos.permission.test1";
309 perms[1] = "ohos.permission.test2";
310 NativeTokenInfoParams infoInstance = {
311 .dcapsNum = 2,
312 .permsNum = 2,
313 .aclsNum = 2,
314 .dcaps = dcaps,
315 .perms = perms,
316 .acls = acls,
317 .processName = "GetAccessTokenId008",
318 .aplStr = "system_core",
319 };
320 tokenId = GetAccessTokenId(&infoInstance);
321 ASSERT_NE(tokenId, static_cast<uint32_t>(0));
322
323 delete[] perms;
324 delete[] dcaps;
325 delete[] acls;
326
327 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::AddPermissionUsedRecord(
328 tokenId, "ohos.permission.READ_CONTACTS", 1, 0));
329
330 PermissionUsedRequest request;
331 PermissionUsedResult result;
332 std::vector<std::string> permissionList;
333 BuildQueryRequest(tokenId, "", "", permissionList, request);
334
335 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
336 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
337 }
338
339 /**
340 * @tc.name: AddPermissionUsedRecord004
341 * @tc.desc: AddPermissionUsedRecord user_grant permission.
342 * @tc.type: FUNC
343 * @tc.require: issueI5P4IU
344 */
345 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord004, TestSize.Level1)
346 {
347 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
348 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.WRITE_CONTACTS", 0, 1));
349 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.LOCATION", 1, 1));
350
351 PermissionUsedRequest request;
352 PermissionUsedResult result;
353 std::vector<std::string> permissionList;
354 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
355 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
356
357 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
358 CheckPermissionUsedResult(request, result, 3, 2, 2);
359 }
360
361 /**
362 * @tc.name: AddPermissionUsedRecord005
363 * @tc.desc: AddPermissionUsedRecord user_grant permission.
364 * @tc.type: FUNC
365 * @tc.require: issueI5P4IU
366 */
367 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord005, TestSize.Level1)
368 {
369 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
370 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.LOCATION", 0, 1));
371
372 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.CAMERA", 0, 1));
373 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.LOCATION", 1, 0));
374
375
376 PermissionUsedRequest request;
377 PermissionUsedResult result;
378 std::vector<std::string> permissionList;
379 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
380 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
381
382 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
383 CheckPermissionUsedResult(request, result, 2, 1, 1);
384
385 BuildQueryRequest(g_tokenIdB, GetLocalDeviceUdid(), g_infoParmsB.bundleName, permissionList, request);
386 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
387
388 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
389 CheckPermissionUsedResult(request, result, 2, 1, 1);
390 }
391
392 /**
393 * @tc.name: AddPermissionUsedRecord006
394 * @tc.desc: AddPermissionUsedRecord permission combine records.
395 * @tc.type: FUNC
396 * @tc.require: issueI5P4IU
397 */
398 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord006, TestSize.Level1)
399 {
400 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
401 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
402 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
403 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
404
405 PermissionUsedRequest request;
406 PermissionUsedResult result;
407 std::vector<std::string> permissionList;
408 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
409 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
410 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
411
412 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
413 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
414 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[0].accessRecords.size());
415 CheckPermissionUsedResult(request, result, 1, 4, 0);
416
417 sleep(61);
418 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
419
420 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
421
422 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
423 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
424 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
425 ASSERT_EQ(static_cast<uint32_t>(2), result.bundleRecords[0].permissionRecords[0].accessRecords.size());
426 CheckPermissionUsedResult(request, result, 1, 5, 0);
427 }
428
429 /**
430 * @tc.name: AddPermissionUsedRecord007
431 * @tc.desc: AddPermissionUsedRecord user_grant permission.
432 * @tc.type: FUNC
433 * @tc.require: issueI5P4IU
434 */
435 HWTEST_F(PrivacyKitTest, AddPermissionUsedRecord007, TestSize.Level1)
436 {
437 std::vector<HapInfoParams> g_InfoParms_List;
438 std::vector<AccessTokenID> g_TokenId_List;
439 SetTokenID(g_InfoParms_List, g_TokenId_List, 100);
440 std::vector<std::string> addPermissionList = {
441 "ohos.permission.ANSWER_CALL",
442 "ohos.permission.READ_CALENDAR",
443 };
444 for (int32_t i = 0; i < 200; i++) {
445 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_TokenId_List[i % 100],
446 addPermissionList[i % 2], 1, 0));
447
448 PermissionUsedRequest request;
449 PermissionUsedResult result;
450 std::vector<std::string> permissionList;
451 BuildQueryRequest(g_TokenId_List[i % 100], GetLocalDeviceUdid(),
452 g_InfoParms_List[i % 100].bundleName, permissionList, request);
453 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
454 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
455 }
456 sleep(70);
457 for (int32_t i = 0; i < 100; i++) {
458 PermissionUsedRequest request;
459 PermissionUsedResult result;
460 std::vector<std::string> permissionList;
461 BuildQueryRequest(g_TokenId_List[i], GetLocalDeviceUdid(),
462 g_InfoParms_List[i].bundleName, permissionList, request);
463 request.flag = FLAG_PERMISSION_USAGE_DETAIL;
464
465 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
466 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
467 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
468 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords[0].accessRecords.size());
469 CheckPermissionUsedResult(request, result, 1, 2, 0);
470 }
471 DeleteTokenID(g_InfoParms_List);
472 }
473
474 /**
475 * @tc.name: RemovePermissionUsedRecords001
476 * @tc.desc: cannot RemovePermissionUsedRecords with illegal tokenId and deviceID.
477 * @tc.type: FUNC
478 * @tc.require: issueI5P4IU
479 */
480 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords001, TestSize.Level1)
481 {
482 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(0, ""));
483 }
484
485 /**
486 * @tc.name: RemovePermissionUsedRecords002
487 * @tc.desc: RemovePermissionUsedRecords with invalid tokenId and deviceID.
488 * @tc.type: FUNC
489 * @tc.require: issueI5P4IU
490 */
491 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords002, TestSize.Level1)
492 {
493 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
494 PermissionUsedRequest request;
495 PermissionUsedResult result;
496 std::vector<std::string> permissionList;
497 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
498
499 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(g_tokenIdA, "invalid_device"));
500 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
501 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
502
503 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(123, GetLocalDeviceUdid()));
504 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
505 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
506 }
507
508 /**
509 * @tc.name: RemovePermissionUsedRecords003
510 * @tc.desc: RemovePermissionUsedRecords with valid tokenId and deviceID.
511 * @tc.type: FUNC
512 * @tc.require: issueI5P4IU
513 */
514 HWTEST_F(PrivacyKitTest, RemovePermissionUsedRecords003, TestSize.Level1)
515 {
516 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
517 PermissionUsedRequest request;
518 PermissionUsedResult result;
519 std::vector<std::string> permissionList;
520 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
521
522 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RemovePermissionUsedRecords(g_tokenIdA, ""));
523 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
524 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
525 }
526
527 /**
528 * @tc.name: GetPermissionUsedRecords001
529 * @tc.desc: cannot GetPermissionUsedRecords with invalid query time and flag.
530 * @tc.type: FUNC
531 * @tc.require: issueI5P4IU
532 */
533 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords001, TestSize.Level1)
534 {
535 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
536 PermissionUsedRequest request;
537 PermissionUsedResult result;
538 std::vector<std::string> permissionList;
539 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
540 request.beginTimeMillis = -1;
541 request.endTimeMillis = -1;
542 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
543
544 request.beginTimeMillis = 3;
545 request.endTimeMillis = 1;
546 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
547
548 request.flag = (PermissionUsageFlag)-1;
549 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, result));
550 }
551
552 /**
553 * @tc.name: GetPermissionUsedRecords002
554 * @tc.desc: cannot GetPermissionUsedRecords with valid query time.
555 * @tc.type: FUNC
556 * @tc.require: issueI5P4IU
557 */
558 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords002, TestSize.Level1)
559 {
560 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
561 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
562 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CALENDAR", 1, 0));
563
564 PermissionUsedRequest request;
565 PermissionUsedResult result;
566 std::vector<std::string> permissionList;
567 // query by tokenId
568 BuildQueryRequest(g_tokenIdA, "", "", permissionList, request);
569 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
570 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
571 request.deviceId = GetLocalDeviceUdid();
572 request.bundleName = g_infoParmsA.bundleName;
573 CheckPermissionUsedResult(request, result, 3, 3, 0);
574
575 // query by unmatched tokenId, deviceId and bundle Name
576 BuildQueryRequest(123, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
577 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
578 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
579
580 // query by invalid permission Name
581 permissionList.clear();
582 permissionList.emplace_back("invalid permission");
583 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
584 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
585 ASSERT_EQ(static_cast<uint32_t>(0), result.bundleRecords.size());
586 }
587
588 /**
589 * @tc.name: GetPermissionUsedRecords003
590 * @tc.desc: can GetPermissionUsedRecords with valid query time.
591 * @tc.type: FUNC
592 * @tc.require: issueI5P4IU
593 */
594 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords003, TestSize.Level1)
595 {
596 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
597 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
598 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
599 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.MICROPHONE", 1, 0));
600
601 PermissionUsedRequest request;
602 PermissionUsedResult result;
603 std::vector<std::string> permissionList;
604 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
605 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
606 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
607 CheckPermissionUsedResult(request, result, 1, 4, 0);
608
609 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
610 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CALENDAR", 1, 0));
611 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.WRITE_CALENDAR", 1, 0));
612
613 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), g_infoParmsA.bundleName, permissionList, request);
614 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
615 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
616 CheckPermissionUsedResult(request, result, 4, 7, 0);
617 }
618
619 /**
620 * @tc.name: GetPermissionUsedRecords004
621 * @tc.desc: can GetPermissionUsedRecords with valid query time.
622 * @tc.type: FUNC
623 * @tc.require: issueI5P4IU
624 */
625 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecords004, TestSize.Level1)
626 {
627 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.CAMERA", 1, 0));
628 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, "ohos.permission.READ_CALENDAR", 1, 0));
629 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.CAMERA", 1, 0));
630 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdB, "ohos.permission.READ_CALENDAR", 1, 0));
631
632 PermissionUsedRequest request;
633 PermissionUsedResult result;
634 std::vector<std::string> permissionList;
635 BuildQueryRequest(0, GetLocalDeviceUdid(), "", permissionList, request);
636
637 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
638 if (result.bundleRecords.size() < static_cast<uint32_t>(2)) {
639 ASSERT_TRUE(false);
640 }
641 }
642
643 /**
644 * @tc.name: GetPermissionUsedRecordsAsync001
645 * @tc.desc: cannot GetPermissionUsedRecordsAsync with invalid query time.
646 * @tc.type: FUNC
647 * @tc.require: issueI5P4IU
648 */
649 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync001, TestSize.Level1)
650 {
651 std::string permission = "ohos.permission.CAMERA";
652 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, permission, 1, 0));
653 PermissionUsedRequest request;
654 std::vector<std::string> permissionList;
655 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), "", permissionList, request);
656 request.beginTimeMillis = -1;
657 request.endTimeMillis = -1;
658 OHOS::sptr<TestCallBack> callback(new TestCallBack());
659 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::GetPermissionUsedRecords(request, callback));
660 }
661
662 /**
663 * @tc.name: GetPermissionUsedRecordsAsync002
664 * @tc.desc: cannot GetPermissionUsedRecordsAsync with valid query time.
665 * @tc.type: FUNC
666 * @tc.require: issueI5P4IU
667 */
668 HWTEST_F(PrivacyKitTest, GetPermissionUsedRecordsAsync002, TestSize.Level1)
669 {
670 std::string permission = "ohos.permission.CAMERA";
671 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::AddPermissionUsedRecord(g_tokenIdA, permission, 1, 0));
672 PermissionUsedRequest request;
673 std::vector<std::string> permissionList;
674 BuildQueryRequest(g_tokenIdA, GetLocalDeviceUdid(), "", permissionList, request);
675 OHOS::sptr<TestCallBack> callback(new TestCallBack());
676 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, callback));
677 }
678
679 class CbCustomizeTest1 : public PermActiveStatusCustomizedCbk {
680 public:
CbCustomizeTest1(const std::vector<std::string> & permList)681 explicit CbCustomizeTest1(const std::vector<std::string> &permList)
682 : PermActiveStatusCustomizedCbk(permList)
683 {
684 GTEST_LOG_(INFO) << "CbCustomizeTest1 create";
685 }
686
~CbCustomizeTest1()687 ~CbCustomizeTest1()
688 {}
689
ActiveStatusChangeCallback(ActiveChangeResponse & result)690 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
691 {
692 type_ = result.type;
693 GTEST_LOG_(INFO) << "CbCustomizeTest1 ActiveChangeResponse";
694 GTEST_LOG_(INFO) << "CbCustomizeTest1 tokenid " << result.tokenID;
695 GTEST_LOG_(INFO) << "CbCustomizeTest1 permissionName " << result.permissionName;
696 GTEST_LOG_(INFO) << "CbCustomizeTest1 deviceId " << result.deviceId;
697 GTEST_LOG_(INFO) << "CbCustomizeTest1 type " << result.type;
698 }
699
700 ActiveChangeType type_ = PERM_INACTIVE;
701 };
702
703 class CbCustomizeTest2 : public PermActiveStatusCustomizedCbk {
704 public:
CbCustomizeTest2(const std::vector<std::string> & permList)705 explicit CbCustomizeTest2(const std::vector<std::string> &permList)
706 : PermActiveStatusCustomizedCbk(permList)
707 {
708 GTEST_LOG_(INFO) << "CbCustomizeTest2 create";
709 }
710
~CbCustomizeTest2()711 ~CbCustomizeTest2()
712 {}
713
ActiveStatusChangeCallback(ActiveChangeResponse & result)714 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
715 {
716 type_ = result.type;
717 GTEST_LOG_(INFO) << "CbCustomizeTest2 ActiveChangeResponse";
718 GTEST_LOG_(INFO) << "CbCustomizeTest2 tokenid " << result.tokenID;
719 GTEST_LOG_(INFO) << "CbCustomizeTest2 permissionName " << result.permissionName;
720 GTEST_LOG_(INFO) << "CbCustomizeTest2 deviceId " << result.deviceId;
721 GTEST_LOG_(INFO) << "CbCustomizeTest2 type " << result.type;
722 }
723
724 ActiveChangeType type_;
725 };
726
727 /**
728 * @tc.name: RegisterPermActiveStatusCallback001
729 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
730 * @tc.type: FUNC
731 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
732 */
733 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback001, TestSize.Level1)
734 {
735 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
736
737 auto callbackPtr = std::make_shared<CbCustomizeTest1>(permList);
738 callbackPtr->type_ = PERM_INACTIVE;
739
740 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
741
742 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
743
744 usleep(500000); // 500000us = 0.5s
745 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
746
747 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
748
749 usleep(500000); // 500000us = 0.5s
750 ASSERT_EQ(PERM_INACTIVE, callbackPtr->type_);
751
752 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
753 callbackPtr->type_ = PERM_INACTIVE;
754
755 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
756 ASSERT_EQ(PERM_INACTIVE, callbackPtr->type_);
757
758 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
759 ASSERT_EQ(PERM_INACTIVE, callbackPtr->type_);
760 }
761
762 class CbCustomizeTest3 : public PermActiveStatusCustomizedCbk {
763 public:
CbCustomizeTest3(const std::vector<std::string> & permList)764 explicit CbCustomizeTest3(const std::vector<std::string> &permList)
765 : PermActiveStatusCustomizedCbk(permList)
766 {}
~CbCustomizeTest3()767 ~CbCustomizeTest3()
768 {}
ActiveStatusChangeCallback(ActiveChangeResponse & result)769 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
770 {
771 type_ = result.type;
772 }
773 ActiveChangeType type_ = PERM_INACTIVE;
774 };
775
776 class CbCustomizeTest4 : public StateCustomizedCbk {
777 public:
CbCustomizeTest4()778 CbCustomizeTest4()
779 {}
780
~CbCustomizeTest4()781 ~CbCustomizeTest4()
782 {}
783
StateChangeNotify(AccessTokenID tokenId,bool isShow)784 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
785 {}
786 };
787
788 /**
789 * @tc.name: RegisterPermActiveStatusCallback002
790 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
791 * @tc.type: FUNC
792 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
793 */
794 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback002, TestSize.Level1)
795 {
796 std::vector<std::string> permList1 = {"ohos.permission.CAMERA"};
797 auto callbackPtr1 = std::make_shared<CbCustomizeTest1>(permList1);
798 callbackPtr1->type_ = PERM_INACTIVE;
799
800 std::vector<std::string> permList2 = {"ohos.permission.MICROPHONE"};
801 auto callbackPtr2 = std::make_shared<CbCustomizeTest2>(permList2);
802 callbackPtr2->type_ = PERM_INACTIVE;
803
804 std::vector<std::string> permList3 = {};
805 auto callbackPtr3 = std::make_shared<CbCustomizeTest2>(permList3);
806 callbackPtr3->type_ = PERM_INACTIVE;
807
808 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
809 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr2));
810 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr3));
811
812 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
813
814 usleep(500000); // 500000us = 0.5s
815 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr1->type_);
816 ASSERT_EQ(PERM_INACTIVE, callbackPtr2->type_);
817 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr3->type_);
818
819 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA"));
820
821 usleep(500000); // 500000us = 0.5s
822 ASSERT_EQ(PERM_INACTIVE, callbackPtr1->type_);
823 ASSERT_EQ(PERM_INACTIVE, callbackPtr3->type_);
824
825 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE"));
826
827 usleep(500000); // 500000us = 0.5s
828 ASSERT_EQ(PERM_INACTIVE, callbackPtr1->type_);
829 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr2->type_);
830
831 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE"));
832
833 usleep(500000); // 500000us = 0.5s
834 ASSERT_EQ(PERM_INACTIVE, callbackPtr2->type_);
835
836 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
837 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr2));
838 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr3));
839 }
840
841 /**
842 * @tc.name: RegisterPermActiveStatusCallback003
843 * @tc.desc: Register callback with permList which contains 1025 permissions.
844 * @tc.type: FUNC
845 * @tc.require: issueI5NT1X
846 */
847 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback003, TestSize.Level1)
848 {
849 std::vector<std::string> permList;
850 for (int32_t i = 0; i < 1024; i++) { // 1024 is the limitation
851 permList.emplace_back("ohos.permission.CAMERA");
852 }
853 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList);
854 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
855 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
856
857 permList.emplace_back("ohos.permission.MICROPHONE");
858 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
859 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
860 }
861
862 /**
863 * @tc.name: RegisterPermActiveStatusCallback004
864 * @tc.desc: Register callback 201 times.
865 * @tc.type: FUNC
866 * @tc.require: issueI5NT1X
867 */
868 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback004, TestSize.Level1)
869 {
870 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
871 std::vector<std::shared_ptr<CbCustomizeTest3>> callbackList;
872
873 for (int32_t i = 0; i <= 200; i++) { // 200 is the max size
874 if (i == 200) { // 200 is the max size
875 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
876 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
877 PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
878 break;
879 }
880 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
881 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
882 callbackList.emplace_back(callbackPtr);
883 }
884 for (int32_t i = 0; i < 200; i++) { // release 200 callback
885 auto callbackPtr = callbackList[i];
886 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
887 }
888 callbackList.clear();
889 }
890
891 /**
892 * @tc.name: RegisterPermActiveStatusCallback005
893 * @tc.desc: RegisterPermActiveStatusCallback with valid permission.
894 * @tc.type: FUNC
895 * @tc.require: issueI5NT1X
896 */
897 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback005, TestSize.Level1)
898 {
899 std::vector<std::string> permList = {"ohos.permission.INVALD"};
900
901 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
902 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
903
904 std::vector<std::string> permList1 = {"ohos.permission.INVALD", "ohos.permission.CAMERA"};
905 auto callbackPtr1 = std::make_shared<CbCustomizeTest3>(permList1);
906 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr1));
907 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr1));
908 }
909
910 /**
911 * @tc.name: RegisterPermActiveStatusCallback006
912 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid callback.
913 * @tc.type: FUNC
914 * @tc.require: issueI5NT1X
915 */
916 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback006, TestSize.Level1)
917 {
918 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
919 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
920 ASSERT_EQ(PrivacyError::ERR_CALLBACK_NOT_EXIST, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
921 }
922
923 /**
924 * @tc.name: RegisterPermActiveStatusCallback007
925 * @tc.desc: RegisterPermActiveStatusCallback with valid permission repeatedly.
926 * @tc.type: FUNC
927 * @tc.require: issueI5NT1X
928 */
929 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback007, TestSize.Level1)
930 {
931 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
932 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
933 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
934 ASSERT_EQ(PrivacyError::ERR_CALLBACK_ALREADY_EXIST, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
935 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
936 ASSERT_EQ(PrivacyError::ERR_CALLBACK_NOT_EXIST, PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr));
937 }
938
939 /**
940 * @tc.name: RegisterPermActiveStatusCallback008
941 * @tc.desc: register and startusing three permission.
942 * @tc.type: FUNC
943 * @tc.require: issueI5SZHG
944 */
945 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback008, TestSize.Level1)
946 {
947 std::vector<std::string> permList = {
948 "ohos.permission.CAMERA",
949 "ohos.permission.MICROPHONE",
950 "ohos.permission.LOCATION"
951 };
952 auto callbackPtr = std::make_shared<CbCustomizeTest3>(permList);
953 int32_t res = PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr);
954 ASSERT_EQ(RET_NO_ERROR, res);
955 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA");
956 ASSERT_EQ(RET_NO_ERROR, res);
957 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE");
958 ASSERT_EQ(RET_NO_ERROR, res);
959 res = PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.LOCATION");
960 ASSERT_EQ(RET_NO_ERROR, res);
961 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.CAMERA");
962 ASSERT_EQ(RET_NO_ERROR, res);
963 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.MICROPHONE");
964 ASSERT_EQ(RET_NO_ERROR, res);
965 res = PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.LOCATION");
966 ASSERT_EQ(RET_NO_ERROR, res);
967 res = PrivacyKit::UnRegisterPermActiveStatusCallback(callbackPtr);
968 ASSERT_EQ(RET_NO_ERROR, res);
969 }
970
971 /**
972 * @tc.name: IsAllowedUsingPermission001
973 * @tc.desc: IsAllowedUsingPermission with invalid tokenId or permission.
974 * @tc.type: FUNC
975 * @tc.require: issueI5RWX3 issueI5RWX8
976 */
977 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission001, TestSize.Level1)
978 {
979 std::string permissionName = "ohos.permission.CAMERA";
980 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
981 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(0, permissionName));
982 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, ""));
983 }
984
985 /**
986 * @tc.name: IsAllowedUsingPermission002
987 * @tc.desc: IsAllowedUsingPermission with no permission.
988 * @tc.type: FUNC
989 * @tc.require: issueI5RWX3 issueI5RWX8
990 */
991 HWTEST_F(PrivacyKitTest, IsAllowedUsingPermission002, TestSize.Level1)
992 {
993 SetSelfTokenID(g_selfTokenId);
994 std::string permissionName = "ohos.permission.CAMERA";
995 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(g_tokenIdE, permissionName));
996 }
997 /**
998 * @tc.name: StartUsingPermission001
999 * @tc.desc: StartUsingPermission with invalid tokenId or permission.
1000 * @tc.type: FUNC
1001 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1002 */
1003 HWTEST_F(PrivacyKitTest, StartUsingPermission001, TestSize.Level1)
1004 {
1005 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA"));
1006 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "permissionName"));
1007 }
1008
1009 /**
1010 * @tc.name: StartUsingPermission002
1011 * @tc.desc: StartUsingPermission is called twice with same permission.
1012 * @tc.type: FUNC
1013 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1014 */
1015 HWTEST_F(PrivacyKitTest, StartUsingPermission002, TestSize.Level1)
1016 {
1017 std::string permissionName = "ohos.permission.CAMERA";
1018 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1019 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
1020 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1021 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1022 }
1023
1024 /**
1025 * @tc.name: StopUsingPermission003
1026 * @tc.desc: Add record when StopUsingPermission is called.
1027 * @tc.type: FUNC
1028 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1029 */
1030 HWTEST_F(PrivacyKitTest, StartUsingPermission003, TestSize.Level1)
1031 {
1032 std::string permissionName = "ohos.permission.CAMERA";
1033 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1034
1035 usleep(500000); // 500000us = 0.5s
1036 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1037
1038 PermissionUsedRequest request;
1039 PermissionUsedResult result;
1040 std::vector<std::string> permissionList;
1041 BuildQueryRequest(g_tokenIdE, GetLocalDeviceUdid(), g_infoParmsE.bundleName, permissionList, request);
1042 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
1043 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
1044 ASSERT_EQ(g_tokenIdE, result.bundleRecords[0].tokenId);
1045 ASSERT_EQ(g_infoParmsE.bundleName, result.bundleRecords[0].bundleName);
1046 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
1047 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[0].accessCount);
1048 }
1049
1050 /**
1051 * @tc.name: StartUsingPermission004
1052 * @tc.desc: StartUsingPermission basic functional verification
1053 * @tc.type: FUNC
1054 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1055 */
1056 HWTEST_F(PrivacyKitTest, StartUsingPermission004, TestSize.Level1)
1057 {
1058 std::string permissionName = "ohos.permission.CAMERA";
1059 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1060 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1061 }
1062
1063 /**
1064 * @tc.name: StartUsingPermission005
1065 * @tc.desc: StartUsingPermission with invalid tokenId or permission.
1066 * @tc.type: FUNC
1067 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1068 */
1069 HWTEST_F(PrivacyKitTest, StartUsingPermission005, TestSize.Level1)
1070 {
1071 std::string permissionName = "ohos.permission.UtTestInvalidPermission";
1072 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1073 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA"));
1074 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::StartUsingPermission(1, "ohos.permission.CAMERA"));
1075 }
1076
1077 /**
1078 * @tc.name: StartUsingPermission006
1079 * @tc.desc: StartUsingPermission with invalid tokenId or permission or callback.
1080 * @tc.type: FUNC
1081 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1082 */
1083 HWTEST_F(PrivacyKitTest, StartUsingPermission006, TestSize.Level1)
1084 {
1085 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1086 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1087 PrivacyKit::StartUsingPermission(0, "ohos.permission.CAMERA", callbackPtr));
1088 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1089 PrivacyKit::StartUsingPermission(g_tokenIdE, "", callbackPtr));
1090 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1091 PrivacyKit::StartUsingPermission(g_tokenIdE, "ohos.permission.CAMERA", nullptr));
1092 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
1093 PrivacyKit::StartUsingPermission(g_tokenIdE, "permissionName", callbackPtr));
1094 }
1095
1096 /**
1097 * @tc.name: StartUsingPermission007
1098 * @tc.desc: StartUsingPermission is called twice with same callback.
1099 * @tc.type: FUNC
1100 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1101 */
1102 HWTEST_F(PrivacyKitTest, StartUsingPermission007, TestSize.Level1)
1103 {
1104 std::string permissionName = "ohos.permission.CAMERA";
1105 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1106 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1107 ASSERT_EQ(PrivacyError::ERR_CALLBACK_ALREADY_EXIST,
1108 PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1109 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1110 }
1111
1112 /**
1113 * @tc.name: StopUsingPermission008
1114 * @tc.desc: Add record when StopUsingPermission is called.
1115 * @tc.type: FUNC
1116 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1117 */
1118 HWTEST_F(PrivacyKitTest, StopUsingPermission008, TestSize.Level1)
1119 {
1120 std::string permissionName = "ohos.permission.CAMERA";
1121 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1122 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1123
1124 usleep(500000); // 500000us = 0.5s
1125 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1126
1127 PermissionUsedRequest request;
1128 PermissionUsedResult result;
1129 std::vector<std::string> permissionList;
1130 BuildQueryRequest(g_tokenIdE, GetLocalDeviceUdid(), g_infoParmsE.bundleName, permissionList, request);
1131 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::GetPermissionUsedRecords(request, result));
1132 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords.size());
1133 ASSERT_EQ(g_tokenIdE, result.bundleRecords[0].tokenId);
1134 ASSERT_EQ(g_infoParmsE.bundleName, result.bundleRecords[0].bundleName);
1135 ASSERT_EQ(static_cast<uint32_t>(1), result.bundleRecords[0].permissionRecords.size());
1136 ASSERT_EQ(1, result.bundleRecords[0].permissionRecords[0].accessCount);
1137 }
1138
1139 /**
1140 * @tc.name: StartUsingPermission009
1141 * @tc.desc: StartUsingPermission basic functional verification
1142 * @tc.type: FUNC
1143 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
1144 */
1145 HWTEST_F(PrivacyKitTest, StartUsingPermission009, TestSize.Level1)
1146 {
1147 std::string permissionName = "ohos.permission.CAMERA";
1148 auto callbackPtr = std::make_shared<CbCustomizeTest4>();
1149 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName, callbackPtr));
1150 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1151 }
1152
1153 /**
1154 * @tc.name: StopUsingPermission001
1155 * @tc.desc: StopUsingPermission with invalid tokenId or permission.
1156 * @tc.type: FUNC
1157 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1158 */
1159 HWTEST_F(PrivacyKitTest, StopUsingPermission001, TestSize.Level1)
1160 {
1161 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, "ohos.permission.CAMERA"));
1162 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, "permissionName"));
1163 }
1164
1165 /**
1166 * @tc.name: StopUsingPermission002
1167 * @tc.desc: StopUsingPermission cancel permissions that you haven't started using
1168 * @tc.type: FUNC
1169 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1170 */
1171 HWTEST_F(PrivacyKitTest, StopUsingPermission002, TestSize.Level1)
1172 {
1173 std::string permissionName = "ohos.permission.CAMERA";
1174 ASSERT_EQ(
1175 PrivacyError::ERR_PERMISSION_NOT_START_USING, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1176 }
1177
1178 /**
1179 * @tc.name: StopUsingPermission003
1180 * @tc.desc: StopUsingPermission invalid tokenid, permission
1181 * @tc.type: FUNC
1182 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1183 */
1184 HWTEST_F(PrivacyKitTest, StopUsingPermission003, TestSize.Level1)
1185 {
1186 std::string permissionName = "ohos.permission.CAMERA";
1187 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1188 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
1189 PrivacyKit::StopUsingPermission(g_tokenIdE, "ohos.permission.uttestpermission"));
1190 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(0, permissionName));
1191 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1192 }
1193
1194 /**
1195 * @tc.name: StopUsingPermission004
1196 * @tc.desc: StopUsingPermission stop a use repeatedly
1197 * @tc.type: FUNC
1198 * @tc.require: issueI5NT1X issueI5P4IU issueI5P530
1199 */
1200 HWTEST_F(PrivacyKitTest, StopUsingPermission004, TestSize.Level1)
1201 {
1202 std::string permissionName = "ohos.permission.CAMERA";
1203 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StartUsingPermission(g_tokenIdE, permissionName));
1204 ASSERT_EQ(RET_NO_ERROR, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1205 ASSERT_EQ(
1206 PrivacyError::ERR_PERMISSION_NOT_START_USING, PrivacyKit::StopUsingPermission(g_tokenIdE, permissionName));
1207 }
1208
1209 /**
1210 * @tc.name: StopUsingPermission005
1211 * @tc.desc: stop use whith native token
1212 * @tc.type: FUNC
1213 * @tc.require: issueI5SZHG
1214 */
1215 HWTEST_F(PrivacyKitTest, StopUsingPermission005, TestSize.Level1)
1216 {
1217 AccessTokenID tokenId = AccessTokenKit::GetNativeTokenId("privacy_service");
1218 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST, PrivacyKit::StopUsingPermission(tokenId, "ohos.permission.CAMERA"));
1219 }
1220
1221 class TestCallBack1 : public StateChangeCallbackStub {
1222 public:
1223 TestCallBack1() = default;
1224 virtual ~TestCallBack1() = default;
1225
StateChangeNotify(AccessTokenID tokenId,bool isShowing)1226 void StateChangeNotify(AccessTokenID tokenId, bool isShowing)
1227 {
1228 GTEST_LOG_(INFO) << "StateChangeNotify, tokenId is " << tokenId << ", isShowing is " << isShowing;
1229 }
1230 };
1231
1232 /**
1233 * @tc.name: OnRemoteRequest001
1234 * @tc.desc: StateChangeCallbackStub::OnRemoteRequest function test
1235 * @tc.type: FUNC
1236 * @tc.require: issueI61A6M
1237 */
1238 HWTEST_F(PrivacyKitTest, OnRemoteRequest001, TestSize.Level1)
1239 {
1240 AccessTokenID tokenId = 123; // 123 is random input
1241 bool isShowing = false;
1242
1243 TestCallBack1 callback;
1244 OHOS::MessageParcel data;
1245 ASSERT_EQ(true, data.WriteInterfaceToken(IStateChangeCallback::GetDescriptor()));
1246 ASSERT_EQ(true, data.WriteUint32(tokenId));
1247 ASSERT_EQ(true, data.WriteBool(isShowing));
1248
1249 OHOS::MessageParcel reply;
1250 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
1251 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(IStateChangeCallback::STATE_CHANGE_CALLBACK),
1252 data, reply, option)); // descriptor true + msgCode true
1253
1254 ASSERT_EQ(true, data.WriteInterfaceToken(IStateChangeCallback::GetDescriptor()));
1255 ASSERT_EQ(true, data.WriteUint32(tokenId));
1256 ASSERT_EQ(true, data.WriteBool(isShowing));
1257 uint32_t code = 10;
1258 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
1259
1260 std::string descriptor = "I don't know";
1261 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
1262 ASSERT_EQ(true, data.WriteUint32(tokenId));
1263 ASSERT_EQ(true, data.WriteBool(isShowing));
1264 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(IStateChangeCallback::STATE_CHANGE_CALLBACK),
1265 data, reply, option)); // descriptor flase + msgCode true
1266 }
1267
1268 class TestCallBack2 : public OnPermissionUsedRecordCallbackStub {
1269 public:
1270 TestCallBack2() = default;
1271 virtual ~TestCallBack2() = default;
1272
OnQueried(OHOS::ErrCode code,PermissionUsedResult & result)1273 void OnQueried(OHOS::ErrCode code, PermissionUsedResult& result)
1274 {
1275 GTEST_LOG_(INFO) << "OnQueried, code is " << code;
1276 }
1277 };
1278
1279 /**
1280 * @tc.name: OnRemoteRequest002
1281 * @tc.desc: OnPermissionUsedRecordCallbackStub::OnRemoteRequest function test
1282 * @tc.type: FUNC
1283 * @tc.require: issueI61A6M
1284 */
1285 HWTEST_F(PrivacyKitTest, OnRemoteRequest002, TestSize.Level1)
1286 {
1287 g_permissionUsedRecord.accessRecords.emplace_back(g_usedRecordDetail);
1288 g_bundleUsedRecord.permissionRecords.emplace_back(g_permissionUsedRecord);
1289
1290 int32_t errCode = 123; // 123 is random input
1291 PermissionUsedResultParcel resultParcel;
1292 resultParcel.result = {
1293 .beginTimeMillis = 0L,
1294 .endTimeMillis = 0L,
1295 };
1296 resultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord);
1297
1298 TestCallBack2 callback;
1299 OHOS::MessageParcel data;
1300 std::string descriptor = "I don't know";
1301 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
1302 ASSERT_EQ(true, data.ReadInt32(errCode));
1303 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
1304
1305 OHOS::MessageParcel reply;
1306 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
1307 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(OnPermissionUsedRecordCallback::ON_QUERIED),
1308 data, reply, option)); // descriptor false
1309
1310 ASSERT_EQ(true, data.WriteInterfaceToken(OnPermissionUsedRecordCallback::GetDescriptor()));
1311 ASSERT_EQ(true, data.ReadInt32(errCode));
1312 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
1313 uint32_t code = 10;
1314 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
1315
1316 ASSERT_EQ(true, data.WriteInterfaceToken(OnPermissionUsedRecordCallback::GetDescriptor()));
1317 ASSERT_EQ(true, data.ReadInt32(errCode));
1318 ASSERT_EQ(true, data.WriteParcelable(&resultParcel));
1319 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(OnPermissionUsedRecordCallback::ON_QUERIED),
1320 data, reply, option)); // descriptor flase + msgCode true + error != 0
1321 }
1322
1323 class TestCallBack3 : public PermActiveStatusChangeCallbackStub {
1324 public:
1325 TestCallBack3() = default;
1326 virtual ~TestCallBack3() = default;
1327
ActiveStatusChangeCallback(ActiveChangeResponse & result)1328 void ActiveStatusChangeCallback(ActiveChangeResponse& result)
1329 {
1330 GTEST_LOG_(INFO) << "ActiveStatusChangeCallback, result is " << result.type;
1331 }
1332 };
1333
1334 /**
1335 * @tc.name: OnRemoteRequest003
1336 * @tc.desc: PermActiveStatusChangeCallbackStub::OnRemoteRequest function test
1337 * @tc.type: FUNC
1338 * @tc.require: issueI61A6M
1339 */
1340 HWTEST_F(PrivacyKitTest, OnRemoteRequest003, TestSize.Level1)
1341 {
1342 ActiveChangeResponse response = {
1343 .tokenID = 123,
1344 .permissionName = "ohos.permission.CAMERA",
1345 .deviceId = "I don't know",
1346 .type = ActiveChangeType::PERM_INACTIVE
1347 };
1348
1349 ActiveChangeResponseParcel responseParcel;
1350 responseParcel.changeResponse = response;
1351
1352 TestCallBack3 callback;
1353 OHOS::MessageParcel data;
1354 std::string descriptor = "I don't know";
1355 data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
1356 ASSERT_EQ(true, data.WriteParcelable(&responseParcel));
1357
1358 OHOS::MessageParcel reply;
1359 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
1360 ASSERT_NE(0, callback.OnRemoteRequest(static_cast<uint32_t>(
1361 IPermActiveStatusCallback::PERM_ACTIVE_STATUS_CHANGE), data, reply, option)); // descriptor false
1362
1363 ASSERT_EQ(true, data.WriteInterfaceToken(IPermActiveStatusCallback::GetDescriptor()));
1364 ASSERT_EQ(true, data.WriteParcelable(&responseParcel));
1365 uint32_t code = 10;
1366 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false
1367 }
1368
1369 /**
1370 * @tc.name: ActiveStatusChangeCallback001
1371 * @tc.desc: PermActiveStatusChangeCallback::ActiveStatusChangeCallback function test
1372 * @tc.type: FUNC
1373 * @tc.require: issueI61A6M
1374 */
1375 HWTEST_F(PrivacyKitTest, ActiveStatusChangeCallback001, TestSize.Level1)
1376 {
1377 ActiveChangeResponse response = {
1378 .tokenID = 123,
1379 .permissionName = "ohos.permission.CAMERA",
1380 .deviceId = "I don't know",
1381 .type = ActiveChangeType::PERM_INACTIVE
1382 };
1383 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
1384 std::shared_ptr<PermActiveStatusCustomizedCbk> callbackPtr = std::make_shared<CbCustomizeTest1>(permList);
1385 OHOS::sptr<PermActiveStatusChangeCallback> callback = new (
1386 std::nothrow) PermActiveStatusChangeCallback(callbackPtr);
1387 ASSERT_NE(nullptr, callback);
1388 callback->ActiveStatusChangeCallback(response); // customizedCallback_ is null
1389 }
1390
1391 /**
1392 * @tc.name: StateChangeNotify001
1393 * @tc.desc: StateChangeCallback::StateChangeNotify function test
1394 * @tc.type: FUNC
1395 * @tc.require: issueI61A6M
1396 */
1397 HWTEST_F(PrivacyKitTest, StateChangeNotify001, TestSize.Level1)
1398 {
1399 AccessTokenID tokenId = 123; // 123 is random input
1400 bool isShowing = false;
1401 std::shared_ptr<StateCustomizedCbk> callbackPtr = std::make_shared<CbCustomizeTest4>();
1402 OHOS::sptr<StateChangeCallback> callback = new (std::nothrow) StateChangeCallback(callbackPtr);
1403 ASSERT_NE(nullptr, callback);
1404 callback->StateChangeNotify(tokenId, isShowing); // customizedCallback_ is null
1405 }
1406
1407 /**
1408 * @tc.name: RegisterPermActiveStatusCallback009
1409 * @tc.desc: PrivacyManagerClient::RegisterPermActiveStatusCallback function test
1410 * @tc.type: FUNC
1411 * @tc.require: issueI61A6M
1412 */
1413 HWTEST_F(PrivacyKitTest, RegisterPermActiveStatusCallback009, TestSize.Level1)
1414 {
1415 std::shared_ptr<PermActiveStatusCustomizedCbk> callback = nullptr;
1416 ASSERT_EQ(nullptr, callback);
1417 PrivacyManagerClient::GetInstance().RegisterPermActiveStatusCallback(callback); // callback is null
1418 }
1419
1420 /**
1421 * @tc.name: InitProxy001
1422 * @tc.desc: PrivacyManagerClient::InitProxy function test
1423 * @tc.type: FUNC
1424 * @tc.require: issueI61A6M
1425 */
1426 HWTEST_F(PrivacyKitTest, InitProxy001, TestSize.Level1)
1427 {
1428 ASSERT_NE(nullptr, PrivacyManagerClient::GetInstance().proxy_);
1429 OHOS::sptr<IPrivacyManager> proxy = PrivacyManagerClient::GetInstance().proxy_; // backup
1430 PrivacyManagerClient::GetInstance().proxy_ = nullptr;
1431 ASSERT_EQ(nullptr, PrivacyManagerClient::GetInstance().proxy_);
1432 PrivacyManagerClient::GetInstance().InitProxy(); // proxy_ is null
1433 PrivacyManagerClient::GetInstance().proxy_ = proxy; // recovery
1434 }
1435
1436 /**
1437 * @tc.name: StartUsingPermission008
1438 * @tc.desc: PrivacyKit:: function test input invalid
1439 * @tc.type: FUNC
1440 * @tc.require: issueI61A6M
1441 */
1442 HWTEST_F(PrivacyKitTest, StartUsingPermission008, TestSize.Level1)
1443 {
1444 AccessTokenID tokenId = 0;
1445 std::string permissionName;
1446 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StartUsingPermission(tokenId, permissionName));
1447 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::StopUsingPermission(tokenId, permissionName));
1448 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PrivacyKit::RemovePermissionUsedRecords(tokenId, permissionName));
1449 ASSERT_EQ(false, PrivacyKit::IsAllowedUsingPermission(tokenId, permissionName));
1450 }