1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "accesstoken_kit.h"
19 #include "app_utils.h"
20 #include "array_wrapper.h"
21 #include "string_wrapper.h"
22
23 #include "uri_utils.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace AAFwk {
30 namespace {
31 const int32_t BEYOND_MAX_URI_COUNT = 501;
32 const int32_t MAX_URI_COUNT = 500;
33 constexpr const char* ABILIY_PARAM_STREAM = "ability.params.stream";
34 }
35 using namespace Security::AccessToken;
36 class UriUtilsTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase()44 void UriUtilsTest::SetUpTestCase() {}
45
TearDownTestCase()46 void UriUtilsTest::TearDownTestCase() {}
47
SetUp()48 void UriUtilsTest::SetUp()
49 {
50 AccessTokenKit::InitMockResult();
51 }
52
TearDown()53 void UriUtilsTest::TearDown() {}
54
55 /*
56 * Feature: UriUtils
57 * Function: GetUriListFromWantDms
58 * SubFunction: NA
59 * FunctionPoints: UriUtils GetUriListFromWantDms
60 */
61 HWTEST_F(UriUtilsTest, GetUriListFromWantDms_001, TestSize.Level1)
62 {
63 Want want;
64 auto uriList = UriUtils::GetInstance().GetUriListFromWantDms(want);
65 EXPECT_EQ(uriList.size(), 0);
66
67 WantParams params;
68 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(BEYOND_MAX_URI_COUNT, AAFwk::g_IID_IString);
69 if (ao != nullptr) {
70 for (size_t i = 0; i < BEYOND_MAX_URI_COUNT; i++) {
71 ao->Set(i, String::Box("file"));
72 }
73 params.SetParam("ability.verify.uri", ao);
74 }
75 want.SetParams(params);
76 auto uriList2 = UriUtils::GetInstance().GetUriListFromWantDms(want);
77 EXPECT_EQ(uriList2.size(), 0);
78
79 sptr<AAFwk::IArray> ao2 = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
80 if (ao2 != nullptr) {
81 ao2->Set(0, String::Box("file://data/storage/el2/distributedfiles/test.txt"));
82 params.SetParam("ability.verify.uri", ao2);
83 }
84 want.SetParams(params);
85 auto uriList3 = UriUtils::GetInstance().GetUriListFromWantDms(want);
86 EXPECT_EQ(uriList3.size(), 0);
87 }
88
89 /*
90 * Feature: UriUtils
91 * Function: GetPermissionedUriList
92 * SubFunction: NA
93 * FunctionPoints: UriUtils GetPermissionedUriList
94 */
95 HWTEST_F(UriUtilsTest, GetPermissionedUriList_001, TestSize.Level1)
96 {
97 AccessTokenKit::hapInfo.apiVersion = 20;
98 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
99 AccessTokenKit::getHapTokenInfoRet = 0;
100 std::vector<std::string> uriVec;
101 std::vector<bool> checkResults = {true};
102 Want want;
103 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
104 EXPECT_EQ(vec.size(), 0);
105
106 want.SetUri("ability.verify.uri");
107 uriVec.push_back("file://data/storage/el2/distributedfiles/test.txt");
108 std::vector<Uri> vec2 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
109 EXPECT_EQ(vec2.size(), 1);
110
111 checkResults[0] = false;
112 std::vector<Uri> vec3 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
113 EXPECT_EQ(vec3.size(), 0);
114
115 checkResults[0] = true;
116 uriVec.push_back("https//test.openharmony.com");
117 checkResults.push_back(true);
118 std::vector<Uri> vec4 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
119 EXPECT_EQ(vec4.size(), 2);
120
121 checkResults[1] = false;
122 std::vector<Uri> vec5 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
123 EXPECT_EQ(vec5.size(), 1);
124 }
125
126 /*
127 * Feature: UriUtils
128 * Function: GetPermissionedUriList
129 * SubFunction: NA
130 * FunctionPoints: UriUtils GetPermissionedUriList, want has permissioned file uri param
131 */
132 HWTEST_F(UriUtilsTest, GetPermissionedUriList_002, TestSize.Level1)
133 {
134 AccessTokenKit::hapInfo.apiVersion = 20;
135 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
136 AccessTokenKit::getHapTokenInfoRet = 0;
137 std::string uri = "file://com.example.test/test.txt";
138 Want want;
139 want.SetUri(uri);
140 std::vector<std::string> uriVec = { uri };
141 std::vector<bool> checkResults = { true };
142 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
143 EXPECT_EQ(vec.size(), 1);
144 EXPECT_EQ(want.GetUriString(), uri);
145 }
146
147 /*
148 * Feature: UriUtils
149 * Function: GetPermissionedUriList
150 * SubFunction: NA
151 * FunctionPoints: UriUtils GetPermissionedUriList, want has unPrivileged file uri param
152 */
153 HWTEST_F(UriUtilsTest, GetPermissionedUriList_003, TestSize.Level1)
154 {
155 AccessTokenKit::hapInfo.apiVersion = 20;
156 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
157 AccessTokenKit::getHapTokenInfoRet = 0;
158 std::string uri = "file://docs/test.txt";
159 Want want;
160 want.SetUri(uri);
161 std::vector<std::string> uriVec = { uri };
162 std::vector<bool> checkResults = { false };
163 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
164 EXPECT_EQ(vec.size(), 0);
165 EXPECT_EQ(want.GetUriString(), "");
166 }
167
168 /*
169 * Feature: UriUtils
170 * Function: GetPermissionedUriList
171 * SubFunction: NA
172 * FunctionPoints: UriUtils GetPermissionedUriList, want has other uri param (scheme is not empty)
173 */
174 HWTEST_F(UriUtilsTest, GetPermissionedUriList_004, TestSize.Level1)
175 {
176 AccessTokenKit::hapInfo.apiVersion = 20;
177 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
178 AccessTokenKit::getHapTokenInfoRet = 0;
179 std::string uri = "http://com.example.test/test.txt";
180 Want want;
181 want.SetUri(uri);
182 std::vector<std::string> uriVec = { uri };
183 std::vector<bool> checkResults = { false };
184 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
185 EXPECT_EQ(vec.size(), 0);
186 EXPECT_EQ(want.GetUriString(), uri);
187 }
188
189 /*
190 * Feature: UriUtils
191 * Function: GetPermissionedUriList
192 * SubFunction: NA
193 * FunctionPoints: UriUtils GetPermissionedUriList, want has other uri param (scheme is empty)
194 */
195 HWTEST_F(UriUtilsTest, GetPermissionedUriList_005, TestSize.Level1)
196 {
197 AccessTokenKit::hapInfo.apiVersion = 20;
198 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
199 AccessTokenKit::getHapTokenInfoRet = 0;
200 std::string uri = "/data/storage/el2/temp.txt";
201 Want want;
202 want.SetUri(uri);
203 std::vector<std::string> uriVec = { uri };
204 std::vector<bool> checkResults = { false };
205 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
206 EXPECT_EQ(vec.size(), 0);
207 EXPECT_EQ(want.GetUriString(), "");
208 }
209
210 /*
211 * Feature: UriUtils
212 * Function: GetPermissionedUriList
213 * SubFunction: NA
214 * FunctionPoints: UriUtils GetPermissionedUriList, want has other uri param (scheme is empty)
215 */
216 HWTEST_F(UriUtilsTest, GetPermissionedUriList_006, TestSize.Level1)
217 {
218 AccessTokenKit::hapInfo.apiVersion = 20;
219 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
220 AccessTokenKit::getHapTokenInfoRet = 0;
221 std::string uri = ":temp.txt";
222 Want want;
223 want.SetUri(uri);
224 std::vector<std::string> uriVec = { uri };
225 std::vector<bool> checkResults = { false };
226 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
227 EXPECT_EQ(vec.size(), 0);
228 EXPECT_EQ(want.GetUriString(), "");
229 }
230
231 /*
232 * Feature: UriUtils
233 * Function: GetPermissionedUriList
234 * SubFunction: NA
235 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with permissioned file uri
236 */
237 HWTEST_F(UriUtilsTest, GetPermissionedUriList_007, TestSize.Level1)
238 {
239 AccessTokenKit::hapInfo.apiVersion = 20;
240 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
241 AccessTokenKit::getHapTokenInfoRet = 0;
242 std::string uri = "file://com.example.test/test.txt";
243 Want want;
244 std::vector<std::string> paramStreamUris = { uri };
245 want.SetParam("ability.params.stream", paramStreamUris);
246
247 std::vector<std::string> uriVec = { uri };
248 std::vector<bool> checkResults = { true };
249 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
250 EXPECT_EQ(vec.size(), 1);
251
252 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
253 EXPECT_EQ(paramStreamUris2.size(), 1);
254 }
255
256 /*
257 * Feature: UriUtils
258 * Function: GetPermissionedUriList
259 * SubFunction: NA
260 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with unprivileged file uri
261 */
262 HWTEST_F(UriUtilsTest, GetPermissionedUriList_008, TestSize.Level1)
263 {
264 AccessTokenKit::hapInfo.apiVersion = 20;
265 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
266 AccessTokenKit::getHapTokenInfoRet = 0;
267 std::string uri = "file://docs/test.txt";
268 Want want;
269 std::vector<std::string> paramStreamUris = { uri };
270 want.SetParam("ability.params.stream", paramStreamUris);
271
272 std::vector<std::string> uriVec = { uri };
273 std::vector<bool> checkResults = { false };
274 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
275 EXPECT_EQ(vec.size(), 0);
276
277 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
278 EXPECT_EQ(paramStreamUris2.size(), 0);
279 }
280
281 /*
282 * Feature: UriUtils
283 * Function: GetPermissionedUriList
284 * SubFunction: NA
285 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with other uri(scheme is not empty)
286 */
287 HWTEST_F(UriUtilsTest, GetPermissionedUriList_009, TestSize.Level1)
288 {
289 AccessTokenKit::hapInfo.apiVersion = 20;
290 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
291 AccessTokenKit::getHapTokenInfoRet = 0;
292 std::string uri = "http://temp/test.txt";
293 Want want;
294 std::vector<std::string> paramStreamUris = { uri };
295 want.SetParam("ability.params.stream", paramStreamUris);
296
297 std::vector<std::string> uriVec = { uri };
298 std::vector<bool> checkResults = { false };
299 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
300 EXPECT_EQ(vec.size(), 0);
301
302 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
303 EXPECT_EQ(paramStreamUris2.size(), 0);
304 }
305
306 /*
307 * Feature: UriUtils
308 * Function: GetPermissionedUriList
309 * SubFunction: NA
310 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with other uri(scheme is empty)
311 */
312 HWTEST_F(UriUtilsTest, GetPermissionedUriList_010, TestSize.Level1)
313 {
314 AccessTokenKit::hapInfo.apiVersion = 20;
315 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
316 AccessTokenKit::getHapTokenInfoRet = 0;
317 std::string uri = "data/temp/test.txt";
318 Want want;
319 std::vector<std::string> paramStreamUris = { uri };
320 want.SetParam("ability.params.stream", paramStreamUris);
321
322 std::vector<std::string> uriVec = { uri };
323 std::vector<bool> checkResults = { false };
324 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
325 EXPECT_EQ(vec.size(), 0);
326
327 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
328 EXPECT_EQ(paramStreamUris2.size(), 0);
329 }
330
331 /*
332 * Feature: UriUtils
333 * Function: GetPermissionedUriList
334 * SubFunction: NA
335 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with other uri(scheme is empty)
336 */
337 HWTEST_F(UriUtilsTest, GetPermissionedUriList_011, TestSize.Level1)
338 {
339 AccessTokenKit::hapInfo.apiVersion = 20;
340 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
341 AccessTokenKit::getHapTokenInfoRet = 0;
342 std::string uri = ":data/temp/test.txt";
343 Want want;
344 std::vector<std::string> paramStreamUris = { uri };
345 want.SetParam("ability.params.stream", paramStreamUris);
346
347 std::vector<std::string> uriVec = { uri };
348 std::vector<bool> checkResults = { false };
349 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
350 EXPECT_EQ(vec.size(), 0);
351
352 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
353 EXPECT_EQ(paramStreamUris2.size(), 0);
354 }
355
356 /*
357 * Feature: UriUtils
358 * Function: GetPermissionedUriList
359 * SubFunction: NA
360 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with file uri and Uri is file uri
361 */
362 HWTEST_F(UriUtilsTest, GetPermissionedUriList_012, TestSize.Level1)
363 {
364 AccessTokenKit::hapInfo.apiVersion = 20;
365 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
366 AccessTokenKit::getHapTokenInfoRet = 0;
367 std::string uri = "file://com.exmaple.test/data/temp/test.txt";
368 Want want;
369 want.SetUri(uri);
370 std::vector<std::string> paramStreamUris = { uri };
371 want.SetParam("ability.params.stream", paramStreamUris);
372
373 std::vector<std::string> uriVec = { uri, uri };
374 std::vector<bool> checkResults = { true, true };
375 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
376 EXPECT_EQ(vec.size(), 2);
377 // param stream
378 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
379 EXPECT_EQ(paramStreamUris2.size(), 1);
380 // uri
381 EXPECT_EQ(want.GetUriString(), uri);
382 }
383
384 /*
385 * Feature: UriUtils
386 * Function: GetPermissionedUriList
387 * SubFunction: NA
388 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with other uri and Uri is file uri
389 */
390 HWTEST_F(UriUtilsTest, GetPermissionedUriList_013, TestSize.Level1)
391 {
392 AccessTokenKit::hapInfo.apiVersion = 20;
393 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
394 AccessTokenKit::getHapTokenInfoRet = 0;
395 std::string uri1 = "file://com.exmaple.test/data/temp/test.txt";
396 std::string uri2 = "http://com.exmaple.test/data/temp/test.txt";
397 Want want;
398 want.SetUri(uri1);
399 std::vector<std::string> paramStreamUris = { uri2 };
400 want.SetParam("ability.params.stream", paramStreamUris);
401
402 std::vector<std::string> uriVec = { uri1, uri2 };
403 std::vector<bool> checkResults = { true, false };
404 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
405 EXPECT_EQ(vec.size(), 1);
406 // param stream
407 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
408 EXPECT_EQ(paramStreamUris2.size(), 0);
409 // uri
410 EXPECT_EQ(want.GetUriString(), uri1);
411 }
412
413 /*
414 * Feature: UriUtils
415 * Function: GetPermissionedUriList
416 * SubFunction: NA
417 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with file uri and Uri is other uri(schem is not empty)
418 */
419 HWTEST_F(UriUtilsTest, GetPermissionedUriList_014, TestSize.Level1)
420 {
421 AccessTokenKit::hapInfo.apiVersion = 20;
422 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
423 AccessTokenKit::getHapTokenInfoRet = 0;
424 std::string uri1 = "file://com.exmaple.test/data/temp/test.txt";
425 std::string uri2 = "http://com.exmaple.test/data/temp/test.txt";
426 Want want;
427 want.SetUri(uri2);
428 std::vector<std::string> paramStreamUris = { uri1 };
429 want.SetParam("ability.params.stream", paramStreamUris);
430
431 std::vector<std::string> uriVec = { uri2, uri1 };
432 std::vector<bool> checkResults = { false, true };
433 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
434 EXPECT_EQ(vec.size(), 1);
435 // param stream
436 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
437 EXPECT_EQ(paramStreamUris2.size(), 1);
438 // uri
439 EXPECT_EQ(want.GetUriString(), uri2);
440 }
441
442 /*
443 * Feature: UriUtils
444 * Function: GetPermissionedUriList
445 * SubFunction: NA
446 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with file uri and Uri is other uri(schem is empty)
447 */
448 HWTEST_F(UriUtilsTest, GetPermissionedUriList_015, TestSize.Level1)
449 {
450 AccessTokenKit::hapInfo.apiVersion = 20;
451 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
452 AccessTokenKit::getHapTokenInfoRet = 0;
453 std::string uri1 = "file://com.exmaple.test/data/temp/test.txt";
454 std::string uri2 = "/data/temp/test.txt";
455 Want want;
456 want.SetUri(uri2);
457 std::vector<std::string> paramStreamUris = { uri1 };
458 want.SetParam("ability.params.stream", paramStreamUris);
459
460 std::vector<std::string> uriVec = { uri2, uri1 };
461 std::vector<bool> checkResults = { false, true };
462 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
463 EXPECT_EQ(vec.size(), 1);
464 // param stream
465 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
466 EXPECT_EQ(paramStreamUris2.size(), 1);
467 // uri
468 EXPECT_EQ(want.GetUriString(), "");
469 }
470
471 /*
472 * Feature: UriUtils
473 * Function: GetPermissionedUriList
474 * SubFunction: NA
475 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with other uri and Uri is other uri(schem is empty)
476 */
477 HWTEST_F(UriUtilsTest, GetPermissionedUriList_016, TestSize.Level1)
478 {
479 AccessTokenKit::hapInfo.apiVersion = 20;
480 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
481 AccessTokenKit::getHapTokenInfoRet = 0;
482 std::string uri1 = "http://com.exmaple.test/data/temp/test.txt";
483 std::string uri2 = "/data/temp/test.txt";
484 Want want;
485 want.SetUri(uri2);
486 std::vector<std::string> paramStreamUris = { uri1 };
487 want.SetParam("ability.params.stream", paramStreamUris);
488
489 std::vector<std::string> uriVec = { uri2, uri1 };
490 std::vector<bool> checkResults = { false, false };
491 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, 0, "target", want);
492 EXPECT_EQ(vec.size(), 0);
493 // param stream
494 std::vector<std::string> paramStreamUris2 = want.GetStringArrayParam("ability.params.stream");
495 EXPECT_EQ(paramStreamUris2.size(), 0);
496 // uri
497 EXPECT_EQ(want.GetUriString(), "");
498 }
499
500 /*
501 * Feature: UriUtils
502 * Function: GetPermissionedUriList
503 * SubFunction: NA
504 * FunctionPoints: UriUtils GetPermissionedUriList, param stream with other uri and Uri is other uri(schem is empty)
505 */
506 HWTEST_F(UriUtilsTest, GetPermissionedUriList_017, TestSize.Level1)
507 {
508 AccessTokenKit::hapInfo.apiVersion = 19;
509 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
510 AccessTokenKit::getHapTokenInfoRet = 0;
511 std::string uri1 = "http://com.exmaple.test/data/temp/test.txt";
512 std::string uri2 = "file://com.example.test/data/temp/test.txt";
513 std::vector<std::string> paramStreamUris = { uri1, uri2 };
514 Want want;
515 want.SetParam("ability.params.stream", paramStreamUris);
516 std::vector<bool> checkResults = { false, false };
517 auto vec = UriUtils::GetInstance().GetPermissionedUriList(paramStreamUris, checkResults, 0, "target", want);
518 EXPECT_EQ(vec.size(), 0);
519 // param stream
520 std::vector<std::string> paramStreamUris1 = want.GetStringArrayParam("ability.params.stream");
521 EXPECT_EQ(paramStreamUris1.size(), 1);
522 }
523
524 /*
525 * Feature: UriUtils
526 * Function: GetUriListFromWant
527 * SubFunction: NA
528 * FunctionPoints: UriUtils GetUriListFromWant
529 */
530 HWTEST_F(UriUtilsTest, GetUriListFromWant_001, TestSize.Level1)
531 {
532 Want want;
533 WantParams params;
534 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
535 if (ao != nullptr) {
536 ao->Set(0, String::Box("file"));
537 params.SetParam("ability.params.stream", ao);
538 }
539 std::vector<std::string> uriVec;
540 bool res0 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
541 EXPECT_EQ(res0, false);
542
543 for (size_t i = 0; i < BEYOND_MAX_URI_COUNT; i++) {
544 uriVec.push_back("https//test.openharmony.com");
545 }
546 want.SetUri("file://data/storage/el2/distributedfiles/test.txt");
547 bool res1 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
548 EXPECT_EQ(res1, true);
549
550 bool res2 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
551 EXPECT_EQ(res2, true);
552
553 uriVec.clear();
554 uriVec.push_back("https//test.openharmony.com");
555 bool res3 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
556 EXPECT_EQ(res3, true);
557 }
558
559 /*
560 * Feature: UriUtils
561 * Function: IsDmsCall
562 * SubFunction: NA
563 * FunctionPoints: UriUtils IsDmsCall
564 */
565 HWTEST_F(UriUtilsTest, IsDmsCall_001, TestSize.Level1)
566 {
567 uint32_t fromTokenId = 1001;
568 bool res1 = UriUtils::GetInstance().IsDmsCall(fromTokenId);
569 EXPECT_EQ(res1, false);
570 }
571
572 #ifdef SUPPORT_UPMS
573 /*
574 * Feature: UriUtils
575 * Function: GrantDmsUriPermission
576 * SubFunction: NA
577 * FunctionPoints: UriUtils GrantDmsUriPermission
578 */
579 HWTEST_F(UriUtilsTest, GrantDmsUriPermission_001, TestSize.Level1)
580 {
581 Want want;
582 uint32_t callerTokenId = 1;
583 std::string targetBundleName = "com.example.tsapplication";
584 int32_t appIndex = 101;
585 WantParams params;
586 sptr<AAFwk::IArray> ao2 = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
587 if (ao2 != nullptr) {
588 ao2->Set(0, String::Box("file://data/storage/el2/distributedfiles/test.txt"));
589 params.SetParam("ability.verify.uri", ao2);
590 }
591 want.SetParams(params);
592 UriUtils::GetInstance().GrantDmsUriPermission(want, callerTokenId, targetBundleName, appIndex);
593 bool res = want.GetParams().HasParam("ability.verify.uri");
594 EXPECT_EQ(res, true);
595 }
596
597 /*
598 * Feature: UriUtils
599 * Function: GrantShellUriPermission
600 * SubFunction: NA
601 * FunctionPoints: UriUtils GrantShellUriPermission
602 */
603 HWTEST_F(UriUtilsTest, GrantShellUriPermission_001, TestSize.Level1)
604 {
605 std::vector<std::string> strUriVec = {"file://data/storage/el2/distributedfiles/test.txt"};
606 uint32_t flag = 0;
607 std::string targetPkg;
608 int32_t appIndex = 101;
609 bool res0 = UriUtils::GetInstance().GrantShellUriPermission(strUriVec, flag, targetPkg, appIndex);
610 EXPECT_EQ(res0, false);
611
612 strUriVec[0] = "content://data/storage/el2/distributedfiles/test.txt";
613 bool res1 = UriUtils::GetInstance().GrantShellUriPermission(strUriVec, flag, targetPkg, appIndex);
614 EXPECT_EQ(res1, true);
615 }
616
617 /*
618 * Feature: UriUtils
619 * Function: CheckUriPermission
620 * SubFunction: NA
621 * FunctionPoints: UriUtils CheckUriPermission
622 */
623 HWTEST_F(UriUtilsTest, CheckUriPermission_001, TestSize.Level1)
624 {
625 AccessTokenKit::hapInfo.apiVersion = 20;
626 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
627 AccessTokenKit::getHapTokenInfoRet = 0;
628 uint32_t callerTokenId = 1;
629 Want want;
630 want.SetFlags(0x00000003);
631
632 WantParams params;
633 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(BEYOND_MAX_URI_COUNT, AAFwk::g_IID_IString);
634 if (ao != nullptr) {
635 for (size_t i = 0; i < BEYOND_MAX_URI_COUNT; i++) {
636 ao->Set(i, String::Box("file"));
637 }
638 params.SetParam("ability.params.stream", ao);
639 }
640 want.SetParams(params);
641 UriUtils::GetInstance().CheckUriPermission(callerTokenId, want);
642 sptr<IInterface> value = want.GetParams().GetParam("ability.params.stream");
643 IArray *arr = IArray::Query(value);
644 long arrSize = 0;
645 if (arr != nullptr && Array::IsStringArray(arr)) {
646 arr->GetLength(arrSize);
647 }
648 EXPECT_EQ(arrSize, 0);
649 }
650
651 /*
652 * Feature: UriUtils
653 * Function: GrantUriPermission
654 * SubFunction: NA
655 * FunctionPoints: UriUtils GrantUriPermission
656 */
657 HWTEST_F(UriUtilsTest, GrantUriPermission_001, TestSize.Level1)
658 {
659 Want want;
660 std::string targetBundleName = "";
661 int32_t appIndex = 101;
662 bool isSandboxApp = false;
663 int32_t callerTokenId = 0;
664 int32_t collaboratorType = 2;
665 want.SetFlags(0x00000003);
666 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
667 collaboratorType);
668
669 want.SetFlags(0x00000001);
670 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
671 collaboratorType);
672
673 targetBundleName = "com.example.tsapplication";
674 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
675 collaboratorType);
676
677 callerTokenId = 1001;
678 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
679 collaboratorType);
680
681 WantParams params;
682 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
683 if (ao != nullptr) {
684 ao->Set(0, String::Box("file"));
685 params.SetParam("ability.params.stream", ao);
686 }
687 want.SetParams(params);
688 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
689 collaboratorType);
690
691 want.SetUri("file://data/storage/el2/distributedfiles/test.txt");
692 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
693 collaboratorType);
694
695 std::string bundleName = AppUtils::GetInstance().GetBrokerDelegateBundleName();
696 EXPECT_EQ(bundleName.empty(), true);
697 }
698
699 /*
700 * Feature: UriUtils
701 * Function: GrantUriPermissionInner
702 * SubFunction: NA
703 * FunctionPoints: UriUtils GrantUriPermissionInner
704 */
705 HWTEST_F(UriUtilsTest, GrantUriPermissionInner_001, TestSize.Level1)
706 {
707 std::vector<std::string> uriVec = {"file://data/storage/el2/distributedfiles/test.txt"};
708 uint32_t callerTokenId = 0;
709 std::string targetBundleName = "com.example.tsapplication";
710 int32_t appIndex = 0;
711 Want want;
712 bool res = UriUtils::GetInstance().GrantUriPermissionInner(uriVec, callerTokenId, targetBundleName, appIndex, want);
713 EXPECT_EQ(res, false);
714 }
715 #endif // SUPPORT_UPMS
716
717 /*
718 * Feature: UriUtils
719 * Function: IsSandboxApp
720 * SubFunction: NA
721 * FunctionPoints: UriUtils IsSandboxApp
722 */
723 HWTEST_F(UriUtilsTest, IsSandboxApp_001, TestSize.Level1)
724 {
725 uint32_t tokenId = 0;
726 bool res = UriUtils::GetInstance().IsSandboxApp(tokenId);
727 EXPECT_EQ(res, false);
728
729 tokenId = 1001;
730 res = UriUtils::GetInstance().IsSandboxApp(tokenId);
731 EXPECT_EQ(res, false);
732 }
733
734 /*
735 * Feature: UriUtils
736 * Function: GrantUriPermissionForServiceExtension
737 * SubFunction: NA
738 * FunctionPoints: UriUtils GrantUriPermissionForServiceExtension
739 */
740 HWTEST_F(UriUtilsTest, GrantUriPermissionForServiceExtension_001, TestSize.Level1)
741 {
742 AbilityRequest abilityRequest;
743 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::FORM;
744 auto ret = UriUtils::GetInstance().GrantUriPermissionForServiceExtension(abilityRequest);
745 EXPECT_EQ(ret, false);
746
747 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SERVICE;
748 ret = UriUtils::GetInstance().GrantUriPermissionForServiceExtension(abilityRequest);
749 EXPECT_EQ(ret, true);
750 }
751
752 /*
753 * Feature: UriUtils
754 * Function: GrantUriPermissionForUIOrServiceExtension
755 * SubFunction: NA
756 * FunctionPoints: UriUtils GrantUriPermissionForUIOrServiceExtension
757 */
758 HWTEST_F(UriUtilsTest, GrantUriPermissionForUIOrServiceExtension_001, TestSize.Level1)
759 {
760 AbilityRequest abilityRequest;
761 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::FORM;
762 auto ret = UriUtils::GetInstance().GrantUriPermissionForUIOrServiceExtension(abilityRequest);
763 EXPECT_EQ(ret, false);
764
765 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SERVICE;
766 ret = UriUtils::GetInstance().GrantUriPermissionForUIOrServiceExtension(abilityRequest);
767 EXPECT_EQ(ret, true);
768 }
769
770 /*
771 * Feature: UriUtils
772 * Function: CheckIsInAncoAppIdentifier
773 * SubFunction: NA
774 * FunctionPoints: UriUtils CheckIsInAncoAppIdentifier
775 */
776 HWTEST_F(UriUtilsTest, CheckIsInAncoAppIdentifier_001, TestSize.Level1)
777 {
778 std::string identifier = "";
779 std::string bundleName = "";
780 auto ret = UriUtils::GetInstance().CheckIsInAncoAppIdentifier(identifier, bundleName);
781 EXPECT_EQ(ret, false);
782
783 identifier = "com.example.test";
784 bundleName = "";
785 ret = UriUtils::GetInstance().CheckIsInAncoAppIdentifier(identifier, bundleName);
786 EXPECT_EQ(ret, false);
787
788 identifier = "com.example.test1|com.example.test2";
789 bundleName = "com.example.test";
790 ret = UriUtils::GetInstance().CheckIsInAncoAppIdentifier(identifier, bundleName);
791 EXPECT_EQ(ret, false);
792
793 identifier = "com.example.test";
794 bundleName = "com.example.test";
795 ret = UriUtils::GetInstance().CheckIsInAncoAppIdentifier(identifier, bundleName);
796 EXPECT_EQ(ret, true);
797
798 identifier = "com.example.test|com.example.test1";
799 bundleName = "com.example.test";
800 ret = UriUtils::GetInstance().CheckIsInAncoAppIdentifier(identifier, bundleName);
801 EXPECT_EQ(ret, true);
802 }
803
804 /*
805 * Feature: UriUtils
806 * Function: ProcessUDMFKey
807 * SubFunction: NA
808 * FunctionPoints: UriUtils ProcessUDMFKey
809 */
810 HWTEST_F(UriUtilsTest, ProcessUDMFKey_001, TestSize.Level1)
811 {
812 auto &uriUtils = UriUtils::GetInstance();
813 Want want;
814 std::string udKey = "udmf:tempKey";
815 want.SetParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY, udKey);
816 uriUtils.ProcessUDMFKey(want);
817 EXPECT_EQ(want.GetStringParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY).empty(), false);
818
819 std::vector<std::string> uris = { "file://com.example.test/aaa.txt" };
820 want.SetParam(ABILIY_PARAM_STREAM, uris);
821 uriUtils.ProcessUDMFKey(want);
822 EXPECT_EQ(want.GetStringParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY).empty(), true);
823 }
824
825 /*
826 * Feature: UriUtils
827 * Function: ProcessUDMFKey
828 * SubFunction: NA
829 * FunctionPoints: UriUtils ProcessUDMFKey
830 */
831 HWTEST_F(UriUtilsTest, ProcessUDMFKey_002, TestSize.Level1)
832 {
833 auto &uriUtils = UriUtils::GetInstance();
834 Want want;
835 std::string udKey;
836 want.SetParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY, udKey);
837 uriUtils.ProcessUDMFKey(want);
838 EXPECT_EQ(want.GetStringParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY).empty(), true);
839
840 std::vector<std::string> uris = { "file://com.example.test/aaa.txt" };
841 want.SetParam(ABILIY_PARAM_STREAM, uris);
842 uriUtils.ProcessUDMFKey(want);
843 EXPECT_EQ(want.GetStringParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY).empty(), true);
844 }
845
846 /*
847 * Feature: UriUtils
848 * Function: IsInAncoAppIdentifier
849 * SubFunction: NA
850 * FunctionPoints: UriUtils IsInAncoAppIdentifier
851 */
852 HWTEST_F(UriUtilsTest, IsInAncoAppIdentifier_001, TestSize.Level1)
853 {
854 auto &uriUtils = UriUtils::GetInstance();
855 std::string uri = "";
856 Want want;
857 want.SetUri(uri);
858 uriUtils.PublishFileOpenEvent(want);
859 auto result = uriUtils.IsInAncoAppIdentifier("com.example.test");
860 EXPECT_FALSE(result);
861 }
862
863 /*
864 * Feature: UriUtils
865 * Function: IsInAncoAppIdentifier
866 * SubFunction: NA
867 * FunctionPoints: UriUtils IsInAncoAppIdentifier
868 */
869 HWTEST_F(UriUtilsTest, IsInAncoAppIdentifier_002, TestSize.Level1)
870 {
871 auto &uriUtils = UriUtils::GetInstance();
872 std::string uri = "file://com.example.test/test.txt";
873 Want want;
874 want.SetUri(uri);
875 uriUtils.PublishFileOpenEvent(want);
876 auto result = uriUtils.IsInAncoAppIdentifier("com.example.test");
877 EXPECT_FALSE(result);
878 }
879
880 /*
881 * Feature: UriUtils
882 * Function: GetCallerNameAndApiVersion
883 * SubFunction: NA
884 * FunctionPoints: token native type, get native info failed.
885 */
886 HWTEST_F(UriUtilsTest, GetCallerNameAndApiVersion_001, TestSize.Level1)
887 {
888 auto &uriUtils = UriUtils::GetInstance();
889 uint32_t tokenId = 0;
890 std::string callerName;
891 int32_t apiVersion = 0;
892 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_NATIVE;
893 AccessTokenKit::getNativeTokenInfoRet = -1;
894 auto ret = uriUtils.GetCallerNameAndApiVersion(tokenId, callerName, apiVersion);
895 EXPECT_EQ(ret, false);
896 }
897
898 /*
899 * Feature: UriUtils
900 * Function: GetCallerNameAndApiVersion
901 * SubFunction: NA
902 * FunctionPoints: token native type, get native info success.
903 */
904 HWTEST_F(UriUtilsTest, GetCallerNameAndApiVersion_002, TestSize.Level1)
905 {
906 auto &uriUtils = UriUtils::GetInstance();
907 uint32_t tokenId = 0;
908 std::string callerName;
909 int32_t apiVersion = 0;
910 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_NATIVE;
911 AccessTokenKit::getNativeTokenInfoRet = 0;
912 AccessTokenKit::nativeTokenInfo.processName = "caller";
913 auto ret = uriUtils.GetCallerNameAndApiVersion(tokenId, callerName, apiVersion);
914 EXPECT_EQ(ret, true);
915 EXPECT_EQ(callerName, "caller");
916 }
917
918 /*
919 * Feature: UriUtils
920 * Function: GetCallerNameAndApiVersion
921 * SubFunction: NA
922 * FunctionPoints: token hap type, get hap info failed.
923 */
924 HWTEST_F(UriUtilsTest, GetCallerNameAndApiVersion_003, TestSize.Level1)
925 {
926 auto &uriUtils = UriUtils::GetInstance();
927 uint32_t tokenId = 0;
928 std::string callerName;
929 int32_t apiVersion = 0;
930 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
931 AccessTokenKit::getHapTokenInfoRet = -1;
932 auto ret = uriUtils.GetCallerNameAndApiVersion(tokenId, callerName, apiVersion);
933 EXPECT_EQ(ret, false);
934 }
935
936 /*
937 * Feature: UriUtils
938 * Function: GetCallerNameAndApiVersion
939 * SubFunction: NA
940 * FunctionPoints: token hap type, get hap info success.
941 */
942 HWTEST_F(UriUtilsTest, GetCallerNameAndApiVersion_004, TestSize.Level1)
943 {
944 auto &uriUtils = UriUtils::GetInstance();
945 uint32_t tokenId = 0;
946 std::string callerName;
947 int32_t apiVersion = 0;
948 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_HAP;
949 AccessTokenKit::getHapTokenInfoRet = 0;
950 AccessTokenKit::hapInfo.bundleName = "caller";
951 AccessTokenKit::hapInfo.apiVersion = 20;
952 auto ret = uriUtils.GetCallerNameAndApiVersion(tokenId, callerName, apiVersion);
953 EXPECT_EQ(ret, true);
954 EXPECT_EQ(callerName, "caller");
955 EXPECT_EQ(apiVersion, 20);
956 }
957
958 /*
959 * Feature: UriUtils
960 * Function: GetCallerNameAndApiVersion
961 * SubFunction: NA
962 * FunctionPoints: invalid token type.
963 */
964 HWTEST_F(UriUtilsTest, GetCallerNameAndApiVersion_005, TestSize.Level1)
965 {
966 auto &uriUtils = UriUtils::GetInstance();
967 uint32_t tokenId = 0;
968 std::string callerName;
969 int32_t apiVersion = 0;
970 AccessTokenKit::getTokenTypeFlagRet = ATokenTypeEnum::TOKEN_INVALID;
971 auto ret = uriUtils.GetCallerNameAndApiVersion(tokenId, callerName, apiVersion);
972 EXPECT_EQ(ret, false);
973 }
974
975 /*
976 * Feature: UriUtils
977 * Function: SendGrantUriPermissionEvent
978 * SubFunction: NA
979 * FunctionPoints: UriUtils SendGrantUriPermissionEvent
980 */
981 HWTEST_F(UriUtilsTest, SendGrantUriPermissionEvent_001, TestSize.Level1)
982 {
983 auto &uriUtils = UriUtils::GetInstance();
984 std::string callerBundleName = "caller";
985 std::string targetBundleName = "target";
986 std::string oriUri = "file://caller/1.txt";
987 int32_t apiVersion = 20;
988 std::string eventType = "eraseUri";
989 auto ret = uriUtils.SendGrantUriPermissionEvent(callerBundleName, targetBundleName, oriUri, apiVersion, eventType);
990 EXPECT_EQ(ret, true);
991 }
992
993 /*
994 * Feature: UriUtils
995 * Function: ProcessWantUri
996 * SubFunction: NA
997 * FunctionPoints: ProcessWantUri test.
998 */
999 HWTEST_F(UriUtilsTest, ProcessWantUri_001, TestSize.Level1)
1000 {
1001 auto &uriUtils = UriUtils::GetInstance();
1002 Want want;
1003 bool checkResult = true;
1004 int32_t apiVersion = 20;
1005 std::vector<Uri> permissionedUri;
1006 auto ret = uriUtils.ProcessWantUri(checkResult, apiVersion, want, permissionedUri);
1007 EXPECT_EQ(ret, true);
1008
1009 want.SetUri("file://caller/1.txt");
1010 ret = uriUtils.ProcessWantUri(checkResult, apiVersion, want, permissionedUri);
1011 EXPECT_EQ(ret, true);
1012
1013 checkResult = false;
1014 // scheme is file
1015 ret = uriUtils.ProcessWantUri(checkResult, apiVersion, want, permissionedUri);
1016 EXPECT_EQ(ret, false);
1017 EXPECT_EQ(want.GetUriString().empty(), true);
1018
1019 want.SetUri("invalidUri");
1020 ret = uriUtils.ProcessWantUri(checkResult, apiVersion, want, permissionedUri);
1021 EXPECT_EQ(ret, false);
1022 EXPECT_EQ(want.GetUriString().empty(), true);
1023
1024 want.SetUri("invalidUri");
1025 apiVersion = 1;
1026 ret = uriUtils.ProcessWantUri(checkResult, apiVersion, want, permissionedUri);
1027 EXPECT_EQ(ret, false);
1028 EXPECT_EQ(want.GetUriString().empty(), false);
1029 }
1030 }
1031 }