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 "app_utils.h"
19 #include "array_wrapper.h"
20 #include "string_wrapper.h"
21
22 #include "uri_utils.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace AAFwk {
29 namespace {
30 const int32_t BEYOND_MAX_URI_COUNT = 501;
31 const int32_t MAX_URI_COUNT = 500;
32 }
33 class UriUtilsTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 };
40
SetUpTestCase()41 void UriUtilsTest::SetUpTestCase() {}
42
TearDownTestCase()43 void UriUtilsTest::TearDownTestCase() {}
44
SetUp()45 void UriUtilsTest::SetUp() {}
46
TearDown()47 void UriUtilsTest::TearDown() {}
48
49 /*
50 * Feature: UriUtils
51 * Function: GetUriListFromWantDms
52 * SubFunction: NA
53 * FunctionPoints: UriUtils GetUriListFromWantDms
54 */
55 HWTEST_F(UriUtilsTest, GetUriListFromWantDms_001, TestSize.Level1)
56 {
57 Want want;
58 auto uriList = UriUtils::GetInstance().GetUriListFromWantDms(want);
59 EXPECT_EQ(uriList.size(), 0);
60
61 WantParams params;
62 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(BEYOND_MAX_URI_COUNT, AAFwk::g_IID_IString);
63 if (ao != nullptr) {
64 for (size_t i = 0; i < BEYOND_MAX_URI_COUNT; i++) {
65 ao->Set(i, String::Box("file"));
66 }
67 params.SetParam("ability.verify.uri", ao);
68 }
69 want.SetParams(params);
70 auto uriList2 = UriUtils::GetInstance().GetUriListFromWantDms(want);
71 EXPECT_EQ(uriList2.size(), 0);
72
73 sptr<AAFwk::IArray> ao2 = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
74 if (ao2 != nullptr) {
75 ao2->Set(0, String::Box("file://data/storage/el2/distributedfiles/test.txt"));
76 params.SetParam("ability.verify.uri", ao2);
77 }
78 want.SetParams(params);
79 auto uriList3 = UriUtils::GetInstance().GetUriListFromWantDms(want);
80 EXPECT_EQ(uriList3.size(), 0);
81 }
82
83 /*
84 * Feature: UriUtils
85 * Function: CheckNonImplicitShareFileUri
86 * SubFunction: NA
87 * FunctionPoints: UriUtils CheckNonImplicitShareFileUri
88 */
89 HWTEST_F(UriUtilsTest, CheckNonImplicitShareFileUri_001, TestSize.Level1)
90 {
91 Want want;
92 int32_t userId = 1;
93 uint32_t specifyTokenId = 1001;
94 int32_t errorCode0 = UriUtils::GetInstance().CheckNonImplicitShareFileUri(want, userId, specifyTokenId);
95 EXPECT_EQ(errorCode0, ERR_OK);
96
97 want.SetElementName("com.example.tsapplication", "EntryAbility");
98 int32_t errorCode1 = UriUtils::GetInstance().CheckNonImplicitShareFileUri(want, userId, specifyTokenId);
99 EXPECT_EQ(errorCode1, ERR_OK);
100 #ifdef SUPPORT_UPMS
101 want.SetFlags(0x00000003);
102 int32_t errorCode2 = UriUtils::GetInstance().CheckNonImplicitShareFileUri(want, userId, specifyTokenId);
103 EXPECT_EQ(errorCode2, ERR_OK);
104
105 want.SetFlags(0x00000001);
106 int32_t errorCode3 = UriUtils::GetInstance().CheckNonImplicitShareFileUri(want, userId, specifyTokenId);
107 EXPECT_EQ(errorCode3, ERR_OK);
108 #endif // SUPPORT_UPMS
109 want.SetUri("file://data/storage/el2/distributedfiles/test.txt");
110 int32_t errorCode4 = UriUtils::GetInstance().CheckNonImplicitShareFileUri(want, userId, specifyTokenId);
111 EXPECT_EQ(errorCode4, ERR_OK);
112
113 WantParams params;
114 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
115 if (ao != nullptr) {
116 ao->Set(0, String::Box("file"));
117 params.SetParam("ability.params.stream", ao);
118 }
119 want.SetParams(params);
120 int32_t errorCode5 = UriUtils::GetInstance().CheckNonImplicitShareFileUri(want, userId, specifyTokenId);
121 EXPECT_EQ(errorCode5, ERR_OK);
122 }
123
124 /*
125 * Feature: UriUtils
126 * Function: CheckNonImplicitShareFileUriInner
127 * SubFunction: NA
128 * FunctionPoints: UriUtils CheckNonImplicitShareFileUriInner
129 */
130 HWTEST_F(UriUtilsTest, CheckNonImplicitShareFileUriInner_001, TestSize.Level1)
131 {
132 uint32_t callerTokenId = 1001;
133 std::string targetBundleName = "com.example.tsapplication";
134 int32_t userId = 1;
135 int32_t errorCode0 =
136 UriUtils::GetInstance().CheckNonImplicitShareFileUriInner(callerTokenId, targetBundleName, userId);
137 EXPECT_EQ(errorCode0, INNER_ERR);
138
139 callerTokenId = 0;
140 int32_t errorCode1 =
141 UriUtils::GetInstance().CheckNonImplicitShareFileUriInner(callerTokenId, targetBundleName, userId);
142 EXPECT_EQ(errorCode1, CHECK_PERMISSION_FAILED);
143 }
144
145 /*
146 * Feature: UriUtils
147 * Function: IsSystemApplication
148 * SubFunction: NA
149 * FunctionPoints: UriUtils IsSystemApplication
150 */
151 HWTEST_F(UriUtilsTest, IsSystemApplication_001, TestSize.Level1)
152 {
153 std::string targetBundleName = "com.example.tsapplication";
154 int32_t userId = 1;
155 bool result = UriUtils::GetInstance().IsSystemApplication(targetBundleName, userId);
156 EXPECT_EQ(result, false);
157 }
158
159 /*
160 * Feature: UriUtils
161 * Function: GetPermissionedUriList
162 * SubFunction: NA
163 * FunctionPoints: UriUtils GetPermissionedUriList
164 */
165 HWTEST_F(UriUtilsTest, GetPermissionedUriList_001, TestSize.Level1)
166 {
167 std::vector<std::string> uriVec;
168 std::vector<bool> checkResults = {true};
169 Want want;
170 std::vector<Uri> vec = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
171 EXPECT_EQ(vec.size(), 0);
172
173 want.SetUri("ability.verify.uri");
174 uriVec.push_back("file://data/storage/el2/distributedfiles/test.txt");
175 std::vector<Uri> vec2 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
176 EXPECT_EQ(vec2.size(), 1);
177
178 checkResults[0] = false;
179 std::vector<Uri> vec3 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
180 EXPECT_EQ(vec3.size(), 0);
181
182 checkResults[0] = true;
183 uriVec.push_back("https//test.openharmony.com");
184 checkResults.push_back(true);
185 std::vector<Uri> vec4 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
186 EXPECT_EQ(vec4.size(), 2);
187
188 checkResults[1] = false;
189 std::vector<Uri> vec5 = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
190 EXPECT_EQ(vec5.size(), 1);
191 }
192
193 /*
194 * Feature: UriUtils
195 * Function: GetUriListFromWant
196 * SubFunction: NA
197 * FunctionPoints: UriUtils GetUriListFromWant
198 */
199 HWTEST_F(UriUtilsTest, GetUriListFromWant_001, TestSize.Level1)
200 {
201 Want want;
202 WantParams params;
203 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
204 if (ao != nullptr) {
205 ao->Set(0, String::Box("file"));
206 params.SetParam("ability.params.stream", ao);
207 }
208 std::vector<std::string> uriVec;
209 bool res0 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
210 EXPECT_EQ(res0, false);
211
212 for (size_t i = 0; i < BEYOND_MAX_URI_COUNT; i++) {
213 uriVec.push_back("https//test.openharmony.com");
214 }
215 want.SetUri("file://data/storage/el2/distributedfiles/test.txt");
216 bool res1 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
217 EXPECT_EQ(res1, true);
218
219 bool res2 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
220 EXPECT_EQ(res2, true);
221
222 uriVec.clear();
223 uriVec.push_back("https//test.openharmony.com");
224 bool res3 = UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
225 EXPECT_EQ(res3, true);
226 }
227
228 /*
229 * Feature: UriUtils
230 * Function: IsDmsCall
231 * SubFunction: NA
232 * FunctionPoints: UriUtils IsDmsCall
233 */
234 HWTEST_F(UriUtilsTest, IsDmsCall_001, TestSize.Level1)
235 {
236 uint32_t fromTokenId = 1001;
237 bool res1 = UriUtils::GetInstance().IsDmsCall(fromTokenId);
238 EXPECT_EQ(res1, false);
239 }
240
241 #ifdef SUPPORT_UPMS
242 /*
243 * Feature: UriUtils
244 * Function: GrantDmsUriPermission
245 * SubFunction: NA
246 * FunctionPoints: UriUtils GrantDmsUriPermission
247 */
248 HWTEST_F(UriUtilsTest, GrantDmsUriPermission_001, TestSize.Level1)
249 {
250 Want want;
251 uint32_t callerTokenId = 1;
252 std::string targetBundleName = "com.example.tsapplication";
253 int32_t appIndex = 101;
254 WantParams params;
255 sptr<AAFwk::IArray> ao2 = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
256 if (ao2 != nullptr) {
257 ao2->Set(0, String::Box("file://data/storage/el2/distributedfiles/test.txt"));
258 params.SetParam("ability.verify.uri", ao2);
259 }
260 want.SetParams(params);
261 UriUtils::GetInstance().GrantDmsUriPermission(want, callerTokenId, targetBundleName, appIndex);
262 bool res = want.GetParams().HasParam("ability.verify.uri");
263 EXPECT_EQ(res, true);
264 }
265
266 /*
267 * Feature: UriUtils
268 * Function: GrantShellUriPermission
269 * SubFunction: NA
270 * FunctionPoints: UriUtils GrantShellUriPermission
271 */
272 HWTEST_F(UriUtilsTest, GrantShellUriPermission_001, TestSize.Level1)
273 {
274 std::vector<std::string> strUriVec = {"file://data/storage/el2/distributedfiles/test.txt"};
275 uint32_t flag = 0;
276 std::string targetPkg;
277 int32_t appIndex = 101;
278 bool res0 = UriUtils::GetInstance().GrantShellUriPermission(strUriVec, flag, targetPkg, appIndex);
279 EXPECT_EQ(res0, false);
280
281 strUriVec[0] = "content://data/storage/el2/distributedfiles/test.txt";
282 bool res1 = UriUtils::GetInstance().GrantShellUriPermission(strUriVec, flag, targetPkg, appIndex);
283 EXPECT_EQ(res1, true);
284 }
285
286 /*
287 * Feature: UriUtils
288 * Function: CheckUriPermission
289 * SubFunction: NA
290 * FunctionPoints: UriUtils CheckUriPermission
291 */
292 HWTEST_F(UriUtilsTest, CheckUriPermission_001, TestSize.Level1)
293 {
294 uint32_t callerTokenId = 1;
295 Want want;
296 want.SetFlags(0x00000003);
297
298 WantParams params;
299 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(BEYOND_MAX_URI_COUNT, AAFwk::g_IID_IString);
300 if (ao != nullptr) {
301 for (size_t i = 0; i < BEYOND_MAX_URI_COUNT; i++) {
302 ao->Set(i, String::Box("file"));
303 }
304 params.SetParam("ability.params.stream", ao);
305 }
306 want.SetParams(params);
307 UriUtils::GetInstance().CheckUriPermission(callerTokenId, want);
308 sptr<IInterface> value = want.GetParams().GetParam("ability.params.stream");
309 IArray *arr = IArray::Query(value);
310 long arrSize = 0;
311 if (arr != nullptr && Array::IsStringArray(arr)) {
312 arr->GetLength(arrSize);
313 }
314 EXPECT_EQ(arrSize, MAX_URI_COUNT);
315 }
316
317 /*
318 * Feature: UriUtils
319 * Function: GrantUriPermission
320 * SubFunction: NA
321 * FunctionPoints: UriUtils GrantUriPermission
322 */
323 HWTEST_F(UriUtilsTest, GrantUriPermission_001, TestSize.Level1)
324 {
325 Want want;
326 std::string targetBundleName = "";
327 int32_t appIndex = 101;
328 bool isSandboxApp = false;
329 int32_t callerTokenId = 0;
330 int32_t collaboratorType = 2;
331 want.SetFlags(0x00000003);
332 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
333 collaboratorType);
334
335 want.SetFlags(0x00000001);
336 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
337 collaboratorType);
338
339 targetBundleName = "com.example.tsapplication";
340 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
341 collaboratorType);
342
343 callerTokenId = 1001;
344 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
345 collaboratorType);
346
347 WantParams params;
348 sptr<AAFwk::IArray> ao = new (std::nothrow) AAFwk::Array(1, AAFwk::g_IID_IString);
349 if (ao != nullptr) {
350 ao->Set(0, String::Box("file"));
351 params.SetParam("ability.params.stream", ao);
352 }
353 want.SetParams(params);
354 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
355 collaboratorType);
356
357 want.SetUri("file://data/storage/el2/distributedfiles/test.txt");
358 UriUtils::GetInstance().GrantUriPermission(want, targetBundleName, appIndex, isSandboxApp, callerTokenId,
359 collaboratorType);
360
361 std::string bundleName = AppUtils::GetInstance().GetBrokerDelegateBundleName();
362 EXPECT_EQ(bundleName.empty(), true);
363 }
364
365 /*
366 * Feature: UriUtils
367 * Function: GrantUriPermissionInner
368 * SubFunction: NA
369 * FunctionPoints: UriUtils GrantUriPermissionInner
370 */
371 HWTEST_F(UriUtilsTest, GrantUriPermissionInner_001, TestSize.Level1)
372 {
373 std::vector<std::string> uriVec = {"file://data/storage/el2/distributedfiles/test.txt"};
374 uint32_t callerTokenId = 0;
375 std::string targetBundleName = "com.example.tsapplication";
376 int32_t appIndex = 0;
377 Want want;
378 bool res = UriUtils::GetInstance().GrantUriPermissionInner(uriVec, callerTokenId, targetBundleName, appIndex, want);
379 EXPECT_EQ(res, false);
380 }
381 #endif // SUPPORT_UPMS
382
383 /*
384 * Feature: UriUtils
385 * Function: IsSandboxApp
386 * SubFunction: NA
387 * FunctionPoints: UriUtils IsSandboxApp
388 */
389 HWTEST_F(UriUtilsTest, IsSandboxApp_001, TestSize.Level1)
390 {
391 uint32_t tokenId = 0;
392 bool res = UriUtils::GetInstance().IsSandboxApp(tokenId);
393 EXPECT_EQ(res, false);
394
395 tokenId = 1001;
396 res = UriUtils::GetInstance().IsSandboxApp(tokenId);
397 EXPECT_EQ(res, false);
398 }
399
400 /*
401 * Feature: UriUtils
402 * Function: GrantUriPermissionForServiceExtension
403 * SubFunction: NA
404 * FunctionPoints: UriUtils GrantUriPermissionForServiceExtension
405 */
406 HWTEST_F(UriUtilsTest, GrantUriPermissionForServiceExtension_001, TestSize.Level1)
407 {
408 AbilityRequest abilityRequest;
409 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::FORM;
410 UriUtils::GetInstance().GrantUriPermissionForServiceExtension(abilityRequest);
411
412 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SERVICE;
413 UriUtils::GetInstance().GrantUriPermissionForServiceExtension(abilityRequest);
414 EXPECT_EQ(abilityRequest.abilityInfo.extensionAbilityType, AppExecFwk::ExtensionAbilityType::SERVICE);
415 }
416
417 /*
418 * Feature: UriUtils
419 * Function: GrantUriPermissionForUIOrServiceExtension
420 * SubFunction: NA
421 * FunctionPoints: UriUtils GrantUriPermissionForUIOrServiceExtension
422 */
423 HWTEST_F(UriUtilsTest, GrantUriPermissionForUIOrServiceExtension_001, TestSize.Level1)
424 {
425 AbilityRequest abilityRequest;
426 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::FORM;
427 UriUtils::GetInstance().GrantUriPermissionForUIOrServiceExtension(abilityRequest);
428
429 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SERVICE;
430 UriUtils::GetInstance().GrantUriPermissionForUIOrServiceExtension(abilityRequest);
431 EXPECT_EQ(abilityRequest.abilityInfo.extensionAbilityType, AppExecFwk::ExtensionAbilityType::SERVICE);
432 }
433 }
434 }