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 "medialibrary_file_access_test_basic.h"
24 #include "accesstoken_kit.h"
25 #include "file_access_extension_info.h"
26 #include "file_access_framework_errno.h"
27 #include "file_access_helper.h"
28 #include "iservice_registry.h"
29 #include "image_source.h"
30 #include "nativetoken_kit.h"
31 #include "token_setproc.h"
32 
33 namespace OHOS::FileAccessFwk {
34 const int ABILITY_ID = 5003;
35 const int INIT_THREADS_NUMBER = 4;
36 const int ACTUAL_SUCCESS_THREADS_NUMBER = 1;
37 int g_num = 0;
38 shared_ptr<FileAccessHelper> g_fah = nullptr;
39 Uri g_newDirUri("");
40 const int UID_TRANSFORM_TMP = 20000000;
41 const int UID_DEFAULT = 0;
42 
SetNativeToken()43 void SetNativeToken()
44 {
45     uint64_t tokenId;
46     const char *perms[] = {
47         "ohos.permission.FILE_ACCESS_MANAGER",
48         "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED",
49         "ohos.permission.CONNECT_FILE_ACCESS_EXTENSION"
50     };
51     NativeTokenInfoParams infoInstance = {
52         .dcapsNum = 0,
53         .permsNum = 3,
54         .aclsNum = 0,
55         .dcaps = nullptr,
56         .perms = perms,
57         .acls = nullptr,
58         .aplStr = "system_core",
59     };
60 
61     infoInstance.processName = "SetUpTestCase";
62     const uint64_t systemAppMask = (static_cast<uint64_t>(1) << 32);
63     tokenId = GetAccessTokenId(&infoInstance);
64     tokenId |= systemAppMask;
65     SetSelfTokenID(tokenId);
66     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
67 }
68 
SetUpTestCase()69 void FileAccessHelperTest::SetUpTestCase()
70 {
71     cout << "FileAccessHelperTest code test" << endl;
72     SetNativeToken();
73     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
74     if (saManager == nullptr) {
75         return;
76     }
77     auto remoteObj = saManager->GetSystemAbility(ABILITY_ID);
78     AAFwk::Want want;
79     vector<AAFwk::Want> wantVec;
80     setuid(UID_TRANSFORM_TMP);
81     int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec);
82     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
83     bool found = false;
84     for (size_t i = 0; i < wantVec.size(); i++) {
85         auto element = wantVec[i].GetElement();
86         if (element.GetBundleName() == "com.ohos.medialibrary.medialibrarydata" &&
87             element.GetAbilityName() == "FileExtensionAbility") {
88             want = wantVec[i];
89             found = true;
90             break;
91         }
92     }
93     EXPECT_TRUE(found);
94     vector<AAFwk::Want> wants{want};
95     g_fah = FileAccessHelper::Creator(remoteObj, wants);
96     if (g_fah == nullptr) {
97         GTEST_LOG_(ERROR) << "medialibrary_file_access_test g_fah is nullptr";
98         exit(1);
99     }
100     setuid(UID_DEFAULT);
101 }
102 
TearDownTestCase()103 void FileAccessHelperTest::TearDownTestCase()
104 {
105     if (g_fah) {
106         g_fah->Release();
107     }
108     g_fah = nullptr;
109 }
110 
TearDown()111 void FileAccessHelperTest::TearDown()
112 {
113 }
114 
SetUp()115 void FileAccessHelperTest::SetUp()
116 {
117 }
118 
GetFileAccessHelper()119 shared_ptr<FileAccessHelper> FileExtensionHelperTest::GetFileAccessHelper()
120 {
121     return g_fah;
122 }
123 
GetParentUri()124 static Uri GetParentUri()
125 {
126     vector<RootInfo> info;
127     EXPECT_NE(g_fah, nullptr);
128     int result = g_fah->GetRoots(info);
129     EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
130     Uri parentUri("");
131     if (info.size() > OHOS::FileAccessFwk::ERR_OK) {
132         parentUri = Uri(info[0].uri + "/file");
133         GTEST_LOG_(ERROR) << parentUri.ToString();
134     }
135     return parentUri;
136 }
137 
138 /**
139  * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0000
140  * @tc.name: medialibrary_file_access_CreateFile_0000
141  * @tc.desc: Test function of CreateFile interface for SUCCESS.
142  * @tc.size: MEDIUM
143  * @tc.type: FUNC
144  * @tc.level Level 1
145  * @tc.require: SR000H0386
146  */
147 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0000, testing::ext::TestSize.Level1)
148 {
149     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0000";
150     try {
151         Uri newFileUri("");
152         EXPECT_NE(g_fah, nullptr);
153         int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_CreateFile_0000.txt", newFileUri);
154         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
155         GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result;
156         result = g_fah->Delete(newFileUri);
157         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
158     } catch (...) {
159         GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0000 occurs an exception.";
160     }
161     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0000";
162 }
163 
164 /**
165  * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0001
166  * @tc.name: medialibrary_file_access_CreateFile_0001
167  * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null.
168  * @tc.size: MEDIUM
169  * @tc.type: FUNC
170  * @tc.level Level 1
171  * @tc.require: SR000H0386
172  */
173 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0001, testing::ext::TestSize.Level1)
174 {
175     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0001";
176     try {
177         Uri newFileUri("");
178         Uri parentUri("");
179         EXPECT_NE(g_fah, nullptr);
180         int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0001.txt", newFileUri);
181         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
182         GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result;
183     } catch (...) {
184         GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0001 occurs an exception.";
185     }
186     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0001";
187 }
188 
189 /**
190  * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0002
191  * @tc.name: medialibrary_file_access_CreateFile_0002
192  * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path.
193  * @tc.size: MEDIUM
194  * @tc.type: FUNC
195  * @tc.level Level 1
196  * @tc.require: SR000H0386
197  */
198 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0002, testing::ext::TestSize.Level1)
199 {
200     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002";
201     try {
202         Uri newFileUri("");
203         Uri parentUri("storage/media/100/local/files/Download");
204         EXPECT_NE(g_fah, nullptr);
205         int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0002.txt", newFileUri);
206         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
207         GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result;
208     } catch (...) {
209         GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0002 occurs an exception.";
210     }
211     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0002";
212 }
213 
214 /**
215  * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0003
216  * @tc.name: medialibrary_file_access_CreateFile_0003
217  * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols.
218  * @tc.size: MEDIUM
219  * @tc.type: FUNC
220  * @tc.level Level 1
221  * @tc.require: SR000H0386
222  */
223 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0003, testing::ext::TestSize.Level1)
224 {
225     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002";
226     try {
227         Uri newFileUri("");
228         Uri parentUri("~!@#$%^&*()_");
229         EXPECT_NE(g_fah, nullptr);
230         int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0003.txt", newFileUri);
231         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
232         GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result;
233     } catch (...) {
234         GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0003 occurs an exception.";
235     }
236     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0003";
237 }
238 
239 /**
240  * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0004
241  * @tc.name: medialibrary_file_access_CreateFile_0004
242  * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null.
243  * @tc.size: MEDIUM
244  * @tc.type: FUNC
245  * @tc.level Level 1
246  * @tc.require: SR000H0386
247  */
248 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0004, testing::ext::TestSize.Level1)
249 {
250     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0004";
251     try {
252         Uri newFileUri("");
253         string displayName = "";
254         EXPECT_NE(g_fah, nullptr);
255         int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri);
256         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
257         GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result;
258     } catch (...) {
259         GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0004 occurs an exception.";
260     }
261     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0004";
262 }
263 
CreateFileTdd(shared_ptr<FileAccessHelper> fahs,Uri parent,std::string displayName,Uri newDir)264 static void CreateFileTdd(shared_ptr<FileAccessHelper> fahs, Uri parent, std::string displayName, Uri newDir)
265 {
266     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFileTdd";
267     int ret = fahs->CreateFile(parent, displayName, newDir);
268     if (ret != OHOS::FileAccessFwk::ERR_OK) {
269         GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret;
270         return;
271     }
272     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
273     EXPECT_NE(newDir.ToString(), "");
274     g_num++;
275     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFileTdd";
276 }
277 
278 /**
279  * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0005
280  * @tc.name: medialibrary_file_access_CreateFile_0005
281  * @tc.desc: Test function of CreateFile interface for SUCCESS while Concurrent.
282  * @tc.size: MEDIUM
283  * @tc.type: FUNC
284  * @tc.level Level 1
285  * @tc.require: SR000H0386
286  */
287 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0005, testing::ext::TestSize.Level1)
288 {
289     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0005";
290     try {
291         Uri newFileUri1("");
292         Uri newFileUri2("");
293         Uri newFileUri3("");
294         std::string displayName1 = "test1";
295         std::string displayName2 = "test2";
296         std::string displayName3 = "test3.txt";
297         EXPECT_NE(g_fah, nullptr);
298         int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1);
299         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
300         result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2);
301         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
302         g_num = 0;
303         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
304             std::thread execthread(CreateFileTdd, g_fah, newFileUri2, displayName3, newFileUri3);
305             execthread.join();
306         }
307         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
308         GTEST_LOG_(INFO) << "g_newDirUri.ToString() =" << g_newDirUri.ToString();
309         result = g_fah->Delete(newFileUri1);
310         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
311     } catch (...) {
312         GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0005 occurs an exception.";
313     }
314     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0005";
315 }
316 
317 /**
318  * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0000
319  * @tc.name: medialibrary_file_access_Mkdir_0000
320  * @tc.desc: Test function of Mkdir interface for SUCCESS.
321  * @tc.size: MEDIUM
322  * @tc.type: FUNC
323  * @tc.level Level 1
324  * @tc.require: SR000H0386
325  */
326 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0000, testing::ext::TestSize.Level1)
327 {
328     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0000";
329     try {
330         Uri newDirUriTest("");
331         EXPECT_NE(g_fah, nullptr);
332         int result = g_fah->Mkdir(g_newDirUri, "medialibrary_file_access_Mkdir_0000", newDirUriTest);
333         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
334         GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result;
335         result = g_fah->Delete(newDirUriTest);
336         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
337     } catch (...) {
338         GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0000 occurs an exception.";
339     }
340     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0000";
341 }
342 
343 /**
344  * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0001
345  * @tc.name: medialibrary_file_access_Mkdir_0001
346  * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null.
347  * @tc.size: MEDIUM
348  * @tc.type: FUNC
349  * @tc.level Level 1
350  * @tc.require: SR000H0386
351  */
352 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0001, testing::ext::TestSize.Level1)
353 {
354     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0001";
355     try {
356         Uri newDirUriTest("");
357         Uri parentUri("");
358         EXPECT_NE(g_fah, nullptr);
359         int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0001", newDirUriTest);
360         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
361         GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result;
362     } catch (...) {
363         GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0001 occurs an exception.";
364     }
365     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0001";
366 }
367 
368 /**
369  * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0002
370  * @tc.name: medialibrary_file_access_Mkdir_0002
371  * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path.
372  * @tc.size: MEDIUM
373  * @tc.type: FUNC
374  * @tc.level Level 1
375  * @tc.require: SR000H0386
376  */
377 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0002, testing::ext::TestSize.Level1)
378 {
379     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002";
380     try {
381         Uri newDirUriTest("");
382         Uri parentUri("storage/media/100/local/files/Download");
383         EXPECT_NE(g_fah, nullptr);
384         int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0002", newDirUriTest);
385         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
386         GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result;
387     } catch (...) {
388         GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0002 occurs an exception.";
389     }
390     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0002";
391 }
392 
393 /**
394  * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0003
395  * @tc.name: medialibrary_file_access_Mkdir_0003
396  * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols.
397  * @tc.size: MEDIUM
398  * @tc.type: FUNC
399  * @tc.level Level 1
400  * @tc.require: SR000H0386
401  */
402 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0003, testing::ext::TestSize.Level1)
403 {
404     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002";
405     try {
406         Uri newDirUriTest("");
407         Uri parentUri("~!@#$%^&*()_");
408         EXPECT_NE(g_fah, nullptr);
409         int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0003", newDirUriTest);
410         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
411         GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result;
412     } catch (...) {
413         GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0003 occurs an exception.";
414     }
415     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0003";
416 }
417 
418 /**
419  * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0004
420  * @tc.name: medialibrary_file_access_Mkdir_0004
421  * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null.
422  * @tc.size: MEDIUM
423  * @tc.type: FUNC
424  * @tc.level Level 1
425  * @tc.require: SR000H0386
426  */
427 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0004, testing::ext::TestSize.Level1)
428 {
429     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0004";
430     try {
431         Uri newDirUriTest("");
432         string displayName = "";
433         EXPECT_NE(g_fah, nullptr);
434         int result = g_fah->Mkdir(g_newDirUri, displayName, newDirUriTest);
435         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
436         GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result;
437     } catch (...) {
438         GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0004 occurs an exception.";
439     }
440     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0004";
441 }
442 
MkdirTdd(shared_ptr<FileAccessHelper> fahs,Uri parent,std::string displayName,Uri newDir)443 static void MkdirTdd(shared_ptr<FileAccessHelper> fahs, Uri parent, std::string displayName, Uri newDir)
444 {
445     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MkdirTdd";
446     int ret = fahs->Mkdir(parent, displayName, newDir);
447     if (ret != OHOS::FileAccessFwk::ERR_OK) {
448         GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret;
449         return;
450     }
451     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
452     EXPECT_NE(newDir.ToString(), "");
453     g_num++;
454     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MkdirTdd";
455 }
456 
457 /**
458  * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0005
459  * @tc.name: medialibrary_file_access_Mkdir_0005
460  * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent.
461  * @tc.size: MEDIUM
462  * @tc.type: FUNC
463  * @tc.level Level 1
464  * @tc.require: SR000H0386
465  */
466 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0005, testing::ext::TestSize.Level1)
467 {
468     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0005";
469     try {
470         Uri newFileUri1("");
471         Uri newFileUri2("");
472         Uri newFileUri3("");
473         std::string displayName1 = "test1";
474         std::string displayName2 = "test2";
475         std::string displayName3 = "test3";
476         EXPECT_NE(g_fah, nullptr);
477         int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1);
478         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
479         result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2);
480         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
481         g_num = 0;
482         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
483             std::thread execthread(MkdirTdd, g_fah, newFileUri2, displayName3, newFileUri3);
484             execthread.join();
485         }
486         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
487         result = g_fah->Delete(newFileUri1);
488         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
489     } catch (...) {
490         GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0005 occurs an exception.";
491     }
492     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0005";
493 }
494 
495 /**
496  * @tc.number: user_file_service_medialibrary_file_access_Delete_0000
497  * @tc.name: medialibrary_file_access_Delete_0000
498  * @tc.desc: Test function of Delete interface for SUCCESS which delete file.
499  * @tc.size: MEDIUM
500  * @tc.type: FUNC
501  * @tc.level Level 1
502  * @tc.require: SR000H0386
503  */
504 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0000, testing::ext::TestSize.Level1)
505 {
506     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0000";
507     try {
508         Uri newDirUriTest("");
509         EXPECT_NE(g_fah, nullptr);
510         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
511         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
512         Uri newFileUri("");
513         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0000.txt", newFileUri);
514         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
515         result = g_fah->Delete(newFileUri);
516         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
517         GTEST_LOG_(INFO) << "Delete_0000 result:" << result;
518         result = g_fah->Delete(newDirUriTest);
519         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
520     } catch (...) {
521         GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0000 occurs an exception.";
522     }
523     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0000";
524 }
525 
526 /**
527  * @tc.number: user_file_service_medialibrary_file_access_Delete_0001
528  * @tc.name: medialibrary_file_access_Delete_0001
529  * @tc.desc: Test function of Delete interface for SUCCESS which delete folder.
530  * @tc.size: MEDIUM
531  * @tc.type: FUNC
532  * @tc.level Level 1
533  * @tc.require: SR000H0386
534  */
535 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0001, testing::ext::TestSize.Level1)
536 {
537     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0001";
538     try {
539         Uri newDirUriTest("");
540         EXPECT_NE(g_fah, nullptr);
541         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
542         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
543         result = g_fah->Delete(newDirUriTest);
544         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
545         GTEST_LOG_(INFO) << "Delete_0001 result:" << result;
546     } catch (...) {
547         GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0001 occurs an exception.";
548     }
549     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0001";
550 }
551 
552 /**
553  * @tc.number: user_file_service_medialibrary_file_access_Delete_0002
554  * @tc.name: medialibrary_file_access_Delete_0002
555  * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null.
556  * @tc.size: MEDIUM
557  * @tc.type: FUNC
558  * @tc.level Level 1
559  * @tc.require: SR000H0386
560  */
561 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0002, testing::ext::TestSize.Level1)
562 {
563     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0002";
564     try {
565         Uri selectFileUri("");
566         EXPECT_NE(g_fah, nullptr);
567         int result = g_fah->Delete(selectFileUri);
568         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
569         GTEST_LOG_(INFO) << "Delete_0002 result:" << result;
570     } catch (...) {
571         GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0002 occurs an exception.";
572     }
573     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0002";
574 }
575 
576 /**
577  * @tc.number: user_file_service_medialibrary_file_access_Delete_0003
578  * @tc.name: medialibrary_file_access_Delete_0003
579  * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path.
580  * @tc.size: MEDIUM
581  * @tc.type: FUNC
582  * @tc.level Level 1
583  * @tc.require: SR000H0386
584  */
585 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0003, testing::ext::TestSize.Level1)
586 {
587     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0003";
588     try {
589         Uri newDirUriTest("");
590         EXPECT_NE(g_fah, nullptr);
591         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
592         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
593         Uri selectFileUri("storage/media/100/local/files/Download/test");
594         result = g_fah->Delete(selectFileUri);
595         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
596         result = g_fah->Delete(newDirUriTest);
597         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
598         GTEST_LOG_(INFO) << "Delete_0003 result:" << result;
599     } catch (...) {
600         GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0003 occurs an exception.";
601     }
602     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0003";
603 }
604 
605 /**
606  * @tc.number: user_file_service_medialibrary_file_access_Delete_0004
607  * @tc.name: medialibrary_file_access_Delete_0004
608  * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols.
609  * @tc.size: MEDIUM
610  * @tc.type: FUNC
611  * @tc.level Level 1
612  * @tc.require: SR000H0386
613  */
614 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0004, testing::ext::TestSize.Level1)
615 {
616     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0004";
617     try {
618         Uri selectFileUri("!@#$%^&*()");
619         EXPECT_NE(g_fah, nullptr);
620         int result = g_fah->Delete(selectFileUri);
621         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
622         GTEST_LOG_(INFO) << "Delete_0004 result:" << result;
623     } catch (...) {
624         GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0004 occurs an exception.";
625     }
626     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0004";
627 }
628 
DeleteTdd(shared_ptr<FileAccessHelper> fahs,Uri selectFile)629 static void DeleteTdd(shared_ptr<FileAccessHelper> fahs, Uri selectFile)
630 {
631     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_DeleteTdd";
632     int ret = fahs->Delete(selectFile);
633     if (ret < OHOS::FileAccessFwk::ERR_OK) {
634         GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret;
635         return;
636     }
637     EXPECT_GE(ret, OHOS::FileAccessFwk::ERR_OK);
638     g_num++;
639     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_DeleteTdd";
640 }
641 
642 /**
643  * @tc.number: user_file_service_medialibrary_file_access_Delete_0005
644  * @tc.name: medialibrary_file_access_Delete_0005
645  * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent.
646  * @tc.size: MEDIUM
647  * @tc.type: FUNC
648  * @tc.level Level 1
649  * @tc.require: SR000H0386
650  */
651 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0005, testing::ext::TestSize.Level1)
652 {
653     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0005";
654     try {
655         Uri newDirUriTest("");
656         EXPECT_NE(g_fah, nullptr);
657         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
658         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
659         Uri newFileUri("");
660         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0005.txt", newFileUri);
661         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
662         Uri testUri("");
663         std::string displayName = "test1.txt";
664         Uri testUri2("");
665         result = g_fah->CreateFile(newDirUriTest, displayName, testUri);
666         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
667         g_num = 0;
668         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
669             std::thread execthread(DeleteTdd, g_fah, testUri);
670             execthread.join();
671         }
672         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
673         result = g_fah->Delete(newDirUriTest);
674         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
675     } catch (...) {
676         GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0005 occurs an exception.";
677     }
678     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0005";
679 }
680 
681 /**
682  * @tc.number: user_file_service_medialibrary_file_access_Move_0000
683  * @tc.name: medialibrary_file_access_Move_0000
684  * @tc.desc: Test function of Move interface for SUCCESS which move file.
685  * @tc.size: MEDIUM
686  * @tc.type: FUNC
687  * @tc.level Level 1
688  * @tc.require: SR000H0386
689  */
690 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0000, testing::ext::TestSize.Level1)
691 {
692     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0000";
693     try {
694         Uri newDirUriTest1("");
695         Uri newDirUriTest2("");
696         EXPECT_NE(g_fah, nullptr);
697         int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
698         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
699         result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
700         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
701         Uri testUri("");
702         result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
703         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
704         Uri testUri2("");
705         result = g_fah->Move(testUri, newDirUriTest2, testUri2);
706         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
707         GTEST_LOG_(INFO) << "Move_0000 result:" << result;
708         result = g_fah->Delete(newDirUriTest1);
709         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
710         result = g_fah->Delete(newDirUriTest2);
711         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
712     } catch (...) {
713         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0000 occurs an exception.";
714     }
715     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0000";
716 }
717 
718 /**
719  * @tc.number: user_file_service_medialibrary_file_access_Move_0001
720  * @tc.name: medialibrary_file_access_Move_0001
721  * @tc.desc: Test function of Move interface for SUCCESS which move folder.
722  * @tc.size: MEDIUM
723  * @tc.type: FUNC
724  * @tc.level Level 1
725  * @tc.require: SR000H0386
726  */
727 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0001, testing::ext::TestSize.Level1)
728 {
729     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0001";
730     try {
731         Uri newDirUriTest1("");
732         Uri newDirUriTest2("");
733         EXPECT_NE(g_fah, nullptr);
734         int result = g_fah->Mkdir(g_newDirUri, "test3", newDirUriTest1);
735         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
736         result = g_fah->Mkdir(g_newDirUri, "test4", newDirUriTest2);
737         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
738         Uri testUri("");
739         result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
740         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
741         Uri testUri2("");
742         result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
743         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
744         GTEST_LOG_(INFO) << "Move_0001 result:" << result;
745         result = g_fah->Delete(newDirUriTest1);
746         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
747         result = g_fah->Delete(newDirUriTest2);
748         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
749     } catch (...) {
750         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0001 occurs an exception.";
751     }
752     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0001";
753 }
754 
755 /**
756  * @tc.number: user_file_service_medialibrary_file_access_Move_0002
757  * @tc.name: medialibrary_file_access_Move_0002
758  * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null.
759  * @tc.size: MEDIUM
760  * @tc.type: FUNC
761  * @tc.level Level 1
762  * @tc.require: SR000H0386
763  */
764 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0002, testing::ext::TestSize.Level1)
765 {
766     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0002";
767     try {
768         Uri newDirUriTest("");
769         EXPECT_NE(g_fah, nullptr);
770         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
771         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
772         Uri testUri("");
773         Uri sourceFileUri("");
774         result = g_fah->Move(sourceFileUri, newDirUriTest, testUri);
775         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
776         GTEST_LOG_(INFO) << "Move_0002 result:" << result;
777         result = g_fah->Delete(newDirUriTest);
778         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
779     } catch (...) {
780         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0002 occurs an exception.";
781     }
782     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0002";
783 }
784 
785 /**
786  * @tc.number: user_file_service_medialibrary_file_access_Move_0003
787  * @tc.name: medialibrary_file_access_Move_0003
788  * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path.
789  * @tc.size: MEDIUM
790  * @tc.type: FUNC
791  * @tc.level Level 1
792  * @tc.require: SR000H0386
793  */
794 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0003, testing::ext::TestSize.Level1)
795 {
796     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0003";
797     try {
798         Uri newDirUriTest1("");
799         Uri newDirUriTest2("");
800         EXPECT_NE(g_fah, nullptr);
801         int result = g_fah->Mkdir(g_newDirUri, "test5", newDirUriTest1);
802         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
803         result = g_fah->Mkdir(g_newDirUri, "test6", newDirUriTest2);
804         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
805         Uri testUri("");
806         result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
807         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
808         Uri testUri2("");
809         Uri sourceFileUri("storage/media/100/local/files/Download/test5/test.txt");
810         result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2);
811         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
812         GTEST_LOG_(INFO) << "Move_0003 result:" << result;
813         result = g_fah->Delete(newDirUriTest1);
814         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
815         result = g_fah->Delete(newDirUriTest2);
816         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
817     } catch (...) {
818         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0003 occurs an exception.";
819     }
820     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0003";
821 }
822 
823 /**
824  * @tc.number: user_file_service_medialibrary_file_access_Move_0004
825  * @tc.name: medialibrary_file_access_Move_0004
826  * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols.
827  * @tc.size: MEDIUM
828  * @tc.type: FUNC
829  * @tc.level Level 1
830  * @tc.require: SR000H0386
831  */
832 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0004, testing::ext::TestSize.Level1)
833 {
834     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0004";
835     try {
836         Uri newDirUriTest("");
837         EXPECT_NE(g_fah, nullptr);
838         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
839         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
840         Uri testUri("");
841         Uri sourceFileUri("~!@#$%^&*()_");
842         result = g_fah->Move(sourceFileUri, newDirUriTest, testUri);
843         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
844         GTEST_LOG_(INFO) << "Move_0004 result:" << result;
845         result = g_fah->Delete(newDirUriTest);
846         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
847     } catch (...) {
848         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0004 occurs an exception.";
849     }
850     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0004";
851 }
852 
853 /**
854  * @tc.number: user_file_service_medialibrary_file_access_Move_0005
855  * @tc.name: medialibrary_file_access_Move_0005
856  * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null.
857  * @tc.size: MEDIUM
858  * @tc.type: FUNC
859  * @tc.level Level 1
860  * @tc.require: SR000H0386
861  */
862 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0005, testing::ext::TestSize.Level1)
863 {
864     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0005";
865     try {
866         Uri newDirUriTest("");
867         EXPECT_NE(g_fah, nullptr);
868         int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest);
869         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
870         Uri testUri("");
871         result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
872         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
873         Uri testUri2("");
874         Uri targetParentUri("");
875         result = g_fah->Move(testUri, targetParentUri, testUri2);
876         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
877         GTEST_LOG_(INFO) << "Move_0005 result:" << result;
878         result = g_fah->Delete(newDirUriTest);
879         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
880     } catch (...) {
881         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0005 occurs an exception.";
882     }
883     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0005";
884 }
885 
886 /**
887  * @tc.number: user_file_service_medialibrary_file_access_Move_0006
888  * @tc.name: medialibrary_file_access_Move_0006
889  * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path.
890  * @tc.size: MEDIUM
891  * @tc.type: FUNC
892  * @tc.level Level 1
893  * @tc.require: SR000H0386
894  */
895 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0006, testing::ext::TestSize.Level1)
896 {
897     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0006";
898     try {
899         Uri newDirUriTest1("");
900         Uri newDirUriTest2("");
901         EXPECT_NE(g_fah, nullptr);
902         int result = g_fah->Mkdir(g_newDirUri, "test7", newDirUriTest1);
903         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
904         result = g_fah->Mkdir(g_newDirUri, "test8", newDirUriTest2);
905         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
906         Uri testUri("");
907         result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
908         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
909         Uri testUri2("");
910         Uri targetParentUri("storage/media/100/local/files/Download/test8");
911         result = g_fah->Move(testUri, targetParentUri, testUri2);
912         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
913         GTEST_LOG_(INFO) << "Move_0006 result:" << result;
914         result = g_fah->Delete(newDirUriTest1);
915         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
916         result = g_fah->Delete(newDirUriTest2);
917         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
918     } catch (...) {
919         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0006 occurs an exception.";
920     }
921     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0006";
922 }
923 
924 /**
925  * @tc.number: user_file_service_medialibrary_file_access_Move_0007
926  * @tc.name: medialibrary_file_access_Move_0007
927  * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols.
928  * @tc.size: MEDIUM
929  * @tc.type: FUNC
930  * @tc.level Level 1
931  * @tc.require: SR000H0386
932  */
933 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0007, testing::ext::TestSize.Level1)
934 {
935     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0007";
936     try {
937         Uri newDirUriTest1("");
938         Uri newDirUriTest2("");
939         EXPECT_NE(g_fah, nullptr);
940         int result = g_fah->Mkdir(g_newDirUri, "test9", newDirUriTest1);
941         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
942         result = g_fah->Mkdir(g_newDirUri, "test10", newDirUriTest2);
943         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
944         Uri testUri("");
945         result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
946         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
947         Uri testUri2("");
948         Uri targetParentUri("~!@#$^%&*()_");
949         result = g_fah->Move(testUri, targetParentUri, testUri2);
950         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
951         GTEST_LOG_(INFO) << "Move_0007 result:" << result;
952         result = g_fah->Delete(newDirUriTest1);
953         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
954         result = g_fah->Delete(newDirUriTest2);
955         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
956     } catch (...) {
957         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0007 occurs an exception.";
958     }
959     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0007";
960 }
961 
962 /**
963  * @tc.number: user_file_service_medialibrary_file_access_Move_0008
964  * @tc.name: medialibrary_file_access_Move_0008
965  * @tc.desc: Test function of Move interface for SUCCESS which move empty folder.
966  * @tc.size: MEDIUM
967  * @tc.type: FUNC
968  * @tc.level Level 1
969  * @tc.require: SR000H0386
970  */
971 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0008, testing::ext::TestSize.Level1)
972 {
973     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0008";
974     try {
975         Uri newDirUriTest1("");
976         Uri newDirUriTest2("");
977         EXPECT_NE(g_fah, nullptr);
978         int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
979         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
980         result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
981         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
982         Uri testUri2("");
983         result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
984         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
985         GTEST_LOG_(INFO) << "Move_0008 result:" << result;
986         result = g_fah->Delete(newDirUriTest1);
987         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
988         result = g_fah->Delete(newDirUriTest2);
989         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
990     } catch (...) {
991         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0008 occurs an exception.";
992     }
993     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0008";
994 }
995 
996 /**
997  * @tc.number: user_file_service_medialibrary_file_access_Move_0009
998  * @tc.name: medialibrary_file_access_Move_0009
999  * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder.
1000  * @tc.size: MEDIUM
1001  * @tc.type: FUNC
1002  * @tc.level Level 1
1003  * @tc.require: SR000H0386
1004  */
1005 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0009, testing::ext::TestSize.Level1)
1006 {
1007     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0009";
1008     try {
1009         Uri newDirUriTest1("");
1010         Uri newDirUriTest2("");
1011         EXPECT_NE(g_fah, nullptr);
1012         int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1013         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1014         result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1015         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1016         Uri testUri("");
1017         size_t fileNumbers = 2000;
1018         for (size_t i = 0; i < fileNumbers; i++) {
1019             string fileName = "test" + ToString(i) + ".txt";
1020             result = g_fah->CreateFile(newDirUriTest1, fileName, testUri);
1021             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1022         }
1023         Uri testUri2("");
1024         result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1025         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1026         GTEST_LOG_(INFO) << "Move_0009 result:" << result;
1027         result = g_fah->Delete(newDirUriTest1);
1028         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1029         result = g_fah->Delete(newDirUriTest2);
1030         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1031     } catch (...) {
1032         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0009 occurs an exception.";
1033     }
1034     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0009";
1035 }
1036 
1037 /**
1038  * @tc.number: user_file_service_medialibrary_file_access_Move_0010
1039  * @tc.name: medialibrary_file_access_Move_0010
1040  * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder.
1041  * @tc.size: MEDIUM
1042  * @tc.type: FUNC
1043  * @tc.level Level 1
1044  * @tc.require: SR000H0386
1045  */
1046 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0010, testing::ext::TestSize.Level1)
1047 {
1048     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0010";
1049     try {
1050         Uri newDirUriTest1("");
1051         Uri newDirUriTest2("");
1052         EXPECT_NE(g_fah, nullptr);
1053         int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1054         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1055         result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1056         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1057         Uri testUri("");
1058         result = g_fah->Mkdir(newDirUriTest1, "test", testUri);
1059         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1060         size_t directoryNumbers = 50;
1061         for (size_t i = 0; i < directoryNumbers; i++) {
1062             result = g_fah->Mkdir(testUri, "test", testUri);
1063             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1064         }
1065         Uri testUri2("");
1066         result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1067         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1068         GTEST_LOG_(INFO) << "Move_0010 result:" << result;
1069         result = g_fah->Delete(newDirUriTest1);
1070         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1071         result = g_fah->Delete(newDirUriTest2);
1072         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1073     } catch (...) {
1074         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0010 occurs an exception.";
1075     }
1076     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0010";
1077 }
1078 
MoveTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,Uri targetParent,Uri newFile)1079 static void MoveTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, Uri targetParent, Uri newFile)
1080 {
1081     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MoveTdd";
1082     int ret = fahs->Move(sourceFile, targetParent, newFile);
1083     if (ret != OHOS::FileAccessFwk::ERR_OK) {
1084         GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret;
1085         return;
1086     }
1087     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1088     EXPECT_NE(newFile.ToString(), "");
1089     g_num++;
1090     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MoveTdd";
1091 }
1092 
1093 /**
1094  * @tc.number: user_file_service_medialibrary_file_access_Move_0011
1095  * @tc.name: medialibrary_file_access_Move_0011
1096  * @tc.desc: Test function of Move interface for SUCCESS which Concurrent.
1097  * @tc.size: MEDIUM
1098  * @tc.type: FUNC
1099  * @tc.level Level 1
1100  * @tc.require: SR000H0386
1101  */
1102 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0011, testing::ext::TestSize.Level1)
1103 {
1104     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0011";
1105     try {
1106         Uri newDirUriTest1("");
1107         Uri newDirUriTest2("");
1108         EXPECT_NE(g_fah, nullptr);
1109         int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1110         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1111         result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1112         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1113         Uri testUri{""};
1114         Uri testUri2("");
1115         std::string displayName = "test1.txt";
1116         result = g_fah->CreateFile(newDirUriTest1, displayName, testUri);
1117         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1118         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
1119             std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2);
1120             execthread.join();
1121         }
1122         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
1123         result = g_fah->Delete(newDirUriTest1);
1124         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1125         result = g_fah->Delete(newDirUriTest2);
1126         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1127     } catch (...) {
1128         GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0011 occurs an exception.";
1129     }
1130     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0011";
1131 }
1132 
1133 /**
1134  * @tc.number: user_file_service_medialibrary_file_access_Copy_0000
1135  * @tc.name: medialibrary_file_access_Copy_0000
1136  * @tc.desc: Test function of Copy interface, copy a file and argument of force is false
1137  * @tc.size: MEDIUM
1138  * @tc.type: FUNC
1139  * @tc.level Level 1
1140  * @tc.require: I6UI3H
1141  */
1142 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0000, testing::ext::TestSize.Level1)
1143 {
1144     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0000";
1145     try {
1146         Uri srcUri("");
1147         EXPECT_NE(g_fah, nullptr);
1148         int result = g_fah->Mkdir(g_newDirUri, "Copy_0000_src", srcUri);
1149         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1150         Uri aFileUri("");
1151         result = g_fah->CreateFile(srcUri, "a.txt", aFileUri);
1152         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1153         int fd;
1154         result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1155         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1156         std::string aFileBuff = "Copy test content for a.txt";
1157         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1158         close(fd);
1159         EXPECT_EQ(aFileSize, aFileBuff.size());
1160 
1161         Uri destUri("");
1162         result = g_fah->Mkdir(g_newDirUri, "Copy_0000_dest", destUri);
1163         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1164 
1165         vector<CopyResult> copyResult;
1166         result = g_fah->Copy(aFileUri, destUri, copyResult, false);
1167         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1168 
1169         result = g_fah->Delete(srcUri);
1170         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1171         result = g_fah->Delete(destUri);
1172         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1173     } catch (...) {
1174         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0000 occurs an exception.";
1175     }
1176     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0000";
1177 }
1178 
1179 /**
1180  * @tc.number: user_file_service_medialibrary_file_access_Copy_0001
1181  * @tc.name: medialibrary_file_access_Copy_0001
1182  * @tc.desc: Test function of Copy interface, copy a directory and argument of force is false
1183  * @tc.size: MEDIUM
1184  * @tc.type: FUNC
1185  * @tc.level Level 1
1186  * @tc.require: I6UI3H
1187  */
1188 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0001, testing::ext::TestSize.Level1)
1189 {
1190     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0001";
1191     try {
1192         Uri srcUri("");
1193         EXPECT_NE(g_fah, nullptr);
1194         int result = g_fah->Mkdir(g_newDirUri, "Copy_0001_src", srcUri);
1195         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1196         Uri aFileUri("");
1197         result = g_fah->CreateFile(srcUri, "b.txt", aFileUri);
1198         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1199         int fd;
1200         result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1201         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1202         std::string aFileBuff = "Copy test content for b.txt";
1203         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1204         close(fd);
1205         EXPECT_EQ(aFileSize, aFileBuff.size());
1206 
1207         Uri bFileUri("");
1208         result = g_fah->CreateFile(srcUri, "c.txt", bFileUri);
1209         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1210         result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1211         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1212         std::string bFileBuff = "Copy test content for c.txt";
1213         ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1214         close(fd);
1215         EXPECT_EQ(bFileSize, bFileBuff.size());
1216 
1217         Uri destUri("");
1218         result = g_fah->Mkdir(g_newDirUri, "Copy_0001_dest", destUri);
1219         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1220 
1221         vector<CopyResult> copyResult;
1222         result = g_fah->Copy(srcUri, destUri, copyResult, false);
1223         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1224 
1225         result = g_fah->Delete(srcUri);
1226         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1227         result = g_fah->Delete(destUri);
1228         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1229     } catch (...) {
1230         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0001 occurs an exception.";
1231     }
1232     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0001";
1233 }
1234 
1235 /**
1236  * @tc.number: user_file_service_medialibrary_file_access_Copy_0002
1237  * @tc.name: medialibrary_file_access_Copy_0002
1238  * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is false
1239  * @tc.size: MEDIUM
1240  * @tc.type: FUNC
1241  * @tc.level Level 1
1242  * @tc.require: I6UI3H
1243  */
1244 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0002, testing::ext::TestSize.Level1)
1245 {
1246     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0002";
1247     try {
1248         Uri srcUri("");
1249         EXPECT_NE(g_fah, nullptr);
1250         int result = g_fah->Mkdir(g_newDirUri, "Copy_0002_src", srcUri);
1251         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1252         Uri srcFileUri("");
1253         result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri);
1254         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1255         int fd;
1256         result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd);
1257         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1258         std::string aFileBuff = "Copy test content for a.txt";
1259         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1260         close(fd);
1261         EXPECT_EQ(aFileSize, aFileBuff.size());
1262 
1263         Uri destUri("");
1264         result = g_fah->Mkdir(g_newDirUri, "Copy_0002_dest_false", destUri);
1265         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1266         Uri destFileUri("");
1267         result = g_fah->CreateFile(destUri, "a.txt", destFileUri);
1268         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1269 
1270         vector<CopyResult> copyResult;
1271         result = g_fah->Copy(srcFileUri, destUri, copyResult, false);
1272         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1273         EXPECT_GT(copyResult.size(), 0);
1274 
1275         result = g_fah->Delete(srcUri);
1276         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1277         result = g_fah->Delete(destUri);
1278         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1279     } catch (...) {
1280         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0002 occurs an exception.";
1281     }
1282     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0002";
1283 }
1284 
1285 /**
1286  * @tc.number: user_file_service_medialibrary_file_access_Copy_0003
1287  * @tc.name: medialibrary_file_access_Copy_0003
1288  * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is true
1289  * @tc.size: MEDIUM
1290  * @tc.type: FUNC
1291  * @tc.level Level 1
1292  * @tc.require: I6UI3H
1293  */
1294 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0003, testing::ext::TestSize.Level1)
1295 {
1296     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0003";
1297     try {
1298         Uri srcUri("");
1299         EXPECT_NE(g_fah, nullptr);
1300         int result = g_fah->Mkdir(g_newDirUri, "Copy_0003_src", srcUri);
1301         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1302         Uri srcFileUri("");
1303         result = g_fah->CreateFile(srcUri, "d.txt", srcFileUri);
1304         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1305         int fd;
1306         result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd);
1307         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1308         std::string aFileBuff = "Copy test content for d.txt";
1309         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1310         close(fd);
1311         EXPECT_EQ(aFileSize, aFileBuff.size());
1312 
1313         Uri destUri("");
1314         result = g_fah->Mkdir(g_newDirUri, "Copy_0003_dest_true", destUri);
1315         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1316         Uri destFileUri("");
1317         result = g_fah->CreateFile(destUri, "d.txt", destFileUri);
1318         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1319 
1320         vector<CopyResult> copyResult;
1321         result = g_fah->Copy(srcFileUri, destUri, copyResult, true);
1322         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1323 
1324         result = g_fah->Delete(srcUri);
1325         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1326         result = g_fah->Delete(destUri);
1327         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1328     } catch (...) {
1329         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0003 occurs an exception.";
1330     }
1331     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0003";
1332 }
1333 
1334 /**
1335  * @tc.number: user_file_service_medialibrary_file_access_Copy_0004
1336  * @tc.name: medialibrary_file_access_Copy_0004
1337  * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is false
1338  * @tc.size: MEDIUM
1339  * @tc.type: FUNC
1340  * @tc.level Level 1
1341  * @tc.require: I6UI3H
1342  */
1343 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0004, testing::ext::TestSize.Level1)
1344 {
1345     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0004";
1346     try {
1347         Uri srcUri("");
1348         EXPECT_NE(g_fah, nullptr);
1349         int result = g_fah->Mkdir(g_newDirUri, "Copy_0004_src", srcUri);
1350         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1351 
1352         Uri aFileUri("");
1353         result = g_fah->CreateFile(srcUri, "e.txt", aFileUri);
1354         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1355         int fd;
1356         result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1357         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1358         std::string aFileBuff = "Copy test content for e.txt";
1359         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1360         close(fd);
1361         EXPECT_EQ(aFileSize, aFileBuff.size());
1362 
1363         Uri bFileUri("");
1364         result = g_fah->CreateFile(srcUri, "f.txt", bFileUri);
1365         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1366         result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1367         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1368         std::string bFileBuff = "Copy test content for f.txt";
1369         ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1370         close(fd);
1371         EXPECT_EQ(bFileSize, bFileBuff.size());
1372 
1373         Uri destUri("");
1374         result = g_fah->Mkdir(g_newDirUri, "Copy_0004_dest_false", destUri);
1375         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1376         Uri destSrcUri("");
1377         result = g_fah->Mkdir(destUri, "Copy_0004_src", destSrcUri);
1378         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1379         Uri destSrcAUri("");
1380         result = g_fah->CreateFile(destSrcUri, "e.txt", destSrcAUri);
1381         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1382 
1383         vector<CopyResult> copyResult;
1384         result = g_fah->Copy(srcUri, destUri, copyResult, false);
1385         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1386         EXPECT_GT(copyResult.size(), 0);
1387 
1388         result = g_fah->Delete(srcUri);
1389         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1390         result = g_fah->Delete(destUri);
1391         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1392     } catch (...) {
1393         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0004 occurs an exception.";
1394     }
1395     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0004";
1396 }
1397 
1398 /**
1399  * @tc.number: user_file_service_medialibrary_file_access_Copy_0005
1400  * @tc.name: medialibrary_file_access_Copy_0005
1401  * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is true
1402  * @tc.size: MEDIUM
1403  * @tc.type: FUNC
1404  * @tc.level Level 1
1405  * @tc.require: I6UI3H
1406  */
1407 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0005, testing::ext::TestSize.Level1)
1408 {
1409     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0005";
1410     try {
1411         Uri srcUri("");
1412         EXPECT_NE(g_fah, nullptr);
1413         int result = g_fah->Mkdir(g_newDirUri, "Copy_0005_src", srcUri);
1414         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1415 
1416         Uri aFileUri("");
1417         result = g_fah->CreateFile(srcUri, "g.txt", aFileUri);
1418         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1419         int fd;
1420         result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1421         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1422         std::string aFileBuff = "Copy test content for g.txt";
1423         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1424         close(fd);
1425         EXPECT_EQ(aFileSize, aFileBuff.size());
1426 
1427         Uri bFileUri("");
1428         result = g_fah->CreateFile(srcUri, "h.txt", bFileUri);
1429         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1430         result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1431         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1432         std::string bFileBuff = "Copy test content for h.txt";
1433         ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1434         close(fd);
1435         EXPECT_EQ(bFileSize, bFileBuff.size());
1436 
1437         Uri destUri("");
1438         result = g_fah->Mkdir(g_newDirUri, "Copy_0005_dest_true", destUri);
1439         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1440         Uri destSrcUri("");
1441         result = g_fah->Mkdir(destUri, "Copy_0005_src", destSrcUri);
1442         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1443         Uri destSrcAUri("");
1444         result = g_fah->CreateFile(destSrcUri, "g.txt", destSrcAUri);
1445         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1446 
1447         vector<CopyResult> copyResult;
1448         result = g_fah->Copy(srcUri, destUri, copyResult, true);
1449         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1450 
1451         result = g_fah->Delete(srcUri);
1452         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1453         result = g_fah->Delete(destUri);
1454         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1455     } catch (...) {
1456         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0005 occurs an exception.";
1457     }
1458     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0005";
1459 }
1460 
1461 /**
1462  * @tc.number: user_file_service_medialibrary_file_access_Copy_0006
1463  * @tc.name: medialibrary_file_access_Copy_0006
1464  * @tc.desc: Test function of Copy interface, copy a file with the same name
1465  * @tc.size: MEDIUM
1466  * @tc.type: FUNC
1467  * @tc.level Level 1
1468  * @tc.require: I6UI3H
1469  */
1470 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0006, testing::ext::TestSize.Level1)
1471 {
1472     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0006";
1473     try {
1474         Uri srcUri("");
1475         EXPECT_NE(g_fah, nullptr);
1476         int result = g_fah->Mkdir(g_newDirUri, "Copy_0006_src", srcUri);
1477         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1478         Uri srcFileUri("");
1479         result = g_fah->CreateFile(srcUri, "i.txt", srcFileUri);
1480         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1481         int fd;
1482         result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd);
1483         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1484         std::string aFileBuff = "Copy test content for i.txt";
1485         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1486         close(fd);
1487         EXPECT_EQ(aFileSize, aFileBuff.size());
1488 
1489         Uri destUri("");
1490         result = g_fah->Mkdir(g_newDirUri, "Copy_0006_dest_false", destUri);
1491         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1492         Uri destFileUri("");
1493         result = g_fah->CreateFile(destUri, "i.txt", destFileUri);
1494         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1495 
1496         vector<CopyResult> copyResult;
1497         result = g_fah->Copy(srcFileUri, destUri, copyResult);
1498         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1499         EXPECT_GT(copyResult.size(), 0);
1500 
1501         result = g_fah->Delete(srcUri);
1502         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1503         result = g_fah->Delete(destUri);
1504         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1505     } catch (...) {
1506         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0006 occurs an exception.";
1507     }
1508     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0006";
1509 }
1510 
1511 /**
1512  * @tc.number: user_file_service_medialibrary_file_access_Copy_0007
1513  * @tc.name: medialibrary_file_access_Copy_0007
1514  * @tc.desc: Test function of Copy interface, copy a directory with the same name
1515  * @tc.size: MEDIUM
1516  * @tc.type: FUNC
1517  * @tc.level Level 1
1518  * @tc.require: I6UI3H
1519  */
1520 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0007, testing::ext::TestSize.Level1)
1521 {
1522     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0007";
1523     try {
1524         Uri srcUri("");
1525         EXPECT_NE(g_fah, nullptr);
1526         int result = g_fah->Mkdir(g_newDirUri, "Copy_0007_src", srcUri);
1527         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1528 
1529         Uri aFileUri("");
1530         result = g_fah->CreateFile(srcUri, "j.txt", aFileUri);
1531         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1532         int fd;
1533         result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1534         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1535         std::string aFileBuff = "Copy test content for j.txt";
1536         ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1537         close(fd);
1538         EXPECT_EQ(aFileSize, aFileBuff.size());
1539 
1540         Uri bFileUri("");
1541         result = g_fah->CreateFile(srcUri, "k.txt", bFileUri);
1542         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1543         result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1544         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1545         std::string bFileBuff = "Copy test content for k.txt";
1546         ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1547         close(fd);
1548         EXPECT_EQ(bFileSize, bFileBuff.size());
1549 
1550         Uri destUri("");
1551         result = g_fah->Mkdir(g_newDirUri, "Copy_0007_dest_false", destUri);
1552         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1553         Uri destSrcUri("");
1554         result = g_fah->Mkdir(destUri, "Copy_0007_src", destSrcUri);
1555         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1556         Uri destSrcAUri("");
1557         result = g_fah->CreateFile(destSrcUri, "j.txt", destSrcAUri);
1558         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1559 
1560         vector<CopyResult> copyResult;
1561         result = g_fah->Copy(srcUri, destUri, copyResult);
1562         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1563         EXPECT_GT(copyResult.size(), 0);
1564 
1565         result = g_fah->Delete(srcUri);
1566         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1567         result = g_fah->Delete(destUri);
1568         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1569     } catch (...) {
1570         GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0007 occurs an exception.";
1571     }
1572     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0007";
1573 }
1574 
1575 /**
1576  * @tc.number: user_file_service_medialibrary_file_access_ListFile_0000
1577  * @tc.name: medialibrary_file_access_ListFile_0000
1578  * @tc.desc: Test function of ListFile interface for SUCCESS.
1579  * @tc.size: MEDIUM
1580  * @tc.type: FUNC
1581  * @tc.level Level 1
1582  * @tc.require: SR000H0386
1583  */
1584 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0000, testing::ext::TestSize.Level1)
1585 {
1586     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0000";
1587     try {
1588         Uri newDirUriTest("");
1589         EXPECT_NE(g_fah, nullptr);
1590         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1591         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1592         Uri testUri("");
1593         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0000.txt", testUri);
1594         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1595         FileInfo fileInfo;
1596         fileInfo.uri = newDirUriTest.ToString();
1597         int64_t offset = 0;
1598         int64_t maxCount = 1000;
1599         std::vector<FileInfo> fileInfoVec;
1600         FileFilter filter;
1601         result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1602         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1603         EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1604         GTEST_LOG_(INFO) << "ListFile_0000 result:" << fileInfoVec.size() << endl;
1605         result = g_fah->Delete(newDirUriTest);
1606         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1607     } catch (...) {
1608         GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0000 occurs an exception.";
1609     }
1610     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0000";
1611 }
1612 
1613 /**
1614  * @tc.number: user_file_service_medialibrary_file_access_ListFile_0001
1615  * @tc.name: medialibrary_file_access_ListFile_0001
1616  * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr.
1617  * @tc.size: MEDIUM
1618  * @tc.type: FUNC
1619  * @tc.level Level 1
1620  * @tc.require: SR000H0386
1621  */
1622 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0001, testing::ext::TestSize.Level1)
1623 {
1624     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0001";
1625     try {
1626         Uri sourceFileUri("");
1627         FileInfo fileInfo;
1628         fileInfo.uri = sourceFileUri.ToString();
1629         int64_t offset = 0;
1630         int64_t maxCount = 1000;
1631         vector<FileAccessFwk::FileInfo> fileInfoVec;
1632         FileFilter filter({}, {}, {}, -1, -1, false, false);
1633         EXPECT_NE(g_fah, nullptr);
1634         int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1635         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1636         EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1637         GTEST_LOG_(INFO) << "ListFile_0001 result:" << fileInfoVec.size() << endl;
1638     } catch (...) {
1639         GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0001 occurs an exception.";
1640     }
1641     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0001";
1642 }
1643 
1644 /**
1645  * @tc.number: user_file_service_medialibrary_file_access_ListFile_0002
1646  * @tc.name: medialibrary_file_access_ListFile_0002
1647  * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path.
1648  * @tc.size: MEDIUM
1649  * @tc.type: FUNC
1650  * @tc.level Level 1
1651  * @tc.require: SR000H0386
1652  */
1653 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0002, testing::ext::TestSize.Level1)
1654 {
1655     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0002";
1656     try {
1657         Uri newDirUriTest("");
1658         EXPECT_NE(g_fah, nullptr);
1659         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1660         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1661         Uri testUri("");
1662         result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
1663         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1664         Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt");
1665         FileInfo fileInfo;
1666         fileInfo.uri = sourceFileUri.ToString();
1667         int64_t offset = 0;
1668         int64_t maxCount = 1000;
1669         vector<FileAccessFwk::FileInfo> fileInfoVec;
1670         FileFilter filter({}, {}, {}, -1, -1, false, false);
1671         result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1672         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1673         EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1674         GTEST_LOG_(INFO) << "ListFile_0002 result:" << fileInfoVec.size() << endl;
1675         result = g_fah->Delete(newDirUriTest);
1676         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1677     } catch (...) {
1678         GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0002 occurs an exception.";
1679     }
1680     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0002";
1681 }
1682 
1683 /**
1684  * @tc.number: user_file_service_medialibrary_file_access_ListFile_0003
1685  * @tc.name: medialibrary_file_access_ListFile_0003
1686  * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols.
1687  * @tc.size: MEDIUM
1688  * @tc.type: FUNC
1689  * @tc.level Level 1
1690  * @tc.require: SR000H0386
1691  */
1692 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0003, testing::ext::TestSize.Level1)
1693 {
1694     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0003";
1695     try {
1696         Uri sourceFileUri("~!@#$%^&*()_");
1697         FileInfo fileInfo;
1698         fileInfo.uri = sourceFileUri.ToString();
1699         int64_t offset = 0;
1700         int64_t maxCount = 1000;
1701         vector<FileAccessFwk::FileInfo> fileInfoVec;
1702         FileFilter filter;
1703         EXPECT_NE(g_fah, nullptr);
1704         int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1705         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1706         EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1707         GTEST_LOG_(INFO) << "ListFile_0003 result:" << fileInfoVec.size() << endl;
1708     } catch (...) {
1709         GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0003 occurs an exception.";
1710     }
1711     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0003";
1712 }
1713 
1714 /**
1715  * @tc.number: user_file_service_medialibrary_file_access_ListFile_0004
1716  * @tc.name: medialibrary_file_access_ListFile_0004
1717  * @tc.desc: Test function of ListFile interface for ERROR which add filter.
1718  * @tc.size: MEDIUM
1719  * @tc.type: FUNC
1720  * @tc.level Level 1
1721  * @tc.require: SR000HB855
1722  */
1723 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0004, testing::ext::TestSize.Level1)
1724 {
1725     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0004";
1726     try {
1727         Uri newDirUriTest("");
1728         EXPECT_NE(g_fah, nullptr);
1729         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1730         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1731         Uri testUri1("");
1732         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.txt", testUri1);
1733         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1734         Uri testUri2("");
1735         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.docx", testUri2);
1736         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1737         FileInfo fileInfo;
1738         fileInfo.uri = newDirUriTest.ToString();
1739         int64_t offset = 0;
1740         int64_t maxCount = 1000;
1741         std::vector<FileInfo> fileInfoVec;
1742         FileFilter filter({".txt"}, {}, {}, -1, 1, false, true);
1743         result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1744         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1745         EXPECT_EQ(fileInfoVec.size(), 1);
1746         result = g_fah->Delete(newDirUriTest);
1747         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1748     } catch (...) {
1749         GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0004 occurs an exception.";
1750     }
1751     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0004";
1752 }
1753 
ListFileTdd(shared_ptr<FileAccessHelper> fahs,FileInfo fileInfo,FileFilter filter,std::vector<FileInfo> fileInfoVec)1754 static void ListFileTdd(shared_ptr<FileAccessHelper> fahs, FileInfo fileInfo, FileFilter filter,
1755     std::vector<FileInfo> fileInfoVec)
1756 {
1757     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFileTdd";
1758     int64_t offset = 0;
1759     int64_t maxCount = 1000;
1760     EXPECT_NE(g_fah, nullptr);
1761     int ret = fahs->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1762     if (ret != OHOS::FileAccessFwk::ERR_OK) {
1763         GTEST_LOG_(ERROR) << "ListFileTdd get result error, code:" << ret;
1764         return;
1765     }
1766     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1767     EXPECT_EQ(fileInfoVec.size(), 1);
1768     g_num++;
1769     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFileTdd";
1770 }
1771 
1772 /**
1773  * @tc.number: user_file_service_medialibrary_file_access_ListFile_0005
1774  * @tc.name: medialibrary_file_access_ListFile_0005
1775  * @tc.desc: Test function of ListFile interface for ERROR which Concurrent.
1776  * @tc.size: MEDIUM
1777  * @tc.type: FUNC
1778  * @tc.level Level 1
1779  * @tc.require: SR000H0386
1780  */
1781 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0005, testing::ext::TestSize.Level1)
1782 {
1783     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0005";
1784     try {
1785         Uri newDirUriTest("");
1786         EXPECT_NE(g_fah, nullptr);
1787         int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1788         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1789         Uri testUri1("");
1790         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.txt", testUri1);
1791         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1792         Uri testUri2("");
1793         result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.docx", testUri2);
1794         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1795         FileInfo fileInfo;
1796         fileInfo.uri = newDirUriTest.ToString();
1797         std::vector<FileInfo> fileInfoVec;
1798         g_num = 0;
1799         FileFilter filter({".txt"}, {}, {}, -1, -1, false, true);
1800         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
1801             std::thread execthread(ListFileTdd, g_fah, fileInfo, filter, fileInfoVec);
1802             execthread.join();
1803         }
1804         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
1805         result = g_fah->Delete(newDirUriTest);
1806         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1807     } catch (...) {
1808         GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0005 occurs an exception.";
1809     }
1810     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0005";
1811 }
1812 } // namespace
1813