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