1 /*
2 * Copyright (c) 2024-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 <cstdio>
17 #include <thread>
18 #include <unistd.h>
19
20 #include <gtest/gtest.h>
21 #include <nlohmann/json.hpp>
22
23 #include "external_file_access_test.h"
24 #include "accesstoken_kit.h"
25 #include "context_impl.h"
26 #include "file_access_framework_errno.h"
27 #include "file_info_shared_memory.h"
28 #include "iservice_registry.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31 #include "file_access_service_client.h"
32
33 namespace OHOS::FileAccessFwk {
34 using json = nlohmann::json;
35 static int g_num = 0;
36
37 /**
38 * @tc.number: user_file_service_external_file_access_GetRoots_0000
39 * @tc.name: external_file_access_GetRoots_0000
40 * @tc.desc: Test function of GetRoots interface for SUCCESS.
41 * @tc.size: MEDIUM
42 * @tc.type: FUNC
43 * @tc.level Level 1
44 * @tc.require: SR000H0387
45 */
46 HWTEST_F(FileExtensionHelperTest, external_file_access_GetRoots_0000, testing::ext::TestSize.Level1)
47 {
48 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
49 EXPECT_NE(fileAccessHelper, nullptr);
50 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetRoots_0000";
51 try {
52 vector<RootInfo> info;
53 int result = fileAccessHelper->GetRoots(info);
54 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
55 EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK);
56 GTEST_LOG_(INFO) << "GetRoots_0000 result:" << info.size() << endl;
57 for (size_t i = 0; i < info.size(); i++) {
58 GTEST_LOG_(INFO) << info[i].uri;
59 GTEST_LOG_(INFO) << info[i].displayName;
60 GTEST_LOG_(INFO) << info[i].deviceFlags;
61 GTEST_LOG_(INFO) << info[i].deviceType;
62 GTEST_LOG_(INFO) << info[i].relativePath;
63 }
64 EXPECT_GE(info.size(), 1);
65 } catch (...) {
66 GTEST_LOG_(ERROR) << "external_file_access_GetRoots_0000 occurs an exception.";
67 }
68 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetRoots_0000";
69 }
70
TestFileAccess(shared_ptr<FileAccessHelper> fileAccessHelper,Uri & dirUri)71 static void TestFileAccess(shared_ptr<FileAccessHelper> fileAccessHelper, Uri& dirUri)
72 {
73 bool isExist = false;
74 int result;
75
76 result = fileAccessHelper->Access(dirUri, isExist);
77 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
78 EXPECT_TRUE(isExist);
79
80 result = fileAccessHelper->Delete(dirUri);
81 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
82
83 result = fileAccessHelper->Access(dirUri, isExist);
84 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
85 EXPECT_FALSE(isExist);
86 }
87
88 /**
89 * @tc.number: user_file_service_external_file_access_Access_0000
90 * @tc.name: external_file_access_Access_0000
91 * @tc.desc: Test function of Access interface for SUCCESS.
92 * @tc.size: MEDIUM
93 * @tc.type: FUNC
94 * @tc.level Level 1
95 * @tc.require: SR000H0386
96 */
97 HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0000, testing::ext::TestSize.Level1)
98 {
99 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
100 EXPECT_NE(fileAccessHelper, nullptr);
101 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0000";
102 try {
103 vector<RootInfo> info;
104 int result = fileAccessHelper->GetRoots(info);
105 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
106 for (size_t i = 0; i < info.size(); i++) {
107 Uri parentUri(info[i].uri);
108 GTEST_LOG_(INFO) << parentUri.ToString();
109 Uri newDirUriTest("");
110 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest);
111 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
112 Uri newFileUri("");
113 result = fileAccessHelper->CreateFile(newDirUriTest, "external_file_access_Access_0000.txt", newFileUri);
114 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
115 TestFileAccess(fileAccessHelper, newDirUriTest);
116 }
117 } catch (...) {
118 GTEST_LOG_(ERROR) << "external_file_access_Access_0000 occurs an exception.";
119 }
120 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0000";
121 }
122
123 /**
124 * @tc.number: user_file_service_external_file_access_Access_0001
125 * @tc.name: external_file_access_Access_0001
126 * @tc.desc: Test function of Access interface FAILED because of GetProxyByUri failed.
127 * @tc.size: MEDIUM
128 * @tc.type: FUNC
129 * @tc.level Level 1
130 * @tc.require: SR000H0386
131 */
132 HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0001, testing::ext::TestSize.Level1)
133 {
134 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
135 EXPECT_NE(fileAccessHelper, nullptr);
136 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0001";
137 try {
138 vector<RootInfo> info;
139 int result = fileAccessHelper->GetRoots(info);
140 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
141 for (size_t i = 0; i < info.size(); i++) {
142 std::string str = info[i].uri;
143 if (ReplaceBundleName(str, "ohos.com.NotExistBundleName")) {
144 Uri newDirUriTest(str + "/test.txt");
145 bool isExist = false;
146 result = fileAccessHelper->Access(newDirUriTest, isExist);
147 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
148 EXPECT_FALSE(isExist);
149 } else {
150 EXPECT_TRUE(false);
151 }
152 }
153 } catch (...) {
154 GTEST_LOG_(ERROR) << "external_file_access_Access_0001 occurs an exception.";
155 }
156 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0001";
157 }
158
159 /**
160 * @tc.number: user_file_service_external_file_access_Access_0002
161 * @tc.name: external_file_access_Access_0002
162 * @tc.desc: Test function of Access interface for SUCCESS, the file and folder name is chinese.
163 * @tc.size: MEDIUM
164 * @tc.type: FUNC
165 * @tc.level Level 1
166 * @tc.require: I70SX9
167 */
168 HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0002, testing::ext::TestSize.Level1)
169 {
170 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
171 EXPECT_NE(fileAccessHelper, nullptr);
172 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0002";
173 try {
174 vector<RootInfo> info;
175 int result = fileAccessHelper->GetRoots(info);
176 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
177 for (size_t i = 0; i < info.size(); i++) {
178 Uri parentUri(info[i].uri);
179 GTEST_LOG_(INFO) << parentUri.ToString();
180 Uri newDirUriTest("");
181 result = fileAccessHelper->Mkdir(parentUri, "访问目录", newDirUriTest);
182 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
183 EXPECT_EQ(newDirUriTest.ToString().find("访问目录"), std::string::npos);
184 Uri newFileUri("");
185 result = fileAccessHelper->CreateFile(newDirUriTest, "访问文件.txt", newFileUri);
186 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
187 EXPECT_EQ(newFileUri.ToString().find("访问文件.txt"), std::string::npos);
188 TestFileAccess(fileAccessHelper, newDirUriTest);
189 }
190 } catch (...) {
191 GTEST_LOG_(ERROR) << "external_file_access_Access_0002 occurs an exception.";
192 }
193 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0002";
194 }
195
196 /**
197 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0000
198 * @tc.name: external_file_access_GetFileInfoFromUri_0000
199 * @tc.desc: Test function of GetFileInfoFromUri interface.
200 * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS.
201 * @tc.size: MEDIUM
202 * @tc.type: FUNC
203 * @tc.level Level 1
204 * @tc.require: SR000H0386
205 */
206 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1)
207 {
208 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
209 EXPECT_NE(fileAccessHelper, nullptr);
210 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0000";
211 try {
212 vector<RootInfo> info;
213 int result = fileAccessHelper->GetRoots(info);
214 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
215 SharedMemoryInfo memInfo;
216 result = FileAccessFwk::SharedMemoryOperation::CreateSharedMemory("FileInfo List", DEFAULT_CAPACITY_200KB,
217 memInfo);
218 for (size_t i = 0; i < info.size(); i++) {
219 Uri parentUri(info[i].uri);
220 FileInfo fileinfo;
221 result = fileAccessHelper->GetFileInfoFromUri(parentUri, fileinfo);
222 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
223
224 int64_t offset = 0;
225 FileFilter filter;
226 result = fileAccessHelper->ListFile(fileinfo, offset, filter, memInfo);
227 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
228 EXPECT_GE(memInfo.Size(), OHOS::FileAccessFwk::ERR_OK);
229 }
230 FileAccessFwk::SharedMemoryOperation::DestroySharedMemory(memInfo);
231 } catch (...) {
232 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0000 occurs an exception.";
233 }
234 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0000";
235 }
236
237 /**
238 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0001
239 * @tc.name: external_file_access_GetFileInfoFromUri_0001
240 * @tc.desc: Test function of GetFileInfoFromUri interface.
241 * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS.
242 * @tc.size: MEDIUM
243 * @tc.type: FUNC
244 * @tc.level Level 1
245 * @tc.require: SR000H0386
246 */
247 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1)
248 {
249 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
250 EXPECT_NE(fileAccessHelper, nullptr);
251 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0001";
252 try {
253 vector<RootInfo> info;
254 int result = fileAccessHelper->GetRoots(info);
255 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
256 SharedMemoryInfo memInfo;
257 result = FileAccessFwk::SharedMemoryOperation::CreateSharedMemory("FileInfo List", DEFAULT_CAPACITY_200KB,
258 memInfo);
259 for (size_t i = 0; i < info.size(); i++) {
260 Uri parentUri(info[i].uri);
261 Uri newDirUriTest("");
262 result = fileAccessHelper->Mkdir(parentUri, "testDir", newDirUriTest);
263 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
264
265 FileInfo dirInfo;
266 result = fileAccessHelper->GetFileInfoFromUri(newDirUriTest, dirInfo);
267 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
268
269 int64_t offset = 0;
270 FileFilter filter;
271 result = fileAccessHelper->ListFile(dirInfo, offset, filter, memInfo);
272 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
273 EXPECT_GE(memInfo.Size(), OHOS::FileAccessFwk::ERR_OK);
274
275 result = fileAccessHelper->Delete(newDirUriTest);
276 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
277 }
278 FileAccessFwk::SharedMemoryOperation::DestroySharedMemory(memInfo);
279 } catch (...) {
280 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0001 occurs an exception.";
281 }
282 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0001";
283 }
284
285 /**
286 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0002
287 * @tc.name: external_file_access_GetFileInfoFromUri_0002
288 * @tc.desc: Test function of GetFileInfoFromUri interface.
289 * @tc.desc: convert the general filepath uri to fileinfo and call listfile for ERROR.
290 * @tc.size: MEDIUM
291 * @tc.type: FUNC
292 * @tc.level Level 1
293 * @tc.require: SR000H0386
294 */
295 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1)
296 {
297 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
298 EXPECT_NE(fileAccessHelper, nullptr);
299 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0002";
300 try {
301 vector<RootInfo> info;
302 int result = fileAccessHelper->GetRoots(info);
303 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
304 SharedMemoryInfo memInfo;
305 result = FileAccessFwk::SharedMemoryOperation::CreateSharedMemory("FileInfo List", DEFAULT_CAPACITY_200KB,
306 memInfo);
307 for (size_t i = 0; i < info.size(); i++) {
308 Uri parentUri(info[i].uri);
309 Uri newDirUriTest("");
310 result = fileAccessHelper->Mkdir(parentUri, "testDir", newDirUriTest);
311 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
312 Uri newFileUri("");
313 result = fileAccessHelper->CreateFile(newDirUriTest,
314 "external_file_access_GetFileInfoFromUri_0002.txt", newFileUri);
315 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
316
317 FileInfo fileinfo;
318 result = fileAccessHelper->GetFileInfoFromUri(newFileUri, fileinfo);
319 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
320
321 int64_t offset = 0;
322 FileFilter filter;
323 result = fileAccessHelper->ListFile(fileinfo, offset, filter, memInfo);
324 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
325 EXPECT_EQ(memInfo.Size(), OHOS::FileAccessFwk::ERR_OK);
326
327 result = fileAccessHelper->Delete(newDirUriTest);
328 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
329 }
330 FileAccessFwk::SharedMemoryOperation::DestroySharedMemory(memInfo);
331 } catch (...) {
332 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0002 occurs an exception.";
333 }
334 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0002";
335 }
336
337 /**
338 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0003
339 * @tc.name: external_file_access_GetFileInfoFromUri_0003
340 * @tc.desc: Test function of GetFileInfoFromUri interface.
341 * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed.
342 * @tc.size: MEDIUM
343 * @tc.type: FUNC
344 * @tc.level Level 1
345 * @tc.require: SR000H0386
346 */
347 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1)
348 {
349 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
350 EXPECT_NE(fileAccessHelper, nullptr);
351 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0003";
352 try {
353 vector<RootInfo> info;
354 int result = fileAccessHelper->GetRoots(info);
355 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
356 for (size_t i = 0; i < info.size(); i++) {
357 FileInfo fileinfo;
358 Uri parentUri(std::string("\?\?\?\?/") + info[i].uri);
359 result = fileAccessHelper->GetFileInfoFromUri(parentUri, fileinfo);
360 EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
361 }
362 } catch (...) {
363 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0003 occurs an exception.";
364 }
365 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0003";
366 }
367
368 /**
369 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0004
370 * @tc.name: external_file_access_GetFileInfoFromUri_0004
371 * @tc.desc: Test function of GetFileInfoFromUri interface.
372 * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed.
373 * @tc.size: MEDIUM
374 * @tc.type: FUNC
375 * @tc.level Level 1
376 * @tc.require: SR000H0386
377 */
378 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1)
379 {
380 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
381 EXPECT_NE(fileAccessHelper, nullptr);
382 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0004";
383 try {
384 vector<RootInfo> info;
385 int result = fileAccessHelper->GetRoots(info);
386 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
387 for (size_t i = 0; i < info.size(); i++) {
388 std::string str = info[i].uri;
389 if (ReplaceBundleName(str, "ohos.com.NotExistBundleName")) {
390 Uri parentUri(str);
391 FileInfo fileinfo;
392 result = fileAccessHelper->GetFileInfoFromUri(parentUri, fileinfo);
393 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
394 } else {
395 EXPECT_TRUE(false);
396 }
397 }
398 } catch (...) {
399 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0004 occurs an exception.";
400 }
401 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0004";
402 }
403
404 /**
405 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0005
406 * @tc.name: external_file_access_GetFileInfoFromUri_0005
407 * @tc.desc: Test function of GetFileInfoFromUri interface.
408 * @tc.desc: convert the invalid uri to fileinfo failed.
409 * @tc.size: MEDIUM
410 * @tc.type: FUNC
411 * @tc.level Level 1
412 * @tc.require: SR000H0386
413 */
414 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1)
415 {
416 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
417 EXPECT_NE(fileAccessHelper, nullptr);
418 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0005";
419 try {
420 Uri uri("~!@#$%^&*()_");
421 FileInfo fileInfo;
422 int result = fileAccessHelper->GetFileInfoFromUri(uri, fileInfo);
423 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
424
425 uri = Uri("/");
426 result = fileAccessHelper->GetFileInfoFromUri(uri, fileInfo);
427 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
428
429 uri = Uri("");
430 result = fileAccessHelper->GetFileInfoFromUri(uri, fileInfo);
431 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
432 } catch (...) {
433 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0005 occurs an exception.";
434 }
435 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0005";
436 }
437
438 /**
439 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0006
440 * @tc.name: external_file_access_GetFileInfoFromUri_0006
441 * @tc.desc: Test function of GetFileInfoFromUri interface.
442 * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS, the folder name is chinese.
443 * @tc.size: MEDIUM
444 * @tc.type: FUNC
445 * @tc.level Level 1
446 * @tc.require: I70SX9
447 */
448 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0006, testing::ext::TestSize.Level1)
449 {
450 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
451 EXPECT_NE(fileAccessHelper, nullptr);
452 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0006";
453 try {
454 vector<RootInfo> info;
455 int result = fileAccessHelper->GetRoots(info);
456 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
457 SharedMemoryInfo memInfo;
458 result = FileAccessFwk::SharedMemoryOperation::CreateSharedMemory("FileInfo List", DEFAULT_CAPACITY_200KB,
459 memInfo);
460 for (size_t i = 0; i < info.size(); i++) {
461 Uri parentUri(info[i].uri);
462 Uri newDirUriTest("");
463 result = fileAccessHelper->Mkdir(parentUri, "测试目录", newDirUriTest);
464 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
465 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
466
467 FileInfo dirInfo;
468 result = fileAccessHelper->GetFileInfoFromUri(newDirUriTest, dirInfo);
469 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
470
471 int64_t offset = 0;
472 FileFilter filter;
473 result = fileAccessHelper->ListFile(dirInfo, offset, filter, memInfo);
474 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
475 EXPECT_GE(memInfo.Size(), OHOS::FileAccessFwk::ERR_OK);
476
477 result = fileAccessHelper->Delete(newDirUriTest);
478 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
479 }
480 FileAccessFwk::SharedMemoryOperation::DestroySharedMemory(memInfo);
481 } catch (...) {
482 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0006 occurs an exception.";
483 }
484 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0006";
485 }
486
487 /**
488 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0007
489 * @tc.name: external_file_access_GetFileInfoFromUri_0007
490 * @tc.desc: Test function of GetFileInfoFromUri interface.
491 * @tc.desc: convert the general filepath uri to fileinfo and call listfile for ERROR, the file name is chinese.
492 * @tc.size: MEDIUM
493 * @tc.type: FUNC
494 * @tc.level Level 1
495 * @tc.require: I70SX9
496 */
497 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0007, testing::ext::TestSize.Level1)
498 {
499 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
500 EXPECT_NE(fileAccessHelper, nullptr);
501 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0007";
502 try {
503 vector<RootInfo> info;
504 int result = fileAccessHelper->GetRoots(info);
505 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
506 SharedMemoryInfo memInfo;
507 result = FileAccessFwk::SharedMemoryOperation::CreateSharedMemory("FileInfo List", DEFAULT_CAPACITY_200KB,
508 memInfo);
509 for (size_t i = 0; i < info.size(); i++) {
510 Uri newDirUriTest("");
511 Uri parentUri(info[i].uri);
512 result = fileAccessHelper->Mkdir(parentUri, "测试目录1", newDirUriTest);
513 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
514 EXPECT_EQ(newDirUriTest.ToString().find("测试目录1"), std::string::npos);
515 Uri newFileUri("");
516 result = fileAccessHelper->CreateFile(newDirUriTest, "测试文件1.txt", newFileUri);
517 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
518 EXPECT_EQ(newFileUri.ToString().find("测试文件1.txt"), std::string::npos);
519
520 FileInfo fileinfo;
521 result = fileAccessHelper->GetFileInfoFromUri(newFileUri, fileinfo);
522 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
523
524 int64_t offset = 0;
525 FileFilter filter;
526 std::vector<FileInfo> fileInfoVecTemp;
527 result = fileAccessHelper->ListFile(fileinfo, offset, filter, memInfo);
528 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
529 EXPECT_EQ(memInfo.Size(), OHOS::FileAccessFwk::ERR_OK);
530
531 result = fileAccessHelper->Delete(newDirUriTest);
532 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
533 }
534 FileAccessFwk::SharedMemoryOperation::DestroySharedMemory(memInfo);
535 } catch (...) {
536 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0007 occurs an exception.";
537 }
538 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0007";
539 }
540
541 /**
542 * @tc.number: user_file_service_external_file_access_Mkdir_0000
543 * @tc.name: external_file_access_Mkdir_0000
544 * @tc.desc: Test function of Mkdir interface for SUCCESS.
545 * @tc.size: MEDIUM
546 * @tc.type: FUNC
547 * @tc.level Level 1
548 * @tc.require: SR000H0386
549 */
550 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0000, testing::ext::TestSize.Level1)
551 {
552 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
553 EXPECT_NE(fileAccessHelper, nullptr);
554 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0000";
555 try {
556 vector<RootInfo> info;
557 int result = fileAccessHelper->GetRoots(info);
558 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
559 for (size_t i = 0; i < info.size(); i++) {
560 Uri parentUri(info[i].uri);
561 Uri newDirUriTest("");
562 result = fileAccessHelper->Mkdir(parentUri, "external_file_access_Mkdir_0000", newDirUriTest);
563 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
564 GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result;
565 result = fileAccessHelper->Delete(newDirUriTest);
566 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
567 }
568 } catch (...) {
569 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0000 occurs an exception.";
570 }
571 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0000";
572 }
573
574 /**
575 * @tc.number: user_file_service_external_file_access_Mkdir_0001
576 * @tc.name: external_file_access_Mkdir_0001
577 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null.
578 * @tc.size: MEDIUM
579 * @tc.type: FUNC
580 * @tc.level Level 1
581 * @tc.require: SR000H0386
582 */
583 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0001, testing::ext::TestSize.Level1)
584 {
585 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
586 EXPECT_NE(fileAccessHelper, nullptr);
587 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0001";
588 try {
589 Uri newDirUriTest("");
590 Uri parentUri("");
591 int result = fileAccessHelper->Mkdir(parentUri, "external_file_access_Mkdir_0001", newDirUriTest);
592 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
593 GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result;
594 } catch (...) {
595 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0001 occurs an exception.";
596 }
597 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0001";
598 }
599
600 /**
601 * @tc.number: user_file_service_external_file_access_Mkdir_0002
602 * @tc.name: external_file_access_Mkdir_0002
603 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path.
604 * @tc.size: MEDIUM
605 * @tc.type: FUNC
606 * @tc.level Level 1
607 * @tc.require: SR000H0386
608 */
609 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0002, testing::ext::TestSize.Level1)
610 {
611 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
612 EXPECT_NE(fileAccessHelper, nullptr);
613 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002";
614 try {
615 Uri newDirUriTest("");
616 Uri parentUri("storage/media/100/local/files/Download");
617 int result = fileAccessHelper->Mkdir(parentUri, "external_file_access_Mkdir_0002", newDirUriTest);
618 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
619 GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result;
620 } catch (...) {
621 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0002 occurs an exception.";
622 }
623 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0002";
624 }
625
626 /**
627 * @tc.number: user_file_service_external_file_access_Mkdir_0003
628 * @tc.name: external_file_access_Mkdir_0003
629 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols.
630 * @tc.size: MEDIUM
631 * @tc.type: FUNC
632 * @tc.level Level 1
633 * @tc.require: SR000H0386
634 */
635 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0003, testing::ext::TestSize.Level1)
636 {
637 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
638 EXPECT_NE(fileAccessHelper, nullptr);
639 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002";
640 try {
641 Uri newDirUriTest("");
642 Uri parentUri("~!@#$%^&*()_");
643 int result = fileAccessHelper->Mkdir(parentUri, "external_file_access_Mkdir_0003", newDirUriTest);
644 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
645 GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result;
646 } catch (...) {
647 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0003 occurs an exception.";
648 }
649 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0003";
650 }
651
652 /**
653 * @tc.number: user_file_service_external_file_access_Mkdir_0004
654 * @tc.name: external_file_access_Mkdir_0004
655 * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null.
656 * @tc.size: MEDIUM
657 * @tc.type: FUNC
658 * @tc.level Level 1
659 * @tc.require: SR000H0386
660 */
661 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0004, testing::ext::TestSize.Level1)
662 {
663 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
664 EXPECT_NE(fileAccessHelper, nullptr);
665 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0004";
666 try {
667 vector<RootInfo> info;
668 int result = fileAccessHelper->GetRoots(info);
669 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
670 for (size_t i = 0; i < info.size(); i++) {
671 Uri parentUri(info[i].uri);
672 Uri newDirUriTest("");
673 string displayName = "";
674 result = fileAccessHelper->Mkdir(parentUri, displayName, newDirUriTest);
675 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
676 GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result;
677 }
678 } catch (...) {
679 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0004 occurs an exception.";
680 }
681 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0004";
682 }
683
MkdirTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,std::string displayName,Uri newFile)684 static void MkdirTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, std::string displayName, Uri newFile)
685 {
686 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
687 EXPECT_NE(fileAccessHelper, nullptr);
688 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MkdirTdd";
689 int ret = fahs->Mkdir(uri, displayName, newFile);
690 if (ret != OHOS::FileAccessFwk::ERR_OK) {
691 GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret;
692 return;
693 }
694 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
695 EXPECT_NE(newFile.ToString(), "");
696 g_num++;
697 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MkdirTdd";
698 }
699
700 /**
701 * @tc.number: user_file_service_external_file_access_Mkdir_0005
702 * @tc.name: external_file_access_Mkdir_0005
703 * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent.
704 * @tc.size: MEDIUM
705 * @tc.type: FUNC
706 * @tc.level Level 1
707 * @tc.require: SR000H0386
708 */
709 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0005, testing::ext::TestSize.Level1)
710 {
711 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
712 EXPECT_NE(fileAccessHelper, nullptr);
713 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0005";
714 try {
715 vector<RootInfo> info;
716 int result = fileAccessHelper->GetRoots(info);
717 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
718 for (size_t i = 0; i < info.size(); i++) {
719 Uri parentUri(info[i].uri);
720 Uri newDirUriTest("");
721 std::string displayName = "test1";
722 g_num = 0;
723 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
724 std::thread execthread(MkdirTdd, fileAccessHelper, parentUri, displayName, newDirUriTest);
725 execthread.join();
726 }
727 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
728 Uri newDelete(info[i].uri + "/" + displayName);
729 result = fileAccessHelper->Delete(newDelete);
730 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
731 }
732 } catch (...) {
733 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0005 occurs an exception.";
734 }
735 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0005";
736 }
737
738 /**
739 * @tc.number: user_file_service_external_file_access_Mkdir_0006
740 * @tc.name: external_file_access_Mkdir_0006
741 * @tc.desc: Test function of Mkdir interface for ERROR because of GetProxyByUri failed.
742 * @tc.size: MEDIUM
743 * @tc.type: FUNC
744 * @tc.level Level 1
745 * @tc.require: SR000H0386
746 */
747 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0006, testing::ext::TestSize.Level1)
748 {
749 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
750 EXPECT_NE(fileAccessHelper, nullptr);
751 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0006";
752 try {
753 vector<RootInfo> info;
754 int result = fileAccessHelper->GetRoots(info);
755 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
756 for (size_t i = 0; i < info.size(); i++) {
757 std::string str = info[i].uri;
758 if (ReplaceBundleName(str, "ohos.com.NotExistBundleName")) {
759 Uri parentUri(str);
760 Uri newDirUriTest("");
761 string displayName = "";
762 result = fileAccessHelper->Mkdir(parentUri, displayName, newDirUriTest);
763 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
764 GTEST_LOG_(INFO) << "Mkdir_0006 result:" << result;
765 } else {
766 EXPECT_TRUE(false);
767 }
768 }
769 } catch (...) {
770 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0006 occurs an exception.";
771 }
772 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0006";
773 }
774
775 /**
776 * @tc.number: user_file_service_external_file_access_Mkdir_0007
777 * @tc.name: external_file_access_Mkdir_0007
778 * @tc.desc: Test function of Mkdir interface for SUCCESS，the folder name is chinese.
779 * @tc.size: MEDIUM
780 * @tc.type: FUNC
781 * @tc.level Level 1
782 * @tc.require: I70SX9
783 */
784 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0007, testing::ext::TestSize.Level1)
785 {
786 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
787 EXPECT_NE(fileAccessHelper, nullptr);
788 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0007";
789 try {
790 vector<RootInfo> info;
791 int result = fileAccessHelper->GetRoots(info);
792 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
793 for (size_t i = 0; i < info.size(); i++) {
794 Uri parentUri(info[i].uri);
795 Uri newDirUriTest("");
796 result = fileAccessHelper->Mkdir(parentUri, "新建目录", newDirUriTest);
797 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
798 EXPECT_EQ(newDirUriTest.ToString().find("新建目录"), std::string::npos);
799 GTEST_LOG_(INFO) << "Mkdir_0007 result:" << result;
800 result = fileAccessHelper->Delete(newDirUriTest);
801 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
802 }
803 } catch (...) {
804 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0007 occurs an exception.";
805 }
806 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0007";
807 }
808
809 /**
810 * @tc.number: user_file_service_external_file_access_Mkdir_0008
811 * @tc.name: external_file_access_Mkdir_0008
812 * @tc.desc: Test function of Mkdir interface for FAIL，the folder name is Documents.
813 * @tc.size: MEDIUM
814 * @tc.type: FUNC
815 * @tc.level Level 1
816 * @tc.require: I7MQMD
817 */
818 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0008, testing::ext::TestSize.Level1)
819 {
820 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
821 EXPECT_NE(fileAccessHelper, nullptr);
822 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0008";
823 try {
824 vector<RootInfo> info;
825 int result = fileAccessHelper->GetRoots(info);
826 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
827 EXPECT_GE(info.size(), 1);
828 Uri parentUri(info[0].uri);
829 Uri newDirUriTest("");
830 result = fileAccessHelper->Mkdir(parentUri, "Documents", newDirUriTest);
831 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
832 result = fileAccessHelper->Mkdir(parentUri, "Download", newDirUriTest);
833 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
834 result = fileAccessHelper->Mkdir(parentUri, "Desktop", newDirUriTest);
835 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
836 } catch (...) {
837 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0008 occurs an exception.";
838 }
839 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0008";
840 }
841
842 /**
843 * @tc.number: user_file_service_external_file_access_GetConnectInfo_0000
844 * @tc.name: external_file_access_GetConnectInfo_0000
845 * @tc.desc: Test function of GetConnectInfo interface.
846 * @tc.desc: helper invoke GetConnectInfo for FAILED.
847 * @tc.size: MEDIUM
848 * @tc.type: FUNC
849 * @tc.level Level 1
850 * @tc.require: SR000H0386
851 */
852 HWTEST_F(FileExtensionHelperTest, external_file_access_GetConnectInfo_0000, testing::ext::TestSize.Level1)
853 {
854 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
855 EXPECT_NE(fileAccessHelper, nullptr);
856 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetConnectInfo_0000";
857 try {
858 std::shared_ptr<ConnectInfo> connectInfo = fileAccessHelper->GetConnectInfo("NotExistBundleName");
859 ASSERT_TRUE(connectInfo == nullptr);
860 } catch (...) {
861 GTEST_LOG_(ERROR) << "external_file_access_GetConnectInfo_0000 occurs an exception.";
862 }
863 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetConnectInfo_0000";
864 }
865
866
867 /**
868 * @tc.number: user_file_service_external_file_access_GetProxyByUri_0000
869 * @tc.name: external_file_access_GetProxyByUri_0000
870 * @tc.desc: Test function of GetProxyByUri interface.
871 * @tc.desc: helper invoke GetProxyByUri for FAILED.
872 * @tc.size: MEDIUM
873 * @tc.type: FUNC
874 * @tc.level Level 1
875 * @tc.require: SR000H0386
876 */
877 HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0000, testing::ext::TestSize.Level1)
878 {
879 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
880 EXPECT_NE(fileAccessHelper, nullptr);
881 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0000";
882 try {
883 Uri uri("");
884 sptr<IFileAccessExtBase> proxy = fileAccessHelper->GetProxyByUri(uri);
885 ASSERT_TRUE(proxy == nullptr);
886 } catch (...) {
887 GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0000 occurs an exception.";
888 }
889 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0000";
890 }
891
892 /**
893 * @tc.number: user_file_service_external_file_access_GetProxyByUri_0001
894 * @tc.name: external_file_access_GetProxyByUri_0001
895 * @tc.desc: Test function of GetProxyByUri interface.
896 * @tc.desc: helper invoke GetProxyByUri for FAILED.
897 * @tc.size: MEDIUM
898 * @tc.type: FUNC
899 * @tc.level Level 1
900 * @tc.require: SR000H0386
901 */
902 HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0001, testing::ext::TestSize.Level1)
903 {
904 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
905 EXPECT_NE(fileAccessHelper, nullptr);
906 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0001";
907 try {
908 Uri uri("file://com.ohos.UserFile.NotExistBundleName/data/storage/el1/bundle/storage_daemon");
909 sptr<IFileAccessExtBase> proxy = fileAccessHelper->GetProxyByUri(uri);
910 ASSERT_TRUE(proxy == nullptr);
911 } catch (...) {
912 GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0001 occurs an exception.";
913 }
914 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0001";
915 }
916
CheckJson(Uri & newDirUriTest,const std::string displayName,const std::string relativePath,int len,shared_ptr<FileAccessHelper> fileAccessHelper)917 static void CheckJson(Uri& newDirUriTest, const std::string displayName, const std::string relativePath,
918 int len, shared_ptr<FileAccessHelper> fileAccessHelper)
919 {
920 json testJson = {
921 {RELATIVE_PATH, " "},
922 {DISPLAY_NAME, " "},
923 {FILE_SIZE, " "},
924 {DATE_MODIFIED, " "},
925 {DATE_ADDED, " "},
926 {HEIGHT, " "},
927 {WIDTH, " "},
928 {DURATION, " "}
929 };
930 auto testJsonString = testJson.dump();
931 int result = fileAccessHelper->Query(newDirUriTest, testJsonString);
932 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
933 auto jsonObject = json::parse(testJsonString);
934 EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
935 EXPECT_EQ(jsonObject.at(FILE_SIZE), len);
936 EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath);
937 ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
938 ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
939 GTEST_LOG_(INFO) << " result" << testJsonString;
940 }
941
WriteBuffToFile(shared_ptr<FileAccessHelper> & fileAccessHelper,Uri & fileUri,std::string & buff)942 static void WriteBuffToFile(shared_ptr<FileAccessHelper>& fileAccessHelper, Uri& fileUri, std::string& buff)
943 {
944 int fd = -1;
945 int result = fileAccessHelper->OpenFile(fileUri, WRITE_READ, fd);
946 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
947
948 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
949 close(fd);
950 EXPECT_EQ(fileSize, buff.size());
951 }
952
953 /**
954 * @tc.number: user_file_service_external_file_access_Query_0000
955 * @tc.name: external_file_access_Query_0000
956 * @tc.desc: Test function of Query directory for SUCCESS.
957 * @tc.size: MEDIUM
958 * @tc.type: FUNC
959 * @tc.level Level 1
960 * @tc.require: I6S4VV
961 */
962 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0000, testing::ext::TestSize.Level1)
963 {
964 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
965 EXPECT_NE(fileAccessHelper, nullptr);
966 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0000";
967 try {
968 vector<RootInfo> info;
969 int result = fileAccessHelper->GetRoots(info);
970 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
971 Uri parentUri(info[0].uri);
972 GTEST_LOG_(INFO) << parentUri.ToString();
973 Uri newDirUriTest1("");
974 Uri newDirUriTest2("");
975 std::string displayName = "QueryTest1";
976 std::string relativePath = "/storage/Users/currentUser/QueryTest1";
977 result = fileAccessHelper->Mkdir(parentUri, "QueryTest1", newDirUriTest1);
978 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
979 result = fileAccessHelper->Mkdir(newDirUriTest1, "QueryTest2", newDirUriTest2);
980 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
981 Uri newFileUri1("");
982 Uri newFileUri2("");
983 std::string fileName = "external_file_access_Query_00001.txt";
984 result = fileAccessHelper->CreateFile(newDirUriTest1, fileName, newFileUri1);
985 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
986 result = fileAccessHelper->CreateFile(newDirUriTest2, fileName, newFileUri2);
987 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
988 std::string buff = "query test";
989 WriteBuffToFile(fileAccessHelper, newFileUri1, buff);
990 WriteBuffToFile(fileAccessHelper, newFileUri2, buff);
991 int len = buff.size() + buff.size();
992 CheckJson(newDirUriTest1, displayName, relativePath, len, fileAccessHelper);
993 result = fileAccessHelper->Delete(newDirUriTest1);
994 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
995 } catch (...) {
996 GTEST_LOG_(ERROR) << "external_file_access_Query_0000 occurs an exception.";
997 }
998 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0000";
999 }
1000
1001 /**
1002 * @tc.number: user_file_service_external_file_access_Query_0001
1003 * @tc.name: external_file_access_Query_0001
1004 * @tc.desc: Test function of Query file for SUCCESS.
1005 * @tc.size: MEDIUM
1006 * @tc.type: FUNC
1007 * @tc.level Level 1
1008 * @tc.require: I6S4VV
1009 */
1010 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0001, testing::ext::TestSize.Level1)
1011 {
1012 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1013 EXPECT_NE(fileAccessHelper, nullptr);
1014 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0001";
1015 try {
1016 vector<RootInfo> info;
1017 int result = fileAccessHelper->GetRoots(info);
1018 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1019 Uri parentUri(info[0].uri);
1020 GTEST_LOG_(INFO) << parentUri.ToString();
1021 Uri newDirUriTest("");
1022 result = fileAccessHelper->Mkdir(parentUri, "QueryTest3", newDirUriTest);
1023 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1024 Uri newFileUri("");
1025 std::string displayName = "external_file_access_Query_0001.txt";
1026 std::string relativePath = "/storage/Users/currentUser/QueryTest3/external_file_access_Query_0001.txt";
1027 result = fileAccessHelper->CreateFile(newDirUriTest, displayName, newFileUri);
1028 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1029 int fd = -1;
1030 result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
1031 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1032 std::string buff = "query test";
1033 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
1034 close(fd);
1035 EXPECT_EQ(fileSize, buff.size());
1036 CheckJson(newFileUri, displayName, relativePath, buff.size(), fileAccessHelper);
1037 result = fileAccessHelper->Delete(newDirUriTest);
1038 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1039 } catch (...) {
1040 GTEST_LOG_(ERROR) << "external_file_access_Query_0001 occurs an exception.";
1041 }
1042 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0001";
1043 }
1044
1045 /**
1046 * @tc.number: user_file_service_external_file_access_Query_0002
1047 * @tc.name: external_file_access_Query_0002
1048 * @tc.desc: Test function of Query directory for SUCCESS.
1049 * @tc.size: MEDIUM
1050 * @tc.type: FUNC
1051 * @tc.level Level 1
1052 * @tc.require: I6S4VV
1053 */
1054 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0002, testing::ext::TestSize.Level1)
1055 {
1056 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1057 EXPECT_NE(fileAccessHelper, nullptr);
1058 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0002";
1059 try {
1060 vector<RootInfo> info;
1061 int result = fileAccessHelper->GetRoots(info);
1062 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1063 Uri parentUri(info[0].uri);
1064 GTEST_LOG_(INFO) << parentUri.ToString();
1065 Uri newDirUriTest1("");
1066 Uri newDirUriTest2("");
1067 result = fileAccessHelper->Mkdir(parentUri, "QueryTest4", newDirUriTest1);
1068 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1069 result = fileAccessHelper->Mkdir(newDirUriTest1, "QueryTest5", newDirUriTest2);
1070 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1071 Uri newFileUri1("");
1072 Uri newFileUri2("");
1073 std::string fileName = "external_file_access_Query_00002.txt";
1074 result = fileAccessHelper->CreateFile(newDirUriTest1, fileName, newFileUri1);
1075 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1076 result = fileAccessHelper->CreateFile(newDirUriTest2, fileName, newFileUri2);
1077 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1078 std::string buff = "query test";
1079 WriteBuffToFile(fileAccessHelper, newFileUri1, buff);
1080 WriteBuffToFile(fileAccessHelper, newFileUri2, buff);
1081 json testJson = {
1082 {FILE_SIZE, " "}
1083 };
1084 auto testJsonString = testJson.dump();
1085 result = fileAccessHelper->Query(newDirUriTest1, testJsonString);
1086 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1087 auto jsonObject = json::parse(testJsonString);
1088 EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2);
1089 GTEST_LOG_(INFO) << " result" << testJsonString;
1090 result = fileAccessHelper->Delete(newDirUriTest1);
1091 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1092 } catch (...) {
1093 GTEST_LOG_(ERROR) << "external_file_access_Query_0002 occurs an exception.";
1094 }
1095 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0002";
1096 }
1097
1098 /**
1099 * @tc.number: user_file_service_external_file_access_Query_0003
1100 * @tc.name: external_file_access_Query_0003
1101 * @tc.desc: Test function of Query interface for which is unreadable code.
1102 * @tc.size: MEDIUM
1103 * @tc.type: FUNC
1104 * @tc.level Level 1
1105 * @tc.require: I6S4VV
1106 */
1107 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0003, testing::ext::TestSize.Level1)
1108 {
1109 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1110 EXPECT_NE(fileAccessHelper, nullptr);
1111 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0003";
1112 try {
1113 Uri testUri("&*()*/?");
1114 json testJson = {
1115 {RELATIVE_PATH, " "},
1116 {DISPLAY_NAME, " "}
1117 };
1118 auto testJsonString = testJson.dump();
1119 int result = fileAccessHelper->Query(testUri, testJsonString);
1120 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1121 GTEST_LOG_(INFO) << " result" << testJsonString;
1122 } catch (...) {
1123 GTEST_LOG_(ERROR) << "external_file_access_Query_0003 occurs an exception.";
1124 }
1125 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0003";
1126 }
1127
1128 /**
1129 * @tc.number: user_file_service_external_file_access_Query_0004
1130 * @tc.name: external_file_access_Query_0004
1131 * @tc.desc: Test function of Query interface for which all column nonexistence.
1132 * @tc.size: MEDIUM
1133 * @tc.type: FUNC
1134 * @tc.level Level 1
1135 * @tc.require: I6S4VV
1136 */
1137 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0004, testing::ext::TestSize.Level1)
1138 {
1139 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1140 EXPECT_NE(fileAccessHelper, nullptr);
1141 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0004";
1142 try {
1143 vector<RootInfo> info;
1144 int result = fileAccessHelper->GetRoots(info);
1145 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1146 Uri parentUri(info[0].uri);
1147 GTEST_LOG_(INFO) << parentUri.ToString();
1148 Uri newDirUriTest("");
1149 result = fileAccessHelper->Mkdir(parentUri, "QueryTest6", newDirUriTest);
1150 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1151 json testJson = {
1152 {"001", " "},
1153 {"#", " "},
1154 {"test", " "},
1155 {"target", " "}
1156 };
1157 auto testJsonString = testJson.dump();
1158 result = fileAccessHelper->Query(newDirUriTest, testJsonString);
1159 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1160 GTEST_LOG_(INFO) << " result" << testJsonString;
1161 result = fileAccessHelper->Delete(newDirUriTest);
1162 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1163 } catch (...) {
1164 GTEST_LOG_(ERROR) << "external_file_access_Query_0004 occurs an exception.";
1165 }
1166 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0004";
1167 }
1168
1169 /**
1170 * @tc.number: user_file_service_external_file_access_Query_0005
1171 * @tc.name: external_file_access_Query_0005
1172 * @tc.desc: Test function of Query interface for which part of column nonexistence.
1173 * @tc.size: MEDIUM
1174 * @tc.type: FUNC
1175 * @tc.level Level 1
1176 * @tc.require: I6S4VV
1177 */
1178 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0005, testing::ext::TestSize.Level1)
1179 {
1180 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1181 EXPECT_NE(fileAccessHelper, nullptr);
1182 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0005";
1183 try {
1184 vector<RootInfo> info;
1185 int result = fileAccessHelper->GetRoots(info);
1186 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1187 Uri parentUri(info[0].uri);
1188 GTEST_LOG_(INFO) << parentUri.ToString();
1189 Uri newDirUriTest("");
1190 result = fileAccessHelper->Mkdir(parentUri, "QueryTest7", newDirUriTest);
1191 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1192 json testJson = {
1193 {RELATIVE_PATH, " "},
1194 {DISPLAY_NAME, " "},
1195 {"test", " "}
1196 };
1197 auto testJsonString = testJson.dump();
1198 result = fileAccessHelper->Query(newDirUriTest, testJsonString);
1199 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1200 GTEST_LOG_(INFO) << " result" << testJsonString;
1201 result = fileAccessHelper->Delete(newDirUriTest);
1202 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1203 } catch (...) {
1204 GTEST_LOG_(ERROR) << "external_file_access_Query_0005 occurs an exception.";
1205 }
1206 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0005";
1207 }
1208
1209 /**
1210 * @tc.number: user_file_service_external_file_access_Query_0006
1211 * @tc.name: external_file_access_Query_0006
1212 * @tc.desc: Test function of Query interface for which column is null.
1213 * @tc.size: MEDIUM
1214 * @tc.type: FUNC
1215 * @tc.level Level 1
1216 * @tc.require: I6S4VV
1217 */
1218 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0006, testing::ext::TestSize.Level1)
1219 {
1220 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1221 EXPECT_NE(fileAccessHelper, nullptr);
1222 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0006";
1223 try {
1224 vector<RootInfo> info;
1225 int result = fileAccessHelper->GetRoots(info);
1226 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1227 Uri parentUri(info[0].uri);
1228 GTEST_LOG_(INFO) << parentUri.ToString();
1229 Uri newDirUriTest("");
1230 result = fileAccessHelper->Mkdir(parentUri, "QueryTest8", newDirUriTest);
1231 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1232 json testJson;
1233 auto testJsonString = testJson.dump();
1234 result = fileAccessHelper->Query(newDirUriTest, testJsonString);
1235 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1236 GTEST_LOG_(INFO) << " result" << testJsonString;
1237 result = fileAccessHelper->Delete(newDirUriTest);
1238 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1239 } catch (...) {
1240 GTEST_LOG_(ERROR) << "external_file_access_Query_0006 occurs an exception.";
1241 }
1242 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0006";
1243 }
1244
1245 /**
1246 * @tc.number: user_file_service_external_file_access_Query_0007
1247 * @tc.name: external_file_access_Query_0007
1248 * @tc.desc: Test function of Query directory for SUCCESS, the folder and file name is chinese.
1249 * @tc.size: MEDIUM
1250 * @tc.type: FUNC
1251 * @tc.level Level 1
1252 * @tc.require: I70SX9
1253 */
1254 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0007, testing::ext::TestSize.Level1)
1255 {
1256 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1257 EXPECT_NE(fileAccessHelper, nullptr);
1258 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0007";
1259 try {
1260 vector<RootInfo> info;
1261 int result = fileAccessHelper->GetRoots(info);
1262 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1263 Uri parentUri(info[0].uri);
1264 GTEST_LOG_(INFO) << parentUri.ToString();
1265 Uri newDirUriTest1("");
1266 Uri newDirUriTest2("");
1267 std::string displayName = "查询目录1";
1268 std::string relativePath = "/storage/Users/currentUser/查询目录1";
1269 result = fileAccessHelper->Mkdir(parentUri, displayName, newDirUriTest1);
1270 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1271 EXPECT_EQ(newDirUriTest1.ToString().find(displayName), std::string::npos);
1272 result = fileAccessHelper->Mkdir(newDirUriTest1, "查询目录2", newDirUriTest2);
1273 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1274 EXPECT_EQ(newDirUriTest2.ToString().find("查询目录2"), std::string::npos);
1275 Uri newFileUri1("");
1276 Uri newFileUri2("");
1277 std::string fileName = "查询文件.txt";
1278 result = fileAccessHelper->CreateFile(newDirUriTest1, fileName, newFileUri1);
1279 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1280 EXPECT_EQ(newFileUri1.ToString().find(fileName), std::string::npos);
1281 result = fileAccessHelper->CreateFile(newDirUriTest2, fileName, newFileUri2);
1282 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1283 EXPECT_EQ(newFileUri2.ToString().find(fileName), std::string::npos);
1284 std::string buff = "query test";
1285 WriteBuffToFile(fileAccessHelper, newFileUri1, buff);
1286 WriteBuffToFile(fileAccessHelper, newFileUri2, buff);
1287 int len = buff.size() + buff.size();
1288 CheckJson(newDirUriTest1, displayName, relativePath, len, fileAccessHelper);
1289 result = fileAccessHelper->Delete(newDirUriTest1);
1290 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1291 } catch (...) {
1292 GTEST_LOG_(ERROR) << "external_file_access_Query_0007 occurs an exception.";
1293 }
1294 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0007";
1295 }
1296
1297 /**
1298 * @tc.number: user_file_service_external_file_access_GetBundleNameFromPath_0000
1299 * @tc.name: external_file_access_GetBundleNameFromPath_0000
1300 * @tc.desc: Test function of GetBundleNameFromPath interface for SUCCESS.
1301 * @tc.size: MEDIUM
1302 * @tc.type: FUNC
1303 * @tc.level Level 1
1304 * @tc.require: SR000H0386
1305 */
1306 HWTEST_F(FileExtensionHelperTest, external_file_access_GetBundleNameFromPath_0000, testing::ext::TestSize.Level1)
1307 {
1308 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1309 EXPECT_NE(fileAccessHelper, nullptr);
1310 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetBundleNameFromPath_0000";
1311 try {
1312 Uri uri("file://media/some/path");
1313 auto result = fileAccessHelper->GetProxyByUri(uri);
1314 EXPECT_EQ(result, nullptr);
1315 } catch (...) {
1316 GTEST_LOG_(ERROR) << "external_file_access_GetBundleNameFromPath_0000 occurs an exception.";
1317 }
1318 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetBundleNameFromPath_0000";
1319 }
1320
1321 /**
1322 * @tc.number: user_file_service_external_file_access_Move_item_0000
1323 * @tc.name: external_file_access_Move_item_0000
1324 * @tc.desc: Test function of Move item interface.
1325 * @tc.size: MEDIUM
1326 * @tc.type: FUNC
1327 * @tc.level Level 1
1328 */
1329 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0000, testing::ext::TestSize.Level1)
1330 {
1331 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1332 EXPECT_NE(fileAccessHelper, nullptr);
1333 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0000";
1334 try {
1335 vector<RootInfo> info;
1336 int result = fileAccessHelper->GetRoots(info);
1337 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1338 Uri parentUri(info[0].uri);
1339 Uri newDirUriTest1("");
1340 Uri newDirUriTest2("");
1341 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
1342 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1343 result = fileAccessHelper->Mkdir(parentUri, "test4", newDirUriTest2);
1344 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1345 Uri testUri("");
1346 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
1347 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1348 std::vector<Result> moveResult;
1349 result = fileAccessHelper->MoveItem(testUri, newDirUriTest2, moveResult, false);
1350 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1351 result = fileAccessHelper->Delete(newDirUriTest1);
1352 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1353 result = fileAccessHelper->Delete(newDirUriTest2);
1354 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1355 } catch (...) {
1356 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0000 occurs an exception.";
1357 }
1358 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0000";
1359 }
1360
1361 /**
1362 * @tc.number: user_file_service_external_file_access_Move_item_0001
1363 * @tc.name: external_file_access_Move_item_0001
1364 * @tc.desc: Test function of Move item interface.
1365 * @tc.size: MEDIUM
1366 * @tc.type: FUNC
1367 * @tc.level Level 1
1368 */
1369 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0001, testing::ext::TestSize.Level1)
1370 {
1371 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1372 EXPECT_NE(fileAccessHelper, nullptr);
1373 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0001";
1374 try {
1375 vector<RootInfo> info;
1376 int result = fileAccessHelper->GetRoots(info);
1377 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1378 Uri parentUri(info[0].uri);
1379 Uri newDirUriTest1("");
1380 Uri newDirUriTest2("");
1381 result = fileAccessHelper->Mkdir(parentUri, "test5", newDirUriTest1);
1382 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1383 result = fileAccessHelper->Mkdir(parentUri, "test6", newDirUriTest2);
1384 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1385 Uri sourceUri("");
1386 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
1387 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1388 Uri targetUri("");
1389 result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
1390 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1391 std::vector<Result> moveResult;
1392 result = fileAccessHelper->MoveItem(sourceUri, newDirUriTest2, moveResult, false);
1393 EXPECT_EQ(result, -2);
1394 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_EXIST);
1395 result = fileAccessHelper->Delete(newDirUriTest1);
1396 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1397 result = fileAccessHelper->Delete(newDirUriTest2);
1398 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1399 } catch (...) {
1400 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0001 occurs an exception.";
1401 }
1402 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0001";
1403 }
1404
1405 /**
1406 * @tc.number: user_file_service_external_file_access_Move_item_0002
1407 * @tc.name: external_file_access_Move_item_0002
1408 * @tc.desc: Test function of Move item interface.
1409 * @tc.size: MEDIUM
1410 * @tc.type: FUNC
1411 * @tc.level Level 1
1412 */
1413 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0002, testing::ext::TestSize.Level1)
1414 {
1415 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1416 EXPECT_NE(fileAccessHelper, nullptr);
1417 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0002";
1418 try {
1419 vector<RootInfo> info;
1420 int result = fileAccessHelper->GetRoots(info);
1421 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1422 Uri parentUri(info[0].uri);
1423 Uri newDirUriTest1("");
1424 Uri newDirUriTest2("");
1425 result = fileAccessHelper->Mkdir(parentUri, "test7", newDirUriTest1);
1426 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1427 result = fileAccessHelper->Mkdir(parentUri, "test8", newDirUriTest2);
1428 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1429 Uri sourceUri("");
1430 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
1431 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1432 Uri targetUri("");
1433 result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
1434 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1435 std::vector<Result> moveResult;
1436 result = fileAccessHelper->MoveItem(sourceUri, newDirUriTest2, moveResult, true);
1437 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1438 result = fileAccessHelper->Delete(newDirUriTest1);
1439 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1440 result = fileAccessHelper->Delete(newDirUriTest2);
1441 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1442 } catch (...) {
1443 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0002 occurs an exception.";
1444 }
1445 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0002";
1446 }
1447
1448 /**
1449 * @tc.number: user_file_service_external_file_access_Move_item_0003
1450 * @tc.name: external_file_access_Move_item_0003
1451 * @tc.desc: Test function of Move item interface.
1452 * @tc.size: MEDIUM
1453 * @tc.type: FUNC
1454 * @tc.level Level 1
1455 */
1456 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0003, testing::ext::TestSize.Level1)
1457 {
1458 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1459 EXPECT_NE(fileAccessHelper, nullptr);
1460 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0003";
1461 try {
1462 vector<RootInfo> info;
1463 int result = fileAccessHelper->GetRoots(info);
1464 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1465 Uri parentUri(info[0].uri);
1466 Uri newDirUriTest1("");
1467 Uri newDirUriTest2("");
1468 result = fileAccessHelper->Mkdir(parentUri, "test9", newDirUriTest1);
1469 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1470 result = fileAccessHelper->Mkdir(parentUri, "test10", newDirUriTest2);
1471 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1472 Uri sourceUri("");
1473 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
1474 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1475 Uri targetUri("");
1476 result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
1477 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1478 std::vector<Result> moveResult;
1479 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest2, moveResult, false);
1480 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1481 GTEST_LOG_(INFO) << "Move_0000 result:" << result;
1482 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1483 result = fileAccessHelper->Delete(newDirUriTest2);
1484 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1485 } catch (...) {
1486 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0003 occurs an exception.";
1487 }
1488 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0003";
1489 }
1490
1491 /**
1492 * @tc.number: user_file_service_external_file_access_Move_item_0004
1493 * @tc.name: external_file_access_Move_item_0004
1494 * @tc.desc: Test function of Move item interface.
1495 * @tc.size: MEDIUM
1496 * @tc.type: FUNC
1497 * @tc.level Level 1
1498 */
1499 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0004, testing::ext::TestSize.Level1)
1500 {
1501 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1502 EXPECT_NE(fileAccessHelper, nullptr);
1503 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0004";
1504 try {
1505 vector<RootInfo> info;
1506 int result = fileAccessHelper->GetRoots(info);
1507 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1508 Uri parentUri(info[0].uri);
1509 Uri newDirUriTest1("");
1510 Uri newDirUriTest2("");
1511 Uri newDirUriTest3("");
1512 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
1513 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1514 result = fileAccessHelper->Mkdir(parentUri, "test4", newDirUriTest2);
1515 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1516 result = fileAccessHelper->Mkdir(newDirUriTest2, "test3", newDirUriTest3);
1517 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1518 Uri sourceUri("");
1519 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
1520 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1521 Uri targetUri("");
1522 result = fileAccessHelper->CreateFile(newDirUriTest3, "test.txt", targetUri);
1523 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1524 std::vector<Result> moveResult;
1525 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest2, moveResult, false);
1526 EXPECT_EQ(result, -2);
1527 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_EXIST);
1528 GTEST_LOG_(INFO) << "Move_0000 result:" << result;
1529 result = fileAccessHelper->Delete(newDirUriTest1);
1530 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1531 result = fileAccessHelper->Delete(newDirUriTest2);
1532 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1533 } catch (...) {
1534 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0004 occurs an exception.";
1535 }
1536 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0004";
1537 }
1538
1539 /**
1540 * @tc.number: user_file_service_external_file_access_Move_item_0005
1541 * @tc.name: external_file_access_Move_item_0005
1542 * @tc.desc: Test function of Move item interface.
1543 * @tc.size: MEDIUM
1544 * @tc.type: FUNC
1545 * @tc.level Level 1
1546 */
1547 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0005, testing::ext::TestSize.Level1)
1548 {
1549 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1550 EXPECT_NE(fileAccessHelper, nullptr);
1551 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0005";
1552 try {
1553 vector<RootInfo> info;
1554 int result = fileAccessHelper->GetRoots(info);
1555 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1556 Uri parentUri(info[0].uri);
1557 Uri newDirUriTest1("");
1558 Uri newDirUriTest2("");
1559 Uri newDirUriTest3("");
1560 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1561 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1562 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1563 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1564 result = fileAccessHelper->Mkdir(newDirUriTest2, "test1", newDirUriTest3);
1565 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1566 Uri sourceUri("");
1567 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
1568 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1569 Uri targetUri("");
1570 result = fileAccessHelper->CreateFile(newDirUriTest3, "test.txt", targetUri);
1571 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1572 std::vector<Result> moveResult;
1573 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest2, moveResult, true);
1574 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1575 GTEST_LOG_(INFO) << "Move_0000 result:" << result;
1576 result = fileAccessHelper->Delete(newDirUriTest2);
1577 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1578 } catch (...) {
1579 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0005 occurs an exception.";
1580 }
1581 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0005";
1582 }
1583
1584 /**
1585 * @tc.number: user_file_service_external_file_access_Move_item_0006
1586 * @tc.name: external_file_access_Move_item_0006
1587 * @tc.desc: Test function of Move item interface.
1588 * @tc.size: MEDIUM
1589 * @tc.type: FUNC
1590 * @tc.level Level 1
1591 */
1592 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0006, testing::ext::TestSize.Level1)
1593 {
1594 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1595 EXPECT_NE(fileAccessHelper, nullptr);
1596 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0006";
1597 try {
1598 vector<RootInfo> info;
1599 int result = fileAccessHelper->GetRoots(info);
1600 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1601 Uri parentUri(info[0].uri);
1602 Uri newDirUriTest1("");
1603 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1604 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1605 Uri newDirUriTest2("");
1606 result = fileAccessHelper->Mkdir(newDirUriTest1, "test2", newDirUriTest2);
1607 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1608 Uri sourceUri1("");
1609 result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", sourceUri1);
1610 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1611 Uri sourceUri2("");
1612 result = fileAccessHelper->CreateFile(newDirUriTest2, "test1.txt", sourceUri2);
1613 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1614 Uri newDirUriTest3("");
1615 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest3);
1616 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1617 Uri newDirUriTest4("");
1618 result = fileAccessHelper->Mkdir(newDirUriTest3, "test1", newDirUriTest4);
1619 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1620 Uri newDirUriTest5("");
1621 result = fileAccessHelper->Mkdir(newDirUriTest4, "test2", newDirUriTest5);
1622 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1623 Uri targetUri1("");
1624 result = fileAccessHelper->CreateFile(newDirUriTest5, "test.txt", targetUri1);
1625 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1626 std::vector<Result> moveResult;
1627 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest3, moveResult, false);
1628 EXPECT_EQ(result, -2);
1629 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_EXIST);
1630 result = fileAccessHelper->Delete(newDirUriTest1);
1631 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1632 result = fileAccessHelper->Delete(newDirUriTest3);
1633 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1634 } catch (...) {
1635 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0006 occurs an exception.";
1636 }
1637 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0006";
1638 }
1639
1640 /**
1641 * @tc.number: user_file_service_external_file_access_Move_item_0007
1642 * @tc.name: external_file_access_Move_item_0007
1643 * @tc.desc: Test function of Move item interface.
1644 * @tc.size: MEDIUM
1645 * @tc.type: FUNC
1646 * @tc.level Level 1
1647 */
1648 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0007, testing::ext::TestSize.Level1)
1649 {
1650 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1651 EXPECT_NE(fileAccessHelper, nullptr);
1652 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0007";
1653 try {
1654 vector<RootInfo> info;
1655 int result = fileAccessHelper->GetRoots(info);
1656 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1657 Uri parentUri(info[0].uri);
1658 Uri newDirUriTest1("");
1659 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
1660 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1661 Uri newDirUriTest2("");
1662 result = fileAccessHelper->Mkdir(newDirUriTest1, "test4", newDirUriTest2);
1663 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1664 Uri sourceUri1("");
1665 result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", sourceUri1);
1666 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1667 Uri sourceUri2("");
1668 result = fileAccessHelper->CreateFile(newDirUriTest2, "test3.txt", sourceUri2);
1669 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1670 Uri newDirUriTest3("");
1671 result = fileAccessHelper->Mkdir(parentUri, "test5", newDirUriTest3);
1672 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1673 Uri newDirUriTest4("");
1674 result = fileAccessHelper->Mkdir(newDirUriTest3, "test3", newDirUriTest4);
1675 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1676 Uri newDirUriTest5("");
1677 result = fileAccessHelper->Mkdir(newDirUriTest4, "test4", newDirUriTest5);
1678 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1679 Uri targetUri1("");
1680 result = fileAccessHelper->CreateFile(newDirUriTest5, "test.txt", targetUri1);
1681 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1682 std::vector<Result> moveResult;
1683 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest3, moveResult, true);
1684 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1685 EXPECT_EQ(moveResult.size(), 0);
1686 result = fileAccessHelper->Delete(newDirUriTest3);
1687 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1688 } catch (...) {
1689 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0007 occurs an exception.";
1690 }
1691 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0007";
1692 }
1693
1694 /**
1695 * @tc.number: user_file_service_external_file_access_Move_item_0008
1696 * @tc.name: external_file_access_Move_item_0008
1697 * @tc.desc: Test function of Move item interface.
1698 * @tc.size: MEDIUM
1699 * @tc.type: FUNC
1700 * @tc.level Level 1
1701 */
1702 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0008, testing::ext::TestSize.Level1)
1703 {
1704 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1705 EXPECT_NE(fileAccessHelper, nullptr);
1706 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0008";
1707 try {
1708 vector<RootInfo> info;
1709 int result = fileAccessHelper->GetRoots(info);
1710 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1711 Uri parentUri(info[0].uri);
1712 Uri newDirUriTest1("");
1713 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1714 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1715 Uri sourceUri("");
1716 result = fileAccessHelper->CreateFile(newDirUriTest1, "test", sourceUri);
1717 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1718
1719 Uri newDirUriTest2("");
1720 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest2);
1721 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1722 Uri newDirUriTest3("");
1723 result = fileAccessHelper->Mkdir(newDirUriTest2, "test", newDirUriTest3);
1724 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1725 std::vector<Result> moveResult;
1726 result = fileAccessHelper->MoveItem(sourceUri, newDirUriTest2, moveResult, true);
1727 EXPECT_EQ(result, -2);
1728 EXPECT_EQ(moveResult.size(), 1);
1729 result = fileAccessHelper->Delete(newDirUriTest1);
1730 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1731 result = fileAccessHelper->Delete(newDirUriTest2);
1732 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1733 } catch (...) {
1734 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0008 occurs an exception.";
1735 }
1736 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0008";
1737 }
1738
1739 /**
1740 * @tc.number: user_file_service_external_file_access_Move_item_0009
1741 * @tc.name: external_file_access_Move_item_0009
1742 * @tc.desc: Test function of Move item interface.
1743 * @tc.size: MEDIUM
1744 * @tc.type: FUNC
1745 * @tc.level Level 1
1746 */
1747 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0009, testing::ext::TestSize.Level1)
1748 {
1749 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1750 EXPECT_NE(fileAccessHelper, nullptr);
1751 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0009";
1752 try {
1753 vector<RootInfo> info;
1754 int result = fileAccessHelper->GetRoots(info);
1755 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1756
1757 Uri parentUri(info[0].uri);
1758 Uri newDirUriTest1("");
1759 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1760 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1761 Uri sourceUri("");
1762 result = fileAccessHelper->Mkdir(newDirUriTest1, "test", sourceUri);
1763 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1764
1765 Uri newDirUriTest2("");
1766 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest2);
1767 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1768 Uri targetUri("");
1769 result = fileAccessHelper->CreateFile(newDirUriTest2, "test", targetUri);
1770 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1771 std::vector<Result> moveResult;
1772 result = fileAccessHelper->MoveItem(sourceUri, newDirUriTest2, moveResult, true);
1773 EXPECT_EQ(result, -2);
1774 result = fileAccessHelper->Delete(newDirUriTest1);
1775 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1776 result = fileAccessHelper->Delete(newDirUriTest2);
1777 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1778 } catch (...) {
1779 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0009 occurs an exception.";
1780 }
1781 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0009";
1782 }
1783
1784 /**
1785 * @tc.number: user_file_service_external_file_access_Move_item_0010
1786 * @tc.name: external_file_access_Move_0007
1787 * @tc.desc: Test function of Move item interface.
1788 * @tc.size: MEDIUM
1789 * @tc.type: FUNC
1790 * @tc.level Level 1
1791 */
1792 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0010, testing::ext::TestSize.Level1)
1793 {
1794 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1795 EXPECT_NE(fileAccessHelper, nullptr);
1796 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0010";
1797 try {
1798 std::vector<Result> moveResult;
1799 vector<RootInfo> info;
1800 int result = fileAccessHelper->GetRoots(info);
1801 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1802 Uri parentUri(info[0].uri);
1803 Uri newDirUriTest1("");
1804 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1805 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1806 Uri sourceUri(newDirUriTest1.ToString() + "/" + "test");
1807
1808 Uri newDirUriTest2("");
1809 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest2);
1810 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1811 result = fileAccessHelper->MoveItem(sourceUri, newDirUriTest2, moveResult, true);
1812 EXPECT_EQ(result, -1);
1813 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_URI);
1814 result = fileAccessHelper->Delete(newDirUriTest1);
1815 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1816 result = fileAccessHelper->Delete(newDirUriTest2);
1817 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1818 } catch (...) {
1819 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0010 occurs an exception.";
1820 }
1821 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0010";
1822 }
1823
1824 /**
1825 * @tc.number: user_file_service_external_file_access_Move_item_0011
1826 * @tc.name: external_file_access_Move_item_0011
1827 * @tc.desc: Test function of Move item interface.
1828 * @tc.size: MEDIUM
1829 * @tc.type: FUNC
1830 * @tc.level Level 1
1831 */
1832 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0011, testing::ext::TestSize.Level1)
1833 {
1834 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1835 EXPECT_NE(fileAccessHelper, nullptr);
1836 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0011";
1837 try {
1838 std::vector<Result> moveResult;
1839 vector<RootInfo> info;
1840 int result = fileAccessHelper->GetRoots(info);
1841 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1842 Uri parentUri(info[0].uri);
1843 Uri newDirUriTest1("");
1844 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1845 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1846 Uri sourceUri("");
1847 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
1848 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1849
1850 Uri newDirUriTest2("");
1851 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1852 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1853 Uri targetUri(newDirUriTest2.ToString() + "/" + "test3");
1854 result = fileAccessHelper->MoveItem(sourceUri, targetUri, moveResult, true);
1855 EXPECT_EQ(result, -1);
1856 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_URI);
1857 result = fileAccessHelper->Delete(newDirUriTest1);
1858 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1859 result = fileAccessHelper->Delete(newDirUriTest2);
1860 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1861 } catch (...) {
1862 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0011 occurs an exception.";
1863 }
1864 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0011";
1865 }
1866
1867 /**
1868 * @tc.number: user_file_service_external_file_access_Move_item_0012
1869 * @tc.name: external_file_access_Move_item_0012
1870 * @tc.desc: Test function of Move item interface.
1871 * @tc.size: MEDIUM
1872 * @tc.type: FUNC
1873 * @tc.level Level 1
1874 */
1875 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0012, testing::ext::TestSize.Level1)
1876 {
1877 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1878 EXPECT_NE(fileAccessHelper, nullptr);
1879 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0012";
1880 try {
1881 std::vector<Result> moveResult;
1882 vector<RootInfo> info;
1883 int result = fileAccessHelper->GetRoots(info);
1884 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1885 Uri parentUri(info[0].uri);
1886 Uri newDirUriTest1("");
1887 result = fileAccessHelper->Mkdir(parentUri, "测试目录1", newDirUriTest1);
1888 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1889 Uri uri1("");
1890 result = fileAccessHelper->CreateFile(newDirUriTest1, "测试文件.txt", uri1);
1891 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1892 Uri uri2("");
1893 result = fileAccessHelper->CreateFile(newDirUriTest1, "测试目录4", uri2);
1894 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1895
1896 Uri newDirUriTest2("");
1897 result = fileAccessHelper->Mkdir(parentUri, "测试目录3", newDirUriTest2);
1898 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1899 Uri newDirUriTest3("");
1900 result = fileAccessHelper->Mkdir(newDirUriTest2, "测试目录1", newDirUriTest3);
1901 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1902 Uri newDirUriTest4("");
1903 result = fileAccessHelper->Mkdir(newDirUriTest3, "测试目录4", newDirUriTest4);
1904 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1905 Uri newDirUriTest5("");
1906 result = fileAccessHelper->CreateFile(newDirUriTest3, "测试文件.txt", newDirUriTest5);
1907 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1908
1909 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest2, moveResult, false);
1910 EXPECT_EQ(result, -2);
1911 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_IS_DIR);
1912 EXPECT_EQ(moveResult[1].errCode, OHOS::FileAccessFwk::ERR_EXIST);
1913 result = fileAccessHelper->Delete(newDirUriTest1);
1914 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1915 result = fileAccessHelper->Delete(newDirUriTest2);
1916 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1917 } catch (...) {
1918 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0012 occurs an exception.";
1919 }
1920 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0012";
1921 }
1922
1923 /**
1924 * @tc.number: user_file_service_external_file_access_Move_item_0013
1925 * @tc.name: external_file_access_Move_item_0013
1926 * @tc.desc: Test function of Move item interface.
1927 * @tc.size: MEDIUM
1928 * @tc.type: FUNC
1929 * @tc.level Level 1
1930 */
1931 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_item_0013, testing::ext::TestSize.Level1)
1932 {
1933 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1934 EXPECT_NE(fileAccessHelper, nullptr);
1935 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_item_0013";
1936 try {
1937 std::vector<Result> moveResult;
1938 vector<RootInfo> info;
1939 int result = fileAccessHelper->GetRoots(info);
1940 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1941 Uri parentUri(info[0].uri);
1942 Uri newDirUriTest1("");
1943 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1944 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1945 Uri uri1("");
1946 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", uri1);
1947 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1948 Uri uri2("");
1949 result = fileAccessHelper->CreateFile(newDirUriTest1, "test4", uri2);
1950 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1951
1952 Uri newDirUriTest2("");
1953 result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest2);
1954 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1955 Uri newDirUriTest3("");
1956 result = fileAccessHelper->Mkdir(newDirUriTest2, "test1", newDirUriTest3);
1957 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1958 Uri newDirUriTest4("");
1959 result = fileAccessHelper->Mkdir(newDirUriTest3, "test4", newDirUriTest4);
1960 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1961 Uri newDirUriTest5("");
1962 result = fileAccessHelper->Mkdir(newDirUriTest3, "test.txt", newDirUriTest5);
1963 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1964
1965 result = fileAccessHelper->MoveItem(newDirUriTest1, newDirUriTest2, moveResult, true);
1966 EXPECT_EQ(result, -2);
1967 EXPECT_EQ(moveResult[0].errCode, OHOS::FileAccessFwk::ERR_IS_DIR);
1968 result = fileAccessHelper->Delete(newDirUriTest1);
1969 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1970 result = fileAccessHelper->Delete(newDirUriTest2);
1971 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1972 } catch (...) {
1973 GTEST_LOG_(ERROR) << "external_file_access_Move_item_0013 occurs an exception.";
1974 }
1975 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_item_0013";
1976 }
1977 } // namespace
1978