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
16 #include <gtest/gtest.h>
17
18 #include "mock_my_flag.h"
19 #include "mock_ability_manager_client.h"
20
21 #define private public
22 #define protected public
23 #include "uri_permission_manager_client.h"
24 #include "uri_permission_manager_stub_impl.h"
25 #include "ability_manager_errors.h"
26 #undef private
27 #undef protected
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace AAFwk {
34 namespace {
35 constexpr int OFFSET = 30;
36 const std::string POLICY_INFO_PATH = "file://com.example.app1001/data/storage/el2/base/haps/entry/files/test_001.txt";
37 }
38 class UriPermissionManagerStubImplTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 };
45
SetUpTestCase()46 void UriPermissionManagerStubImplTest::SetUpTestCase() {}
47
TearDownTestCase()48 void UriPermissionManagerStubImplTest::TearDownTestCase() {}
49
SetUp()50 void UriPermissionManagerStubImplTest::SetUp()
51 {
52 MyFlag::Init();
53 }
54
TearDown()55 void UriPermissionManagerStubImplTest::TearDown() {}
56
57 /*
58 * Feature: UriPermissionManagerService
59 * Function: VerifyUriPermission
60 * SubFunction: NA
61 * FunctionPoints: UriPermissionManagerService VerifyUriPermission
62 */
63 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_VerifyUriPermission_001, TestSize.Level1)
64 {
65 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
66 MyFlag::isSAOrSystemAppCall_ = false;
67 std::string uri = "uri";
68 uint32_t flag = 1;
69 uint32_t tokenId = 1;
70 bool funcResult = true;
71 auto result = upmsi->VerifyUriPermission(Uri(uri), flag, tokenId, funcResult);
72 EXPECT_FALSE(funcResult);
73 EXPECT_EQ(result, ERR_OK);
74 }
75
76 /*
77 * Feature: UriPermissionManagerService
78 * Function: VerifyUriPermission
79 * SubFunction: NA
80 * FunctionPoints: UriPermissionManagerService VerifyUriPermission
81 */
82 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_VerifyUriPermission_002, TestSize.Level1)
83 {
84 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
85 std::string uri = "uri";
86 uint32_t flag = 0;
87 uint32_t tokenId = 1;
88 bool funcResult = true;
89 auto result = upmsi->VerifyUriPermission(Uri(uri), flag, tokenId, funcResult);
90 EXPECT_FALSE(funcResult);
91 EXPECT_EQ(result, ERR_OK);
92 }
93
94 /*
95 * Feature: UriPermissionManagerService
96 * Function: VerifyUriPermission
97 * SubFunction: NA
98 * FunctionPoints: UriPermissionManagerService VerifyUriPermission
99 */
100 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_VerifyUriPermission_003, TestSize.Level1)
101 {
102 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
103 MyFlag::isSAOrSystemAppCall_ = true;
104 MyFlag::isUriTypeValid_ = false;
105 std::string uri = "uri";
106 uint32_t flag = 1;
107 uint32_t tokenId = 1;
108 bool funcResult = true;
109 auto result = upmsi->VerifyUriPermission(Uri(uri), flag, tokenId, funcResult);
110 EXPECT_FALSE(funcResult);
111 EXPECT_EQ(result, ERR_OK);
112 }
113
114 /*
115 * Feature: UriPermissionManagerService
116 * Function: VerifySubDirUriPermission
117 * SubFunction: NA
118 * FunctionPoints: UriPermissionManagerService VerifySubDirUriPermission
119 */
120 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_VerifySubDirUriPermission_001, TestSize.Level1)
121 {
122 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
123 upmsi->uriMap_.clear();
124 std::string uriStr = "?networkid=";
125 uint32_t newFlag = 1;
126 uint32_t tokenId = 1;
127 auto result = upmsi->VerifySubDirUriPermission(uriStr, newFlag, tokenId);
128 EXPECT_FALSE(result);
129 }
130
131 /*
132 * Feature: UriPermissionManagerService
133 * Function: IsDistributedSubDirUri
134 * SubFunction: NA
135 * FunctionPoints: UriPermissionManagerService IsDistributedSubDirUri
136 */
137 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_IsDistributedSubDirUri_001, TestSize.Level1)
138 {
139 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
140 std::string inputUri = "";
141 std::string cachedUri = "";
142 auto result = upmsi->IsDistributedSubDirUri(inputUri, cachedUri);
143 EXPECT_FALSE(result);
144 }
145
146 /*
147 * Feature: UriPermissionManagerService
148 * Function: IsDistributedSubDirUri
149 * SubFunction: NA
150 * FunctionPoints: UriPermissionManagerService IsDistributedSubDirUri
151 */
152 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_IsDistributedSubDirUri_002, TestSize.Level1)
153 {
154 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
155 std::string inputUri = "file://home/user/shared_folder?networkid=12345";
156 std::string cachedUri = "file://home/user?networkid=12345";
157 auto result = upmsi->IsDistributedSubDirUri(inputUri, cachedUri);
158 EXPECT_TRUE(result);
159 }
160
161 /*
162 * Feature: UriPermissionManagerService
163 * Function: GrantUriPermission
164 * SubFunction: NA
165 * FunctionPoints: UriPermissionManagerService GrantUriPermission
166 */
167 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermission_001, TestSize.Level1)
168 {
169 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
170 MyFlag::isSystemAppCall_ = true;
171 Uri uri("uri");
172 unsigned int flag = 1;
173 std::string targetBundleName = "targetBundleName";
174 int32_t appIndex = 1;
175 uint32_t initiatorTokenId = 1;
176 int32_t funcResult;
177 auto result = upmsi->GrantUriPermission(uri, flag, targetBundleName, appIndex, initiatorTokenId, funcResult);
178 EXPECT_EQ(funcResult, ERR_CODE_INVALID_URI_TYPE);
179 EXPECT_EQ(result, ERR_OK);
180 }
181
182 /*
183 * Feature: UriPermissionManagerService
184 * Function: GrantUriPermission
185 * SubFunction: NA
186 * FunctionPoints: UriPermissionManagerService GrantUriPermission
187 */
188 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermission_002, TestSize.Level1)
189 {
190 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
191 MyFlag::isSystemAppCall_ = false;
192 Uri uri("file");
193 unsigned int flag = 1;
194 std::string targetBundleName = "targetBundleName";
195 int32_t appIndex = 1;
196 uint32_t initiatorTokenId = 1;
197 int32_t funcResult = 0;
198 auto result = upmsi->GrantUriPermission(uri, flag, targetBundleName, appIndex, initiatorTokenId, funcResult);
199 EXPECT_EQ(result, ERR_OK);
200 }
201
202 /*
203 * Feature: UriPermissionManagerService
204 * Function: GrantUriPermission
205 * SubFunction: NA
206 * FunctionPoints: UriPermissionManagerService GrantUriPermission
207 */
208 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermission_003, TestSize.Level1)
209 {
210 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
211 MyFlag::isSAOrSystemAppCall_ = true;
212 std::vector<std::string> uriVec;
213 unsigned int flag = 1;
214 std::string targetBundleName = "targetBundleName";
215 int32_t appIndex = 1;
216 uint32_t initiatorTokenId = 1;
217 int32_t funcResult = 1;
218 auto result = upmsi->GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, funcResult);
219 EXPECT_EQ(result, ERR_OK);
220 EXPECT_EQ(funcResult, INNER_ERR);
221 }
222
223 /*
224 * Feature: UriPermissionManagerService
225 * Function: GrantUriPermission
226 * SubFunction: NA
227 * FunctionPoints: UriPermissionManagerService GrantUriPermission
228 */
229 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermission_004, TestSize.Level1)
230 {
231 #define ABILITY_RUNTIME_MEDIA_LIBRARY_ENABLE
232 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
233 std::vector<std::string> mediaUris;
234 mediaUris.push_back("media://test");
235 uint32_t flag = 1;
236 uint32_t callerTokenId = 1;
237 uint32_t targetTokenId = 1;
238 int32_t hideSensitiveType = 1;
239 auto result = upmsi->GrantBatchMediaUriPermissionImpl(
240 mediaUris, flag, callerTokenId, targetTokenId, hideSensitiveType);
241 EXPECT_EQ(result, -1);
242 #undef ABILITY_RUNTIME_MEDIA_LIBRARY_ENABLE
243 }
244
245 /*
246 * Feature: UriPermissionManagerService
247 * Function: GrantBatchUriPermissionImpl
248 * SubFunction: NA
249 * FunctionPoints: UriPermissionManagerService GrantBatchUriPermissionImpl
250 */
251 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantBatchUriPermissionImpl_001, TestSize.Level1)
252 {
253 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
254 std::vector<std::string> uriVec;
255 uriVec.push_back("file://test");
256 uint32_t flag = 1;
257 TokenId callerTokenId = 1;
258 TokenId targetTokenId = 1;
259 auto result = upmsi->GrantBatchUriPermissionImpl(uriVec, flag, callerTokenId, targetTokenId);
260 EXPECT_EQ(result, INNER_ERR);
261 }
262
263 /*
264 * Feature: UriPermissionManagerService
265 * Function: AddTempUriPermission
266 * SubFunction: NA
267 * FunctionPoints: UriPermissionManagerService AddTempUriPermission
268 */
269 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_AddTempUriPermission_001, TestSize.Level1)
270 {
271 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
272 std::string uri = "file://test";
273 uint32_t flag = 1;
274 TokenId fromTokenId = 1;
275 TokenId targetTokenId = 1;
276 GrantInfo info = { flag, fromTokenId, targetTokenId };
277 upmsi->uriMap_.insert({ uri, { info } });
278 auto result = upmsi->AddTempUriPermission(uri, flag, fromTokenId, targetTokenId);
279 EXPECT_EQ(result, ERR_OK);
280 }
281
282 /*
283 * Feature: UriPermissionManagerService
284 * Function: AddTempUriPermission
285 * SubFunction: NA
286 * FunctionPoints: UriPermissionManagerService AddTempUriPermission
287 */
288 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_AddTempUriPermission_002, TestSize.Level1)
289 {
290 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
291 std::string uri = "file://test";
292 uint32_t flag = 1;
293 TokenId fromTokenId = 1;
294 TokenId targetTokenId = 1;
295 GrantInfo info = { 0, 0, 0 };
296 upmsi->uriMap_.insert({ uri, { info } });
297 auto result = upmsi->AddTempUriPermission(uri, flag, fromTokenId, targetTokenId);
298 EXPECT_EQ(result, ERR_OK);
299 }
300
301 /*
302 * Feature: UriPermissionManagerService
303 * Function: GrantUriPermissionPrivileged
304 * SubFunction: NA
305 * FunctionPoints: UriPermissionManagerService GrantUriPermissionPrivileged
306 */
307 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermissionPrivileged_001, TestSize.Level1)
308 {
309 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
310 std::vector<std::string> uriVec;
311 uint32_t flag = 1;
312 const std::string targetBundleName = "targetBundleName";
313 int32_t appIndex = 1;
314 uint32_t initiatorTokenId = 1;
315 int32_t hideSensitiveType = 1;
316 int32_t funcResult = ERR_CODE_INVALID_URI_TYPE;
317 auto result = upmsi->GrantUriPermissionPrivileged(uriVec, flag, targetBundleName, appIndex, initiatorTokenId,
318 hideSensitiveType, funcResult);
319 EXPECT_EQ(funcResult, ERR_URI_LIST_OUT_OF_RANGE);
320 EXPECT_EQ(result, ERR_URI_LIST_OUT_OF_RANGE);
321 }
322
323 /*
324 * Feature: UriPermissionManagerService
325 * Function: GrantUriPermissionPrivileged
326 * SubFunction: NA
327 * FunctionPoints: UriPermissionManagerService GrantUriPermissionPrivileged
328 */
329 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermissionPrivileged_002, TestSize.Level1)
330 {
331 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
332 UriPermissionRawData rawData;
333 rawData.data = nullptr;
334 uint32_t flag = 1;
335 const std::string targetBundleName = "";
336 int32_t appIndex = 1;
337 uint32_t initiatorTokenId = 1;
338 int32_t hideSensitiveType = 1;
339 int32_t funcResult = ERR_CODE_INVALID_URI_TYPE;
340 auto result = upmsi->GrantUriPermissionPrivileged(rawData, flag, targetBundleName, appIndex, initiatorTokenId,
341 hideSensitiveType, funcResult);
342 EXPECT_EQ(funcResult, ERR_DEAD_OBJECT);
343 EXPECT_EQ(result, ERR_DEAD_OBJECT);
344 }
345
346 /*
347 * Feature: UriPermissionManagerService
348 * Function: GrantUriPermissionPrivilegedInner
349 * SubFunction: NA
350 * FunctionPoints: UriPermissionManagerService GrantUriPermissionPrivilegedInner
351 */
352 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermissionPrivilegedInner_001, TestSize.Level1)
353 {
354 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
355 Uri uri("content");
356 std::vector<Uri> uriVec;
357 uriVec.push_back(uri);
358 uint32_t flag = 1;
359 uint32_t callerTokenId = 1;
360 uint32_t targetTokenId = 1;
361 std::string targetAlterBundleName = "targetAlterBundleName";
362 int32_t hideSensitiveType = 1;
363 MyFlag::isUriTypeValid_ = true;
364 MyFlag::isDocsCloudUri_ = true;
365 std::string bundleName = "bundleName";
366 UPMSAppInfo targetAppInfo = { targetTokenId, bundleName, targetAlterBundleName };
367 auto result = upmsi->GrantUriPermissionPrivilegedInner(uriVec, flag, callerTokenId, targetAppInfo,
368 hideSensitiveType);
369 EXPECT_EQ(result, INNER_ERR);
370 }
371
372 /*
373 * Feature: UriPermissionManagerService
374 * Function: GrantUriPermissionPrivilegedInner
375 * SubFunction: NA
376 * FunctionPoints: UriPermissionManagerService GrantUriPermissionPrivilegedInner
377 */
378 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermissionPrivilegedInner_002, TestSize.Level1)
379 {
380 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
381 Uri uri("uri://targetAlterBundleName");
382 std::vector<Uri> uriVec;
383 uriVec.push_back(uri);
384 uint32_t flag = 1;
385 uint32_t callerTokenId = 1;
386 uint32_t targetTokenId = 1;
387 std::string targetAlterBundleName = "targetAlterBundleName";
388 int32_t hideSensitiveType = 1;
389 MyFlag::isUriTypeValid_ = true;
390 MyFlag::isDocsCloudUri_ = false;
391 std::string bundleName = "bundleName";
392 UPMSAppInfo targetAppInfo = { targetTokenId, bundleName, targetAlterBundleName };
393 auto result = upmsi->GrantUriPermissionPrivilegedInner(uriVec, flag, callerTokenId, targetAppInfo,
394 hideSensitiveType);
395 EXPECT_EQ(result, ERR_OK);
396 }
397
398 /*
399 * Feature: UriPermissionManagerService
400 * Function: GrantUriPermissionPrivilegedInner
401 * SubFunction: NA
402 * FunctionPoints: UriPermissionManagerService GrantUriPermissionPrivilegedInner
403 */
404 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_GrantUriPermissionPrivilegedInner_003, TestSize.Level1)
405 {
406 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
407 Uri uri("uri://media");
408 std::vector<Uri> uriVec;
409 uriVec.push_back(uri);
410 uint32_t flag = 1;
411 uint32_t callerTokenId = 1;
412 uint32_t targetTokenId = 1;
413 std::string targetAlterBundleName = "targetAlterBundleName";
414 int32_t hideSensitiveType = 1;
415 MyFlag::isUriTypeValid_ = true;
416 MyFlag::isDocsCloudUri_ = false;
417 std::string bundleName = "bundleName";
418 UPMSAppInfo targetAppInfo = { targetTokenId, bundleName, targetAlterBundleName };
419 auto result = upmsi->GrantUriPermissionPrivilegedInner(uriVec, flag, callerTokenId, targetAppInfo,
420 hideSensitiveType);
421 EXPECT_EQ(result, INNER_ERR);
422 }
423
424 /*
425 * Feature: UriPermissionManagerService
426 * Function: CheckUriAuthorization
427 * SubFunction: NA
428 * FunctionPoints: UriPermissionManagerService CheckUriAuthorization
429 */
430 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_CheckUriAuthorization_001, TestSize.Level1)
431 {
432 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
433 std::vector<std::string> uriStrVec;
434 uint32_t flag = 1;
435 uint32_t tokenId = 1;
436 std::vector<bool> funcResult;
437 auto result = upmsi->CheckUriAuthorization(uriStrVec, flag, tokenId, funcResult);
438 EXPECT_EQ(result, ERR_URI_LIST_OUT_OF_RANGE);
439 }
440
441 /*
442 * Feature: UriPermissionManagerService
443 * Function: CheckUriAuthorization
444 * SubFunction: NA
445 * FunctionPoints: UriPermissionManagerService CheckUriAuthorization
446 */
447 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_CheckUriAuthorization_002, TestSize.Level1)
448 {
449 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
450 UriPermissionRawData rawData;
451 rawData.data = nullptr;
452 uint32_t flag = 1;
453 uint32_t tokenId = 1;
454 UriPermissionRawData funcResult;
455 auto result = upmsi->CheckUriAuthorization(rawData, flag, tokenId, funcResult);
456 EXPECT_EQ(result, ERR_DEAD_OBJECT);
457 }
458
459 /*
460 * Feature: UriPermissionManagerService
461 * Function: RevokeAllMapUriPermissions
462 * SubFunction: NA
463 * FunctionPoints: UriPermissionManagerService RevokeAllMapUriPermissions
464 */
465 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeAllMapUriPermissions_001, TestSize.Level1)
466 {
467 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
468 MyFlag::upmsUtilsBundleName_ = "callerAuthority";
469 GrantInfo info = { 1, 1, 1 };
470 upmsi->uriMap_.insert({ "uri://callerAuthority", { info } });
471 uint32_t tokenId = 1;
472 auto result = upmsi->RevokeAllMapUriPermissions(tokenId);
473 EXPECT_EQ(result, 0);
474 }
475
476 /*
477 * Feature: UriPermissionManagerService
478 * Function: RevokeAllMapUriPermissions
479 * SubFunction: NA
480 * FunctionPoints: UriPermissionManagerService RevokeAllMapUriPermissions
481 */
482 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeAllMapUriPermissions_002, TestSize.Level1)
483 {
484 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
485 MyFlag::upmsUtilsBundleName_ = "bundleName";
486 GrantInfo info = { 1, 1, 1 };
487 upmsi->uriMap_.insert({ "uri://callerAuthority", { info } });
488 uint32_t tokenId = 1;
489 auto result = upmsi->RevokeAllMapUriPermissions(tokenId);
490 EXPECT_EQ(upmsi->uriMap_.size(), 0);
491 EXPECT_EQ(result, 0);
492 }
493
494 /*
495 * Feature: UriPermissionManagerService
496 * Function: RevokeUriPermissionManually
497 * SubFunction: NA
498 * FunctionPoints: UriPermissionManagerService RevokeUriPermissionManually
499 */
500 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeUriPermissionManually_001, TestSize.Level1)
501 {
502 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
503 MyFlag::isSAOrSystemAppCall_ = true;
504 MyFlag::isUriTypeValid_ = true;
505 MyFlag::getTokenIdByBundleNameStatus_ = -1;
506 Uri uri("uri");
507 std::string bundleName = "bundleName";
508 int32_t appIndex = 1;
509 int32_t funcResult = 1;
510 auto result = upmsi->RevokeUriPermissionManually(uri, bundleName, appIndex, funcResult);
511 EXPECT_EQ(funcResult, -1);
512 EXPECT_EQ(result, ERR_OK);
513 }
514
515 /*
516 * Feature: UriPermissionManagerService
517 * Function: RevokeUriPermissionManuallyInner
518 * SubFunction: NA
519 * FunctionPoints: UriPermissionManagerService RevokeUriPermissionManuallyInner
520 */
521 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeUriPermissionManuallyInner_001, TestSize.Level1)
522 {
523 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
524 upmsi->uriMap_.clear();
525 Uri uri("uri://content");
526 uint32_t targetTokenId = 1;
527 MyFlag::isDocsCloudUri_ = true;
528 auto result = upmsi->RevokeUriPermissionManuallyInner(uri, targetTokenId);
529 EXPECT_EQ(result, ERR_OK);
530 }
531
532 /*
533 * Feature: UriPermissionManagerService
534 * Function: RevokeUriPermissionManuallyInner
535 * SubFunction: NA
536 * FunctionPoints: UriPermissionManagerService RevokeUriPermissionManuallyInner
537 */
538 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeUriPermissionManuallyInner_002, TestSize.Level1)
539 {
540 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
541 upmsi->uriMap_.clear();
542 Uri uri("uri://media");
543 uint32_t targetTokenId = 1;
544 MyFlag::isDocsCloudUri_ = false;
545 auto result = upmsi->RevokeUriPermissionManuallyInner(uri, targetTokenId);
546 EXPECT_EQ(result, -1);
547 }
548
549 /*
550 * Feature: UriPermissionManagerService
551 * Function: RevokeMapUriPermissionManually
552 * SubFunction: NA
553 * FunctionPoints: UriPermissionManagerService RevokeMapUriPermissionManually
554 */
555 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeMapUriPermissionManually_001, TestSize.Level1)
556 {
557 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
558 uint32_t callerTokenId = 1;
559 uint32_t targetTokenId = 1;
560 Uri uri("uri");
561 upmsi->uriMap_.clear();
562 auto result = upmsi->RevokeMapUriPermissionManually(callerTokenId, targetTokenId, uri);
563 EXPECT_EQ(result, ERR_OK);
564 }
565
566 /*
567 * Feature: UriPermissionManagerService
568 * Function: RevokeMapUriPermissionManually
569 * SubFunction: NA
570 * FunctionPoints: UriPermissionManagerService RevokeMapUriPermissionManually
571 */
572 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RevokeMapUriPermissionManually_002, TestSize.Level1)
573 {
574 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
575 uint32_t callerTokenId = 1;
576 uint32_t targetTokenId = 1;
577 Uri uri("uri");
578 GrantInfo info = { 1, 1, 1 };
579 upmsi->uriMap_.clear();
580 upmsi->uriMap_.insert({ uri.ToString(), { info } });
581 auto result = upmsi->RevokeMapUriPermissionManually(callerTokenId, targetTokenId, uri);
582 EXPECT_EQ(upmsi->uriMap_.size(), 0);
583 EXPECT_EQ(result, ERR_OK);
584 }
585
586 /*
587 * Feature: UriPermissionManagerService
588 * Function: ClearPermissionTokenByMap
589 * SubFunction: NA
590 * FunctionPoints: UriPermissionManagerService ClearPermissionTokenByMap
591 */
592 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_ClearPermissionTokenByMap_001, TestSize.Level1)
593 {
594 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
595 uint32_t tokenId = 0;
596 int32_t funcResult = 0;
597 auto result = upmsi->ClearPermissionTokenByMap(tokenId, funcResult);
598 EXPECT_EQ(funcResult, ERR_PERMISSION_DENIED);
599 EXPECT_EQ(result, ERR_OK);
600 }
601
602 /*
603 * Feature: UriPermissionManagerService
604 * Function: BoolVecToCharVec
605 * SubFunction: NA
606 * FunctionPoints: UriPermissionManagerService BoolVecToCharVec
607 */
608 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_BoolVecToCharVec_001, TestSize.Level1)
609 {
610 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
611 std::vector<bool> boolVector;
612 std::vector<char> charVector;
613 upmsi->BoolVecToCharVec(boolVector, charVector);
614 EXPECT_EQ(charVector.size(), 0);
615 }
616
617 /*
618 * Feature: UriPermissionManagerService
619 * Function: RawDataToStringVec
620 * SubFunction: NA
621 * FunctionPoints: UriPermissionManagerService RawDataToStringVec
622 */
623 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToStringVec_001, TestSize.Level1)
624 {
625 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
626 UriPermissionRawData rawData;
627 rawData.data = nullptr;
628 std::vector<std::string> stringVec;
629 auto result = upmsi->RawDataToStringVec(rawData, stringVec);
630 EXPECT_EQ(result, ERR_DEAD_OBJECT);
631 }
632
633 /*
634 * Feature: UriPermissionManagerService
635 * Function: RawDataToStringVec
636 * SubFunction: NA
637 * FunctionPoints: UriPermissionManagerService RawDataToStringVec
638 */
639 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToStringVec_002, TestSize.Level1)
640 {
641 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
642 UriPermissionRawData rawData;
643 rawData.data = upmsi.get();
644 rawData.size = 0;
645 std::vector<std::string> stringVec;
646 auto result = upmsi->RawDataToStringVec(rawData, stringVec);
647 EXPECT_EQ(result, ERR_DEAD_OBJECT);
648 }
649
650 /*
651 * Feature: UriPermissionManagerService
652 * Function: RawDataToStringVec
653 * SubFunction: NA
654 * FunctionPoints: UriPermissionManagerService RawDataToStringVec
655 */
656 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToStringVec_003, TestSize.Level1)
657 {
658 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
659 auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
660 std::vector<std::string> strArray;
661 strArray.emplace_back(POLICY_INFO_PATH);
662 UriPermissionRawData rawData;
663 upmc.StringVecToRawData(strArray, rawData);
664 rawData.size -= OFFSET;
665 UriPermissionRawData stubRawData;
666 stubRawData.size = rawData.size;
667 EXPECT_EQ(stubRawData.RawDataCpy(rawData.data), ERR_NONE);
668 std::vector<std::string> stringVec;
669 auto result = upmsi->RawDataToStringVec(stubRawData, stringVec);
670 EXPECT_EQ(result, ERR_DEAD_OBJECT);
671 }
672
673 /*
674 * Feature: UriPermissionManagerService
675 * Function: RawDataToPolicyInfo
676 * SubFunction: NA
677 * FunctionPoints: UriPermissionManagerService RawDataToPolicyInfo
678 */
679 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToPolicyInfo_001, TestSize.Level1)
680 {
681 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
682 auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
683 auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
684 PolicyInfo policyInfo;
685 policyInfo.path = POLICY_INFO_PATH;
686 policyInfo.mode = 1;
687 std::vector<PolicyInfo> policyInfoArray;
688 policyInfoArray.push_back(policyInfo);
689 UriPermissionRawData policyRawData;
690 upmc.PolicyInfoToRawData(policyInfoArray, policyRawData);
691 policyRawData.size -= OFFSET;
692 UriPermissionRawData stubPolicyRawData;
693 stubPolicyRawData.size = policyRawData.size;
694 EXPECT_EQ(stubPolicyRawData.RawDataCpy(policyRawData.data), ERR_NONE);
695 std::vector<PolicyInfo> policy;
696 auto result = upmsi->RawDataToPolicyInfo(stubPolicyRawData, policy);
697 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
698 #endif
699 }
700 } // namespace AAFwk
701 } // namespace OHOS