1 /*
2 * Copyright (c) 2023 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 #include "get_self_permission_state_test.h"
16 #include "nativetoken_kit.h"
17 #include "test_common.h"
18 #include "token_setproc.h"
19
20 namespace OHOS {
21 namespace Security {
22 namespace AccessToken {
23 using namespace testing::ext;
24 namespace {
25 static const int MAX_PERMISSION_SIZE = 1024;
26 static const std::string TEST_BUNDLE_NAME = "ohos";
27 static const int TEST_USER_ID = 0;
28 static const std::string LOCATION_PERMISSION = "ohos.permission.LOCATION";
29 static const std::string APPROXIMATELY_LOCATION_PERMISSION = "ohos.permission.APPROXIMATELY_LOCATION";
30 static const std::string LOCATION_IN_BACKGROUND_PERMISSION = "ohos.permission.LOCATION_IN_BACKGROUND";
31 PermissionStateFull g_permTestState1 = {
32 .permissionName = LOCATION_PERMISSION,
33 .isGeneral = true,
34 .resDeviceID = {"local"},
35 .grantStatus = {PermissionState::PERMISSION_DENIED},
36 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG},
37 };
38
39 PermissionStateFull g_permTestState2 = {
40 .permissionName = "ohos.permission.MICROPHONE",
41 .isGeneral = true,
42 .resDeviceID = {"local"},
43 .grantStatus = {PermissionState::PERMISSION_DENIED},
44 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
45 };
46
47 PermissionStateFull g_permTestState3 = {
48 .permissionName = "ohos.permission.WRITE_CALENDAR",
49 .isGeneral = true,
50 .resDeviceID = {"local"},
51 .grantStatus = {PermissionState::PERMISSION_DENIED},
52 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
53 };
54
55 PermissionStateFull g_permTestState4 = {
56 .permissionName = "ohos.permission.READ_IMAGEVIDEO",
57 .isGeneral = true,
58 .resDeviceID = {"local"},
59 .grantStatus = {PermissionState::PERMISSION_GRANTED},
60 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
61 };
62
63 HapInfoParams g_infoManager = {
64 .userID = 1,
65 .bundleName = "accesstoken_test",
66 .instIndex = 0,
67 .appIDDesc = "test2",
68 .apiVersion = 8 // 8: api version
69 };
70
71 HapPolicyParams g_policy = {
72 .apl = APL_NORMAL,
73 .domain = "domain",
74 .permStateList = {g_permTestState1, g_permTestState2, g_permTestState3, g_permTestState4}
75 };
76
77 static uint64_t g_selfTokenId = 0;
78 }
79
SetUpTestCase()80 void GetSelfPermissionStateTest::SetUpTestCase()
81 {
82 g_selfTokenId = GetSelfTokenID();
83 TestCommon::SetTestEvironment(g_selfTokenId);
84 }
85
TearDownTestCase()86 void GetSelfPermissionStateTest::TearDownTestCase()
87 {
88 ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId));
89 TestCommon::ResetTestEvironment();
90 }
91
SetUp()92 void GetSelfPermissionStateTest::SetUp()
93 {
94 HapInfoParams info = {
95 .userID = TEST_USER_ID,
96 .bundleName = TEST_BUNDLE_NAME,
97 .instIndex = 0,
98 .appIDDesc = "appIDDesc",
99 .apiVersion = 8 // 8: api version
100 };
101
102 AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(info, g_policy);
103 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
104 ASSERT_NE(tokenId, INVALID_TOKENID);
105 ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx));
106 }
107
TearDown()108 void GetSelfPermissionStateTest::TearDown()
109 {
110 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
111 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
112 if (tokenId != INVALID_TOKENID) {
113 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId));
114 }
115 }
116
GetPermsList1(std::vector<PermissionListState> & permsList1)117 void GetPermsList1(std::vector<PermissionListState> &permsList1)
118 {
119 PermissionListState perm1 = {
120 .permissionName = LOCATION_PERMISSION,
121 .state = SETTING_OPER,
122 };
123 PermissionListState perm2 = {
124 .permissionName = "ohos.permission.MICROPHONE",
125 .state = SETTING_OPER,
126 };
127 PermissionListState perm3 = {
128 .permissionName = "ohos.permission.WRITE_CALENDAR",
129 .state = SETTING_OPER,
130 };
131 PermissionListState perm4 = {
132 .permissionName = "ohos.permission.READ_IMAGEVIDEO",
133 .state = SETTING_OPER,
134 };
135 permsList1.emplace_back(perm1);
136 permsList1.emplace_back(perm2);
137 permsList1.emplace_back(perm3);
138 permsList1.emplace_back(perm4);
139 }
140
GetPermsList2(std::vector<PermissionListState> & permsList2)141 void GetPermsList2(std::vector<PermissionListState> &permsList2)
142 {
143 PermissionListState perm3 = {
144 .permissionName = "ohos.permission.WRITE_CALENDAR",
145 .state = SETTING_OPER,
146 };
147 PermissionListState perm4 = {
148 .permissionName = "ohos.permission.READ_IMAGEVIDEO",
149 .state = SETTING_OPER,
150 };
151 permsList2.emplace_back(perm3);
152 permsList2.emplace_back(perm4);
153 }
154
155 /**
156 * @tc.name: GetSelfPermissionsState001
157 * @tc.desc: get permission list state
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState001, TestSize.Level0)
162 {
163 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
164 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
165 ASSERT_NE(INVALID_TOKENID, tokenID);
166
167 std::vector<PermissionListState> permsList1;
168 GetPermsList1(permsList1);
169 PermissionGrantInfo info;
170 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList1, info);
171 ASSERT_EQ(DYNAMIC_OPER, ret);
172 ASSERT_EQ(static_cast<uint32_t>(4), permsList1.size());
173 ASSERT_EQ(DYNAMIC_OPER, permsList1[0].state);
174 ASSERT_EQ(DYNAMIC_OPER, permsList1[1].state);
175 ASSERT_EQ(SETTING_OPER, permsList1[2].state);
176 ASSERT_EQ(PASS_OPER, permsList1[3].state);
177 ASSERT_EQ(LOCATION_PERMISSION, permsList1[0].permissionName);
178 ASSERT_EQ("ohos.permission.MICROPHONE", permsList1[1].permissionName);
179 ASSERT_EQ("ohos.permission.WRITE_CALENDAR", permsList1[2].permissionName);
180 ASSERT_EQ("ohos.permission.READ_IMAGEVIDEO", permsList1[3].permissionName);
181
182 PermissionListState perm5 = {
183 .permissionName = "ohos.permission.testPermDef5",
184 .state = SETTING_OPER,
185 };
186 permsList1.emplace_back(perm5);
187 ret = AccessTokenKit::GetSelfPermissionsState(permsList1, info);
188 ASSERT_EQ(INVALID_OPER, permsList1[4].state);
189 ASSERT_EQ(DYNAMIC_OPER, ret);
190
191 std::vector<PermissionListState> permsList2;
192 GetPermsList2(permsList2);
193 ret = AccessTokenKit::GetSelfPermissionsState(permsList2, info);
194 ASSERT_EQ(SETTING_OPER, permsList2[0].state);
195 ASSERT_EQ(PASS_OPER, permsList2[1].state);
196 ASSERT_EQ(PASS_OPER, ret);
197
198 permsList2.emplace_back(perm5);
199 ret = AccessTokenKit::GetSelfPermissionsState(permsList2, info);
200 ASSERT_EQ(SETTING_OPER, permsList2[0].state);
201 ASSERT_EQ(PASS_OPER, permsList2[1].state);
202 ASSERT_EQ(INVALID_OPER, permsList2[2].state);
203 ASSERT_EQ(PASS_OPER, ret);
204
205 std::vector<PermissionListState> permsList3;
206 permsList3.emplace_back(perm5);
207 ret = AccessTokenKit::GetSelfPermissionsState(permsList3, info);
208 ASSERT_EQ(INVALID_OPER, permsList3[0].state);
209 ASSERT_EQ(PASS_OPER, ret);
210 }
211
212 /**
213 * @tc.name: GetSelfPermissionsState002
214 * @tc.desc: permission list is empty or oversize
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState002, TestSize.Level0)
219 {
220 std::vector<PermissionListState> permsList;
221 PermissionGrantInfo info;
222 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
223
224 for (uint32_t i = 0; i < MAX_PERMISSION_SIZE + 1; i++) {
225 PermissionListState tmp = {
226 .permissionName = "ohos.permission.CAMERA",
227 .state = PASS_OPER
228 };
229 permsList.emplace_back(tmp);
230 }
231 ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
232 }
233
234 /**
235 * @tc.name: GetSelfPermissionsState003
236 * @tc.desc: test token id is native
237 * @tc.type: FUNC
238 * @tc.require:
239 */
240 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState003, TestSize.Level0)
241 {
242 MockNativeToken mock("hdcd");
243 std::vector<PermissionListState> permsList3;
244 PermissionListState tmp = {
245 .permissionName = "ohos.permission.CAMERA",
246 .state = PASS_OPER
247 };
248 permsList3.emplace_back(tmp);
249 PermissionGrantInfo info;
250 ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permsList3, info));
251 }
252
253 /**
254 * @tc.name: GetSelfPermissionsState004
255 * @tc.desc: test noexist token id
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState004, TestSize.Level0)
260 {
261 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
262 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
263 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId));
264 std::vector<PermissionListState> permsList4;
265 PermissionListState tmp = {
266 .permissionName = "ohos.permission.CAMERA",
267 .state = PASS_OPER
268 };
269 permsList4.emplace_back(tmp);
270 PermissionGrantInfo info;
271 ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permsList4, info));
272 }
273
274 /**
275 * @tc.name: GetSelfPermissionsState005
276 * @tc.desc: test noexist permission
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState005, TestSize.Level0)
281 {
282 std::vector<PermissionListState> permsList4;
283 PermissionListState tmp = {
284 .permissionName = "ohos.permission.SHORT_TERM_WRITE_IMAGEVIDEO",
285 .state = PASS_OPER
286 };
287 permsList4.emplace_back(tmp);
288 PermissionGrantInfo info;
289 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList4, info));
290 }
291
292 /**
293 * @tc.name: GetSelfPermissionsState006
294 * @tc.desc: get self permissions state with wrong token type.
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState006, TestSize.Level0)
299 {
300 std::vector<PermissionListState> permsList;
301 PermissionListState tmp = {
302 .permissionName = g_policy.permStateList[0].permissionName,
303 .state = BUTT_OPER
304 };
305 permsList.emplace_back(tmp);
306
307 {
308 std::vector<std::string> reqPerm;
309 reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG");
310 MockHapToken mock("GetSelfPermissionsState006", reqPerm, true);
311
312 HapBaseInfo hapBaseInfo = {
313 .userID = TEST_USER_ID,
314 .bundleName = TEST_BUNDLE_NAME,
315 .instIndex = 0,
316 };
317
318 // test dialog isn't forbiddedn
319 ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false));
320 }
321
322 PermissionGrantInfo info;
323 ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
324 }
325
GetPolicyParam()326 HapPolicyParams GetPolicyParam()
327 {
328 //test REQ_SUCCESS
329 PermissionStateFull permState1 = {
330 .permissionName = "ohos.permission.READ_HEALTH_DATA",
331 .isGeneral = true,
332 .resDeviceID = {"local3"},
333 .grantStatus = {PermissionState::PERMISSION_GRANTED},
334 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
335 };
336 PermissionStateFull permState2 = {
337 .permissionName = "ohos.permission.DISTRIBUTED_DATASYNC",
338 .isGeneral = true,
339 .resDeviceID = {"local3"},
340 .grantStatus = {PermissionState::PERMISSION_DENIED},
341 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}
342 };
343 //test UNABLE_POP_UP
344 PermissionStateFull permState3 = {
345 .permissionName = "ohos.permission.READ_MESSAGES",
346 .isGeneral = true,
347 .resDeviceID = {"local3"},
348 .grantStatus = {PermissionState::PERMISSION_DENIED},
349 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
350 };
351 //test CONDITIONS_NOT_MET
352 PermissionStateFull permState4 = {
353 .permissionName = APPROXIMATELY_LOCATION_PERMISSION,
354 .isGeneral = true,
355 .resDeviceID = {"local3"},
356 .grantStatus = {PermissionState::PERMISSION_DENIED},
357 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
358 };
359 //test REQ_SUCCESS
360 PermissionStateFull permState5 = {
361 .permissionName = "ohos.permission.WRITE_MEDIA",
362 .isGeneral = true,
363 .resDeviceID = {"local3"},
364 .grantStatus = {PermissionState::PERMISSION_DENIED},
365 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
366 };
367
368 HapPolicyParams policyParam = {
369 .apl = APL_NORMAL,
370 .domain = "test.domain3",
371 .permStateList = {permState1, permState2, permState3, permState4, permState5}
372 };
373 return policyParam;
374 }
375
376 /**
377 * @tc.name: GetSelfPermissionsState007
378 * @tc.desc: The test function GetSelfPermissionsState returns the object property field errorReason.
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState007, TestSize.Level0)
383 {
384 HapPolicyParams policyParam = GetPolicyParam();
385 AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(g_infoManager, policyParam);
386 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
387 ASSERT_NE(tokenID, INVALID_TOKENID);
388 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token
389
390 PermissionListState permInvalid = {
391 .permissionName = "ohos.permission.WU_ERROR_REASON",
392 .state = FORBIDDEN_OPER
393 };
394 PermissionListState permNotConfig = {
395 .permissionName = "ohos.permission.READ_MEDIA",
396 .state = FORBIDDEN_OPER
397 };
398 std::vector<PermissionListState> permsList;
399 permsList.emplace_back(permInvalid);
400 permsList.emplace_back(permNotConfig);
401 for (auto& perm : policyParam.permStateList) {
402 PermissionListState tmp = {
403 .permissionName = perm.permissionName,
404 .state = FORBIDDEN_OPER
405 };
406 permsList.emplace_back(tmp);
407 }
408 PermissionGrantInfo info;
409 ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
410 EXPECT_EQ(permsList[0].errorReason, PERM_INVALID);
411 EXPECT_EQ(permsList[1].errorReason, PERM_NOT_DECLEARED);
412 EXPECT_EQ(permsList[2].errorReason, REQ_SUCCESS);
413 EXPECT_EQ(permsList[3].errorReason, REQ_SUCCESS);
414 EXPECT_EQ(permsList[4].errorReason, UNABLE_POP_UP);
415 EXPECT_EQ(permsList[5].errorReason, CONDITIONS_NOT_MET);
416 EXPECT_EQ(permsList[6].errorReason, REQ_SUCCESS);
417 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
418 ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId));
419 }
420
421 /**
422 * @tc.name: GetSelfPermissionsState008
423 * @tc.desc: If the user does not agree to the privacy statement, the test function GetSelfPermissionsState returns
424 * the object attribute field errorReason.
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState008, TestSize.Level0)
429 {
430 HapPolicyParams policyParam = GetPolicyParam();
431 AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(g_infoManager, policyParam);
432 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
433 ASSERT_NE(tokenID, INVALID_TOKENID);
434 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token
435
436 std::vector<PermissionListState> permsList;
437 for (auto& perm : policyParam.permStateList) {
438 PermissionListState tmp = {
439 .permissionName = perm.permissionName,
440 .state = FORBIDDEN_OPER
441 };
442 permsList.emplace_back(tmp);
443 }
444 {
445 std::vector<std::string> reqPerm;
446 reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG");
447 MockHapToken mock("GetSelfPermissionsState008", reqPerm, true);
448
449 HapBaseInfo hapBaseInfo = {
450 .userID = g_infoManager.userID,
451 .bundleName = g_infoManager.bundleName,
452 .instIndex = g_infoManager.instIndex,
453 };
454
455 // test dialog isn't forbiddedn
456 ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true));
457 }
458
459 PermissionGrantInfo info;
460 ASSERT_EQ(FORBIDDEN_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
461 EXPECT_EQ(permsList[0].errorReason, PRIVACY_STATEMENT_NOT_AGREED);
462 EXPECT_EQ(permsList[1].errorReason, PRIVACY_STATEMENT_NOT_AGREED);
463 EXPECT_EQ(permsList[2].errorReason, UNABLE_POP_UP);
464 EXPECT_EQ(permsList[3].errorReason, CONDITIONS_NOT_MET);
465 EXPECT_EQ(permsList[4].errorReason, PRIVACY_STATEMENT_NOT_AGREED);
466 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
467 ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId));
468 }
469
getHapPolicyLocationParams(const std::vector<std::string> & permissions)470 HapPolicyParams getHapPolicyLocationParams(const std::vector<std::string>& permissions)
471 {
472 HapPolicyParams policyParam = {
473 .apl = APL_NORMAL,
474 .domain = "test.domain3",
475 .permStateList = {}
476 };
477 for (auto& perm : permissions) {
478 PermissionStateFull location = {
479 .permissionName = perm,
480 .isGeneral = true,
481 .resDeviceID = {"local3"},
482 .grantStatus = {PermissionState::PERMISSION_DENIED},
483 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
484 };
485 policyParam.permStateList.emplace_back(location);
486 }
487 return policyParam;
488 }
489
490 /**
491 * @tc.name: GetSelfPermissionsState009
492 * @tc.desc: The test position-related permission function GetSelfPermissionsState returns the object property
493 * field errorReason.
494 * @tc.type: FUNC
495 * @tc.require:
496 */
497 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState009, TestSize.Level0)
498 {
499 std::vector<std::string> permissions = {LOCATION_PERMISSION, APPROXIMATELY_LOCATION_PERMISSION};
500 HapPolicyParams policyParam = getHapPolicyLocationParams(permissions);
501 HapInfoParams hapInfo = g_infoManager;
502 hapInfo.apiVersion = 14;
503
504 AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(hapInfo, policyParam);
505 ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID);
506 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token
507
508 std::vector<PermissionListState> permsList;
509 PermissionListState locationState = {
510 .permissionName = APPROXIMATELY_LOCATION_PERMISSION,
511 .state = FORBIDDEN_OPER
512 };
513 permsList.emplace_back(locationState);
514 PermissionGrantInfo info;
515 ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
516 EXPECT_EQ(permsList[0].errorReason, REQ_SUCCESS);
517
518 locationState.permissionName = LOCATION_PERMISSION;
519 permsList.emplace_back(locationState);
520 ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
521 EXPECT_EQ(permsList[0].errorReason, REQ_SUCCESS);
522 EXPECT_EQ(permsList[1].errorReason, REQ_SUCCESS);
523
524 permsList[1].permissionName = LOCATION_IN_BACKGROUND_PERMISSION;
525 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info));
526 EXPECT_EQ(permsList[0].errorReason, CONDITIONS_NOT_MET);
527 EXPECT_EQ(permsList[1].errorReason, CONDITIONS_NOT_MET);
528
529 std::vector<PermissionListState> locationPermsList = {locationState};
530 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(locationPermsList, info));
531 EXPECT_EQ(locationPermsList[0].errorReason, CONDITIONS_NOT_MET);
532
533 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
534 tokenIdEx.tokenIdExStruct.tokenID, APPROXIMATELY_LOCATION_PERMISSION, PERMISSION_USER_FIXED));
535 ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(locationPermsList, info));
536 EXPECT_EQ(locationPermsList[0].errorReason, REQ_SUCCESS);
537
538 locationState.permissionName = LOCATION_IN_BACKGROUND_PERMISSION;
539 std::vector<PermissionListState> backgroundPermsList = {locationState};
540 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(backgroundPermsList, info));
541 EXPECT_EQ(backgroundPermsList[0].errorReason, CONDITIONS_NOT_MET);
542
543 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
544 std::vector<std::string> vaguePermissions = {APPROXIMATELY_LOCATION_PERMISSION};
545 policyParam = getHapPolicyLocationParams(vaguePermissions);
546
547 tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(hapInfo, policyParam);
548 ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID);
549 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token
550
551 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(locationPermsList, info));
552 EXPECT_EQ(locationPermsList[0].errorReason, PERM_NOT_DECLEARED);
553 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
554 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); // set self hap token
555 }
556 } // namespace AccessToken
557 } // namespace Security
558 } // namespace OHOS