1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16
17 #define private public
18 #include "uri_permission_manager_client.h"
19 #include "uri_permission_load_callback.h"
20 #undef private
21 #include "ability_manager_errors.h"
22 #include "mock_sa_call.h"
23 #include "want.h"
24 using namespace testing;
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace AAFwk {
28 namespace {
29 const int MAX_URI_COUNT = 200000;
30 }
31
32 class UriPermissionManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38 };
39
SetUpTestCase()40 void UriPermissionManagerTest::SetUpTestCase() {}
41
TearDownTestCase()42 void UriPermissionManagerTest::TearDownTestCase() {}
43
SetUp()44 void UriPermissionManagerTest::SetUp()
45 {
46 AAFwk::UriPermissionManagerClient::GetInstance().isUriPermServiceStarted_.store(false);
47 }
48
TearDown()49 void UriPermissionManagerTest::TearDown() {}
50
51 /*
52 * Feature: UriPermissionManagerClient
53 * Function: ConnectUriPermService
54 * SubFunction: NA
55 * FunctionPoints: UriPermissionManagerClient ConnectUriPermService
56 */
57 HWTEST_F(UriPermissionManagerTest, ConnectUriPermService_001, TestSize.Level1)
58 {
59 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
60 upmc.saLoadFinished_ = true;
61 EXPECT_EQ(upmc.GetUriPermMgr(), nullptr);
62 auto ret = upmc.ConnectUriPermService();
63 EXPECT_EQ(ret, nullptr);
64 }
65
66 /*
67 * Feature: UriPermissionManagerClient
68 * Function: ConnectUriPermService
69 * SubFunction: NA
70 * FunctionPoints: UriPermissionManagerClient ConnectUriPermService
71 */
72 HWTEST_F(UriPermissionManagerTest, ConnectUriPermService_002, TestSize.Level1)
73 {
74 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
75 sptr<IRemoteObject> remoteObject = new (std::nothrow) UriPermissionLoadCallback();
76 upmc.SetUriPermMgr(remoteObject);
77 EXPECT_EQ(upmc.GetUriPermMgr(), nullptr);
78 auto ret = upmc.ConnectUriPermService();
79 EXPECT_EQ(ret, nullptr);
80 }
81
82 /*
83 * Feature: UriPermissionManagerClient
84 * Function: ConnectUriPermService
85 * SubFunction: NA
86 * FunctionPoints: UriPermissionManagerClient ConnectUriPermService
87 */
88 HWTEST_F(UriPermissionManagerTest, ConnectUriPermService_003, TestSize.Level1)
89 {
90 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
91 sptr<IRemoteObject> remoteObject = nullptr;
92 upmc.SetUriPermMgr(remoteObject);
93 EXPECT_EQ(upmc.GetUriPermMgr(), nullptr);
94 auto ret = upmc.ConnectUriPermService();
95 EXPECT_NE(ret, nullptr);
96 }
97
98 /*
99 * Feature: UriPermissionManagerClient
100 * Function: LoadUriPermService
101 * SubFunction: NA
102 * FunctionPoints: UriPermissionManagerClient LoadUriPermService
103 */
104 HWTEST_F(UriPermissionManagerTest, LoadUriPermService_001, TestSize.Level1)
105 {
106 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
107 upmc.saLoadFinished_ = true;
108 auto ret = upmc.LoadUriPermService();
109 EXPECT_TRUE(ret);
110 }
111
112 /*
113 * Feature: UriPermissionManagerClient
114 * Function: GrantUriPermission
115 * SubFunction: SingleGrantUriPermission
116 * FunctionPoints: NA.
117 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
118 */
119 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermission_001, TestSize.Level1)
120 {
121 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
122 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
123 std::string bundleName = "com.example.test1001";
124 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
125 auto ret = upmc.GrantUriPermission(uri, flag, bundleName, 0, 0);
126 EXPECT_NE(ret, ERR_OK);
127 }
128
129 /*
130 * Feature: UriPermissionManagerClient
131 * Function: GrantUriPermission
132 * SubFunction: BatchGrantUriPermission
133 * FunctionPoints: Size of uris is 0
134 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
135 */
136 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_BatchGrantUriPermission_001, TestSize.Level1)
137 {
138 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
139 std::vector<Uri> uriVec;
140 std::string bundleName = "com.example.test1001";
141 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
142 auto ret = upmc.GrantUriPermission(uriVec, flag, bundleName, 0, 0);
143 EXPECT_EQ(ret, ERR_URI_LIST_OUT_OF_RANGE);
144 }
145
146 /*
147 * Feature: UriPermissionManagerClient
148 * Function: GrantUriPermission
149 * SubFunction: BatchGrantUriPermission
150 * FunctionPoints: Size of uris is more than 500
151 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
152 */
153 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_BatchGrantUriPermission_002, TestSize.Level1)
154 {
155 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
156 Uri uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
157 std::vector<Uri> uriVec(MAX_URI_COUNT + 1, uri);
158 std::string bundleName = "com.example.test1001";
159 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
160 auto ret = upmc.GrantUriPermission(uriVec, flag, bundleName, 0, 0);
161 EXPECT_EQ(ret, ERR_URI_LIST_OUT_OF_RANGE);
162 }
163
164 /*
165 * Feature: UriPermissionManagerClient
166 * Function: GrantUriPermission
167 * SubFunction: BatchGrantUriPermission
168 * FunctionPoints: Size of uris is betweent 1 and 500
169 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermission
170 */
171 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_BatchGrantUriPermission_003, TestSize.Level1)
172 {
173 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
174 Uri uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
175 std::vector<Uri> uriVec(500, uri);
176 std::string bundleName = "com.example.test1001";
177 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
178 auto ret = upmc.GrantUriPermission(uriVec, flag, bundleName, 0, 0);
179 EXPECT_NE(ret, ERR_OK);
180 }
181
182 /*
183 * Feature: UriPermissionManagerClient
184 * Function: RevokeUriPermissionManually
185 * SubFunction: RevokeUriPermissionManually
186 * FunctionPoints: Uri is invalid.
187 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermissionManually
188 */
189 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermissionManually_001, TestSize.Level1)
190 {
191 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
192 auto uri = Uri("http://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
193 std::string bundleName = "com.example.test1001";
194 auto ret = upmc.RevokeUriPermissionManually(uri, bundleName);
195 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
196 }
197
198 /*
199 * Feature: UriPermissionManagerClient
200 * Function: RevokeUriPermissionManually
201 * SubFunction: RevokeUriPermissionManually
202 * FunctionPoints: Uri is valid.
203 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermissionManually
204 */
205 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermissionManually_002, TestSize.Level1)
206 {
207 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
208 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
209 std::string bundleName = "com.example.test1001";
210 auto ret = upmc.RevokeUriPermissionManually(uri, bundleName);
211 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
212 }
213
214 /*
215 * Feature: UriPermissionManagerClient
216 * Function: RevokeUriPermissionManually
217 * SubFunction: RevokeUriPermissionManually
218 * FunctionPoints: Uri is valid.
219 * CaseDescription: Verify UriPermissionManagerClient RevokeUriPermissionManually
220 */
221 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeUriPermissionManually_003, TestSize.Level1)
222 {
223 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
224 auto uri = Uri("file://com.example.test1001/data/storage/el2/base/haps/entry/files/test_A.txt");
225 std::string bundleName = "com.example.test1001";
226 auto ret = upmc.RevokeUriPermissionManually(uri, bundleName, 1001);
227 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
228 }
229
230 /*
231 * Feature: UriPermissionManagerClient
232 * Function: RevokeAllUriPermissions
233 * SubFunction: RevokeAllUriPermissions
234 * FunctionPoints: NA
235 * CaseDescription: Verify UriPermissionManagerClient RevokeAllUriPermissions
236 */
237 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_RevokeAllUriPermissions_001, TestSize.Level1)
238 {
239 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
240 uint32_t targetTokenId = 1001;
241 auto ret = upmc.RevokeAllUriPermissions(targetTokenId);
242 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
243 }
244
245 /*
246 * Feature: UriPermissionManagerClient
247 * Function: VerifyUriPermission
248 * SubFunction: VerifyUriPermission
249 * FunctionPoints: NA
250 * CaseDescription: Verify UriPermissionManagerClient VerifyUriPermission
251 */
252 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_VerifyUriPermission_001, TestSize.Level1)
253 {
254 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
255 auto uriStr = "file://docs/storage/Users/currentUser/test.txt";
256 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
257 std::string bundleName = "com.example.test";
258 uint32_t targetTokenId = 100002;
259 Uri uri(uriStr);
260 bool res = upmc.VerifyUriPermission(uri, flag, targetTokenId);
261 EXPECT_EQ(res, false);
262 }
263
264 /*
265 * Feature: UriPermissionManagerClient
266 * Function: CheckUriAuthorization
267 * SubFunction: CheckUriAuthorization
268 * FunctionPoints: Size of uris is 0
269 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
270 */
271 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_001, TestSize.Level1)
272 {
273 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
274 std::vector<std::string> uriVec;
275 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
276 uint32_t tokenId = 1001;
277 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
278 std::vector<bool> expectRes;
279 EXPECT_EQ(res, expectRes);
280 }
281
282 /*
283 * Feature: UriPermissionManagerClient
284 * Function: CheckUriAuthorization
285 * SubFunction: CheckUriAuthorization
286 * FunctionPoints: Size of uris is between 1 and 500
287 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
288 */
289 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_002, TestSize.Level1)
290 {
291 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
292 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
293 std::vector<std::string> uriVec(1, uriStr);
294 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
295 uint32_t tokenId = 1001;
296 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
297 std::vector<bool> expectRes(1, false);
298 EXPECT_EQ(res, expectRes);
299 }
300
301 /*
302 * Feature: UriPermissionManagerClient
303 * Function: CheckUriAuthorization
304 * SubFunction: CheckUriAuthorization
305 * FunctionPoints: Size of uris is more than 500
306 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
307 */
308 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_003, TestSize.Level1)
309 {
310 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
311 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
312 std::vector<std::string> uriVec(MAX_URI_COUNT + 1, uriStr);
313 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
314 uint32_t tokenId = 1001;
315 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
316 std::vector<bool> expectRes(MAX_URI_COUNT + 1, false);
317 EXPECT_EQ(res, expectRes);
318 }
319
320 /*
321 * Feature: UriPermissionManagerClient
322 * Function: CheckUriAuthorization
323 * SubFunction: CheckUriAuthorization
324 * FunctionPoints: Write Uri and result by raw data
325 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
326 */
327 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_004, TestSize.Level1)
328 {
329 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
330 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
331 std::vector<std::string> uriVec(50000, uriStr);
332 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
333 uint32_t tokenId = 1001;
334 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
335 std::vector<bool> expectRes(50000, false);
336 EXPECT_EQ(res, expectRes);
337 }
338
339 /*
340 * Feature: UriPermissionManagerClient
341 * Function: CheckUriAuthorization
342 * SubFunction: CheckUriAuthorization
343 * FunctionPoints: Write Uri and result by raw data
344 * CaseDescription: Verify UriPermissionManagerClient CheckUriAuthorization
345 */
346 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_CheckUriAuthorization_005, TestSize.Level1)
347 {
348 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
349 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
350 std::vector<std::string> uriVec(MAX_URI_COUNT, uriStr);
351 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
352 uint32_t tokenId = 1001;
353 auto res = upmc.CheckUriAuthorization(uriVec, flag, tokenId);
354 std::vector<bool> expectRes(MAX_URI_COUNT, false);
355 EXPECT_EQ(res, expectRes);
356 }
357
358 /*
359 * Feature: UriPermissionManagerClient
360 * Function: GrantUriPermissionPrivileged
361 * SubFunction: GrantUriPermissionPrivileged
362 * FunctionPoints: Size of uris is 0
363 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
364 */
365 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_001, TestSize.Level1)
366 {
367 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
368 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
369 std::vector<Uri> uriVec;
370 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
371 std::string bundleName = "com.example.test1001";
372 int32_t appIndex = 0;
373 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
374 EXPECT_EQ(res, ERR_URI_LIST_OUT_OF_RANGE);
375 }
376
377 /*
378 * Feature: UriPermissionManagerClient
379 * Function: GrantUriPermissionPrivileged
380 * SubFunction: GrantUriPermissionPrivileged
381 * FunctionPoints: Size of uris is more than 500
382 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
383 */
384 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_002, TestSize.Level1)
385 {
386 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
387 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
388 std::vector<Uri> uriVec(MAX_URI_COUNT + 1, Uri(uriStr));
389 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
390 std::string bundleName = "com.example.test1001";
391 int32_t appIndex = 0;
392 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
393 EXPECT_EQ(res, ERR_URI_LIST_OUT_OF_RANGE);
394 }
395
396 /*
397 * Feature: UriPermissionManagerClient
398 * Function: GrantUriPermissionPrivileged
399 * SubFunction: GrantUriPermissionPrivileged
400 * FunctionPoints: size of uri is between 1 and 500
401 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
402 */
403 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_003, TestSize.Level1)
404 {
405 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
406 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
407 std::vector<Uri> uriVec(1, Uri(uriStr));
408 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
409 std::string bundleName = "com.example.test1001";
410 int32_t appIndex = 0;
411 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
412 EXPECT_EQ(res, CHECK_PERMISSION_FAILED);
413 }
414
415 /*
416 * Feature: UriPermissionManagerClient
417 * Function: GrantUriPermissionPrivileged
418 * SubFunction: GrantUriPermissionPrivileged
419 * FunctionPoints: Write Uri by raw data
420 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
421 */
422 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_004, TestSize.Level1)
423 {
424 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
425 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
426 std::vector<Uri> uriVec(50000, Uri(uriStr));
427 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
428 std::string bundleName = "com.example.test1001";
429 int32_t appIndex = 0;
430 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
431 EXPECT_EQ(res, CHECK_PERMISSION_FAILED);
432 }
433
434 /*
435 * Feature: UriPermissionManagerClient
436 * Function: GrantUriPermissionPrivileged
437 * SubFunction: GrantUriPermissionPrivileged
438 * FunctionPoints: Write Uri by raw data
439 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
440 */
441 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_005, TestSize.Level1)
442 {
443 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
444 std::string uriStr = "file://docs/storage/Users/currentUser/test.txt";
445 std::vector<Uri> uriVec(MAX_URI_COUNT, Uri(uriStr));
446 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
447 std::string bundleName = "com.example.test1001";
448 int32_t appIndex = 0;
449 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
450 EXPECT_EQ(res, CHECK_PERMISSION_FAILED);
451 }
452
453 /*
454 * Feature: UriPermissionManagerClient
455 * Function: GrantUriPermissionPrivileged
456 * SubFunction: GrantUriPermissionPrivileged
457 * FunctionPoints: Write Uri by raw data, more than 128M
458 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionPrivileged
459 */
460 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionPrivileged_006, TestSize.Level1)
461 {
462 auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
463 std::string uriStr = "file://docs/storage/Users/currentUser/";
464 for (int32_t i = 0; i < 100; i++) {
465 uriStr += "aaaaaaaaaaaa/";
466 }
467 uriStr += "1.txt";
468 std::vector<Uri> uriVec(MAX_URI_COUNT, Uri(uriStr));
469 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
470 std::string bundleName = "com.example.test1001";
471 int32_t appIndex = 0;
472 auto res = upmc.GrantUriPermissionPrivileged(uriVec, flag, bundleName, appIndex, 0, 0);
473 EXPECT_EQ(res, INNER_ERR);
474 }
475
476 /*
477 * Feature: UriPermissionManagerClient
478 * Function: GrantUriPermissionByKey
479 * SubFunction: NA
480 * FunctionPoints: Grant permission failed
481 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionByKey
482 */
483 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionByKey_001, TestSize.Level1)
484 {
485 auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
486 std::string key = "testKey";
487 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
488 uint32_t targetTokenId = 100002;
489 auto ret = upmc.GrantUriPermissionByKey(key, flag, targetTokenId);
490 EXPECT_NE(ret, ERR_OK);
491 }
492
493 /*
494 * Feature: UriPermissionManagerClient
495 * Function: GrantUriPermissionByKeyAsCaller
496 * SubFunction: NA
497 * FunctionPoints: Grant permission failed
498 * CaseDescription: Verify UriPermissionManagerClient GrantUriPermissionByKeyAsCaller
499 */
500 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_GrantUriPermissionByKeyAsCaller_001, TestSize.Level1)
501 {
502 auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
503 std::string key = "testKey";
504 uint32_t flag = Want::FLAG_AUTH_READ_URI_PERMISSION;
505 uint32_t callerTokenId = 100001;
506 uint32_t targetTokenId = 100002;
507 auto ret = upmc.GrantUriPermissionByKeyAsCaller(key, flag, callerTokenId, targetTokenId);
508 EXPECT_NE(ret, ERR_OK);
509 }
510
511 /*
512 * Feature: UriPermissionManagerClient
513 * Function: ClearPermissionTokenByMap
514 * SubFunction: ClearPermissionTokenByMap
515 * FunctionPoints: Do clear uri permission, when upms is started and not started.
516 */
517 HWTEST_F(UriPermissionManagerTest, UriPermissionManager_ClearPermissionTokenByMap_001, TestSize.Level1)
518 {
519 auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
520 uint32_t tokenId = 1001;
521 auto res = upmc.ClearPermissionTokenByMap(tokenId);
522 EXPECT_EQ(res, ERR_UPMS_SERVICE_NOT_START);
523
524 upmc.isUriPermServiceStarted_.store(true);
525 res = upmc.ClearPermissionTokenByMap(tokenId);
526 EXPECT_NE(res, ERR_UPMS_SERVICE_NOT_START);
527 }
528 } // namespace AAFwk
529 } // namespace OHOS