1 /*
2  * Copyright (c) 2024 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 
32 namespace OHOS::FileAccessFwk {
33 static int g_num = 0;
34 
35 /**
36  * @tc.number: user_file_service_external_file_access_CreateFile_0000
37  * @tc.name: external_file_access_CreateFile_0000
38  * @tc.desc: Test function of CreateFile interface for SUCCESS.
39  * @tc.size: MEDIUM
40  * @tc.type: FUNC
41  * @tc.level Level 1
42  * @tc.require: SR000H0386
43  */
44 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0000, testing::ext::TestSize.Level1)
45 {
46     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
47     EXPECT_NE(fileAccessHelper, nullptr);
48     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0000";
49     try {
50         vector<RootInfo> info;
51         int result = fileAccessHelper->GetRoots(info);
52         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
53         for (size_t i = 0; i < info.size(); i++) {
54             Uri parentUri(info[i].uri);
55             Uri newFileUri("");
56             result = fileAccessHelper->CreateFile(parentUri, "external_file_access_CreateFile_0000.txt", newFileUri);
57             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
58             GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result;
59             result = fileAccessHelper->Delete(newFileUri);
60             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
61         }
62     } catch (...) {
63         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0000 occurs an exception.";
64     }
65     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0000";
66 }
67 
68 /**
69  * @tc.number: user_file_service_external_file_access_CreateFile_0001
70  * @tc.name: external_file_access_CreateFile_0001
71  * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null.
72  * @tc.size: MEDIUM
73  * @tc.type: FUNC
74  * @tc.level Level 1
75  * @tc.require: SR000H0386
76  */
77 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0001, testing::ext::TestSize.Level1)
78 {
79     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
80     EXPECT_NE(fileAccessHelper, nullptr);
81     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0001";
82     try {
83         Uri newFileUri("");
84         Uri parentUri("");
85         int result = fileAccessHelper->CreateFile(parentUri, "external_file_access_CreateFile_0001.txt", newFileUri);
86         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
87         GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result;
88     } catch (...) {
89         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0001 occurs an exception.";
90     }
91     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0001";
92 }
93 
94 /**
95  * @tc.number: user_file_service_external_file_access_CreateFile_0002
96  * @tc.name: external_file_access_CreateFile_0002
97  * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path.
98  * @tc.size: MEDIUM
99  * @tc.type: FUNC
100  * @tc.level Level 1
101  * @tc.require: SR000H0386
102  */
103 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0002, testing::ext::TestSize.Level1)
104 {
105     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
106     EXPECT_NE(fileAccessHelper, nullptr);
107     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002";
108     try {
109         Uri newFileUri("");
110         Uri parentUri("storage/media/100/local/files/Download");
111         int result = fileAccessHelper->CreateFile(parentUri, "external_file_access_CreateFile_0002.txt", newFileUri);
112         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
113         GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result;
114     } catch (...) {
115         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0002 occurs an exception.";
116     }
117     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0002";
118 }
119 
120 /**
121  * @tc.number: user_file_service_external_file_access_CreateFile_0003
122  * @tc.name: external_file_access_CreateFile_0003
123  * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols.
124  * @tc.size: MEDIUM
125  * @tc.type: FUNC
126  * @tc.level Level 1
127  * @tc.require: SR000H0386
128  */
129 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0003, testing::ext::TestSize.Level1)
130 {
131     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
132     EXPECT_NE(fileAccessHelper, nullptr);
133     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0003";
134     try {
135         Uri newFileUri("");
136         Uri parentUri("~!@#$%^&*()_");
137         int result = fileAccessHelper->CreateFile(parentUri, "external_file_access_CreateFile_0003.txt", newFileUri);
138         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
139         GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result;
140     } catch (...) {
141         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0003 occurs an exception.";
142     }
143     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0003";
144 }
145 
146 /**
147  * @tc.number: user_file_service_external_file_access_CreateFile_0004
148  * @tc.name: external_file_access_CreateFile_0004
149  * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null.
150  * @tc.size: MEDIUM
151  * @tc.type: FUNC
152  * @tc.level Level 1
153  * @tc.require: SR000H0386
154  */
155 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0004, testing::ext::TestSize.Level1)
156 {
157     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
158     EXPECT_NE(fileAccessHelper, nullptr);
159     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0004";
160     try {
161         vector<RootInfo> info;
162         int result = fileAccessHelper->GetRoots(info);
163         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
164         for (size_t i = 0; i < info.size(); i++) {
165             Uri parentUri(info[i].uri);
166             Uri newFileUri("");
167             string displayName = "";
168             result = fileAccessHelper->CreateFile(parentUri, displayName, newFileUri);
169             EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
170             GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result;
171         }
172     } catch (...) {
173         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0004 occurs an exception.";
174     }
175     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0004";
176 }
177 
CreateFileTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,std::string displayName,Uri newFile)178 static void CreateFileTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, std::string displayName, Uri newFile)
179 {
180     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
181     EXPECT_NE(fileAccessHelper, nullptr);
182     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFileTdd";
183     int ret = fahs->CreateFile(uri, displayName, newFile);
184     if (ret != OHOS::FileAccessFwk::ERR_OK) {
185         GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret;
186         return;
187     }
188     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
189     EXPECT_NE(newFile.ToString(), "");
190     g_num++;
191     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFileTdd";
192 }
193 
194 /**
195  * @tc.number: user_file_service_external_file_access_CreateFile_0005
196  * @tc.name: external_file_access_CreateFile_0005
197  * @tc.desc: Test function of CreateFile interface for ERROR which Concurrent.
198  * @tc.size: MEDIUM
199  * @tc.type: FUNC
200  * @tc.level Level 1
201  * @tc.require: SR000H0386
202  */
203 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0005, testing::ext::TestSize.Level1)
204 {
205     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
206     EXPECT_NE(fileAccessHelper, nullptr);
207     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0005";
208     try {
209         vector<RootInfo> info;
210         int result = fileAccessHelper->GetRoots(info);
211         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
212         for (size_t i = 0; i < info.size(); i++) {
213             Uri parentUri(info[i].uri);
214             Uri newFileUri("");
215             std::string displayName = "external_file_access_CreateFile_0005.txt";
216             g_num = 0;
217             for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
218                 std::thread execthread(CreateFileTdd, fileAccessHelper, parentUri, displayName, newFileUri);
219                 execthread.join();
220             }
221             EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
222             Uri newDelete(info[i].uri + "/" + displayName);
223             result = fileAccessHelper->Delete(newDelete);
224             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
225         }
226     } catch (...) {
227         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0005 occurs an exception.";
228     }
229     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0005";
230 }
231 
232 /**
233  * @tc.number: user_file_service_external_file_access_CreateFile_0006
234  * @tc.name: external_file_access_CreateFile_0006
235  * @tc.desc: Test function of CreateFile interface for ERROR because of GetProxyByUri failed.
236  * @tc.size: MEDIUM
237  * @tc.type: FUNC
238  * @tc.level Level 1
239  * @tc.require: SR000H0386
240  */
241 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0006, testing::ext::TestSize.Level1)
242 {
243     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
244     EXPECT_NE(fileAccessHelper, nullptr);
245     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0006";
246     try {
247         vector<RootInfo> info;
248         int result = fileAccessHelper->GetRoots(info);
249         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
250         for (size_t i = 0; i < info.size(); i++) {
251             std::string str = info[i].uri;
252             if (ReplaceBundleName(str, "ohos.com.NotExistBundleName")) {
253                 Uri parentUri(str);
254                 Uri newFileUri("");
255                 string displayName = "test.txt";
256                 result = fileAccessHelper->CreateFile(parentUri, displayName, newFileUri);
257                 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
258                 GTEST_LOG_(INFO) << "CreateFile_0006 result:" << result;
259             } else {
260                 EXPECT_TRUE(false);
261             }
262         }
263     } catch (...) {
264         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0006 occurs an exception.";
265     }
266     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0006";
267 }
268 
269 /**
270  * @tc.number: user_file_service_external_file_access_CreateFile_0007
271  * @tc.name: external_file_access_CreateFile_0007
272  * @tc.desc: Test function of CreateFile interface for SUCCESS, the file name is chinese.
273  * @tc.size: MEDIUM
274  * @tc.type: FUNC
275  * @tc.level Level 1
276  * @tc.require: I70SX9
277  */
278 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0007, testing::ext::TestSize.Level1)
279 {
280     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
281     EXPECT_NE(fileAccessHelper, nullptr);
282     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0007";
283     try {
284         vector<RootInfo> info;
285         int result = fileAccessHelper->GetRoots(info);
286         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
287         for (size_t i = 0; i < info.size(); i++) {
288             Uri parentUri(info[i].uri);
289             Uri newFileUri("");
290             result = fileAccessHelper->CreateFile(parentUri, "新建文件.txt", newFileUri);
291             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
292             EXPECT_EQ(newFileUri.ToString().find("新建文件.txt"), std::string::npos);
293             GTEST_LOG_(INFO) << "CreateFile_0007 result:" << result;
294             result = fileAccessHelper->Delete(newFileUri);
295             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
296         }
297     } catch (...) {
298         GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0007 occurs an exception.";
299     }
300     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0007";
301 }
302 
303 /**
304 * @tc.number: user_file_service_external_file_access_Move_file_0000
305 * @tc.name: external_file_access_Move_file_0000
306 * @tc.desc: Test function of Move file interface.
307 * @tc.size: MEDIUM
308 * @tc.type: FUNC
309 * @tc.level Level 1
310 */
311 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_file_0000, testing::ext::TestSize.Level1)
312 {
313     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
314     EXPECT_NE(fileAccessHelper, nullptr);
315     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_file_0000";
316     try {
317         vector<RootInfo> info;
318         int result = fileAccessHelper->GetRoots(info);
319         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
320         Uri parentUri(info[0].uri);
321         Uri newDirUriTest1("");
322         result = fileAccessHelper->Mkdir(parentUri, "测试目录1", newDirUriTest1);
323         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
324         Uri sourceUri(newDirUriTest1.ToString() + "/" + "test");
325 
326         Uri newDirUriTest2("");
327         result = fileAccessHelper->Mkdir(parentUri, "测试目录3", newDirUriTest2);
328         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
329         Uri newFile("");
330         std::string fileName = "a";
331         result = fileAccessHelper->MoveFile(sourceUri, newDirUriTest2, fileName, newFile);
332         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_URI);
333         result = fileAccessHelper->Delete(newDirUriTest1);
334         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
335         result = fileAccessHelper->Delete(newDirUriTest2);
336         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
337     } catch (...) {
338         GTEST_LOG_(ERROR) << "external_file_access_Move_file_0000 occurs an exception.";
339     }
340     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_file_0000";
341 }
342 
343 /**
344 * @tc.number: user_file_service_external_file_access_Move_file_0001
345 * @tc.name: external_file_access_Move_file_0001
346 * @tc.desc: Test function of Move file interface.
347 * @tc.size: MEDIUM
348 * @tc.type: FUNC
349 * @tc.level Level 1
350 */
351 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_file_001, testing::ext::TestSize.Level1)
352 {
353     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
354     EXPECT_NE(fileAccessHelper, nullptr);
355     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_file_0001";
356     try {
357         vector<RootInfo> info;
358         int result = fileAccessHelper->GetRoots(info);
359         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
360         Uri parentUri(info[0].uri);
361         Uri newDirUriTest1("");
362         result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
363         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
364         Uri sourceUri("");
365         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
366         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
367 
368         Uri newDirUriTest2("");
369         result = fileAccessHelper->Mkdir(parentUri, "test4", newDirUriTest2);
370         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
371         Uri targetUri(newDirUriTest2.ToString() + "/" + "test5");
372         std::string fileName("a.txt");
373         Uri newFile("");
374         result = fileAccessHelper->MoveFile(sourceUri, targetUri, fileName, newFile);
375         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_URI);
376         result = fileAccessHelper->Delete(newDirUriTest1);
377         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
378         result = fileAccessHelper->Delete(newDirUriTest2);
379         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
380     } catch (...) {
381         GTEST_LOG_(ERROR) << "external_file_access_Move_file_0001 occurs an exception.";
382     }
383     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_file_0001";
384 }
385 
386 /**
387 * @tc.number: user_file_service_external_file_access_Move_file_0002
388 * @tc.name: external_file_access_Move_file_0002
389 * @tc.desc: Test function of Move file interface.
390 * @tc.size: MEDIUM
391 * @tc.type: FUNC
392 * @tc.level Level 1
393 */
394 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_file_002, testing::ext::TestSize.Level1)
395 {
396     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
397     EXPECT_NE(fileAccessHelper, nullptr);
398     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_file_0002";
399     try {
400         vector<RootInfo> info;
401         int result = fileAccessHelper->GetRoots(info);
402         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
403         Uri parentUri(info[0].uri);
404         Uri newDirUriTest1("");
405         result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
406         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
407 
408         Uri newDirUriTest2("");
409         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
410         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
411         std::string fileName("a.txt");
412         Uri newFile("");
413         result = fileAccessHelper->MoveFile(newDirUriTest1, newDirUriTest2, fileName, newFile);
414         EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
415         result = fileAccessHelper->Delete(newDirUriTest1);
416         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
417         result = fileAccessHelper->Delete(newDirUriTest2);
418         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
419     } catch (...) {
420         GTEST_LOG_(ERROR) << "external_file_access_Move_file_0002 occurs an exception.";
421     }
422     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_file_0002";
423 }
424 
425 /**
426 * @tc.number: user_file_service_external_file_access_Move_file_0003
427 * @tc.name: external_file_access_Move_file_0003
428 * @tc.desc: Test function of Move file interface.
429 * @tc.size: MEDIUM
430 * @tc.type: FUNC
431 * @tc.level Level 1
432 */
433 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_file_003, testing::ext::TestSize.Level1)
434 {
435     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
436     EXPECT_NE(fileAccessHelper, nullptr);
437     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_file_0003";
438     try {
439         vector<RootInfo> info;
440         int result = fileAccessHelper->GetRoots(info);
441         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
442         Uri parentUri(info[0].uri);
443         Uri newDirUriTest1("");
444         result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
445         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
446         Uri sourceUri("");
447         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
448         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
449 
450         Uri newDirUriTest2("");
451         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
452         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
453         std::string fileName("a.txt");
454         Uri newFile("");
455         result = fileAccessHelper->MoveFile(sourceUri, newDirUriTest2, fileName, newFile);
456         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
457         EXPECT_EQ(newFile.GetPath(), newDirUriTest2.GetPath() + '/' +"test.txt");
458         result = fileAccessHelper->Delete(newDirUriTest1);
459         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
460         result = fileAccessHelper->Delete(newDirUriTest2);
461         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
462     } catch (...) {
463         GTEST_LOG_(ERROR) << "external_file_access_Move_file_0003 occurs an exception.";
464     }
465     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_file_0003";
466 }
467 
468 /**
469 * @tc.number: user_file_service_external_file_access_Move_file_0004
470 * @tc.name: external_file_access_Move_file_0004
471 * @tc.desc: Test function of Move file interface.
472 * @tc.size: MEDIUM
473 * @tc.type: FUNC
474 * @tc.level Level 1
475 */
476 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_file_004, testing::ext::TestSize.Level1)
477 {
478     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
479     EXPECT_NE(fileAccessHelper, nullptr);
480     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_file_0004";
481     try {
482         vector<RootInfo> info;
483         int result = fileAccessHelper->GetRoots(info);
484         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
485         Uri parentUri(info[0].uri);
486         Uri newDirUriTest1("");
487         result = fileAccessHelper->Mkdir(parentUri, "test4", newDirUriTest1);
488         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
489         Uri sourceUri("");
490         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
491         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
492 
493         Uri newDirUriTest2("");
494         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
495         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
496         Uri targetUri("");
497         result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
498         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
499         std::string fileName("a.txt");
500         Uri newFile("");
501         result = fileAccessHelper->MoveFile(sourceUri, newDirUriTest2, fileName, newFile);
502         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
503         EXPECT_EQ(newFile.GetPath(), newDirUriTest2.GetPath() + '/' +"a.txt");
504         result = fileAccessHelper->Delete(newDirUriTest1);
505         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
506         result = fileAccessHelper->Delete(newDirUriTest2);
507         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
508     } catch (...) {
509         GTEST_LOG_(ERROR) << "external_file_access_Move_file_0004 occurs an exception.";
510     }
511     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_file_0004";
512 }
513 
514 /**
515 * @tc.number: user_file_service_external_file_access_Move_file_0005
516 * @tc.name: external_file_access_Move_file_0005
517 * @tc.desc: Test function of Move file interface.
518 * @tc.size: MEDIUM
519 * @tc.type: FUNC
520 * @tc.level Level 1
521 */
522 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_file_005, testing::ext::TestSize.Level1)
523 {
524     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
525     EXPECT_NE(fileAccessHelper, nullptr);
526     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_file_0005";
527     try {
528         vector<RootInfo> info;
529         int result = fileAccessHelper->GetRoots(info);
530         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
531         Uri parentUri(info[0].uri);
532         Uri newDirUriTest1("");
533         result = fileAccessHelper->Mkdir(parentUri, "test5", newDirUriTest1);
534         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
535         Uri sourceUri("");
536         result = fileAccessHelper->CreateFile(newDirUriTest1, "test1.txt", sourceUri);
537         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
538 
539         Uri newDirUriTest2("");
540         result = fileAccessHelper->Mkdir(parentUri, "test05", newDirUriTest2);
541         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
542         Uri targetUri1("");
543         result = fileAccessHelper->CreateFile(newDirUriTest2, "test5.txt", targetUri1);
544         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
545         Uri targetUri2("");
546         result = fileAccessHelper->CreateFile(newDirUriTest2, "test05.txt", targetUri2);
547         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
548         std::string fileName("test05.txt");
549         Uri newFile("");
550         result = fileAccessHelper->MoveFile(sourceUri, newDirUriTest2, fileName, newFile);
551         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
552         result = fileAccessHelper->Delete(newDirUriTest1);
553         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
554         result = fileAccessHelper->Delete(newDirUriTest2);
555         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
556     } catch (...) {
557         GTEST_LOG_(ERROR) << "external_file_access_Move_file_0005 occurs an exception.";
558     }
559     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_file_0005";
560 }
561 
562 /**
563 * @tc.number: user_file_service_external_file_access_Copy_file_000
564 * @tc.name: external_file_access_Copy_file_000
565 * @tc.desc: Test function of Copy file interface.
566 * @tc.size: MEDIUM
567 * @tc.type: FUNC
568 * @tc.level Level 1
569 */
570 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_000, testing::ext::TestSize.Level1)
571 {
572     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
573     EXPECT_NE(fileAccessHelper, nullptr);
574     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_000";
575     try {
576         vector<RootInfo> info;
577         int result = fileAccessHelper->GetRoots(info);
578         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
579         Uri parentUri(info[0].uri);
580         Uri newDirUriTest1("");
581         result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
582         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
583         Uri sourceUri(newDirUriTest1.ToString() + "/" + "test");
584 
585         Uri newDirUriTest2("");
586         result = fileAccessHelper->Mkdir(parentUri, "test5", newDirUriTest2);
587         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
588         Uri newFile("");
589         std::string fileName = "a";
590         result = fileAccessHelper->CopyFile(sourceUri, newDirUriTest2, fileName, newFile);
591         EXPECT_EQ(result, OHOS::FileAccessFwk::E_GETRESULT);
592         result = fileAccessHelper->Delete(newDirUriTest1);
593         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
594         result = fileAccessHelper->Delete(newDirUriTest2);
595         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
596     } catch (...) {
597         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_000 occurs an exception.";
598     }
599     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_000";
600 }
601 
602 /**
603 * @tc.number: user_file_service_external_file_access_Copy_file_001
604 * @tc.name: external_file_access_Copy_file_001
605 * @tc.desc: Test function of Copy file interface.
606 * @tc.size: MEDIUM
607 * @tc.type: FUNC
608 * @tc.level Level 1
609 */
610 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_001, testing::ext::TestSize.Level1)
611 {
612     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
613     EXPECT_NE(fileAccessHelper, nullptr);
614     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_001";
615     try {
616         vector<RootInfo> info;
617         int result = fileAccessHelper->GetRoots(info);
618         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
619         Uri parentUri(info[0].uri);
620         Uri newDirUriTest1("");
621         result = fileAccessHelper->Mkdir(parentUri, "test6", newDirUriTest1);
622         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
623         Uri sourceUri("");
624         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
625         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
626 
627         Uri newDirUriTest2("");
628         result = fileAccessHelper->Mkdir(parentUri, "test7", newDirUriTest2);
629         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
630         Uri targetUri(newDirUriTest2.ToString() + "/" + "test8");
631         std::string fileName("a.txt");
632         Uri newFile("");
633         result = fileAccessHelper->CopyFile(sourceUri, targetUri, fileName, newFile);
634         EXPECT_EQ(result, OHOS::FileAccessFwk::E_GETRESULT);
635         result = fileAccessHelper->Delete(newDirUriTest1);
636         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
637         result = fileAccessHelper->Delete(newDirUriTest2);
638         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
639     } catch (...) {
640         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_001 occurs an exception.";
641     }
642     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_001";
643 }
644 
645 /**
646 * @tc.number: user_file_service_external_file_access_Copy_file_002
647 * @tc.name: external_file_access_Copy_file_002
648 * @tc.desc: Test function of Copy file interface.
649 * @tc.size: MEDIUM
650 * @tc.type: FUNC
651 * @tc.level Level 1
652 */
653 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_002, testing::ext::TestSize.Level1)
654 {
655     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
656     EXPECT_NE(fileAccessHelper, nullptr);
657     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_002";
658     try {
659         vector<RootInfo> info;
660         int result = fileAccessHelper->GetRoots(info);
661         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
662         Uri parentUri(info[0].uri);
663         Uri newDirUriTest1("");
664         result = fileAccessHelper->Mkdir(parentUri, "test3", newDirUriTest1);
665         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
666 
667         Uri newDirUriTest2("");
668         result = fileAccessHelper->Mkdir(parentUri, "test4", newDirUriTest2);
669         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
670         std::string fileName("a.txt");
671         Uri newFile("");
672         result = fileAccessHelper->CopyFile(newDirUriTest1, newDirUriTest2, fileName, newFile);
673         EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
674         result = fileAccessHelper->Delete(newDirUriTest1);
675         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
676         result = fileAccessHelper->Delete(newDirUriTest2);
677         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
678     } catch (...) {
679         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_002 occurs an exception.";
680     }
681     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_002";
682 }
683 
684 /**
685 * @tc.number: user_file_service_external_file_access_Copy_file_003
686 * @tc.name: external_file_access_Copy_file_003
687 * @tc.desc: Test function of Copy file interface.
688 * @tc.size: MEDIUM
689 * @tc.type: FUNC
690 * @tc.level Level 1
691 */
692 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_003, testing::ext::TestSize.Level1)
693 {
694     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
695     EXPECT_NE(fileAccessHelper, nullptr);
696     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_003";
697     try {
698         vector<RootInfo> info;
699         int result = fileAccessHelper->GetRoots(info);
700         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
701         Uri parentUri(info[0].uri);
702         Uri newDirUriTest1("");
703         result = fileAccessHelper->Mkdir(parentUri, "test7", newDirUriTest1);
704         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
705         Uri sourceUri("");
706         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
707         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
708 
709         Uri newDirUriTest2("");
710         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
711         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
712         Uri targetUri(newDirUriTest2.ToString() + "/" + "test.txt");
713         std::string fileName("a.txt");
714         Uri newFile("");
715         result = fileAccessHelper->CopyFile(sourceUri, targetUri, fileName, newFile);
716         EXPECT_EQ(result, OHOS::FileAccessFwk::E_GETRESULT);
717         result = fileAccessHelper->Delete(newDirUriTest1);
718         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
719         result = fileAccessHelper->Delete(newDirUriTest2);
720         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
721     } catch (...) {
722         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_003 occurs an exception.";
723     }
724     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_003";
725 }
726 
727 /**
728 * @tc.number: user_file_service_external_file_access_Copy_file_004
729 * @tc.name: external_file_access_Copy_file_004
730 * @tc.desc: Test function of Copy file interface.
731 * @tc.size: MEDIUM
732 * @tc.type: FUNC
733 * @tc.level Level 1
734 */
735 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_004, testing::ext::TestSize.Level1)
736 {
737     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
738     EXPECT_NE(fileAccessHelper, nullptr);
739     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_004";
740     try {
741         vector<RootInfo> info;
742         int result = fileAccessHelper->GetRoots(info);
743         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
744         Uri parentUri(info[0].uri);
745         Uri newDirUriTest1("");
746         result = fileAccessHelper->Mkdir(parentUri, "test8", newDirUriTest1);
747         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
748         Uri sourceUri("");
749         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
750         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
751 
752         Uri newDirUriTest2("");
753         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
754         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
755         Uri targetUri("");
756         result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
757         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
758         std::string fileName("a.txt");
759         Uri newFile("");
760         result = fileAccessHelper->CopyFile(sourceUri, targetUri, fileName, newFile);
761         EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
762         result = fileAccessHelper->Delete(newDirUriTest1);
763         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
764         result = fileAccessHelper->Delete(newDirUriTest2);
765         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
766     } catch (...) {
767         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_004 occurs an exception.";
768     }
769     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_004";
770 }
771 
772 /**
773 * @tc.number: user_file_service_external_file_access_Copy_file_005
774 * @tc.name: external_file_access_Copy_file_005
775 * @tc.desc: Test function of Copy file interface.
776 * @tc.size: MEDIUM
777 * @tc.type: FUNC
778 * @tc.level Level 1
779 */
780 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_005, testing::ext::TestSize.Level1)
781 {
782     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
783     EXPECT_NE(fileAccessHelper, nullptr);
784     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_005";
785     try {
786         vector<RootInfo> info;
787         int result = fileAccessHelper->GetRoots(info);
788         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
789         Uri parentUri(info[0].uri);
790         Uri newDirUriTest1("");
791         result = fileAccessHelper->Mkdir(parentUri, "test9", newDirUriTest1);
792         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
793         Uri sourceUri("");
794         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
795         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
796 
797         Uri newDirUriTest10("");
798         result = fileAccessHelper->Mkdir(parentUri, "test10", newDirUriTest10);
799         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
800         std::string fileName("a.txt");
801         Uri newFile("");
802         result = fileAccessHelper->CopyFile(sourceUri, newDirUriTest10, fileName, newFile);
803         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
804         EXPECT_EQ(newFile.GetPath(), newDirUriTest10.GetPath() + '/' +"test.txt");
805         result = fileAccessHelper->Delete(newDirUriTest1);
806         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
807         result = fileAccessHelper->Delete(newDirUriTest10);
808         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
809     } catch (...) {
810         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_005 occurs an exception.";
811     }
812     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_005";
813 }
814 
815 /**
816 * @tc.number: user_file_service_external_file_access_Copy_file_006
817 * @tc.name: external_file_access_Copy_file_006
818 * @tc.desc: Test function of Copy file interface.
819 * @tc.size: MEDIUM
820 * @tc.type: FUNC
821 * @tc.level Level 1
822 */
823 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_006, testing::ext::TestSize.Level1)
824 {
825     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
826     EXPECT_NE(fileAccessHelper, nullptr);
827     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_006";
828     try {
829         vector<RootInfo> info;
830         int result = fileAccessHelper->GetRoots(info);
831         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
832         Uri parentUri(info[0].uri);
833         Uri newDirUriTest1("");
834         result = fileAccessHelper->Mkdir(parentUri, "test10", newDirUriTest1);
835         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
836         Uri sourceUri("");
837         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
838         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
839 
840         Uri newDirUriTest2("");
841         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
842         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
843         Uri targetUri("");
844         result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
845         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
846         std::string fileName("a.txt");
847         Uri newFile("");
848         result = fileAccessHelper->CopyFile(sourceUri, newDirUriTest2, fileName, newFile);
849         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
850         EXPECT_EQ(newFile.GetPath(), newDirUriTest2.GetPath() + '/' +"a.txt");
851         result = fileAccessHelper->Delete(newDirUriTest1);
852         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
853         result = fileAccessHelper->Delete(newDirUriTest2);
854         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
855     } catch (...) {
856         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_006 occurs an exception.";
857     }
858     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_006";
859 }
860 
861 /**
862 * @tc.number: user_file_service_external_file_access_Copy_file_007
863 * @tc.name: external_file_access_Copy_file_007
864 * @tc.desc: Test function of Copy file interface.
865 * @tc.size: MEDIUM
866 * @tc.type: FUNC
867 * @tc.level Level 1
868 */
869 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_007, testing::ext::TestSize.Level1)
870 {
871     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
872     EXPECT_NE(fileAccessHelper, nullptr);
873     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_007";
874     try {
875         vector<RootInfo> info;
876         int result = fileAccessHelper->GetRoots(info);
877         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
878         Uri parentUri(info[0].uri);
879         Uri newDirUriTest1("");
880         result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
881         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
882         Uri sourceUri("");
883         result = fileAccessHelper->CreateFile(newDirUriTest1, "test1.txt", sourceUri);
884         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
885 
886         Uri newDirUriTest2("");
887         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
888         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
889         Uri targetUri1("");
890         result = fileAccessHelper->CreateFile(newDirUriTest2, "test1.txt", targetUri1);
891         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
892         Uri targetUri2("");
893         result = fileAccessHelper->CreateFile(newDirUriTest2, "test2.txt", targetUri2);
894         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
895         std::string fileName("test2.txt");
896         Uri newFile("");
897         result = fileAccessHelper->CopyFile(sourceUri, newDirUriTest2, fileName, newFile);
898         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_EXIST);
899         result = fileAccessHelper->Delete(newDirUriTest1);
900         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
901         result = fileAccessHelper->Delete(newDirUriTest2);
902         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
903     } catch (...) {
904         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_007 occurs an exception.";
905     }
906     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_007";
907 }
908 
909 /**
910 * @tc.number: user_file_service_external_file_access_Copy_file_008
911 * @tc.name: external_file_access_Copy_file_008
912 * @tc.desc: Test function of Copy file interface.
913 * @tc.size: MEDIUM
914 * @tc.type: FUNC
915 * @tc.level Level 1
916 */
917 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_008, testing::ext::TestSize.Level1)
918 {
919     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
920     EXPECT_NE(fileAccessHelper, nullptr);
921     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_008";
922     try {
923         vector<RootInfo> info;
924         int result = fileAccessHelper->GetRoots(info);
925         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
926         Uri parentUri(info[0].uri);
927         Uri newDirUriTest1("");
928         result = fileAccessHelper->Mkdir(parentUri, "测试目录1", newDirUriTest1);
929         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
930         Uri sourceUri("");
931         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
932         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
933 
934         Uri newDirUriTest2("");
935         result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
936         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
937         std::string fileName("a.txt");
938         Uri newFile("");
939         result = fileAccessHelper->CopyFile(sourceUri, newDirUriTest2, fileName, newFile);
940         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
941         EXPECT_EQ(newFile.GetPath(), newDirUriTest2.GetPath() + '/' +"test.txt");
942         result = fileAccessHelper->Delete(newDirUriTest1);
943         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
944         result = fileAccessHelper->Delete(newDirUriTest2);
945         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
946     } catch (...) {
947         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_008 occurs an exception.";
948     }
949     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_008";
950 }
951 
952 /**
953 * @tc.number: user_file_service_external_file_access_Copy_file_009
954 * @tc.name: external_file_access_Copy_file_009
955 * @tc.desc: Test function of Copy file interface.
956 * @tc.size: MEDIUM
957 * @tc.type: FUNC
958 * @tc.level Level 1
959 */
960 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_file_009, testing::ext::TestSize.Level1)
961 {
962     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
963     EXPECT_NE(fileAccessHelper, nullptr);
964     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_file_009";
965     try {
966         vector<RootInfo> info;
967         int result = fileAccessHelper->GetRoots(info);
968         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
969         Uri parentUri(info[0].uri);
970         Uri newDirUriTest1("");
971         result = fileAccessHelper->Mkdir(parentUri, "测试1", newDirUriTest1);
972         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
973         Uri sourceUri("");
974         result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", sourceUri);
975         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
976 
977         Uri newDirUriTest2("");
978         result = fileAccessHelper->Mkdir(parentUri, "测试2", newDirUriTest2);
979         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
980         Uri targetUri("");
981         result = fileAccessHelper->CreateFile(newDirUriTest2, "test.txt", targetUri);
982         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
983         std::string fileName("测试.txt");
984         Uri newFile("");
985         result = fileAccessHelper->CopyFile(sourceUri, newDirUriTest2, fileName, newFile);
986         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
987         EXPECT_EQ(newDirUriTest1.ToString().find("测试.txt"), std::string::npos);
988         result = fileAccessHelper->Delete(newDirUriTest1);
989         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
990         result = fileAccessHelper->Delete(newDirUriTest2);
991         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
992     } catch (...) {
993         GTEST_LOG_(ERROR) << "external_file_access_Copy_file_009 occurs an exception.";
994     }
995     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_file_009";
996 }
997 } // namespace
998