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 using json = nlohmann::json;
35 const int INIT_THREADS_NUMBER = 4;
36 const int ACTUAL_SUCCESS_THREADS_NUMBER = 1;
37 int g_num = 0;
38 Uri g_newDirUri("");
39 
40 /**
41  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0000
42  * @tc.name: medialibrary_file_access_OpenFile_0000
43  * @tc.desc: Test function of OpenFile interface for SUCCESS.
44  * @tc.size: MEDIUM
45  * @tc.type: FUNC
46  * @tc.level Level 1
47  * @tc.require: SR000H0386
48  */
49 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0000, testing::ext::TestSize.Level1)
50 {
51     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
52     EXPECT_NE(fileAccessHelper, nullptr);
53     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0000";
54     try {
55         Uri parentUri = GetParentUri();
56         bool isExist = false;
57         int result = fileAccessHelper->Access(g_newDirUri, isExist);
58         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
59         if (!isExist) {
60             result = fileAccessHelper->Mkdir(parentUri, "Download", g_newDirUri);
61             EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
62         }
63         Uri newDirUriTest("file://media/root/file");
64         FileInfo fileInfo;
65         fileInfo.uri = newDirUriTest.ToString();
66         int64_t offset = 0;
67         int64_t maxCount = 1000;
68         std::vector<FileInfo> fileInfoVec;
69         FileFilter filter;
70         result = fileAccessHelper->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
71         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
72         EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
73         for (size_t i = 0; i < fileInfoVec.size(); i++) {
74             if (fileInfoVec[i].fileName.compare("Download") == 0) {
75                 g_newDirUri = Uri(fileInfoVec[i].uri);
76                 break;
77             }
78         }
79         result = fileAccessHelper->Mkdir(g_newDirUri, "test1", newDirUriTest);
80         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
81         Uri newFileUri("");
82         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_OpenFile_0000.txt",
83             newFileUri);
84         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
85         int fd;
86         result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
87         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
88         GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result;
89         close(fd);
90         result = fileAccessHelper->Delete(newDirUriTest);
91         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
92     } catch (...) {
93         GTEST_LOG_(ERROR) << "medialibrary_file_accsess_OpenFile_0000 occurs an exception.";
94     }
95     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0000";
96 }
97 
98 /**
99  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0001
100  * @tc.name: medialibrary_file_access_OpenFile_0001
101  * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null.
102  * @tc.size: MEDIUM
103  * @tc.type: FUNC
104  * @tc.level Level 1
105  * @tc.require: SR000H0386
106  */
107 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0001, testing::ext::TestSize.Level1)
108 {
109     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
110     EXPECT_NE(fileAccessHelper, nullptr);
111     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0001";
112     try {
113         Uri uri("");
114         int fd;
115         int result = fileAccessHelper->OpenFile(uri, WRITE_READ, fd);
116         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
117         GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result;
118     } catch (...) {
119         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0001 occurs an exception.";
120     }
121     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0001";
122 }
123 
124 /**
125  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0002
126  * @tc.name: medialibrary_file_access_OpenFile_0002
127  * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path.
128  * @tc.size: MEDIUM
129  * @tc.type: FUNC
130  * @tc.level Level 1
131  * @tc.require: SR000H0386
132  */
133 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0002, testing::ext::TestSize.Level1)
134 {
135     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
136     EXPECT_NE(fileAccessHelper, nullptr);
137     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0002";
138     try {
139         Uri uri("storage/media/100/local/files/Download/medialibrary_file_access_OpenFile_0002.txt");
140         int fd;
141         int result = fileAccessHelper->OpenFile(uri, WRITE_READ, fd);
142         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
143         GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result;
144     } catch (...) {
145         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0002 occurs an exception.";
146     }
147     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0002";
148 }
149 
150 /**
151  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0003
152  * @tc.name: medialibrary_file_access_OpenFile_0003
153  * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols.
154  * @tc.size: MEDIUM
155  * @tc.type: FUNC
156  * @tc.level Level 1
157  * @tc.require: SR000H0386
158  */
159 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0003, testing::ext::TestSize.Level1)
160 {
161     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
162     EXPECT_NE(fileAccessHelper, nullptr);
163     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0003";
164     try {
165         Uri uri("~!@#$%^&*()_");
166         int fd;
167         int result = fileAccessHelper->OpenFile(uri, WRITE_READ, fd);
168         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
169         GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result;
170     } catch (...) {
171         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0003 occurs an exception.";
172     }
173     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0003";
174 }
175 
176 /**
177  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0004
178  * @tc.name: medialibrary_file_access_OpenFile_0004
179  * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1.
180  * @tc.size: MEDIUM
181  * @tc.type: FUNC
182  * @tc.level Level 1
183  * @tc.require: SR000H0386
184  */
185 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0004, testing::ext::TestSize.Level1)
186 {
187     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
188     EXPECT_NE(fileAccessHelper, nullptr);
189     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0004";
190     try {
191         Uri newFileUri("");
192         int result = fileAccessHelper->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0004.txt",
193             newFileUri);
194         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
195         int fd;
196         int flag = -1;
197         result = fileAccessHelper->OpenFile(newFileUri, flag, fd);
198         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
199         GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result;
200         result = fileAccessHelper->Delete(newFileUri);
201         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
202     } catch (...) {
203         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0004 occurs an exception.";
204     }
205     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0004";
206 }
207 
208 /**
209  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0005
210  * @tc.name: medialibrary_file_access_OpenFile_0005
211  * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0.
212  * @tc.size: MEDIUM
213  * @tc.type: FUNC
214  * @tc.level Level 1
215  * @tc.require: SR000H0386
216  */
217 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0005, testing::ext::TestSize.Level1)
218 {
219     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
220     EXPECT_NE(fileAccessHelper, nullptr);
221     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0005";
222     try {
223         Uri newFileUri("");
224         int result = fileAccessHelper->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0005.txt",
225             newFileUri);
226         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
227         int fd;
228         result = fileAccessHelper->OpenFile(newFileUri, READ, fd);
229         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
230         GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result;
231         close(fd);
232         result = fileAccessHelper->Delete(newFileUri);
233         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
234     } catch (...) {
235         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0005 occurs an exception.";
236     }
237     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0005";
238 }
239 
240 /**
241  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0006
242  * @tc.name: medialibrary_file_access_OpenFile_0006
243  * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1.
244  * @tc.size: MEDIUM
245  * @tc.type: FUNC
246  * @tc.level Level 1
247  * @tc.require: SR000H0386
248  */
249 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0006, testing::ext::TestSize.Level1)
250 {
251     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
252     EXPECT_NE(fileAccessHelper, nullptr);
253     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0006";
254     try {
255         Uri newFileUri("");
256         int result = fileAccessHelper->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0006.txt",
257             ewFileUri);
258         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
259         int fd;
260         result = fileAccessHelper->OpenFile(newFileUri, WRITE, fd);
261         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
262         GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result;
263         close(fd);
264         result = fileAccessHelper->Delete(newFileUri);
265         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
266     } catch (...) {
267         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0006 occurs an exception.";
268     }
269     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0006";
270 }
271 
272 /**
273  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0007
274  * @tc.name: medialibrary_file_access_OpenFile_0007
275  * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2.
276  * @tc.size: MEDIUM
277  * @tc.type: FUNC
278  * @tc.level Level 1
279  * @tc.require: SR000H0386
280  */
281 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0007, testing::ext::TestSize.Level1)
282 {
283     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
284     EXPECT_NE(fileAccessHelper, nullptr);
285     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0007";
286     try {
287         Uri newFileUri("");
288         int result = fileAccessHelper->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0007.txt",
289             newFileUri);
290         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
291         int fd;
292         result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
293         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
294         GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result;
295         close(fd);
296         result = fileAccessHelper->Delete(newFileUri);
297         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
298     } catch (...) {
299         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0007 occurs an exception.";
300     }
301     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0007";
302 }
303 
OpenFileTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,int flag,int fd)304 static void OpenFileTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, int flag, int fd)
305 {
306     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFileTdd";
307     int ret = fahs->OpenFile(uri, flag, fd);
308     if (ret != OHOS::FileAccessFwk::ERR_OK) {
309         GTEST_LOG_(ERROR) << "OpenFileTdd get result error, code:" << ret;
310         return;
311     }
312     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
313     EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK);
314     g_num++;
315     close(fd);
316     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFileTdd";
317 }
318 
319 /**
320  * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0008
321  * @tc.name: medialibrary_file_access_OpenFile_0008
322  * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent.
323  * @tc.size: MEDIUM
324  * @tc.type: FUNC
325  * @tc.level Level 1
326  * @tc.require: SR000H0386
327  */
328 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0008, testing::ext::TestSize.Level1)
329 {
330     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
331     EXPECT_NE(fileAccessHelper, nullptr);
332     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0008";
333     try {
334         Uri newFileUri("");
335         int fd;
336         g_num = 0;
337         std::string displayName = "test1.txt";
338         int result = fileAccessHelper->CreateFile(g_newDirUri, displayName, newFileUri);
339         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
340         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
341             std::thread execthread(OpenFileTdd, fileAccessHelper, newFileUri, WRITE_READ, fd);
342             execthread.join();
343         }
344         EXPECT_EQ(g_num, INIT_THREADS_NUMBER);
345         result = fileAccessHelper->Delete(newFileUri);
346         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
347     } catch (...) {
348         GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0008 occurs an exception.";
349     }
350     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0008";
351 }
352 
353 /**
354  * @tc.number: user_file_service_medialibrary_file_access_Rename_0000
355  * @tc.name: medialibrary_file_access_Rename_0000
356  * @tc.desc: Test function of Rename interface for SUCCESS which rename file.
357  * @tc.size: MEDIUM
358  * @tc.type: FUNC
359  * @tc.level Level 1
360  * @tc.require: SR000H0386
361  */
362 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0000, testing::ext::TestSize.Level1)
363 {
364     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
365     EXPECT_NE(fileAccessHelper, nullptr);
366     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0000";
367     try {
368         Uri newDirUriTest("");
369         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
370         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
371         Uri testUri("");
372         result = fileAccessHelper->CreateFile(newDirUriTest, "test.txt", testUri);
373         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
374         Uri renameUri("");
375         result = fileAccessHelper->Rename(testUri, "test2.txt", renameUri);
376         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
377         GTEST_LOG_(INFO) << "Rename_0000 result:" << result;
378         result = fileAccessHelper->Delete(newDirUriTest);
379         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
380     } catch (...) {
381         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0000 occurs an exception.";
382     }
383     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0000";
384 }
385 
386 /**
387  * @tc.number: user_file_service_medialibrary_file_access_Rename_0001
388  * @tc.name: medialibrary_file_access_Rename_0001
389  * @tc.desc: Test function of Rename interface for SUCCESS which rename folder.
390  * @tc.size: MEDIUM
391  * @tc.type: FUNC
392  * @tc.level Level 1
393  * @tc.require: SR000H0386
394  */
395 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0001, testing::ext::TestSize.Level1)
396 {
397     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
398     EXPECT_NE(fileAccessHelper, nullptr);
399     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0001";
400     try {
401         Uri newDirUriTest("");
402         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
403         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
404         Uri renameUri("");
405         result = fileAccessHelper->Rename(newDirUriTest, "testRename", renameUri);
406         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
407         GTEST_LOG_(INFO) << "Rename_0001 result:" << result;
408         result = fileAccessHelper->Delete(renameUri);
409         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
410     } catch (...) {
411         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0001 occurs an exception.";
412     }
413     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0001";
414 }
415 
416 /**
417  * @tc.number: user_file_service_medialibrary_file_access_Rename_0002
418  * @tc.name: medialibrary_file_access_Rename_0002
419  * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null.
420  * @tc.size: MEDIUM
421  * @tc.type: FUNC
422  * @tc.level Level 1
423  * @tc.require: SR000H0386
424  */
425 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0002, testing::ext::TestSize.Level1)
426 {
427     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
428     EXPECT_NE(fileAccessHelper, nullptr);
429     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0002";
430     try {
431         Uri renameUri("");
432         Uri sourceFileUri("");
433         int result = fileAccessHelper->Rename(sourceFileUri, "testRename.txt", renameUri);
434         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
435         GTEST_LOG_(INFO) << "Rename_0002 result:" << result;
436     } catch (...) {
437         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0002 occurs an exception.";
438     }
439     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0002";
440 }
441 
442 /**
443  * @tc.number: user_file_service_medialibrary_file_access_Rename_0003
444  * @tc.name: medialibrary_file_access_Rename_0003
445  * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path.
446  * @tc.size: MEDIUM
447  * @tc.type: FUNC
448  * @tc.level Level 1
449  * @tc.require: SR000H0386
450  */
451 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0003, testing::ext::TestSize.Level1)
452 {
453     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
454     EXPECT_NE(fileAccessHelper, nullptr);
455     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0003";
456     try {
457         Uri newDirUriTest("");
458         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
459         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
460         Uri testUri("");
461         result = fileAccessHelper->CreateFile(newDirUriTest, "test.txt", testUri);
462         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
463         Uri renameUri("");
464         Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt");
465         result = fileAccessHelper->Rename(sourceFileUri, "testRename.txt", renameUri);
466         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
467         GTEST_LOG_(INFO) << "Rename_0003 result:" << result;
468         result = fileAccessHelper->Delete(newDirUriTest);
469         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
470     } catch (...) {
471         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0003 occurs an exception.";
472     }
473     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0003";
474 }
475 
476 /**
477  * @tc.number: user_file_service_medialibrary_file_access_Rename_0004
478  * @tc.name: medialibrary_file_access_Rename_0004
479  * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols.
480  * @tc.size: MEDIUM
481  * @tc.type: FUNC
482  * @tc.level Level 1
483  * @tc.require: SR000H0386
484  */
485 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0004, testing::ext::TestSize.Level1)
486 {
487     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
488     EXPECT_NE(fileAccessHelper, nullptr);
489     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0004";
490     try {
491         Uri renameUri("");
492         Uri sourceFileUri("~!@#$%^&*()_");
493         int result = fileAccessHelper->Rename(sourceFileUri, "testRename.txt", renameUri);
494         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
495         GTEST_LOG_(INFO) << "Rename_0004 result:" << result;
496     } catch (...) {
497         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0004 occurs an exception.";
498     }
499     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0004";
500 }
501 
502 /**
503  * @tc.number: user_file_service_medialibrary_file_access_Rename_0005
504  * @tc.name: medialibrary_file_access_Rename_0005
505  * @tc.desc: Test function of Rename interface for ERROR which displayName is null.
506  * @tc.size: MEDIUM
507  * @tc.type: FUNC
508  * @tc.level Level 1
509  * @tc.require: SR000H0386
510  */
511 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0005, testing::ext::TestSize.Level1)
512 {
513     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
514     EXPECT_NE(fileAccessHelper, nullptr);
515     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0005";
516     try {
517         Uri newDirUriTest("");
518         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
519         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
520         Uri testUri("");
521         result = fileAccessHelper->CreateFile(newDirUriTest, "test.txt", testUri);
522         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
523         Uri renameUri("");
524         result = fileAccessHelper->Rename(testUri, "", renameUri);
525         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
526         GTEST_LOG_(INFO) << "Rename_0005 result:" << result;
527         result = fileAccessHelper->Delete(newDirUriTest);
528         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
529     } catch (...) {
530         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0005 occurs an exception.";
531     }
532     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0005";
533 }
534 
RenameTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,std::string displayName,Uri newFile)535 static void RenameTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, std::string displayName, Uri newFile)
536 {
537     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_RenameTdd";
538     int ret = fahs->Rename(sourceFile, displayName, newFile);
539     if (ret != OHOS::FileAccessFwk::ERR_OK) {
540         GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret;
541         return;
542     }
543     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
544     EXPECT_NE(newFile.ToString(), "");
545     g_num++;
546     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_RenameTdd";
547 }
548 
549 /**
550  * @tc.number: user_file_service_medialibrary_file_access_Rename_0006
551  * @tc.name: medialibrary_file_access_Rename_0006
552  * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent.
553  * @tc.size: MEDIUM
554  * @tc.type: FUNC
555  * @tc.level Level 1
556  * @tc.require: SR000H0386
557  */
558 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0006, testing::ext::TestSize.Level1)
559 {
560     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
561     EXPECT_NE(fileAccessHelper, nullptr);
562     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0006";
563     try {
564         Uri newDirUriTest("");
565         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
566         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
567         Uri testUri{""};
568         std::string displayName1 = "test1.txt";
569         std::string displayName2 = "test2.txt";
570         Uri renameUri("");
571         result = fileAccessHelper->CreateFile(newDirUriTest, displayName1, testUri);
572         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
573         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
574             std::thread execthread(RenameTdd, fileAccessHelper, testUri, displayName2, renameUri);
575             execthread.join();
576         }
577         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
578         result = fileAccessHelper->Delete(newDirUriTest);
579         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
580     } catch (...) {
581         GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0006 occurs an exception.";
582     }
583     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0006";
584 }
585 
586 /**
587  * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0000
588  * @tc.name: medialibrary_file_access_ScanFile_0000
589  * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with filter.
590  * @tc.size: MEDIUM
591  * @tc.type: FUNC
592  * @tc.level Level 1
593  * @tc.require: SR000HB866
594  */
595 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0000, testing::ext::TestSize.Level1)
596 {
597     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
598     EXPECT_NE(fileAccessHelper, nullptr);
599     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0000";
600     try {
601         Uri newDirUriTest("");
602         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
603         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
604         Uri testUri("");
605         FileInfo fileInfo;
606         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4",
607             testUri);
608         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
609         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt",
610             testUri);
611         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
612         fileInfo.uri = "file://media/root";
613         int64_t offset = 0;
614         int64_t maxCount = 1000;
615         std::vector<FileInfo> fileInfoVec;
616         FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
617         result = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
618         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
619         EXPECT_GE(fileInfoVec.size(), 1);
620         GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl;
621         result = fileAccessHelper->Delete(newDirUriTest);
622         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
623     } catch (...) {
624         GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0000 occurs an exception.";
625     }
626     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0000";
627 }
628 
629 /**
630  * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0001
631  * @tc.name: medialibrary_file_access_ScanFile_0001
632  * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with no filter.
633  * @tc.size: MEDIUM
634  * @tc.type: FUNC
635  * @tc.level Level 1
636  * @tc.require: SR000HB866
637  */
638 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0001, testing::ext::TestSize.Level1)
639 {
640     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
641     EXPECT_NE(fileAccessHelper, nullptr);
642     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0001";
643     try {
644         Uri newDirUriTest("");
645         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
646         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
647         Uri testUri("");
648         FileInfo fileInfo;
649         fileInfo.uri = "file://media/root";
650         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.q1w2e3r4",
651             testUri);
652         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
653         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.txt",
654             testUri);
655         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
656         int64_t offset = 0;
657         int64_t maxCount = 1000;
658         std::vector<FileInfo> fileInfoVec;
659         FileFilter filter({}, {}, {}, -1, -1, false, false);
660         result = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
661         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
662         EXPECT_GE(fileInfoVec.size(), 2);
663         GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl;
664         result = fileAccessHelper->Delete(newDirUriTest);
665         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
666     } catch (...) {
667         GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0001 occurs an exception.";
668     }
669     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0001";
670 }
671 
672 /**
673  * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0002
674  * @tc.name: medialibrary_file_access_ScanFile_0002
675  * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter.
676  * @tc.size: MEDIUM
677  * @tc.type: FUNC
678  * @tc.level Level 1
679  * @tc.require: SR000HB866
680  */
681 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0002, testing::ext::TestSize.Level1)
682 {
683     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
684     EXPECT_NE(fileAccessHelper, nullptr);
685     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0002";
686     try {
687         Uri newDirUriTest("");
688         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
689         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
690         Uri testUri("");
691         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0002.q1w2e3r4",
692             testUri);
693         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
694         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt",
695             testUri);
696         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
697         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.docx",
698             testUri);
699         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
700         FileInfo fileInfo;
701         fileInfo.uri = newDirUriTest.ToString();
702         int64_t offset = 0;
703         int64_t maxCount = 1000;
704         std::vector<FileInfo> fileInfoVec;
705         FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
706         result = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
707         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
708         EXPECT_EQ(fileInfoVec.size(), 1);
709         FileFilter filter1({".q1w2e3r4", ".txt"}, {}, {}, -1, -1, false, true);
710         result = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter1, fileInfoVec);
711         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
712         EXPECT_EQ(fileInfoVec.size(), 2);
713         GTEST_LOG_(INFO) << "ScanFile_0002 result:" << fileInfoVec.size() << endl;
714         result = fileAccessHelper->Delete(newDirUriTest);
715         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
716     } catch (...) {
717         GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0002 occurs an exception.";
718     }
719     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0002";
720 }
721 
722 /**
723  * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0003
724  * @tc.name: medialibrary_file_access_ScanFile_0003
725  * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter.
726  * @tc.size: MEDIUM
727  * @tc.type: FUNC
728  * @tc.level Level 1
729  * @tc.require: SR000HB866
730  */
731 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0003, testing::ext::TestSize.Level1)
732 {
733     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
734     EXPECT_NE(fileAccessHelper, nullptr);
735     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0003";
736     try {
737         Uri newDirUriTest("");
738         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
739         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
740         Uri testUri("");
741         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0003.q1w2e3r4",
742             testUri);
743         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
744         FileInfo fileInfo;
745         fileInfo.uri = newDirUriTest.ToString();
746         int64_t offset = 0;
747         int64_t maxCount = 1000;
748         std::vector<FileInfo> fileInfoVec;
749         FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
750         result = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
751         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
752         EXPECT_EQ(fileInfoVec.size(), 1);
753         GTEST_LOG_(INFO) << "ScanFile_0003 result:" << fileInfoVec.size() << endl;
754         result = fileAccessHelper->Delete(newDirUriTest);
755         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
756     } catch (...) {
757         GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0003 occurs an exception.";
758     }
759     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0003";
760 }
761 
ScanFileTdd(FileInfo fileInfo,FileFilter filter,std::vector<FileInfo> fileInfoVec,shared_ptr<FileAccessHelper> fileAccessHelper)762 static void ScanFileTdd(FileInfo fileInfo, FileFilter filter, std::vector<FileInfo> fileInfoVec,
763     shared_ptr<FileAccessHelper> fileAccessHelper)
764 {
765     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFileTdd";
766     int64_t offset = 0;
767     int64_t maxCount = 1000;
768     int ret = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
769     if (ret != OHOS::FileAccessFwk::ERR_OK) {
770         GTEST_LOG_(ERROR) << "ScanFileTdd get result error, code:" << ret;
771         return;
772     }
773     EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
774     EXPECT_EQ(fileInfoVec.size(), 1);
775     g_num++;
776     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFileTdd";
777 }
778 
779 /**
780  * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0004
781  * @tc.name: medialibrary_file_access_ScanFile_0004
782  * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with Concurrent.
783  * @tc.size: MEDIUM
784  * @tc.type: FUNC
785  * @tc.level Level 1
786  * @tc.require: SR000HB866
787  */
788 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0004, testing::ext::TestSize.Level1)
789 {
790     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
791     EXPECT_NE(fileAccessHelper, nullptr);
792     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0004";
793     try {
794         Uri newDirUriTest("");
795         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
796         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
797         Uri testUri("");
798         FileInfo fileInfo;
799         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4",
800             testUri);
801         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
802         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt",
803             testUri);
804         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
805         fileInfo.uri = "file://media/root";
806         std::vector<FileInfo> fileInfoVec;
807         FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
808         g_num = 0;
809         for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
810             std::thread execthread(ScanFileTdd, fileInfo, filter, fileInfoVec, fileAccessHelper);
811             execthread.join();
812         }
813         EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
814         result = fileAccessHelper->Delete(newDirUriTest);
815         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
816     } catch (...) {
817         GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0004 occurs an exception.";
818     }
819     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0004";
820 }
821 
ReplaceBundleNameFromPath(std::string & path,const std::string & newName)822 static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName)
823 {
824     Uri uri(path);
825     std::string scheme = uri.GetScheme();
826     if (scheme == FILE_SCHEME_NAME) {
827         std::string curName = uri.GetAuthority();
828         if (curName.empty()) {
829             return false;
830         }
831         path.replace(path.find(curName), curName.length(), newName);
832         return true;
833     }
834 
835     std::string tPath = Uri(path).GetPath();
836     if (tPath.empty()) {
837         GTEST_LOG_(INFO) << "Uri path error.";
838         return false;
839     }
840 
841     if (tPath.front() != '/') {
842         GTEST_LOG_(INFO) << "Uri path format error.";
843         return false;
844     }
845 
846     auto index = tPath.substr(1).find_first_of("/");
847     auto bundleName = tPath.substr(1, index);
848     if (bundleName.empty()) {
849         GTEST_LOG_(INFO) << "bundleName empty.";
850         return false;
851     }
852 
853     path.replace(path.find(bundleName), bundleName.length(), newName);
854     return true;
855 }
856 
857 /**
858  * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0005
859  * @tc.name: medialibrary_file_access_ScanFile_0005
860  * @tc.desc: Test function of ScanFile interface for FAILED because of GetProxyByUri failed.
861  * @tc.size: MEDIUM
862  * @tc.type: FUNC
863  * @tc.level Level 1
864  * @tc.require: SR000HB866
865  */
866 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0005, testing::ext::TestSize.Level1)
867 {
868     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
869     EXPECT_NE(fileAccessHelper, nullptr);
870     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0005";
871     try {
872         Uri newDirUriTest("");
873         int result = fileAccessHelper->Mkdir(g_newDirUri, "test", newDirUriTest);
874         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
875         Uri testUri("");
876         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0005.q1w2e3r4",
877             testUri);
878         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
879 
880         std::string str = testUri.ToString();
881         if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
882             GTEST_LOG_(INFO) << "replace BundleName failed.";
883             EXPECT_TRUE(false);
884         }
885         FileInfo fileInfo;
886         fileInfo.uri = str;
887         int64_t offset = 0;
888         int64_t maxCount = 1000;
889         std::vector<FileInfo> fileInfoVec;
890         FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
891         result = fileAccessHelper->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
892         EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
893         EXPECT_EQ(fileInfoVec.size(), 0);
894         GTEST_LOG_(INFO) << "ScanFile_0005 result:" << fileInfoVec.size() << endl;
895         result = fileAccessHelper->Delete(newDirUriTest);
896         EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
897     } catch (...) {
898         GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0005 occurs an exception.";
899     }
900     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0005";
901 }
902 
903 /**
904  * @tc.number: user_file_service_medialibrary_file_access_GetRoots_0000
905  * @tc.name: medialibrary_file_access_GetRoots_0000
906  * @tc.desc: Test function of GetRoots interface for SUCCESS.
907  * @tc.size: MEDIUM
908  * @tc.type: FUNC
909  * @tc.level Level 1
910  * @tc.require: SR000H0386
911  */
912 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetRoots_0000, testing::ext::TestSize.Level1)
913 {
914     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
915     EXPECT_NE(fileAccessHelper, nullptr);
916     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetRoots_0000";
917     try {
918         vector<RootInfo> info;
919         int result = fileAccessHelper->GetRoots(info);
920         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
921         EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK);
922         if (info.size() > OHOS::FileAccessFwk::ERR_OK) {
923             GTEST_LOG_(INFO) << info[0].uri;
924             GTEST_LOG_(INFO) << info[0].displayName;
925             GTEST_LOG_(INFO) << info[0].deviceType;
926             GTEST_LOG_(INFO) << info[0].deviceFlags;
927         }
928         string uri = "file://media/root";
929         string displayName = "LOCAL";
930         EXPECT_EQ(info[0].uri, uri);
931         EXPECT_EQ(info[0].displayName, displayName);
932         EXPECT_EQ(info[0].deviceType, DEVICE_LOCAL_DISK);
933         EXPECT_EQ(info[0].deviceFlags, DEVICE_FLAG_SUPPORTS_READ | DEVICE_FLAG_SUPPORTS_WRITE);
934     } catch (...) {
935         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetRoots_0000 occurs an exception.";
936     }
937     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetRoots_0000";
938 }
939 
940 /**
941  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0000
942  * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0000
943  * @tc.desc: Test function of GetFileInfoFromUri interface.
944  * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS.
945  * @tc.size: MEDIUM
946  * @tc.type: FUNC
947  * @tc.level Level 1
948  * @tc.require: SR000HRLBS
949  */
950 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1)
951 {
952     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
953     EXPECT_NE(fileAccessHelper, nullptr);
954     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0000";
955     try {
956         vector<RootInfo> infos;
957         int result = fileAccessHelper->GetRoots(infos);
958         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
959         for (size_t i = 0; i < infos.size(); i++) {
960             Uri parentUri(infos[i].uri);
961             FileInfo fileinfo;
962             result = fileAccessHelper->GetFileInfoFromUri(parentUri, fileinfo);
963             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
964 
965             int64_t offset = 0;
966             int64_t maxCount = 1000;
967             FileFilter filter;
968             std::vector<FileInfo> fileInfoVecTemp;
969             result = fileAccessHelper->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
970             EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
971             EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
972         }
973     } catch (...) {
974         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0000 occurs an exception.";
975     }
976     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0000";
977 }
978 
979 /**
980  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0001
981  * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0001
982  * @tc.desc: Test function of GetFileInfoFromUri interface.
983  * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS.
984  * @tc.size: MEDIUM
985  * @tc.type: FUNC
986  * @tc.level Level 1
987  * @tc.require: SR000HRLBS
988  */
989 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1)
990 {
991     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
992     EXPECT_NE(fileAccessHelper, nullptr);
993     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0001";
994     try {
995         Uri newDirUriTest("");
996         int result = fileAccessHelper->Mkdir(g_newDirUri, "testDir", newDirUriTest);
997         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
998 
999         FileInfo dirInfo;
1000         result = fileAccessHelper->GetFileInfoFromUri(newDirUriTest, dirInfo);
1001         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1002 
1003         int64_t offset = 0;
1004         int64_t maxCount = 1000;
1005         FileFilter filter;
1006         std::vector<FileInfo> fileInfoVec;
1007         result = fileAccessHelper->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec);
1008         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1009         EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1010 
1011         result = fileAccessHelper->Delete(newDirUriTest);
1012         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1013     } catch (...) {
1014         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0001 occurs an exception.";
1015     }
1016     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0001";
1017 }
1018 
1019 /**
1020  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0002
1021  * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0002
1022  * @tc.desc: Test function of GetFileInfoFromUri interface.
1023  * @tc.desc: convert the regular file uri to fileinfo and call listfile for ERROR.
1024  * @tc.size: MEDIUM
1025  * @tc.type: FUNC
1026  * @tc.level Level 1
1027  * @tc.require: SR000HRLBS
1028  */
1029 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1)
1030 {
1031     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1032     EXPECT_NE(fileAccessHelper, nullptr);
1033     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0002";
1034     try {
1035         Uri newDirUriTest("");
1036         int result = fileAccessHelper->Mkdir(g_newDirUri, "testDir", newDirUriTest);
1037         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1038         Uri newFileUri("");
1039         result = fileAccessHelper->CreateFile(newDirUriTest, "medialibrary_file_access_GetFileInfoFromUri_0002.txt",
1040             newFileUri);
1041         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1042 
1043         FileInfo fileinfo;
1044         result = fileAccessHelper->GetFileInfoFromUri(newFileUri, fileinfo);
1045         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1046 
1047         int64_t offset = 0;
1048         int64_t maxCount = 1000;
1049         FileFilter filter;
1050         std::vector<FileInfo> fileInfoVecTemp;
1051         result = fileAccessHelper->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
1052         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1053         EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
1054 
1055         result = fileAccessHelper->Delete(newDirUriTest);
1056         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1057     } catch (...) {
1058         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0002 occurs an exception.";
1059     }
1060     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0002";
1061 }
1062 
1063 /**
1064  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0003
1065  * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0003
1066  * @tc.desc: Test function of GetFileInfoFromUri interface.
1067  * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed.
1068  * @tc.size: MEDIUM
1069  * @tc.type: FUNC
1070  * @tc.level Level 1
1071  * @tc.require: SR000HRLBS
1072  */
1073 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1)
1074 {
1075     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1076     EXPECT_NE(fileAccessHelper, nullptr);
1077     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0003";
1078     try {
1079         vector<RootInfo> info;
1080         int result = fileAccessHelper->GetRoots(info);
1081         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1082         for (size_t i = 0; i < info.size(); i++) {
1083             Uri parentUri(std::string("\?\?\?\?/") + info[i].uri);
1084             FileInfo fileinfo;
1085             result = fileAccessHelper->GetFileInfoFromUri(parentUri, fileinfo);
1086             EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
1087         }
1088     } catch (...) {
1089         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0003 occurs an exception.";
1090     }
1091     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0003";
1092 }
1093 
1094 /**
1095  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0004
1096  * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0004
1097  * @tc.desc: Test function of GetFileInfoFromUri interface.
1098  * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed.
1099  * @tc.size: MEDIUM
1100  * @tc.type: FUNC
1101  * @tc.level Level 1
1102  * @tc.require: SR000HRLBS
1103  */
1104 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1)
1105 {
1106     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1107     EXPECT_NE(fileAccessHelper, nullptr);
1108     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0004";
1109     try {
1110         vector<RootInfo> info;
1111         int result = fileAccessHelper->GetRoots(info);
1112         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1113         for (size_t i = 0; i < info.size(); i++) {
1114             std::string str = info[i].uri;
1115             if (ReplaceBundleName(str, "ohos.com.NotExistBundleName")) {
1116                 Uri parentUri(str);
1117                 FileInfo fileinfo;
1118                 result = fileAccessHelper->GetFileInfoFromUri(parentUri, fileinfo);
1119                 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
1120             } else {
1121                 EXPECT_TRUE(false);
1122             }
1123         }
1124     } catch (...) {
1125         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0004 occurs an exception.";
1126     }
1127     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0004";
1128 }
1129 
1130 /**
1131  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0005
1132  * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0005
1133  * @tc.desc: Test function of GetFileInfoFromUri interface.
1134  * @tc.desc: convert the invalid uri to fileinfo failed.
1135  * @tc.size: MEDIUM
1136  * @tc.type: FUNC
1137  * @tc.level Level 1
1138  * @tc.require: SR000HRLBS
1139  */
1140 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1)
1141 {
1142     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1143     EXPECT_NE(fileAccessHelper, nullptr);
1144     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0005";
1145     try {
1146         Uri uri("~!@#$%^&*()_");
1147         FileInfo fileInfo;
1148         int result = fileAccessHelper->GetFileInfoFromUri(uri, fileInfo);
1149         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1150 
1151         uri = Uri("");
1152         result = fileAccessHelper->GetFileInfoFromUri(uri, fileInfo);
1153         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1154 
1155         uri = Uri("/");
1156         result = fileAccessHelper->GetFileInfoFromUri(uri, fileInfo);
1157         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1158 
1159     } catch (...) {
1160         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0005 occurs an exception.";
1161     }
1162     GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0005";
1163 }
1164 
1165 /**
1166  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0000
1167  * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0000
1168  * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
1169  * @tc.desc: convert the general directory relativePath to fileinfo for SUCCESS.
1170  * @tc.size: MEDIUM
1171  * @tc.type: FUNC
1172  * @tc.level Level 1
1173  * @tc.require: SR000HRLBS
1174  */
1175 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0000, testing::ext::TestSize.Level1)
1176 {
1177     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1178     EXPECT_NE(fileAccessHelper, nullptr);
1179     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0000";
1180     try {
1181         FileInfo fileInfo;
1182         string relativePath = "";
1183         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1184         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1185 
1186         relativePath = "Audios/";
1187         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1188         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1189 
1190         relativePath = "Camera/";
1191         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1192         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1193 
1194         relativePath = "Documents/";
1195         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1196         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1197 
1198         relativePath = "Download";
1199         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1200         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1201 
1202         relativePath = "Pictures";
1203         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1204         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1205 
1206         relativePath = "Videos";
1207         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1208         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1209     } catch (...) {
1210         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0000 occurs an exception.";
1211     }
1212     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0000";
1213 }
1214 
1215 /**
1216  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0001
1217  * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0001
1218  * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
1219  * @tc.desc: convert the general directory relativePath to fileinfo for failed.
1220  * @tc.size: MEDIUM
1221  * @tc.type: FUNC
1222  * @tc.level Level 1
1223  * @tc.require: SR000HRLBS
1224  */
1225 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0001, testing::ext::TestSize.Level1)
1226 {
1227     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1228     EXPECT_NE(fileAccessHelper, nullptr);
1229     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0001";
1230     try {
1231         FileInfo fileInfo;
1232         string relativePath = "test/";
1233         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1234         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1235 
1236         relativePath = "/";
1237         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1238         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1239 
1240         relativePath = "~!@#$%^&*()_";
1241         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1242         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1243 
1244         relativePath = "/d";
1245         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1246         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1247     } catch (...) {
1248         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0001 occurs an exception.";
1249     }
1250     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0001";
1251 }
1252 
1253 /**
1254  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0002
1255  * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0002
1256  * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
1257  * @tc.desc: convert the general directory relativePath to fileinfo and call listfile for SUCCESS.
1258  * @tc.size: MEDIUM
1259  * @tc.type: FUNC
1260  * @tc.level Level 1
1261  * @tc.require: SR000HRLBS
1262  */
1263 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0002, testing::ext::TestSize.Level1)
1264 {
1265     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1266     EXPECT_NE(fileAccessHelper, nullptr);
1267     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0002";
1268     try {
1269         FileInfo fileInfo;
1270         string relativePath = "Download/";
1271         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1272         ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1273 
1274         Uri parentUri(fileInfo.uri);
1275         Uri newFile("");
1276         result = fileAccessHelper->CreateFile(parentUri, "GetFileInfoFromRelativePath_0002.jpg", newFile);
1277         ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1278 
1279         int64_t offset = 0;
1280         int64_t maxCount = 1000;
1281         FileFilter filter;
1282         std::vector<FileInfo> fileInfoVec;
1283         result = fileAccessHelper->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1284         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1285         EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1286 
1287         result = fileAccessHelper->Delete(newFile);
1288         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1289     } catch (...) {
1290         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0002 occurs an exception.";
1291     }
1292     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0002";
1293 }
1294 
1295 /**
1296  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0003
1297  * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0003
1298  * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
1299  * @tc.desc: convert the relative file path to fileinfo and call listfile for failed.
1300  * @tc.size: MEDIUM
1301  * @tc.type: FUNC
1302  * @tc.level Level 1
1303  * @tc.require: SR000HRLBS
1304  */
1305 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0003, testing::ext::TestSize.Level1)
1306 {
1307     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1308     EXPECT_NE(fileAccessHelper, nullptr);
1309     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0003";
1310     try {
1311         FileInfo fileInfo;
1312         string relativePath = "Download/";
1313         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1314         ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1315 
1316         Uri parentUri(fileInfo.uri);
1317         Uri newFile("");
1318         result = fileAccessHelper->CreateFile(parentUri, "GetFileInfoFromRelativePath_0003.jpg", newFile);
1319         ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1320 
1321         relativePath = "Download/GetFileInfoFromRelativePath_0003.jpg";
1322         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1323         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1324 
1325         int64_t offset = 0;
1326         int64_t maxCount = 1000;
1327         FileFilter filter;
1328         std::vector<FileInfo> fileInfoVec;
1329         result = fileAccessHelper->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1330         EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1331 
1332         result = fileAccessHelper->Delete(newFile);
1333         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1334     } catch (...) {
1335         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0003 occurs an exception.";
1336     }
1337     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0003";
1338 }
1339 
1340 /**
1341  * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0004
1342  * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0004
1343  * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
1344  * @tc.desc: convert the relative directory path to fileinfo and call listfile for SUCCESS.
1345  * @tc.size: MEDIUM
1346  * @tc.type: FUNC
1347  * @tc.level Level 1
1348  * @tc.require: SR000HRLBS
1349  */
1350 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0004, testing::ext::TestSize.Level1)
1351 {
1352     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1353     EXPECT_NE(fileAccessHelper, nullptr);
1354     GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0004";
1355     try {
1356         FileInfo fileInfo;
1357         string relativePath = "Download/";
1358         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1359         ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1360 
1361         Uri parentUri(fileInfo.uri);
1362         Uri newDir("");
1363         result = fileAccessHelper->Mkdir(parentUri, "DirGetFileInfoFromRelativePath_0004", newDir);
1364         ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1365 
1366         Uri fileUri("");
1367         result = fileAccessHelper->CreateFile(newDir, "file1.jpg", fileUri);
1368         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1369 
1370         result = fileAccessHelper->CreateFile(newDir, "file2.jpg", fileUri);
1371         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1372 
1373         relativePath = "Download/DirGetFileInfoFromRelativePath_0004";
1374         result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1375         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1376 
1377         int64_t offset = 0;
1378         int64_t maxCount = 1000;
1379         FileFilter filter;
1380         std::vector<FileInfo> fileInfoVec;
1381         result = fileAccessHelper->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
1382         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1383         EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
1384 
1385         result = fileAccessHelper->Delete(newDir);
1386         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1387     } catch (...) {
1388         GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0004 occurs an exception.";
1389     }
1390     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0004";
1391 }
1392 
1393 /**
1394  * @tc.number: user_file_service_medialibrary_file_access_Query_0000
1395  * @tc.name: medialibrary_file_access_Query_0000
1396  * @tc.desc: Test function of Query directory for SUCCESS.
1397  * @tc.size: MEDIUM
1398  * @tc.type: FUNC
1399  * @tc.level Level 1
1400  * @tc.require: I6S4VV
1401  */
1402 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0000, testing::ext::TestSize.Level1)
1403 {
1404     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1405     EXPECT_NE(fileAccessHelper, nullptr);
1406     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0000";
1407     try {
1408         FileAccessFwk::FileInfo fileInfo;
1409         std::string relativePath = "Documents/";
1410         std::string displayName = "Documents";
1411         int targetSize = 46;
1412         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1413         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1414         Uri dirUriTest(fileInfo.uri);
1415 
1416         json testJson = {
1417             {RELATIVE_PATH, " "},
1418             {DISPLAY_NAME, " "},
1419             {FILE_SIZE, " "},
1420             {DATE_MODIFIED, " "},
1421             {DATE_ADDED, " "}
1422         };
1423         auto testJsonString = testJson.dump();
1424         int ret = fileAccessHelper->Query(dirUriTest, testJsonString);
1425         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1426         auto jsonObject = json::parse(testJsonString);
1427         EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
1428         EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize);
1429         ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
1430         ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
1431         GTEST_LOG_(INFO) << testJsonString;
1432     } catch (...) {
1433         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0000 occurs an exception.";
1434     }
1435     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0000";
1436 }
1437 
1438 /**
1439  * @tc.number: user_file_service_medialibrary_file_access_Query_0001
1440  * @tc.name: medialibrary_file_access_Query_0001
1441  * @tc.desc: Test function of Query file for SUCCESS.
1442  * @tc.size: MEDIUM
1443  * @tc.type: FUNC
1444  * @tc.level Level 1
1445  * @tc.require: I6S4VV
1446  */
1447 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0001, testing::ext::TestSize.Level1)
1448 {
1449     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1450     EXPECT_NE(fileAccessHelper, nullptr);
1451     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0001";
1452     try {
1453         FileAccessFwk::FileInfo fileInfo;
1454         std::string relativePath = "Documents/Test/";
1455         std::string displayName = "CreateQueryTest_002.txt";
1456         int targetSize = 23;
1457         std::string filePath = "Documents/Test/CreateQueryTest_002.txt";
1458         int ret = fileAccessHelper->GetFileInfoFromRelativePath(filePath, fileInfo);
1459         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1460         Uri testUri(fileInfo.uri);
1461 
1462         json testJson = {
1463             {RELATIVE_PATH, " "},
1464             {DISPLAY_NAME, " "},
1465             {FILE_SIZE, " "},
1466             {DATE_MODIFIED, " "},
1467             {DATE_ADDED, " "}
1468         };
1469         auto testJsonString = testJson.dump();
1470         ret = fileAccessHelper->Query(testUri, testJsonString);
1471         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1472         GTEST_LOG_(INFO) << testJsonString;
1473         auto jsonObject = json::parse(testJsonString);
1474         EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath);
1475         EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
1476         EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize);
1477         ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
1478         ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
1479     } catch (...) {
1480         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0001 occurs an exception.";
1481     }
1482     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0001";
1483 }
1484 
1485 /**
1486  * @tc.number: user_file_service_medialibrary_file_access_Query_0002
1487  * @tc.name: medialibrary_file_access_Query_0002
1488  * @tc.desc: Test function of Query directory size for SUCCESS.
1489  * @tc.size: MEDIUM
1490  * @tc.type: FUNC
1491  * @tc.level Level 1
1492  * @tc.require:
1493  */
1494 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0002, testing::ext::TestSize.Level1)
1495 {
1496     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1497     EXPECT_NE(fileAccessHelper, nullptr);
1498     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0002";
1499     try {
1500         FileAccessFwk::FileInfo fileInfo;
1501         std::string relativePath = "Documents/";
1502         std::string displayName = "Documents";
1503         int targetSize = 46;
1504         int result = fileAccessHelper->GetFileInfoFromRelativePath(relativePath, fileInfo);
1505         EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1506         Uri dirUriTest(fileInfo.uri);
1507 
1508         json testJson = {
1509             {FILE_SIZE, " "}
1510         };
1511         auto testJsonString = testJson.dump();
1512         int ret = fileAccessHelper->Query(dirUriTest, testJsonString);
1513         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1514         auto jsonObject = json::parse(testJsonString);
1515         EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize);
1516         GTEST_LOG_(INFO) << testJsonString;
1517     } catch (...) {
1518         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0002 occurs an exception.";
1519     }
1520     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0002";
1521 }
1522 
1523 /**
1524  * @tc.number: user_file_service_medialibrary_file_access_Query_0003
1525  * @tc.name: medialibrary_file_access_Query_0003
1526  * @tc.desc: Test function of Query interface for ERROR which Uri is unreadable code.
1527  * @tc.size: MEDIUM
1528  * @tc.type: FUNC
1529  * @tc.level Level 1
1530  * @tc.require: I6S4VV
1531  */
1532 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0003, testing::ext::TestSize.Level1)
1533 {
1534     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1535     EXPECT_NE(fileAccessHelper, nullptr);
1536     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0003";
1537     try {
1538         Uri testUri("&*()*/?");
1539         json testJson = {
1540             {RELATIVE_PATH, " "},
1541             {DISPLAY_NAME, " "}
1542         };
1543         auto testJsonString = testJson.dump();
1544         int ret = fileAccessHelper->Query(testUri, testJsonString);
1545         EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
1546     } catch (...) {
1547         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception.";
1548     }
1549     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0003";
1550 }
1551 
1552 /**
1553  * @tc.number: user_file_service_medialibrary_file_access_Query_0004
1554  * @tc.name: medialibrary_file_access_Query_0004
1555  * @tc.desc: Test function of Query interface for which all column nonexistence.
1556  * @tc.size: MEDIUM
1557  * @tc.type: FUNC
1558  * @tc.level Level 1
1559  * @tc.require: I6S4VV
1560  */
1561 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0004, testing::ext::TestSize.Level1)
1562 {
1563     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1564     EXPECT_NE(fileAccessHelper, nullptr);
1565     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0004";
1566     try {
1567         Uri newDirUriTest("");
1568         std::string fileName = "test.txt";
1569         int ret = fileAccessHelper->Mkdir(g_newDirUri, "Query004", newDirUriTest);
1570         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1571         Uri testUri("");
1572         ret = fileAccessHelper->CreateFile(newDirUriTest, fileName, testUri);
1573         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1574         json testJson = {
1575             {"001", " "},
1576             {"#", " "},
1577             {"test", " "},
1578             {"target", " "}
1579         };
1580         auto testJsonString = testJson.dump();
1581         ret = fileAccessHelper->Query(testUri, testJsonString);
1582         EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
1583         ret = fileAccessHelper->Delete(newDirUriTest);
1584         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1585     } catch (...) {
1586         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception.";
1587     }
1588     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0004";
1589 }
1590 
1591 /**
1592  * @tc.number: user_file_service_medialibrary_file_access_Query_0005
1593  * @tc.name: medialibrary_file_access_Query_0005
1594  * @tc.desc: Test function of Query interface for which part of column nonexistence.
1595  * @tc.size: MEDIUM
1596  * @tc.type: FUNC
1597  * @tc.level Level 1
1598  * @tc.require: I6S4VV
1599  */
1600 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0005, testing::ext::TestSize.Level1)
1601 {
1602     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1603     EXPECT_NE(fileAccessHelper, nullptr);
1604     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0005";
1605     try {
1606         Uri newDirUriTest("");
1607         std::string fileName = "test.txt";
1608         int ret = fileAccessHelper->Mkdir(g_newDirUri, "Query005", newDirUriTest);
1609         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1610         Uri testUri("");
1611         ret = fileAccessHelper->CreateFile(newDirUriTest, fileName, testUri);
1612         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1613         json testJson = {
1614             {RELATIVE_PATH, " "},
1615             {DISPLAY_NAME, " "},
1616             {"test", " "}
1617         };
1618         auto testJsonString = testJson.dump();
1619         ret = fileAccessHelper->Query(testUri, testJsonString);
1620         EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
1621         ret = fileAccessHelper->Delete(newDirUriTest);
1622         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1623     } catch (...) {
1624         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0005 occurs an exception.";
1625     }
1626     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0005";
1627 }
1628 
1629 /**
1630  * @tc.number: user_file_service_medialibrary_file_access_Query_0006
1631  * @tc.name: medialibrary_file_access_Query_0006
1632  * @tc.desc: Test function of Query interface for which column is null.
1633  * @tc.size: MEDIUM
1634  * @tc.type: FUNC
1635  * @tc.level Level 1
1636  * @tc.require: I6S4VV
1637  */
1638 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0006, testing::ext::TestSize.Level1)
1639 {
1640     shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1641     EXPECT_NE(fileAccessHelper, nullptr);
1642     GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0006";
1643     try {
1644         Uri newDirUriTest("");
1645         std::string fileName = "test.txt";
1646         std::string relativePath = "test/test.txt";
1647         int ret = fileAccessHelper->Mkdir(g_newDirUri, "Query006", newDirUriTest);
1648         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1649         Uri testUri("");
1650         ret = fileAccessHelper->CreateFile(newDirUriTest, fileName, testUri);
1651         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1652         json testJson;
1653         auto testJsonString = testJson.dump();
1654         ret = fileAccessHelper->Query(testUri, testJsonString);
1655         EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
1656         ret = fileAccessHelper->Delete(newDirUriTest);
1657         EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1658     } catch (...) {
1659         GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0006 occurs an exception.";
1660     }
1661     GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0006";
1662 }
1663 } // namespace
1664