1 /*
2 * Copyright (c) 2025 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 "accesstoken_location_request_test.h"
17
18 #include "access_token.h"
19 #include "accesstoken_kit.h"
20 #include "hap_token_info.h"
21 #include "permission_def.h"
22 #include "permission_grant_info.h"
23 #include "permission_list_state.h"
24 #include "permission_state_full.h"
25 #include "test_common.h"
26 #include "token_setproc.h"
27
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Security {
32 namespace AccessToken {
33 namespace {
34 static uint64_t g_selfTokenId = 0;
35 static constexpr int32_t TEST_USER_ID = 100;
36 static std::string TEST_BUNDLE_NAME = "accesstoken_location_request_test";
37 static constexpr int32_t TEST_INST_INDEX = 0;
38 static constexpr int32_t DEFAULT_API_VERSION = 8;
39 static constexpr int32_t VAGUE_LOCATION_API_VERSION = 9;
40 static constexpr int32_t BACKGROUND_LOCATION_API_VERSION = 11;
41
42 PermissionStateFull g_locationTestStateSystemGrant = {
43 .permissionName = "ohos.permission.UPDATE_SYSTEM",
44 .isGeneral = true,
45 .resDeviceID = {"device"},
46 .grantStatus = {PermissionState::PERMISSION_GRANTED},
47 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
48 };
49 PermissionStateFull g_locationTestStateUserGrant = {
50 .permissionName = "ohos.permission.APP_TRACKING_CONSENT",
51 .isGeneral = true,
52 .resDeviceID = {"device"},
53 .grantStatus = {PermissionState::PERMISSION_DENIED},
54 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
55 };
56
57 PermissionStateFull g_locationTestStateVague02 = {
58 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
59 .isGeneral = true,
60 .resDeviceID = {"device"},
61 .grantStatus = {PermissionState::PERMISSION_GRANTED},
62 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
63 };
64 PermissionStateFull g_locationTestStateVague10 = {
65 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
66 .isGeneral = true,
67 .resDeviceID = {"device"},
68 .grantStatus = {PermissionState::PERMISSION_DENIED},
69 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
70 };
71 PermissionStateFull g_locationTestStateVague12 = {
72 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
73 .isGeneral = true,
74 .resDeviceID = {"device"},
75 .grantStatus = {PermissionState::PERMISSION_DENIED},
76 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
77 };
78
79 PermissionStateFull g_locationTestStateAccurate02 = {
80 .permissionName = "ohos.permission.LOCATION",
81 .isGeneral = true,
82 .resDeviceID = {"device"},
83 .grantStatus = {PermissionState::PERMISSION_GRANTED},
84 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
85 };
86 PermissionStateFull g_locationTestStateAccurate10 = {
87 .permissionName = "ohos.permission.LOCATION",
88 .isGeneral = true,
89 .resDeviceID = {"device"},
90 .grantStatus = {PermissionState::PERMISSION_DENIED},
91 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
92 };
93 PermissionStateFull g_locationTestStateAccurate12 = {
94 .permissionName = "ohos.permission.LOCATION",
95 .isGeneral = true,
96 .resDeviceID = {"device"},
97 .grantStatus = {PermissionState::PERMISSION_DENIED},
98 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
99 };
100
101 PermissionStateFull g_locationTestStateBack02 = {
102 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
103 .isGeneral = true,
104 .resDeviceID = {"device"},
105 .grantStatus = {PermissionState::PERMISSION_GRANTED},
106 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
107 };
108 PermissionStateFull g_locationTestStateBack10 = {
109 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
110 .isGeneral = true,
111 .resDeviceID = {"device"},
112 .grantStatus = {PermissionState::PERMISSION_DENIED},
113 .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}
114 };
115 PermissionStateFull g_locationTestStateBack12 = {
116 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
117 .isGeneral = true,
118 .resDeviceID = {"device"},
119 .grantStatus = {PermissionState::PERMISSION_DENIED},
120 .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED}
121 };
122 }
123
SetUpTestCase()124 void AccessTokenLocationRequestTest::SetUpTestCase()
125 {
126 g_selfTokenId = GetSelfTokenID();
127 TestCommon::SetTestEvironment(g_selfTokenId);
128 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
129 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
130 if (tokenId != INVALID_TOKENID) {
131 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId));
132 }
133 }
134
TearDownTestCase()135 void AccessTokenLocationRequestTest::TearDownTestCase()
136 {
137 SetSelfTokenID(g_selfTokenId);
138 TestCommon::ResetTestEvironment();
139 }
140
SetUp()141 void AccessTokenLocationRequestTest::SetUp()
142 {
143 }
144
TearDown()145 void AccessTokenLocationRequestTest::TearDown()
146 {
147 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
148 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
149 if (tokenId != INVALID_TOKENID) {
150 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId));
151 }
152 }
153
AllocHapToken(std::vector<PermissionStateFull> & permissionStateFulls,int32_t apiVersion)154 AccessTokenIDEx AllocHapToken(std::vector<PermissionStateFull>& permissionStateFulls, int32_t apiVersion)
155 {
156 HapInfoParams info = {
157 .userID = TEST_USER_ID,
158 .bundleName = TEST_BUNDLE_NAME,
159 .instIndex = TEST_INST_INDEX,
160 .appIDDesc = "location_test",
161 .apiVersion = apiVersion,
162 .isSystemApp = true,
163 };
164
165 HapPolicyParams policy = {
166 .apl = APL_NORMAL,
167 .domain = "domain"
168 };
169
170 for (const auto& permissionStateFull : permissionStateFulls) {
171 PermissionDef permDefResult;
172 if (AccessTokenKit::GetDefPermission(permissionStateFull.permissionName, permDefResult) != RET_SUCCESS) {
173 continue;
174 }
175 policy.permStateList.emplace_back(permissionStateFull);
176 if (permDefResult.availableLevel > policy.apl) {
177 policy.aclRequestedList.emplace_back(permissionStateFull.permissionName);
178 }
179 }
180
181 AccessTokenIDEx tokenIdEx = {0};
182 EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx));
183 AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
184 EXPECT_NE(tokenId, INVALID_TOKENID);
185 EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx));
186
187 for (const auto& permissionStateFull : permissionStateFulls) {
188 if (permissionStateFull.grantStatus[0] == PERMISSION_GRANTED) {
189 TestCommon::GrantPermissionByTest(
190 tokenId, permissionStateFull.permissionName, permissionStateFull.grantFlags[0]);
191 } else {
192 TestCommon::RevokePermissionByTest(
193 tokenId, permissionStateFull.permissionName, permissionStateFull.grantFlags[0]);
194 }
195 }
196 return tokenIdEx;
197 }
198
199 /**
200 * @tc.name: GetSelfPermissionsState001
201 * @tc.desc: only vague location permission, ret: DYNAMIC_OPER, state: DYNAMIC_OPER
202 * @tc.type: FUNC
203 * @tc.require: issueI5NOQI
204 */
205 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState001, TestSize.Level0)
206 {
207 std::vector<PermissionStateFull> permissionStateFulls;
208 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0} {grantStatus, grantFlags}
209
210 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
211 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
212 ASSERT_NE(INVALID_TOKENID, tokenID);
213 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
214
215 PermissionListState permVague1 = {
216 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
217 .state = SETTING_OPER,
218 };
219
220 std::vector<PermissionListState> permsList1;
221 permsList1.emplace_back(permVague1);
222
223 PermissionGrantInfo info;
224 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList1, info);
225 EXPECT_EQ(DYNAMIC_OPER, ret);
226 EXPECT_EQ(static_cast<uint32_t>(1), permsList1.size());
227 EXPECT_EQ(DYNAMIC_OPER, permsList1[0].state);
228 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
229 }
230
231 /**
232 * @tc.name: GetSelfPermissionsState002
233 * @tc.desc: only vague location permission after refuse, ret: PASS_OPER, state: SETTING_OPER
234 * @tc.type: FUNC
235 * @tc.require: issueI5NOQI
236 */
237 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState002, TestSize.Level0)
238 {
239 std::vector<PermissionStateFull> permissionStateFulls;
240 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
241
242 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
243 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
244 ASSERT_NE(INVALID_TOKENID, tokenID);
245 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
246
247 PermissionListState permVague2 = {
248 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
249 .state = SETTING_OPER,
250 };
251
252 std::vector<PermissionListState> permsList2;
253 permsList2.emplace_back(permVague2);
254
255 PermissionGrantInfo info;
256 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList2, info);
257 ASSERT_EQ(PASS_OPER, ret);
258 ASSERT_EQ(static_cast<uint32_t>(1), permsList2.size());
259 ASSERT_EQ(SETTING_OPER, permsList2[0].state);
260
261 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
262 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
263 }
264
265 /**
266 * @tc.name: GetSelfPermissionsState003
267 * @tc.desc: only vague location permission after accept, ret: PASS_OPER, state: PASS_OPER
268 * @tc.type: FUNC
269 * @tc.require: issueI5NOQI
270 */
271 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState003, TestSize.Level0)
272 {
273 std::vector<PermissionStateFull> permissionStateFulls;
274 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
275
276 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
277 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
278 ASSERT_NE(INVALID_TOKENID, tokenID);
279 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
280
281 PermissionListState permVague3 = {
282 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
283 .state = SETTING_OPER,
284 };
285
286 std::vector<PermissionListState> permsList3;
287 permsList3.emplace_back(permVague3);
288
289 PermissionGrantInfo info;
290 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList3, info);
291 ASSERT_EQ(PASS_OPER, ret);
292 ASSERT_EQ(static_cast<uint32_t>(1), permsList3.size());
293 ASSERT_EQ(PASS_OPER, permsList3[0].state);
294
295 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
296 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
297 }
298
299 /**
300 * @tc.name: GetSelfPermissionsState004
301 * @tc.desc: only accurate location permission, ret: PASS_OPER, state: INVALID_OPER
302 * @tc.type: FUNC
303 * @tc.require: issueI5NOQI
304 */
305 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState004, TestSize.Level0)
306 {
307 std::vector<PermissionStateFull> permissionStateFulls;
308 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
309
310 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
311 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
312 ASSERT_NE(INVALID_TOKENID, tokenID);
313 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
314
315 std::vector<PermissionListState> permsList4;
316 PermissionListState permAccurate4 = {
317 .permissionName = "ohos.permission.LOCATION",
318 .state = SETTING_OPER,
319 };
320
321 permsList4.emplace_back(permAccurate4);
322
323 PermissionGrantInfo info;
324 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList4, info);
325 ASSERT_EQ(PASS_OPER, ret);
326 ASSERT_EQ(static_cast<uint32_t>(1), permsList4.size());
327 ASSERT_EQ(INVALID_OPER, permsList4[0].state);
328
329 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
330 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
331 }
332
333 /**
334 * @tc.name: GetSelfPermissionsState005
335 * @tc.desc: only accurate location permission with granted vague location, ret: DYNAMIC_OPER, state: DYNAMIC_OPER
336 * @tc.type: FUNC
337 * @tc.require: issueI5NOQI
338 */
339 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState005, TestSize.Level0)
340 {
341 std::vector<PermissionStateFull> permissionStateFulls;
342 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
343 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
344
345 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
346 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
347 ASSERT_NE(INVALID_TOKENID, tokenID);
348 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
349
350 std::vector<PermissionListState> permsList5;
351 PermissionListState permAccurate5 = {
352 .permissionName = "ohos.permission.LOCATION",
353 .state = SETTING_OPER,
354 };
355
356 permsList5.emplace_back(permAccurate5);
357
358 PermissionGrantInfo info;
359 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList5, info);
360 ASSERT_EQ(DYNAMIC_OPER, ret);
361 ASSERT_EQ(static_cast<uint32_t>(1), permsList5.size());
362 ASSERT_EQ(DYNAMIC_OPER, permsList5[0].state);
363
364 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
365 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
366 }
367
368 /**
369 * @tc.name: GetSelfPermissionsState006
370 * @tc.desc: only background location permission, ret: PASS_OPER, state: INVALID_OPER
371 * @tc.type: FUNC
372 * @tc.require: issueI5NOQI
373 */
374 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState006, TestSize.Level0)
375 {
376 std::vector<PermissionStateFull> permissionStateFulls;
377 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
378
379 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
380 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
381 ASSERT_NE(INVALID_TOKENID, tokenID);
382 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
383
384 std::vector<PermissionListState> permsList6;
385 PermissionListState permBack6 = {
386 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
387 .state = SETTING_OPER,
388 };
389
390 permsList6.emplace_back(permBack6);
391
392 PermissionGrantInfo info;
393 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList6, info);
394 ASSERT_EQ(PASS_OPER, ret);
395 ASSERT_EQ(static_cast<uint32_t>(1), permsList6.size());
396 ASSERT_EQ(INVALID_OPER, permsList6[0].state);
397
398 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
399 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
400 }
401
402 /**
403 * @tc.name: GetSelfPermissionsState007
404 * @tc.desc: only background location permission with granted vague location, ret: PASS_OPER, state: INVALID_OPER
405 * @tc.type: FUNC
406 * @tc.require: issueI5NOQI
407 */
408 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState007, TestSize.Level0)
409 {
410 std::vector<PermissionStateFull> permissionStateFulls;
411 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
412 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
413
414 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
415 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
416 ASSERT_NE(INVALID_TOKENID, tokenID);
417 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
418
419 std::vector<PermissionListState> permsList7;
420 PermissionListState permBack7 = {
421 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
422 .state = SETTING_OPER,
423 };
424
425 permsList7.emplace_back(permBack7);
426
427 PermissionGrantInfo info;
428 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList7, info);
429 ASSERT_EQ(PASS_OPER, ret);
430 ASSERT_EQ(static_cast<uint32_t>(1), permsList7.size());
431 ASSERT_EQ(INVALID_OPER, permsList7[0].state);
432
433 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
434 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
435 }
436
437 /**
438 * @tc.name: GetSelfPermissionsState008
439 * @tc.desc: vague + accurate location permissions, ret: DYNAMIC_OPER, state: DYNAMIC_OPER
440 * @tc.type: FUNC
441 * @tc.require: issueI5NOQI
442 */
443 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState008, TestSize.Level0)
444 {
445 std::vector<PermissionStateFull> permissionStateFulls;
446 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
447 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
448
449 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
450 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
451 ASSERT_NE(INVALID_TOKENID, tokenID);
452 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
453
454 PermissionListState permVague8 = {
455 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
456 .state = SETTING_OPER,
457 };
458 PermissionListState permAccurate8 = {
459 .permissionName = "ohos.permission.LOCATION",
460 .state = SETTING_OPER,
461 };
462
463 std::vector<PermissionListState> permsList8;
464 permsList8.emplace_back(permVague8);
465 permsList8.emplace_back(permAccurate8);
466
467 PermissionGrantInfo info;
468 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList8, info);
469 ASSERT_EQ(DYNAMIC_OPER, ret);
470 ASSERT_EQ(static_cast<uint32_t>(2), permsList8.size());
471 ASSERT_EQ(DYNAMIC_OPER, permsList8[0].state);
472 ASSERT_EQ(DYNAMIC_OPER, permsList8[1].state);
473
474 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
475 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
476 }
477
478 /**
479 * @tc.name: GetSelfPermissionsState009
480 * @tc.desc: vague + accurate after accept vague location permission, ret: DYNAMIC_OPER, state: PASS_OPER + DYNAMIC_OPER
481 * @tc.type: FUNC
482 * @tc.require: issueI5NOQI
483 */
484 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState009, TestSize.Level0)
485 {
486 std::vector<PermissionStateFull> permissionStateFulls;
487 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
488 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
489
490 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
491 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
492 ASSERT_NE(INVALID_TOKENID, tokenID);
493 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
494
495 PermissionListState permVague9 = {
496 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
497 .state = SETTING_OPER,
498 };
499 PermissionListState permAccurate9 = {
500 .permissionName = "ohos.permission.LOCATION",
501 .state = SETTING_OPER,
502 };
503
504 std::vector<PermissionListState> permsList9;
505 permsList9.emplace_back(permVague9);
506 permsList9.emplace_back(permAccurate9);
507
508 PermissionGrantInfo info;
509 ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList9, info));
510 ASSERT_EQ(static_cast<uint32_t>(2), permsList9.size());
511 ASSERT_EQ(PASS_OPER, permsList9[0].state);
512 ASSERT_EQ(DYNAMIC_OPER, permsList9[1].state);
513
514 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
515 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
516 }
517
518 /**
519 * @tc.name: GetSelfPermissionsState010
520 * @tc.desc: vague + accurate after refuse vague location permission, ret: PASS_OPER, state: SETTING_OPER + INVALID_OPER
521 * @tc.type: FUNC
522 * @tc.require: issueI5NOQI
523 */
524 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState010, TestSize.Level0)
525 {
526 std::vector<PermissionStateFull> permissionStateFulls;
527 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
528 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
529
530 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
531 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
532 ASSERT_NE(INVALID_TOKENID, tokenID);
533 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
534
535 PermissionListState permVague10 = {
536 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
537 .state = SETTING_OPER,
538 };
539 PermissionListState permAccurate10 = {
540 .permissionName = "ohos.permission.LOCATION",
541 .state = SETTING_OPER,
542 };
543
544 std::vector<PermissionListState> permsList10;
545 permsList10.emplace_back(permVague10);
546 permsList10.emplace_back(permAccurate10);
547
548 PermissionGrantInfo info;
549 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList10, info);
550 ASSERT_EQ(PASS_OPER, ret);
551 ASSERT_EQ(static_cast<uint32_t>(2), permsList10.size());
552 ASSERT_EQ(SETTING_OPER, permsList10[0].state);
553 ASSERT_EQ(INVALID_OPER, permsList10[1].state);
554
555 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
556 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
557 }
558
559 /**
560 * @tc.name: GetSelfPermissionsState011
561 * @tc.desc: vague + accurate after accept all location permissions, ret: PASS_OPER, state: PASS_OPER + PASS_OPER
562 * @tc.type: FUNC
563 * @tc.require: issueI5NOQI
564 */
565 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState011, TestSize.Level0)
566 {
567 std::vector<PermissionStateFull> permissionStateFulls;
568 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
569 permissionStateFulls.emplace_back(g_locationTestStateAccurate02); // {0,2}
570
571 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
572 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
573 ASSERT_NE(INVALID_TOKENID, tokenID);
574 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
575
576 PermissionListState permVague11 = {
577 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
578 .state = SETTING_OPER,
579 };
580 PermissionListState permAccurate11 = {
581 .permissionName = "ohos.permission.LOCATION",
582 .state = SETTING_OPER,
583 };
584
585 std::vector<PermissionListState> permsList11;
586 permsList11.emplace_back(permVague11);
587 permsList11.emplace_back(permAccurate11);
588
589 PermissionGrantInfo info;
590 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList11, info);
591 ASSERT_EQ(PASS_OPER, ret);
592 ASSERT_EQ(static_cast<uint32_t>(2), permsList11.size());
593 ASSERT_EQ(PASS_OPER, permsList11[0].state);
594 ASSERT_EQ(PASS_OPER, permsList11[1].state);
595
596 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
597 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
598 }
599
600 /**
601 * @tc.name: GetSelfPermissionsState012
602 * @tc.desc: vague + background location permissions, ret: PASS_OPER, state: INVALID_OPER + INVALID_OPER
603 * @tc.type: FUNC
604 * @tc.require: issueI5NOQI
605 */
606 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState012, TestSize.Level0)
607 {
608 std::vector<PermissionStateFull> permissionStateFulls;
609 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
610 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
611
612 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
613 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
614 ASSERT_NE(INVALID_TOKENID, tokenID);
615 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
616
617 PermissionListState permVague12 = {
618 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
619 .state = SETTING_OPER,
620 };
621 PermissionListState permBack12 = {
622 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
623 .state = SETTING_OPER,
624 };
625
626 std::vector<PermissionListState> permsList12;
627 permsList12.emplace_back(permVague12);
628 permsList12.emplace_back(permBack12);
629
630 PermissionGrantInfo info;
631 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList12, info);
632 ASSERT_EQ(PASS_OPER, ret);
633 ASSERT_EQ(static_cast<uint32_t>(2), permsList12.size());
634 ASSERT_EQ(INVALID_OPER, permsList12[0].state);
635 ASSERT_EQ(INVALID_OPER, permsList12[1].state);
636
637 // grant back permission, get vague again, ret: DYNAMIC_OPER, state: DYNAMIC_OPER
638 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
639 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
640 std::vector<PermissionListState> permsList121;
641 permsList121.emplace_back(permVague12);
642 ret = AccessTokenKit::GetSelfPermissionsState(permsList121, info);
643 ASSERT_EQ(DYNAMIC_OPER, ret);
644 ASSERT_EQ(static_cast<uint32_t>(1), permsList121.size());
645 ASSERT_EQ(DYNAMIC_OPER, permsList121[0].state);
646
647 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
648 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
649 }
650
651 /**
652 * @tc.name: GetSelfPermissionsState013
653 * @tc.desc: vague + background after accept vague location permission, ret: DYNAMIC_OPER, state: INVALID_OPER
654 * @tc.type: FUNC
655 * @tc.require: issueI5NOQI
656 */
657 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState013, TestSize.Level0)
658 {
659 std::vector<PermissionStateFull> permissionStateFulls;
660 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
661 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
662
663 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
664 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
665 ASSERT_NE(INVALID_TOKENID, tokenID);
666 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
667
668 PermissionListState permVague13 = {
669 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
670 .state = SETTING_OPER,
671 };
672 PermissionListState permBack13 = {
673 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
674 .state = SETTING_OPER,
675 };
676
677 std::vector<PermissionListState> permsList13;
678 permsList13.emplace_back(permVague13);
679 permsList13.emplace_back(permBack13);
680
681 PermissionGrantInfo info;
682 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList13, info);
683 ASSERT_EQ(PASS_OPER, ret);
684 ASSERT_EQ(static_cast<uint32_t>(2), permsList13.size());
685 ASSERT_EQ(INVALID_OPER, permsList13[0].state);
686 ASSERT_EQ(INVALID_OPER, permsList13[1].state);
687 // grant back permission, get vague again, ret: PASS_OPER, state: PASS_OPER
688 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
689 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
690 std::vector<PermissionListState> permsList131;
691 permsList131.emplace_back(permVague13);
692 ret = AccessTokenKit::GetSelfPermissionsState(permsList131, info);
693 ASSERT_EQ(PASS_OPER, ret);
694 ASSERT_EQ(static_cast<uint32_t>(1), permsList131.size());
695 ASSERT_EQ(PASS_OPER, permsList131[0].state);
696
697 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
698 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
699 }
700
701 /**
702 * @tc.name: GetSelfPermissionsState014
703 * @tc.desc: vague + background after refuse vague location permission, ret: PASS_OPER, state: INVALID_OPER
704 * @tc.type: FUNC
705 * @tc.require: issueI5NOQI
706 */
707 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState014, TestSize.Level0)
708 {
709 std::vector<PermissionStateFull> permissionStateFulls;
710 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
711 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
712
713 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
714 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
715 ASSERT_NE(INVALID_TOKENID, tokenID);
716 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
717
718 PermissionListState permVague14 = {
719 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
720 .state = SETTING_OPER,
721 };
722 PermissionListState permBack14 = {
723 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
724 .state = SETTING_OPER,
725 };
726
727 std::vector<PermissionListState> permsList14;
728 permsList14.emplace_back(permVague14);
729 permsList14.emplace_back(permBack14);
730
731 PermissionGrantInfo info;
732 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList14, info);
733 ASSERT_EQ(PASS_OPER, ret);
734 ASSERT_EQ(static_cast<uint32_t>(2), permsList14.size());
735 ASSERT_EQ(INVALID_OPER, permsList14[0].state);
736 ASSERT_EQ(INVALID_OPER, permsList14[1].state);
737 // grant back permission, get vague again, ret: PASS_OPER, state: SETTING_OPER
738 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
739 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
740 std::vector<PermissionListState> permsList141;
741 permsList141.emplace_back(permVague14);
742 ret = AccessTokenKit::GetSelfPermissionsState(permsList141, info);
743 ASSERT_EQ(PASS_OPER, ret);
744 ASSERT_EQ(static_cast<uint32_t>(1), permsList141.size());
745 ASSERT_EQ(SETTING_OPER, permsList141[0].state);
746
747 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
748 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
749 }
750
751 /**
752 * @tc.name: GetSelfPermissionsState015
753 * @tc.desc: vague + background after accept all location permissions, ret: PASS_OPER, state: INVALID_OPER
754 * @tc.type: FUNC
755 * @tc.require: issueI5NOQI
756 */
757 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState015, TestSize.Level0)
758 {
759 std::vector<PermissionStateFull> permissionStateFulls;
760 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
761 permissionStateFulls.emplace_back(g_locationTestStateBack02); // {0,2}
762
763 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
764 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
765 ASSERT_NE(INVALID_TOKENID, tokenID);
766 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
767
768 PermissionListState permVague15 = {
769 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
770 .state = SETTING_OPER,
771 };
772 PermissionListState permBack15 = {
773 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
774 .state = SETTING_OPER,
775 };
776
777 std::vector<PermissionListState> permsList15;
778 permsList15.emplace_back(permVague15);
779 permsList15.emplace_back(permBack15);
780
781 PermissionGrantInfo info;
782 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList15, info);
783 ASSERT_EQ(PASS_OPER, ret);
784 ASSERT_EQ(static_cast<uint32_t>(2), permsList15.size());
785 ASSERT_EQ(INVALID_OPER, permsList15[0].state);
786 ASSERT_EQ(INVALID_OPER, permsList15[1].state);
787 // grant back permission, get vague again, ret: PASS_OPER, state: PASS_OPER
788 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
789 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
790 std::vector<PermissionListState> permsList151;
791 permsList151.emplace_back(permVague15);
792 ret = AccessTokenKit::GetSelfPermissionsState(permsList151, info);
793 ASSERT_EQ(PASS_OPER, ret);
794 ASSERT_EQ(static_cast<uint32_t>(1), permsList151.size());
795 ASSERT_EQ(PASS_OPER, permsList151[0].state);
796
797 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
798 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
799 }
800
801 /**
802 * @tc.name: GetSelfPermissionsState016
803 * @tc.desc: accurate + background, ret: PASS_OPER, state: INVALID_OPER
804 * @tc.type: FUNC
805 * @tc.require: issueI5NOQI
806 */
807 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState016, TestSize.Level0)
808 {
809 std::vector<PermissionStateFull> permissionStateFulls;
810 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
811 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
812
813 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
814 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
815 ASSERT_NE(INVALID_TOKENID, tokenID);
816 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
817
818 PermissionListState permAccurate16 = {
819 .permissionName = "ohos.permission.LOCATION",
820 .state = SETTING_OPER,
821 };
822 PermissionListState permBack16 = {
823 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
824 .state = SETTING_OPER,
825 };
826
827 std::vector<PermissionListState> permsList16;
828 permsList16.emplace_back(permAccurate16);
829 permsList16.emplace_back(permBack16);
830
831 PermissionGrantInfo info;
832 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList16, info);
833 ASSERT_EQ(PASS_OPER, ret);
834 ASSERT_EQ(static_cast<uint32_t>(2), permsList16.size());
835 ASSERT_EQ(INVALID_OPER, permsList16[0].state);
836 ASSERT_EQ(INVALID_OPER, permsList16[1].state);
837
838 // grant back permission, get accerate again, ret: PASS_OPER, state: INVALID_OPER
839 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
840 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
841 std::vector<PermissionListState> permsList161;
842 permsList161.emplace_back(permAccurate16);
843 ret = AccessTokenKit::GetSelfPermissionsState(permsList161, info);
844 ASSERT_EQ(PASS_OPER, ret);
845 ASSERT_EQ(static_cast<uint32_t>(1), permsList161.size());
846 ASSERT_EQ(INVALID_OPER, permsList161[0].state);
847
848 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
849 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
850 }
851
852 /**
853 * @tc.name: GetSelfPermissionsState017
854 * @tc.desc: accurate + background with granted vague location api11, ret: PASS_OPER, state: INVALID_OPER
855 * @tc.type: FUNC
856 * @tc.require: issueI5NOQI
857 */
858 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState017, TestSize.Level0)
859 {
860 std::vector<PermissionStateFull> permissionStateFulls;
861 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
862 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
863 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
864
865 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
866 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
867 ASSERT_NE(INVALID_TOKENID, tokenID);
868 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
869
870 PermissionListState permAccurate17 = {
871 .permissionName = "ohos.permission.LOCATION",
872 .state = SETTING_OPER,
873 };
874 PermissionListState permBack17 = {
875 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
876 .state = SETTING_OPER,
877 };
878
879 std::vector<PermissionListState> permsList17;
880 permsList17.emplace_back(permAccurate17);
881 permsList17.emplace_back(permBack17);
882
883 PermissionGrantInfo info;
884 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList17, info);
885 ASSERT_EQ(PASS_OPER, ret); // API>=11, request permission includebackground, needn't pop dialog
886 ASSERT_EQ(static_cast<uint32_t>(2), permsList17.size());
887 ASSERT_EQ(INVALID_OPER, permsList17[0].state);
888 ASSERT_EQ(INVALID_OPER, permsList17[1].state);
889
890 // grant back permission, get accerate again, ret: PASS_OPER, state: INVALID_OPER
891 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
892 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
893 std::vector<PermissionListState> permsList171;
894 permsList171.emplace_back(permAccurate17);
895 ret = AccessTokenKit::GetSelfPermissionsState(permsList171, info);
896 ASSERT_EQ(DYNAMIC_OPER, ret); // API>=11, only request accrtate, need pop dialog
897 ASSERT_EQ(static_cast<uint32_t>(1), permsList171.size());
898 ASSERT_EQ(DYNAMIC_OPER, permsList171[0].state);
899
900 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
901 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
902 }
903
904 /**
905 * @tc.name: GetSelfPermissionsState018
906 * @tc.desc: vague + accurate + background, ret: PASS_OPER, state: INVALID_OPER
907 * @tc.type: FUNC
908 * @tc.require: issueI5NOQI
909 */
910 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState018, TestSize.Level0)
911 {
912 std::vector<PermissionStateFull> permissionStateFulls;
913 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
914 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
915 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
916
917 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
918 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
919 ASSERT_NE(INVALID_TOKENID, tokenID);
920 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
921
922 PermissionListState permVague18 = {
923 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
924 .state = SETTING_OPER,
925 };
926 PermissionListState permAccurate18 = {
927 .permissionName = "ohos.permission.LOCATION",
928 .state = SETTING_OPER,
929 };
930 PermissionListState permBack18 = {
931 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
932 .state = SETTING_OPER,
933 };
934
935 std::vector<PermissionListState> permsList18;
936 permsList18.emplace_back(permVague18);
937 permsList18.emplace_back(permAccurate18);
938 permsList18.emplace_back(permBack18);
939
940 PermissionGrantInfo info;
941 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList18, info);
942 ASSERT_EQ(PASS_OPER, ret);
943 ASSERT_EQ(static_cast<uint32_t>(3), permsList18.size());
944 ASSERT_EQ(INVALID_OPER, permsList18[0].state);
945 ASSERT_EQ(INVALID_OPER, permsList18[1].state);
946 ASSERT_EQ(INVALID_OPER, permsList18[2].state);
947
948 // grant back permission, get accerate&vague again, ret: DYNAMIC_OPER, state: DYNAMIC_OPER
949 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
950 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
951 std::vector<PermissionListState> permsList181;
952 permsList181.emplace_back(permVague18);
953 permsList181.emplace_back(permAccurate18);
954 ret = AccessTokenKit::GetSelfPermissionsState(permsList181, info);
955 ASSERT_EQ(DYNAMIC_OPER, ret);
956 ASSERT_EQ(static_cast<uint32_t>(2), permsList181.size());
957 ASSERT_EQ(DYNAMIC_OPER, permsList181[0].state);
958 ASSERT_EQ(DYNAMIC_OPER, permsList181[1].state);
959
960 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
961 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
962 }
963
964 /**
965 * @tc.name: GetSelfPermissionsState019
966 * @tc.desc: vague + accurate + background after accept vague location permission, ret: PASS_OPER, state: INVALID_OPER
967 * @tc.type: FUNC
968 * @tc.require: issueI5NOQI
969 */
970 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState019, TestSize.Level0)
971 {
972 std::vector<PermissionStateFull> permissionStateFulls;
973 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
974 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
975 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
976
977 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
978 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
979 ASSERT_NE(INVALID_TOKENID, tokenID);
980 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
981
982 PermissionListState permVague19 = {
983 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
984 .state = SETTING_OPER,
985 };
986 PermissionListState permAccurate19 = {
987 .permissionName = "ohos.permission.LOCATION",
988 .state = SETTING_OPER,
989 };
990 PermissionListState permBack19 = {
991 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
992 .state = SETTING_OPER,
993 };
994
995 std::vector<PermissionListState> permsList19;
996 permsList19.emplace_back(permVague19);
997 permsList19.emplace_back(permAccurate19);
998 permsList19.emplace_back(permBack19);
999
1000 PermissionGrantInfo info;
1001 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList19, info);
1002 ASSERT_EQ(PASS_OPER, ret);
1003 ASSERT_EQ(static_cast<uint32_t>(3), permsList19.size());
1004 ASSERT_EQ(INVALID_OPER, permsList19[0].state);
1005 ASSERT_EQ(INVALID_OPER, permsList19[1].state);
1006 ASSERT_EQ(INVALID_OPER, permsList19[2].state);
1007
1008 // grant back permission, get accerate&vague again, ret: DYNAMIC_OPER, state: PASS_OPER + DYNAMIC_OPER
1009 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1010 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1011 std::vector<PermissionListState> permsList191;
1012 permsList191.emplace_back(permVague19);
1013 permsList191.emplace_back(permAccurate19);
1014 ret = AccessTokenKit::GetSelfPermissionsState(permsList191, info);
1015 ASSERT_EQ(DYNAMIC_OPER, ret);
1016 ASSERT_EQ(static_cast<uint32_t>(2), permsList191.size());
1017 ASSERT_EQ(PASS_OPER, permsList191[0].state);
1018 ASSERT_EQ(DYNAMIC_OPER, permsList191[1].state);
1019
1020 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1021 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1022 }
1023
1024 /**
1025 * @tc.name: GetSelfPermissionsState020
1026 * @tc.desc: vague + accurate + background after accept vague + accurate, ret: PASS_OPER, state: INVALID_OPER
1027 * @tc.type: FUNC
1028 * @tc.require: issueI5NOQI
1029 */
1030 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState020, TestSize.Level0)
1031 {
1032 std::vector<PermissionStateFull> permissionStateFulls;
1033 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
1034 permissionStateFulls.emplace_back(g_locationTestStateAccurate02); // {0,2}
1035 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1036
1037 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1038 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1039 ASSERT_NE(INVALID_TOKENID, tokenID);
1040 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1041
1042 PermissionListState permVague20 = {
1043 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1044 .state = SETTING_OPER,
1045 };
1046 PermissionListState permAccurate20 = {
1047 .permissionName = "ohos.permission.LOCATION",
1048 .state = SETTING_OPER,
1049 };
1050 PermissionListState permBack20 = {
1051 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1052 .state = SETTING_OPER,
1053 };
1054
1055 std::vector<PermissionListState> permsList20;
1056 permsList20.emplace_back(permVague20);
1057 permsList20.emplace_back(permAccurate20);
1058 permsList20.emplace_back(permBack20);
1059
1060 PermissionGrantInfo info;
1061 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList20, info);
1062 ASSERT_EQ(PASS_OPER, ret);
1063 ASSERT_EQ(static_cast<uint32_t>(3), permsList20.size());
1064 ASSERT_EQ(INVALID_OPER, permsList20[0].state);
1065 ASSERT_EQ(INVALID_OPER, permsList20[1].state);
1066 ASSERT_EQ(INVALID_OPER, permsList20[2].state);
1067
1068 // grant back permission, get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + PASS_OPER
1069 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1070 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1071 std::vector<PermissionListState> permsList201;
1072 permsList201.emplace_back(permVague20);
1073 permsList201.emplace_back(permAccurate20);
1074 ret = AccessTokenKit::GetSelfPermissionsState(permsList201, info);
1075 ASSERT_EQ(PASS_OPER, ret);
1076 ASSERT_EQ(static_cast<uint32_t>(2), permsList201.size());
1077 ASSERT_EQ(PASS_OPER, permsList201[0].state);
1078 ASSERT_EQ(PASS_OPER, permsList201[1].state);
1079
1080 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1081 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1082 }
1083
1084 /**
1085 * @tc.name: GetSelfPermissionsState021
1086 * @tc.desc: vague + accurate + background after accept vague + back, ret: PASS_OPER, state: INVALID_OPER
1087 * @tc.type: FUNC
1088 * @tc.require: issueI5NOQI
1089 */
1090 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState021, TestSize.Level0)
1091 {
1092 std::vector<PermissionStateFull> permissionStateFulls;
1093 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
1094 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1095 permissionStateFulls.emplace_back(g_locationTestStateBack02); // {0,2}
1096
1097 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1098 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1099 ASSERT_NE(INVALID_TOKENID, tokenID);
1100 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1101
1102 PermissionListState permVague21 = {
1103 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1104 .state = SETTING_OPER,
1105 };
1106 PermissionListState permAccurate21 = {
1107 .permissionName = "ohos.permission.LOCATION",
1108 .state = SETTING_OPER,
1109 };
1110 PermissionListState permBack21 = {
1111 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1112 .state = SETTING_OPER,
1113 };
1114
1115 std::vector<PermissionListState> permsList21;
1116 permsList21.emplace_back(permVague21);
1117 permsList21.emplace_back(permAccurate21);
1118 permsList21.emplace_back(permBack21);
1119
1120 PermissionGrantInfo info;
1121 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList21, info);
1122 ASSERT_EQ(PASS_OPER, ret);
1123 ASSERT_EQ(static_cast<uint32_t>(3), permsList21.size());
1124 ASSERT_EQ(INVALID_OPER, permsList21[0].state);
1125 ASSERT_EQ(INVALID_OPER, permsList21[1].state);
1126 ASSERT_EQ(INVALID_OPER, permsList21[2].state);
1127
1128 // get accerate&vague again, ret: DYNAMIC_OPER, state: PASS_OPER + DYNAMIC_OPER
1129 std::vector<PermissionListState> permsList211;
1130 permsList211.emplace_back(permVague21);
1131 permsList211.emplace_back(permAccurate21);
1132 ret = AccessTokenKit::GetSelfPermissionsState(permsList211, info);
1133 ASSERT_EQ(DYNAMIC_OPER, ret);
1134 ASSERT_EQ(static_cast<uint32_t>(2), permsList211.size());
1135 ASSERT_EQ(PASS_OPER, permsList211[0].state);
1136 ASSERT_EQ(DYNAMIC_OPER, permsList211[1].state);
1137
1138 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1139 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1140 }
1141
1142 /**
1143 * @tc.name: GetSelfPermissionsState022
1144 * @tc.desc: vague + accurate + background after accept all, ret: PASS_OPER, state: INVALID_OPER
1145 * @tc.type: FUNC
1146 * @tc.require: issueI5NOQI
1147 */
1148 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState022, TestSize.Level0)
1149 {
1150 std::vector<PermissionStateFull> permissionStateFulls;
1151 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
1152 permissionStateFulls.emplace_back(g_locationTestStateAccurate02); // {0,2}
1153 permissionStateFulls.emplace_back(g_locationTestStateBack02); // {0,2}
1154
1155 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1156 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1157 ASSERT_NE(INVALID_TOKENID, tokenID);
1158 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1159
1160 PermissionListState permVague22 = {
1161 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1162 .state = SETTING_OPER,
1163 };
1164 PermissionListState permAccurate22 = {
1165 .permissionName = "ohos.permission.LOCATION",
1166 .state = SETTING_OPER,
1167 };
1168 PermissionListState permBack22 = {
1169 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1170 .state = SETTING_OPER,
1171 };
1172
1173 std::vector<PermissionListState> permsList22;
1174 permsList22.emplace_back(permVague22);
1175 permsList22.emplace_back(permAccurate22);
1176 permsList22.emplace_back(permBack22);
1177
1178 PermissionGrantInfo info;
1179 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList22, info);
1180 ASSERT_EQ(PASS_OPER, ret);
1181 ASSERT_EQ(static_cast<uint32_t>(3), permsList22.size());
1182 ASSERT_EQ(INVALID_OPER, permsList22[0].state);
1183 ASSERT_EQ(INVALID_OPER, permsList22[1].state);
1184 ASSERT_EQ(INVALID_OPER, permsList22[2].state);
1185
1186 // get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + PASS_OPER
1187 std::vector<PermissionListState> permsList221;
1188 permsList221.emplace_back(permVague22);
1189 permsList221.emplace_back(permAccurate22);
1190 ret = AccessTokenKit::GetSelfPermissionsState(permsList221, info);
1191 ASSERT_EQ(PASS_OPER, ret);
1192 ASSERT_EQ(static_cast<uint32_t>(2), permsList221.size());
1193 ASSERT_EQ(PASS_OPER, permsList221[0].state);
1194 ASSERT_EQ(PASS_OPER, permsList221[1].state);
1195
1196 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1197 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1198 }
1199
1200 /**
1201 * @tc.name: GetSelfPermissionsState023
1202 * @tc.desc: vague + accurate + background after refuse vague location permission, ret: PASS_OPER, state: INVALID_OPER
1203 * @tc.type: FUNC
1204 * @tc.require: issueI5NOQI
1205 */
1206 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState023, TestSize.Level0)
1207 {
1208 std::vector<PermissionStateFull> permissionStateFulls;
1209 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
1210 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1211 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1212
1213 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1214 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1215 ASSERT_NE(INVALID_TOKENID, tokenID);
1216 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1217
1218 PermissionListState permVague23 = {
1219 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1220 .state = SETTING_OPER,
1221 };
1222 PermissionListState permAccurate23 = {
1223 .permissionName = "ohos.permission.LOCATION",
1224 .state = SETTING_OPER,
1225 };
1226 PermissionListState permBack23 = {
1227 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1228 .state = SETTING_OPER,
1229 };
1230
1231 std::vector<PermissionListState> permsList23;
1232 permsList23.emplace_back(permVague23);
1233 permsList23.emplace_back(permAccurate23);
1234 permsList23.emplace_back(permBack23);
1235
1236 PermissionGrantInfo info;
1237 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList23, info);
1238 ASSERT_EQ(PASS_OPER, ret);
1239 ASSERT_EQ(static_cast<uint32_t>(3), permsList23.size());
1240 ASSERT_EQ(INVALID_OPER, permsList23[0].state);
1241 ASSERT_EQ(INVALID_OPER, permsList23[1].state);
1242 ASSERT_EQ(INVALID_OPER, permsList23[2].state);
1243 // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + INVALID_OPER
1244 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1245 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1246 std::vector<PermissionListState> permsList231;
1247 permsList231.emplace_back(permVague23);
1248 permsList231.emplace_back(permAccurate23);
1249 ret = AccessTokenKit::GetSelfPermissionsState(permsList231, info);
1250 ASSERT_EQ(PASS_OPER, ret);
1251 ASSERT_EQ(static_cast<uint32_t>(2), permsList231.size());
1252 ASSERT_EQ(SETTING_OPER, permsList231[0].state);
1253 ASSERT_EQ(INVALID_OPER, permsList231[1].state);
1254
1255 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1256 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1257 }
1258
1259 /**
1260 * @tc.name: GetSelfPermissionsState024
1261 * @tc.desc: vague + accurate + background after refuse vague + accurate, ret: PASS_OPER, state: INVALID_OPER
1262 * @tc.type: FUNC
1263 * @tc.require: issueI5NOQI
1264 */
1265 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState024, TestSize.Level0)
1266 {
1267 std::vector<PermissionStateFull> permissionStateFulls;
1268 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
1269 permissionStateFulls.emplace_back(g_locationTestStateAccurate12); // {-1,2}
1270 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1271
1272 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1273 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1274 ASSERT_NE(INVALID_TOKENID, tokenID);
1275 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1276
1277 PermissionListState permVague24 = {
1278 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1279 .state = SETTING_OPER,
1280 };
1281 PermissionListState permAccurate24 = {
1282 .permissionName = "ohos.permission.LOCATION",
1283 .state = SETTING_OPER,
1284 };
1285 PermissionListState permBack24 = {
1286 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1287 .state = SETTING_OPER,
1288 };
1289
1290 std::vector<PermissionListState> permsList24;
1291 permsList24.emplace_back(permVague24);
1292 permsList24.emplace_back(permAccurate24);
1293 permsList24.emplace_back(permBack24);
1294
1295 PermissionGrantInfo info;
1296 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList24, info));
1297 ASSERT_EQ(static_cast<uint32_t>(3), permsList24.size());
1298 ASSERT_EQ(INVALID_OPER, permsList24[0].state);
1299 ASSERT_EQ(INVALID_OPER, permsList24[1].state);
1300 ASSERT_EQ(INVALID_OPER, permsList24[2].state);
1301
1302 // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + SETTING_OPER
1303 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1304 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1305 std::vector<PermissionListState> permsList241;
1306 permsList241.emplace_back(permVague24);
1307 permsList241.emplace_back(permAccurate24);
1308 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList241, info));
1309 ASSERT_EQ(static_cast<uint32_t>(2), permsList241.size());
1310 ASSERT_EQ(SETTING_OPER, permsList241[0].state);
1311 ASSERT_EQ(SETTING_OPER, permsList241[1].state);
1312
1313 // grant vague permission, get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + SETTING_OPER
1314 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1315 tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PermissionFlag::PERMISSION_USER_FIXED));
1316 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList241, info));
1317 ASSERT_EQ(static_cast<uint32_t>(2), permsList241.size());
1318 ASSERT_EQ(PASS_OPER, permsList241[0].state);
1319 ASSERT_EQ(SETTING_OPER, permsList241[1].state);
1320
1321 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1322 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1323 }
1324
1325 /**
1326 * @tc.name: GetSelfPermissionsState025
1327 * @tc.desc: vague + accurate + background after refuse vague + back, ret: PASS_OPER, state: INVALID_OPER
1328 * @tc.type: FUNC
1329 * @tc.require: issueI5NOQI
1330 */
1331 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState025, TestSize.Level0)
1332 {
1333 std::vector<PermissionStateFull> permissionStateFulls;
1334 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
1335 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1336 permissionStateFulls.emplace_back(g_locationTestStateBack12); // {-1,2}
1337
1338 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1339 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1340 ASSERT_NE(INVALID_TOKENID, tokenID);
1341 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1342
1343 PermissionListState permVague25 = {
1344 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1345 .state = SETTING_OPER,
1346 };
1347 PermissionListState permAccurate25 = {
1348 .permissionName = "ohos.permission.LOCATION",
1349 .state = SETTING_OPER,
1350 };
1351 PermissionListState permBack25 = {
1352 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1353 .state = SETTING_OPER,
1354 };
1355
1356 std::vector<PermissionListState> permsList25;
1357 permsList25.emplace_back(permVague25);
1358 permsList25.emplace_back(permAccurate25);
1359 permsList25.emplace_back(permBack25);
1360
1361 PermissionGrantInfo info;
1362 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList25, info));
1363 ASSERT_EQ(static_cast<uint32_t>(3), permsList25.size());
1364 ASSERT_EQ(INVALID_OPER, permsList25[0].state);
1365 ASSERT_EQ(INVALID_OPER, permsList25[1].state);
1366 ASSERT_EQ(INVALID_OPER, permsList25[2].state);
1367
1368 // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + INVALID_OPER
1369 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1370 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1371 std::vector<PermissionListState> permsList251;
1372 permsList251.emplace_back(permVague25);
1373 permsList251.emplace_back(permAccurate25);
1374 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList251, info));
1375 ASSERT_EQ(static_cast<uint32_t>(2), permsList251.size());
1376 ASSERT_EQ(SETTING_OPER, permsList251[0].state);
1377 ASSERT_EQ(INVALID_OPER, permsList251[1].state);
1378
1379 // grant vague permission, get accerate&vague again, ret: DYNAMIC_OPER, state: PASS_OPER + DYNAMIC_OPER
1380 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1381 tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PermissionFlag::PERMISSION_USER_FIXED));
1382 ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList251, info));
1383 ASSERT_EQ(static_cast<uint32_t>(2), permsList251.size());
1384 ASSERT_EQ(PASS_OPER, permsList251[0].state);
1385 ASSERT_EQ(DYNAMIC_OPER, permsList251[1].state);
1386
1387 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1388 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1389 }
1390
1391 /**
1392 * @tc.name: GetSelfPermissionsState026
1393 * @tc.desc: vague + accurate + background after refuse all, ret: PASS_OPER, state: INVALID_OPER
1394 * @tc.type: FUNC
1395 * @tc.require: issueI5NOQI
1396 */
1397 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState026, TestSize.Level0)
1398 {
1399 std::vector<PermissionStateFull> permissionStateFulls;
1400 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
1401 permissionStateFulls.emplace_back(g_locationTestStateAccurate12); // {-1,2}
1402 permissionStateFulls.emplace_back(g_locationTestStateBack12); // {-1,2}
1403
1404 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1405 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1406 ASSERT_NE(INVALID_TOKENID, tokenID);
1407 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1408
1409 PermissionListState permVague26 = {
1410 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1411 .state = SETTING_OPER,
1412 };
1413 PermissionListState permAccurate26 = {
1414 .permissionName = "ohos.permission.LOCATION",
1415 .state = SETTING_OPER,
1416 };
1417 PermissionListState permBack26 = {
1418 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1419 .state = SETTING_OPER,
1420 };
1421
1422 std::vector<PermissionListState> permsList26;
1423 permsList26.emplace_back(permVague26);
1424 permsList26.emplace_back(permAccurate26);
1425 permsList26.emplace_back(permBack26);
1426
1427 PermissionGrantInfo info;
1428 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList26, info));
1429 ASSERT_EQ(static_cast<uint32_t>(3), permsList26.size());
1430 ASSERT_EQ(INVALID_OPER, permsList26[0].state);
1431 ASSERT_EQ(INVALID_OPER, permsList26[1].state);
1432 ASSERT_EQ(INVALID_OPER, permsList26[2].state);
1433
1434 // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + SETTING_OPER
1435 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1436 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1437 std::vector<PermissionListState> permsList261;
1438 permsList261.emplace_back(permVague26);
1439 permsList261.emplace_back(permAccurate26);
1440 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList261, info));
1441 ASSERT_EQ(static_cast<uint32_t>(2), permsList261.size());
1442 ASSERT_EQ(SETTING_OPER, permsList261[0].state);
1443 ASSERT_EQ(SETTING_OPER, permsList261[1].state);
1444
1445 // grant vague permission, get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + SETTING_OPER
1446 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1447 tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PermissionFlag::PERMISSION_USER_FIXED));
1448 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList261, info));
1449 ASSERT_EQ(static_cast<uint32_t>(2), permsList261.size());
1450 ASSERT_EQ(PASS_OPER, permsList261[0].state);
1451 ASSERT_EQ(SETTING_OPER, permsList261[1].state);
1452
1453 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1454 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1455 }
1456
1457 /**
1458 * @tc.name: GetSelfPermissionsState027
1459 * @tc.desc: vague + accurate + back + other, ret: DYNAMIC_OPER, state: INVALID_OPER + PASS_OPER/DYNAMIC_OPER
1460 * @tc.type: FUNC
1461 * @tc.require: issueI5NOQI
1462 */
1463 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState027, TestSize.Level0)
1464 {
1465 std::vector<PermissionStateFull> permissionStateFulls;
1466 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
1467 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1468 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1469 permissionStateFulls.emplace_back(g_locationTestStateSystemGrant); // {0,4}
1470 permissionStateFulls.emplace_back(g_locationTestStateUserGrant); // {-1,0}
1471
1472 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, BACKGROUND_LOCATION_API_VERSION);
1473 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1474 ASSERT_NE(INVALID_TOKENID, tokenID);
1475 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1476
1477 PermissionListState permVague27 = {
1478 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1479 .state = SETTING_OPER,
1480 };
1481 PermissionListState permAccurate27 = {
1482 .permissionName = "ohos.permission.LOCATION",
1483 .state = SETTING_OPER,
1484 };
1485 PermissionListState permBack27 = {
1486 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1487 .state = SETTING_OPER,
1488 };
1489 PermissionListState permSystem27 = {
1490 .permissionName = "ohos.permission.UPDATE_SYSTEM",
1491 .state = SETTING_OPER,
1492 };
1493 PermissionListState permUser27 = {
1494 .permissionName = "ohos.permission.APP_TRACKING_CONSENT",
1495 .state = SETTING_OPER,
1496 };
1497
1498 std::vector<PermissionListState> permsList27;
1499 permsList27.emplace_back(permVague27);
1500 permsList27.emplace_back(permAccurate27);
1501 permsList27.emplace_back(permBack27);
1502 permsList27.emplace_back(permSystem27);
1503 permsList27.emplace_back(permUser27);
1504
1505 PermissionGrantInfo info;
1506 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList27, info);
1507 ASSERT_EQ(DYNAMIC_OPER, ret);
1508 ASSERT_EQ(static_cast<uint32_t>(5), permsList27.size());
1509 ASSERT_EQ(INVALID_OPER, permsList27[0].state);
1510 ASSERT_EQ(INVALID_OPER, permsList27[1].state);
1511 ASSERT_EQ(INVALID_OPER, permsList27[2].state);
1512 ASSERT_EQ(PASS_OPER, permsList27[3].state);
1513 ASSERT_EQ(DYNAMIC_OPER, permsList27[4].state);
1514
1515 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1516 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1517 }
1518
1519 /**
1520 * @tc.name: GetSelfPermissionsState028
1521 * @tc.desc: vague + api8
1522 * @tc.type: FUNC
1523 * @tc.require: issueI5NOQI
1524 */
1525 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState028, TestSize.Level0)
1526 {
1527 std::vector<PermissionStateFull> permissionStateFulls;
1528 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
1529
1530 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1531 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1532 ASSERT_NE(INVALID_TOKENID, tokenID);
1533 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1534
1535 PermissionListState permVague28 = {
1536 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1537 .state = SETTING_OPER,
1538 };
1539
1540 std::vector<PermissionListState> permsList28;
1541 permsList28.emplace_back(permVague28);
1542
1543 PermissionGrantInfo info;
1544 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList28, info);
1545 ASSERT_EQ(PASS_OPER, ret);
1546 ASSERT_EQ(static_cast<uint32_t>(1), permsList28.size());
1547 ASSERT_EQ(INVALID_OPER, permsList28[0].state);
1548
1549 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1550 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1551 }
1552
1553 /**
1554 * @tc.name: GetSelfPermissionsState029
1555 * @tc.desc: accurate + api8
1556 * @tc.type: FUNC
1557 * @tc.require: issueI5NOQI
1558 */
1559 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState029, TestSize.Level0)
1560 {
1561 std::vector<PermissionStateFull> permissionStateFulls;
1562 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1563
1564 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1565 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1566 ASSERT_NE(INVALID_TOKENID, tokenID);
1567 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1568
1569 PermissionListState permAccurate29 = {
1570 .permissionName = "ohos.permission.LOCATION",
1571 .state = SETTING_OPER,
1572 };
1573
1574 std::vector<PermissionListState> permsList29;
1575 permsList29.emplace_back(permAccurate29);
1576
1577 PermissionGrantInfo info;
1578 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList29, info);
1579 ASSERT_EQ(DYNAMIC_OPER, ret);
1580 ASSERT_EQ(static_cast<uint32_t>(1), permsList29.size());
1581 ASSERT_EQ(DYNAMIC_OPER, permsList29[0].state);
1582
1583 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1584 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1585 }
1586
1587 /**
1588 * @tc.name: GetSelfPermissionsState030
1589 * @tc.desc: back + api8
1590 * @tc.type: FUNC
1591 * @tc.require: issueI5NOQI
1592 */
1593 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState030, TestSize.Level0)
1594 {
1595 std::vector<PermissionStateFull> permissionStateFulls;
1596 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1597
1598 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1599 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1600 ASSERT_NE(INVALID_TOKENID, tokenID);
1601 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1602
1603 PermissionListState permBack30 = {
1604 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1605 .state = SETTING_OPER,
1606 };
1607
1608 std::vector<PermissionListState> permsList30;
1609 permsList30.emplace_back(permBack30);
1610
1611 PermissionGrantInfo info;
1612 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList30, info);
1613 ASSERT_EQ(DYNAMIC_OPER, ret);
1614 ASSERT_EQ(static_cast<uint32_t>(1), permsList30.size());
1615 ASSERT_EQ(DYNAMIC_OPER, permsList30[0].state);
1616
1617 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1618 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1619 }
1620
1621 /**
1622 * @tc.name: GetSelfPermissionsState031
1623 * @tc.desc: vague + accurate + api8
1624 * @tc.type: FUNC
1625 * @tc.require: issueI5NOQI
1626 */
1627 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState031, TestSize.Level0)
1628 {
1629 std::vector<PermissionStateFull> permissionStateFulls;
1630 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
1631 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1632
1633 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1634 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1635 ASSERT_NE(INVALID_TOKENID, tokenID);
1636 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1637
1638 PermissionListState permVague31 = {
1639 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1640 .state = SETTING_OPER,
1641 };
1642 PermissionListState permAccurate31 = {
1643 .permissionName = "ohos.permission.LOCATION",
1644 .state = SETTING_OPER,
1645 };
1646
1647 std::vector<PermissionListState> permsList31;
1648 permsList31.emplace_back(permVague31);
1649 permsList31.emplace_back(permAccurate31);
1650
1651 PermissionGrantInfo info;
1652 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList31, info);
1653 ASSERT_EQ(DYNAMIC_OPER, ret);
1654 ASSERT_EQ(static_cast<uint32_t>(2), permsList31.size());
1655 ASSERT_EQ(INVALID_OPER, permsList31[0].state);
1656 ASSERT_EQ(DYNAMIC_OPER, permsList31[1].state);
1657
1658 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1659 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1660 }
1661
1662 /**
1663 * @tc.name: GetSelfPermissionsState032
1664 * @tc.desc: vague + back + api8
1665 * @tc.type: FUNC
1666 * @tc.require: issueI5NOQI
1667 */
1668 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState032, TestSize.Level0)
1669 {
1670 std::vector<PermissionStateFull> permissionStateFulls;
1671 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
1672 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1673
1674 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1675 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1676 ASSERT_NE(INVALID_TOKENID, tokenID);
1677 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1678
1679 PermissionListState permVague32 = {
1680 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1681 .state = SETTING_OPER,
1682 };
1683 PermissionListState permBack32 = {
1684 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1685 .state = SETTING_OPER,
1686 };
1687
1688 std::vector<PermissionListState> permsList32;
1689 permsList32.emplace_back(permVague32);
1690 permsList32.emplace_back(permBack32);
1691
1692 PermissionGrantInfo info;
1693 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList32, info);
1694 ASSERT_EQ(DYNAMIC_OPER, ret);
1695 ASSERT_EQ(static_cast<uint32_t>(2), permsList32.size());
1696 ASSERT_EQ(INVALID_OPER, permsList32[0].state);
1697 ASSERT_EQ(DYNAMIC_OPER, permsList32[1].state);
1698
1699 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1700 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1701 }
1702
1703 /**
1704 * @tc.name: GetSelfPermissionsState033
1705 * @tc.desc: accurate + back + api8
1706 * @tc.type: FUNC
1707 * @tc.require: issueI5NOQI
1708 */
1709 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState033, TestSize.Level0)
1710 {
1711 std::vector<PermissionStateFull> permissionStateFulls;
1712 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1713 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1714
1715 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1716 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1717 ASSERT_NE(INVALID_TOKENID, tokenID);
1718 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1719
1720 PermissionListState permAccurate33 = {
1721 .permissionName = "ohos.permission.LOCATION",
1722 .state = SETTING_OPER,
1723 };
1724 PermissionListState permBack33 = {
1725 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1726 .state = SETTING_OPER,
1727 };
1728
1729 std::vector<PermissionListState> permsList33;
1730 permsList33.emplace_back(permAccurate33);
1731 permsList33.emplace_back(permBack33);
1732
1733 PermissionGrantInfo info;
1734 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList33, info);
1735 ASSERT_EQ(DYNAMIC_OPER, ret);
1736 ASSERT_EQ(static_cast<uint32_t>(2), permsList33.size());
1737 ASSERT_EQ(DYNAMIC_OPER, permsList33[0].state);
1738
1739 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1740 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1741 }
1742
1743 /**
1744 * @tc.name: GetSelfPermissionsState034
1745 * @tc.desc: vague + accurate + back + api8
1746 * @tc.type: FUNC
1747 * @tc.require: issueI5NOQI
1748 */
1749 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState034, TestSize.Level0)
1750 {
1751 std::vector<PermissionStateFull> permissionStateFulls;
1752 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
1753 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1754 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1755
1756 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, DEFAULT_API_VERSION);
1757 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1758 ASSERT_NE(INVALID_TOKENID, tokenID);
1759 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1760
1761 PermissionListState permVague34 = {
1762 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1763 .state = SETTING_OPER,
1764 };
1765 PermissionListState permAccurate34 = {
1766 .permissionName = "ohos.permission.LOCATION",
1767 .state = SETTING_OPER,
1768 };
1769 PermissionListState permBack34 = {
1770 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1771 .state = SETTING_OPER,
1772 };
1773
1774 std::vector<PermissionListState> permsList34;
1775 permsList34.emplace_back(permVague34);
1776 permsList34.emplace_back(permAccurate34);
1777 permsList34.emplace_back(permBack34);
1778
1779 PermissionGrantInfo info;
1780 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList34, info);
1781 ASSERT_EQ(DYNAMIC_OPER, ret);
1782 ASSERT_EQ(static_cast<uint32_t>(3), permsList34.size());
1783 ASSERT_EQ(INVALID_OPER, permsList34[0].state);
1784 ASSERT_EQ(DYNAMIC_OPER, permsList34[1].state);
1785 ASSERT_EQ(DYNAMIC_OPER, permsList34[2].state);
1786
1787 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1788 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1789 }
1790
1791 /**
1792 * @tc.name: GetSelfPermissionsState035
1793 * @tc.desc: vague + background location permissions api9, ret: DYNAMIC_OPER, state: DYNAMIC_OPER + SETTING_OPER
1794 * @tc.type: FUNC
1795 * @tc.require: issueI5NOQI
1796 */
1797 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState035, TestSize.Level0)
1798 {
1799 std::vector<PermissionStateFull> permissionStateFulls;
1800 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
1801 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1802
1803 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
1804 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1805 ASSERT_NE(INVALID_TOKENID, tokenID);
1806 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1807
1808 PermissionListState permVague35 = {
1809 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1810 .state = SETTING_OPER,
1811 };
1812 PermissionListState permBack35 = {
1813 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1814 .state = SETTING_OPER,
1815 };
1816
1817 std::vector<PermissionListState> permsList35;
1818 permsList35.emplace_back(permVague35);
1819 permsList35.emplace_back(permBack35);
1820
1821 PermissionGrantInfo info;
1822 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList35, info);
1823 ASSERT_EQ(DYNAMIC_OPER, ret);
1824 ASSERT_EQ(static_cast<uint32_t>(2), permsList35.size());
1825 ASSERT_EQ(DYNAMIC_OPER, permsList35[0].state);
1826 ASSERT_EQ(SETTING_OPER, permsList35[1].state);
1827
1828 // grant back permission, get vague again, ret: DYNAMIC_OPER, state: DYNAMIC_OPER
1829 ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(
1830 tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED));
1831 std::vector<PermissionListState> permsList351;
1832 permsList351.emplace_back(permVague35);
1833 ret = AccessTokenKit::GetSelfPermissionsState(permsList351, info);
1834 ASSERT_EQ(DYNAMIC_OPER, ret);
1835 ASSERT_EQ(static_cast<uint32_t>(1), permsList351.size());
1836 ASSERT_EQ(DYNAMIC_OPER, permsList351[0].state);
1837
1838 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1839 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1840 }
1841
1842 /**
1843 * @tc.name: GetSelfPermissionsState036
1844 * @tc.desc: vague + background after accept vague location permission api9
1845 * @tc.type: FUNC
1846 * @tc.require: issueI5NOQI
1847 */
1848 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState036, TestSize.Level0)
1849 {
1850 std::vector<PermissionStateFull> permissionStateFulls;
1851 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
1852 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1853
1854 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
1855 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1856 ASSERT_NE(INVALID_TOKENID, tokenID);
1857 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1858
1859 PermissionListState permVague36 = {
1860 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1861 .state = SETTING_OPER,
1862 };
1863 PermissionListState permBack36 = {
1864 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1865 .state = SETTING_OPER,
1866 };
1867
1868 std::vector<PermissionListState> permsList36;
1869 permsList36.emplace_back(permVague36);
1870 permsList36.emplace_back(permBack36);
1871
1872 PermissionGrantInfo info;
1873 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList36, info);
1874 ASSERT_EQ(PASS_OPER, ret);
1875 ASSERT_EQ(static_cast<uint32_t>(2), permsList36.size());
1876 ASSERT_EQ(PASS_OPER, permsList36[0].state);
1877 ASSERT_EQ(INVALID_OPER, permsList36[1].state);
1878
1879 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1880 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1881 }
1882
1883 /**
1884 * @tc.name: GetSelfPermissionsState037
1885 * @tc.desc: vague + background after refuse vague location permission api9
1886 * @tc.type: FUNC
1887 * @tc.require: issueI5NOQI
1888 */
1889 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState037, TestSize.Level0)
1890 {
1891 std::vector<PermissionStateFull> permissionStateFulls;
1892 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
1893 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1894
1895 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
1896 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1897 ASSERT_NE(INVALID_TOKENID, tokenID);
1898 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1899
1900 PermissionListState permVague37 = {
1901 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1902 .state = SETTING_OPER,
1903 };
1904 PermissionListState permBack37 = {
1905 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1906 .state = SETTING_OPER,
1907 };
1908
1909 std::vector<PermissionListState> permsList37;
1910 permsList37.emplace_back(permVague37);
1911 permsList37.emplace_back(permBack37);
1912
1913 PermissionGrantInfo info;
1914 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList37, info);
1915 ASSERT_EQ(PASS_OPER, ret);
1916 ASSERT_EQ(static_cast<uint32_t>(2), permsList37.size());
1917 ASSERT_EQ(SETTING_OPER, permsList37[0].state);
1918 ASSERT_EQ(INVALID_OPER, permsList37[1].state);
1919
1920 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1921 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1922 }
1923
1924 /**
1925 * @tc.name: GetSelfPermissionsState038
1926 * @tc.desc: vague + background after accept all location permissions api9
1927 * @tc.type: FUNC
1928 * @tc.require: issueI5NOQI
1929 */
1930 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState038, TestSize.Level0)
1931 {
1932 std::vector<PermissionStateFull> permissionStateFulls;
1933 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
1934 permissionStateFulls.emplace_back(g_locationTestStateBack02); // {0,2}
1935
1936 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
1937 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1938 ASSERT_NE(INVALID_TOKENID, tokenID);
1939 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1940
1941 PermissionListState permVague38 = {
1942 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
1943 .state = SETTING_OPER,
1944 };
1945 PermissionListState permBack38 = {
1946 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1947 .state = SETTING_OPER,
1948 };
1949
1950 std::vector<PermissionListState> permsList38;
1951 permsList38.emplace_back(permVague38);
1952 permsList38.emplace_back(permBack38);
1953
1954 PermissionGrantInfo info;
1955 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList38, info);
1956 ASSERT_EQ(PASS_OPER, ret);
1957 ASSERT_EQ(static_cast<uint32_t>(2), permsList38.size());
1958 ASSERT_EQ(PASS_OPER, permsList38[0].state);
1959 ASSERT_EQ(PASS_OPER, permsList38[1].state);
1960
1961 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
1962 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
1963 }
1964
1965 /**
1966 * @tc.name: GetSelfPermissionsState039
1967 * @tc.desc: accurate + background api9, ret: PASS_OPER, state: INVALID_OPER
1968 * @tc.type: FUNC
1969 * @tc.require: issueI5NOQI
1970 */
1971 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState039, TestSize.Level0)
1972 {
1973 std::vector<PermissionStateFull> permissionStateFulls;
1974 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
1975 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
1976
1977 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
1978 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
1979 ASSERT_NE(INVALID_TOKENID, tokenID);
1980 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
1981
1982 PermissionListState permAccurate39 = {
1983 .permissionName = "ohos.permission.LOCATION",
1984 .state = SETTING_OPER,
1985 };
1986 PermissionListState permBack39 = {
1987 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
1988 .state = SETTING_OPER,
1989 };
1990
1991 std::vector<PermissionListState> permsList39;
1992 permsList39.emplace_back(permAccurate39);
1993 permsList39.emplace_back(permBack39);
1994
1995 PermissionGrantInfo info;
1996 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList39, info);
1997 ASSERT_EQ(PASS_OPER, ret);
1998 ASSERT_EQ(static_cast<uint32_t>(2), permsList39.size());
1999 ASSERT_EQ(INVALID_OPER, permsList39[0].state);
2000 ASSERT_EQ(INVALID_OPER, permsList39[1].state);
2001
2002 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2003 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2004 }
2005
2006 /**
2007 * @tc.name: GetSelfPermissionsState040
2008 * @tc.desc: accurate/background with granted vague location api9, ret: DYNAMIC_OPER, state: DYNAMIC_OPER/SETTING_OPER
2009 * @tc.type: FUNC
2010 * @tc.require: issueI5NOQI
2011 */
2012 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState040, TestSize.Level0)
2013 {
2014 std::vector<PermissionStateFull> permissionStateFulls;
2015 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
2016 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2017 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2018
2019 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2020 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2021 ASSERT_NE(INVALID_TOKENID, tokenID);
2022 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2023
2024 PermissionListState permAccurate40 = {
2025 .permissionName = "ohos.permission.LOCATION",
2026 .state = SETTING_OPER,
2027 };
2028 PermissionListState permBack40 = {
2029 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2030 .state = SETTING_OPER,
2031 };
2032
2033 std::vector<PermissionListState> permsList40;
2034 permsList40.emplace_back(permAccurate40);
2035 permsList40.emplace_back(permBack40);
2036
2037 PermissionGrantInfo info;
2038 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList40, info);
2039 ASSERT_EQ(DYNAMIC_OPER, ret);
2040 ASSERT_EQ(static_cast<uint32_t>(2), permsList40.size());
2041 ASSERT_EQ(DYNAMIC_OPER, permsList40[0].state);
2042 ASSERT_EQ(SETTING_OPER, permsList40[1].state);
2043
2044 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2045 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2046 }
2047
2048 /**
2049 * @tc.name: GetSelfPermissionsState041
2050 * @tc.desc: vague + accurate + background api9, ret: DYNAMIC_OPER, state: DYNAMIC_OPER + DYNAMIC_OPER + SETTING_OPER
2051 * @tc.type: FUNC
2052 * @tc.require: issueI5NOQI
2053 */
2054 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState041, TestSize.Level0)
2055 {
2056 std::vector<PermissionStateFull> permissionStateFulls;
2057 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
2058 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2059 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2060
2061 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2062 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2063 ASSERT_NE(INVALID_TOKENID, tokenID);
2064 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2065
2066 PermissionListState permVague41 = {
2067 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2068 .state = SETTING_OPER,
2069 };
2070 PermissionListState permAccurate41 = {
2071 .permissionName = "ohos.permission.LOCATION",
2072 .state = SETTING_OPER,
2073 };
2074 PermissionListState permBack41 = {
2075 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2076 .state = SETTING_OPER,
2077 };
2078
2079 std::vector<PermissionListState> permsList41;
2080 permsList41.emplace_back(permVague41);
2081 permsList41.emplace_back(permAccurate41);
2082 permsList41.emplace_back(permBack41);
2083
2084 PermissionGrantInfo info;
2085 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList41, info);
2086 ASSERT_EQ(DYNAMIC_OPER, ret);
2087 ASSERT_EQ(static_cast<uint32_t>(3), permsList41.size());
2088 ASSERT_EQ(DYNAMIC_OPER, permsList41[0].state);
2089 ASSERT_EQ(DYNAMIC_OPER, permsList41[1].state);
2090 ASSERT_EQ(SETTING_OPER, permsList41[2].state);
2091
2092 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2093 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2094 }
2095
2096 /**
2097 * @tc.name: GetSelfPermissionsState042
2098 * @tc.desc: vague + accurate + background after accept vague location permission api9
2099 * @tc.type: FUNC
2100 * @tc.require: issueI5NOQI
2101 */
2102 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState042, TestSize.Level0)
2103 {
2104 std::vector<PermissionStateFull> permissionStateFulls;
2105 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
2106 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2107 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2108
2109 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2110 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2111 ASSERT_NE(INVALID_TOKENID, tokenID);
2112 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2113
2114 PermissionListState permVague42 = {
2115 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2116 .state = SETTING_OPER,
2117 };
2118 PermissionListState permAccurate42 = {
2119 .permissionName = "ohos.permission.LOCATION",
2120 .state = SETTING_OPER,
2121 };
2122 PermissionListState permBack42 = {
2123 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2124 .state = SETTING_OPER,
2125 };
2126
2127 std::vector<PermissionListState> permsList42;
2128 permsList42.emplace_back(permVague42);
2129 permsList42.emplace_back(permAccurate42);
2130 permsList42.emplace_back(permBack42);
2131
2132 PermissionGrantInfo info;
2133 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList42, info);
2134 ASSERT_EQ(DYNAMIC_OPER, ret);
2135 ASSERT_EQ(static_cast<uint32_t>(3), permsList42.size());
2136 ASSERT_EQ(PASS_OPER, permsList42[0].state);
2137 ASSERT_EQ(DYNAMIC_OPER, permsList42[1].state);
2138 ASSERT_EQ(SETTING_OPER, permsList42[2].state);
2139
2140 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2141 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2142 }
2143
2144 /**
2145 * @tc.name: GetSelfPermissionsState043
2146 * @tc.desc: vague + accurate + background after accept vague + accurate, api9
2147 * @tc.type: FUNC
2148 * @tc.require: issueI5NOQI
2149 */
2150 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState043, TestSize.Level0)
2151 {
2152 std::vector<PermissionStateFull> permissionStateFulls;
2153 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
2154 permissionStateFulls.emplace_back(g_locationTestStateAccurate02); // {0,2}
2155 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2156
2157 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2158 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2159 ASSERT_NE(INVALID_TOKENID, tokenID);
2160 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2161
2162 PermissionListState permVague20 = {
2163 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2164 .state = SETTING_OPER,
2165 };
2166 PermissionListState permAccurate20 = {
2167 .permissionName = "ohos.permission.LOCATION",
2168 .state = SETTING_OPER,
2169 };
2170 PermissionListState permBack20 = {
2171 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2172 .state = SETTING_OPER,
2173 };
2174
2175 std::vector<PermissionListState> permsList43;
2176 permsList43.emplace_back(permVague20);
2177 permsList43.emplace_back(permAccurate20);
2178 permsList43.emplace_back(permBack20);
2179
2180 PermissionGrantInfo info;
2181 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList43, info);
2182 ASSERT_EQ(PASS_OPER, ret);
2183 ASSERT_EQ(static_cast<uint32_t>(3), permsList43.size());
2184 ASSERT_EQ(PASS_OPER, permsList43[0].state);
2185 ASSERT_EQ(PASS_OPER, permsList43[1].state);
2186 ASSERT_EQ(INVALID_OPER, permsList43[2].state);
2187
2188 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2189 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2190 }
2191
2192 /**
2193 * @tc.name: GetSelfPermissionsState044
2194 * @tc.desc: vague + accurate + background after accept vague + back, api9
2195 * @tc.type: FUNC
2196 * @tc.require: issueI5NOQI
2197 */
2198 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState044, TestSize.Level0)
2199 {
2200 std::vector<PermissionStateFull> permissionStateFulls;
2201 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
2202 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2203 permissionStateFulls.emplace_back(g_locationTestStateBack02); // {0,2}
2204
2205 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2206 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2207 ASSERT_NE(INVALID_TOKENID, tokenID);
2208 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2209
2210 PermissionListState permVague44 = {
2211 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2212 .state = SETTING_OPER,
2213 };
2214 PermissionListState permAccurate44 = {
2215 .permissionName = "ohos.permission.LOCATION",
2216 .state = SETTING_OPER,
2217 };
2218 PermissionListState permBack44 = {
2219 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2220 .state = SETTING_OPER,
2221 };
2222
2223 std::vector<PermissionListState> permsList44;
2224 permsList44.emplace_back(permVague44);
2225 permsList44.emplace_back(permAccurate44);
2226 permsList44.emplace_back(permBack44);
2227
2228 PermissionGrantInfo info;
2229 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList44, info);
2230 ASSERT_EQ(DYNAMIC_OPER, ret);
2231 ASSERT_EQ(static_cast<uint32_t>(3), permsList44.size());
2232 ASSERT_EQ(PASS_OPER, permsList44[0].state);
2233 ASSERT_EQ(DYNAMIC_OPER, permsList44[1].state);
2234 ASSERT_EQ(PASS_OPER, permsList44[2].state);
2235
2236 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2237 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2238 }
2239
2240 /**
2241 * @tc.name: GetSelfPermissionsState045
2242 * @tc.desc: vague + accurate + background after accept all, api9
2243 * @tc.type: FUNC
2244 * @tc.require: issueI5NOQI
2245 */
2246 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState045, TestSize.Level0)
2247 {
2248 std::vector<PermissionStateFull> permissionStateFulls;
2249 permissionStateFulls.emplace_back(g_locationTestStateVague02); // {0,2}
2250 permissionStateFulls.emplace_back(g_locationTestStateAccurate02); // {0,2}
2251 permissionStateFulls.emplace_back(g_locationTestStateBack02); // {0,2}
2252
2253 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2254 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2255 ASSERT_NE(INVALID_TOKENID, tokenID);
2256 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2257
2258 PermissionListState permVague45 = {
2259 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2260 .state = SETTING_OPER,
2261 };
2262 PermissionListState permAccurate45 = {
2263 .permissionName = "ohos.permission.LOCATION",
2264 .state = SETTING_OPER,
2265 };
2266 PermissionListState permBack45 = {
2267 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2268 .state = SETTING_OPER,
2269 };
2270
2271 std::vector<PermissionListState> permsList45;
2272 permsList45.emplace_back(permVague45);
2273 permsList45.emplace_back(permAccurate45);
2274 permsList45.emplace_back(permBack45);
2275
2276 PermissionGrantInfo info;
2277 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList45, info);
2278 ASSERT_EQ(PASS_OPER, ret);
2279 ASSERT_EQ(static_cast<uint32_t>(3), permsList45.size());
2280 ASSERT_EQ(PASS_OPER, permsList45[0].state);
2281 ASSERT_EQ(PASS_OPER, permsList45[1].state);
2282 ASSERT_EQ(PASS_OPER, permsList45[2].state);
2283
2284 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2285 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2286 }
2287
2288 /**
2289 * @tc.name: GetSelfPermissionsState046
2290 * @tc.desc: vague + accurate + background after refuse vague location permission, api9
2291 * @tc.type: FUNC
2292 * @tc.require: issueI5NOQI
2293 */
2294 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState046, TestSize.Level0)
2295 {
2296 std::vector<PermissionStateFull> permissionStateFulls;
2297 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
2298 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2299 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2300
2301 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2302 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2303 ASSERT_NE(INVALID_TOKENID, tokenID);
2304 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2305
2306 PermissionListState permVague46 = {
2307 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2308 .state = SETTING_OPER,
2309 };
2310 PermissionListState permAccurate46 = {
2311 .permissionName = "ohos.permission.LOCATION",
2312 .state = SETTING_OPER,
2313 };
2314 PermissionListState permBack46 = {
2315 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2316 .state = SETTING_OPER,
2317 };
2318
2319 std::vector<PermissionListState> permsList46;
2320 permsList46.emplace_back(permVague46);
2321 permsList46.emplace_back(permAccurate46);
2322 permsList46.emplace_back(permBack46);
2323
2324 PermissionGrantInfo info;
2325 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList46, info);
2326 ASSERT_EQ(PASS_OPER, ret);
2327 ASSERT_EQ(static_cast<uint32_t>(3), permsList46.size());
2328 ASSERT_EQ(SETTING_OPER, permsList46[0].state);
2329 ASSERT_EQ(INVALID_OPER, permsList46[1].state);
2330 ASSERT_EQ(INVALID_OPER, permsList46[2].state);
2331
2332 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2333 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2334 }
2335
2336 /**
2337 * @tc.name: GetSelfPermissionsState047
2338 * @tc.desc: vague + accurate + background after refuse vague + accurate, api9
2339 * @tc.type: FUNC
2340 * @tc.require: issueI5NOQI
2341 */
2342 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState047, TestSize.Level0)
2343 {
2344 std::vector<PermissionStateFull> permissionStateFulls;
2345 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
2346 permissionStateFulls.emplace_back(g_locationTestStateAccurate12); // {-1,2}
2347 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2348
2349 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2350 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2351 ASSERT_NE(INVALID_TOKENID, tokenID);
2352 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2353
2354 PermissionListState permVague47 = {
2355 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2356 .state = SETTING_OPER,
2357 };
2358 PermissionListState permAccurate47 = {
2359 .permissionName = "ohos.permission.LOCATION",
2360 .state = SETTING_OPER,
2361 };
2362 PermissionListState permBack47 = {
2363 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2364 .state = SETTING_OPER,
2365 };
2366
2367 std::vector<PermissionListState> permsList47;
2368 permsList47.emplace_back(permVague47);
2369 permsList47.emplace_back(permAccurate47);
2370 permsList47.emplace_back(permBack47);
2371
2372 PermissionGrantInfo info;
2373 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList47, info);
2374 ASSERT_EQ(PASS_OPER, ret);
2375 ASSERT_EQ(static_cast<uint32_t>(3), permsList47.size());
2376 ASSERT_EQ(SETTING_OPER, permsList47[0].state);
2377 ASSERT_EQ(SETTING_OPER, permsList47[1].state);
2378 ASSERT_EQ(INVALID_OPER, permsList47[2].state);
2379
2380 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2381 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2382 }
2383
2384 /**
2385 * @tc.name: GetSelfPermissionsState048
2386 * @tc.desc: vague + accurate + background after refuse vague + back, api9
2387 * @tc.type: FUNC
2388 * @tc.require: issueI5NOQI
2389 */
2390 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState048, TestSize.Level0)
2391 {
2392 std::vector<PermissionStateFull> permissionStateFulls;
2393 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
2394 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2395 permissionStateFulls.emplace_back(g_locationTestStateBack12); // {-1,2}
2396
2397 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2398 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2399 ASSERT_NE(INVALID_TOKENID, tokenID);
2400 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2401
2402 PermissionListState permVague48 = {
2403 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2404 .state = SETTING_OPER,
2405 };
2406 PermissionListState permAccurate48 = {
2407 .permissionName = "ohos.permission.LOCATION",
2408 .state = SETTING_OPER,
2409 };
2410 PermissionListState permBack48 = {
2411 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2412 .state = SETTING_OPER,
2413 };
2414
2415 std::vector<PermissionListState> permsList48;
2416 permsList48.emplace_back(permVague48);
2417 permsList48.emplace_back(permAccurate48);
2418 permsList48.emplace_back(permBack48);
2419
2420 PermissionGrantInfo info;
2421 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList48, info);
2422 ASSERT_EQ(PASS_OPER, ret);
2423 ASSERT_EQ(static_cast<uint32_t>(3), permsList48.size());
2424 ASSERT_EQ(SETTING_OPER, permsList48[0].state);
2425 ASSERT_EQ(INVALID_OPER, permsList48[1].state);
2426 ASSERT_EQ(SETTING_OPER, permsList48[2].state);
2427
2428 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2429 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2430 }
2431
2432 /**
2433 * @tc.name: GetSelfPermissionsState049
2434 * @tc.desc: vague + accurate + background after refuse all, api9
2435 * @tc.type: FUNC
2436 * @tc.require: issueI5NOQI
2437 */
2438 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState049, TestSize.Level0)
2439 {
2440 std::vector<PermissionStateFull> permissionStateFulls;
2441 permissionStateFulls.emplace_back(g_locationTestStateVague12); // {-1,2}
2442 permissionStateFulls.emplace_back(g_locationTestStateAccurate12); // {-1,2}
2443 permissionStateFulls.emplace_back(g_locationTestStateBack12); // {-1,2}
2444
2445 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2446 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2447 ASSERT_NE(INVALID_TOKENID, tokenID);
2448 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2449
2450 PermissionListState permVague49 = {
2451 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2452 .state = SETTING_OPER,
2453 };
2454 PermissionListState permAccurate49 = {
2455 .permissionName = "ohos.permission.LOCATION",
2456 .state = SETTING_OPER,
2457 };
2458 PermissionListState permBack49 = {
2459 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2460 .state = SETTING_OPER,
2461 };
2462
2463 std::vector<PermissionListState> permsList49;
2464 permsList49.emplace_back(permVague49);
2465 permsList49.emplace_back(permAccurate49);
2466 permsList49.emplace_back(permBack49);
2467
2468 PermissionGrantInfo info;
2469 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList49, info);
2470 ASSERT_EQ(PASS_OPER, ret);
2471 ASSERT_EQ(static_cast<uint32_t>(3), permsList49.size());
2472 ASSERT_EQ(SETTING_OPER, permsList49[0].state);
2473 ASSERT_EQ(SETTING_OPER, permsList49[1].state);
2474 ASSERT_EQ(SETTING_OPER, permsList49[2].state);
2475
2476 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2477 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2478 }
2479
2480 /**
2481 * @tc.name: GetSelfPermissionsState050
2482 * @tc.desc: vague + accurate + back + other, api9
2483 * @tc.type: FUNC
2484 * @tc.require: issueI5NOQI
2485 */
2486 HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState050, TestSize.Level0)
2487 {
2488 std::vector<PermissionStateFull> permissionStateFulls;
2489 permissionStateFulls.emplace_back(g_locationTestStateVague10); // {-1,0}
2490 permissionStateFulls.emplace_back(g_locationTestStateAccurate10); // {-1,0}
2491 permissionStateFulls.emplace_back(g_locationTestStateBack10); // {-1,0}
2492 permissionStateFulls.emplace_back(g_locationTestStateSystemGrant); // {0,4}
2493 permissionStateFulls.emplace_back(g_locationTestStateUserGrant); // {-1,0}
2494
2495 AccessTokenIDEx tokenIdEx = AllocHapToken(permissionStateFulls, VAGUE_LOCATION_API_VERSION);
2496 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
2497 ASSERT_NE(INVALID_TOKENID, tokenID);
2498 ASSERT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
2499
2500 PermissionListState permVague50 = {
2501 .permissionName = "ohos.permission.APPROXIMATELY_LOCATION",
2502 .state = SETTING_OPER,
2503 };
2504 PermissionListState permAccurate50 = {
2505 .permissionName = "ohos.permission.LOCATION",
2506 .state = SETTING_OPER,
2507 };
2508 PermissionListState permBack50 = {
2509 .permissionName = "ohos.permission.LOCATION_IN_BACKGROUND",
2510 .state = SETTING_OPER,
2511 };
2512 PermissionListState permSystem50 = {
2513 .permissionName = "ohos.permission.UPDATE_SYSTEM",
2514 .state = SETTING_OPER,
2515 };
2516 PermissionListState permUser50 = {
2517 .permissionName = "ohos.permission.APP_TRACKING_CONSENT",
2518 .state = SETTING_OPER,
2519 };
2520
2521 std::vector<PermissionListState> permsList50;
2522 permsList50.emplace_back(permVague50);
2523 permsList50.emplace_back(permAccurate50);
2524 permsList50.emplace_back(permBack50);
2525 permsList50.emplace_back(permSystem50);
2526 permsList50.emplace_back(permUser50);
2527
2528 PermissionGrantInfo info;
2529 PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList50, info);
2530 ASSERT_EQ(DYNAMIC_OPER, ret);
2531 ASSERT_EQ(static_cast<uint32_t>(5), permsList50.size());
2532 ASSERT_EQ(DYNAMIC_OPER, permsList50[0].state);
2533 ASSERT_EQ(DYNAMIC_OPER, permsList50[1].state);
2534 ASSERT_EQ(SETTING_OPER, permsList50[2].state);
2535 ASSERT_EQ(PASS_OPER, permsList50[3].state);
2536 ASSERT_EQ(DYNAMIC_OPER, permsList50[4].state);
2537
2538 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId));
2539 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
2540 }
2541 } // namespace AccessToken
2542 } // namespace Security
2543 } // namespace OHOS
2544