1 /*
2 * Copyright (c) 2022 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 "accesstoken_kit.h"
24 #include "file_access_extension_info.h"
25 #include "file_access_framework_errno.h"
26 #include "file_access_helper.h"
27 #include "iservice_registry.h"
28 #include "image_source.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31
32 namespace {
33 using namespace std;
34 using namespace OHOS;
35 using namespace FileAccessFwk;
36 using namespace OHOS::Media;
37 using json = nlohmann::json;
38 const int ABILITY_ID = 5003;
39 const int INIT_THREADS_NUMBER = 4;
40 const int ACTUAL_SUCCESS_THREADS_NUMBER = 1;
41 int g_num = 0;
42 shared_ptr<FileAccessHelper> g_fah = nullptr;
43 Uri g_newDirUri("");
44 const int UID_TRANSFORM_TMP = 20000000;
45 const int UID_DEFAULT = 0;
46
SetNativeToken()47 void SetNativeToken()
48 {
49 uint64_t tokenId;
50 const char **perms = new const char *[1];
51 perms[0] = "ohos.permission.FILE_ACCESS_MANAGER";
52 NativeTokenInfoParams infoInstance = {
53 .dcapsNum = 0,
54 .permsNum = 1,
55 .aclsNum = 0,
56 .dcaps = nullptr,
57 .perms = perms,
58 .acls = nullptr,
59 .aplStr = "system_core",
60 };
61
62 infoInstance.processName = "SetUpTestCase";
63 tokenId = GetAccessTokenId(&infoInstance);
64 const uint64_t systemAppMask = (static_cast<uint64_t>(1) << 32);
65 tokenId |= systemAppMask;
66 SetSelfTokenID(tokenId);
67 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
68 delete[] perms;
69 }
70
71 class FileAccessHelperTest : public testing::Test {
72 public:
SetUpTestCase(void)73 static void SetUpTestCase(void)
74 {
75 cout << "FileAccessHelperTest code test" << endl;
76 SetNativeToken();
77 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
78 auto remoteObj = saManager->GetSystemAbility(ABILITY_ID);
79 AAFwk::Want want;
80 vector<AAFwk::Want> wantVec;
81 setuid(UID_TRANSFORM_TMP);
82 int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec);
83 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
84 bool sus = false;
85 for (size_t i = 0; i < wantVec.size(); i++) {
86 auto element = wantVec[i].GetElement();
87 if (element.GetBundleName() == "com.ohos.medialibrary.medialibrarydata" &&
88 element.GetAbilityName() == "FileExtensionAbility") {
89 want = wantVec[i];
90 sus = true;
91 break;
92 }
93 }
94 EXPECT_TRUE(sus);
95 vector<AAFwk::Want> wants{want};
96 g_fah = FileAccessHelper::Creator(remoteObj, wants);
97 if (g_fah == nullptr) {
98 GTEST_LOG_(ERROR) << "medialibrary_file_access_test g_fah is nullptr";
99 exit(1);
100 }
101 setuid(UID_DEFAULT);
102 }
TearDownTestCase()103 static void TearDownTestCase()
104 {
105 g_fah->Release();
106 g_fah = nullptr;
107 };
SetUp()108 void SetUp(){};
TearDown()109 void TearDown(){};
110 };
111
GetParentUri()112 static Uri GetParentUri()
113 {
114 vector<RootInfo> info;
115 int result = g_fah->GetRoots(info);
116 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
117 Uri parentUri("");
118 if (info.size() > OHOS::FileAccessFwk::ERR_OK) {
119 parentUri = Uri(info[0].uri + "/file");
120 GTEST_LOG_(ERROR) << parentUri.ToString();
121 }
122 return parentUri;
123 }
124
125 /**
126 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0000
127 * @tc.name: medialibrary_file_access_OpenFile_0000
128 * @tc.desc: Test function of OpenFile interface for SUCCESS.
129 * @tc.size: MEDIUM
130 * @tc.type: FUNC
131 * @tc.level Level 1
132 * @tc.require: SR000H0386
133 */
134 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0000, testing::ext::TestSize.Level1)
135 {
136 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0000";
137 try {
138 Uri parentUri = GetParentUri();
139 bool isExist = false;
140 int result = g_fah->Access(g_newDirUri, isExist);
141 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
142 if (!isExist) {
143 result = g_fah->Mkdir(parentUri, "Download", g_newDirUri);
144 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
145 }
146 Uri newDirUriTest("file://media/root/file");
147 FileInfo fileInfo;
148 fileInfo.uri = newDirUriTest.ToString();
149 int64_t offset = 0;
150 int64_t maxCount = 1000;
151 std::vector<FileInfo> fileInfoVec;
152 FileFilter filter;
153 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
154 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
155 EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
156 for (size_t i = 0; i < fileInfoVec.size(); i++) {
157 if (fileInfoVec[i].fileName.compare("Download") == 0) {
158 g_newDirUri = Uri(fileInfoVec[i].uri);
159 break;
160 }
161 }
162 result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest);
163 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
164 Uri newFileUri("");
165 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_OpenFile_0000.txt", newFileUri);
166 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
167 int fd;
168 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
169 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
170 GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result;
171 close(fd);
172 result = g_fah->Delete(newDirUriTest);
173 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
174 } catch (...) {
175 GTEST_LOG_(ERROR) << "medialibrary_file_accsess_OpenFile_0000 occurs an exception.";
176 }
177 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0000";
178 }
179
180 /**
181 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0001
182 * @tc.name: medialibrary_file_access_OpenFile_0001
183 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null.
184 * @tc.size: MEDIUM
185 * @tc.type: FUNC
186 * @tc.level Level 1
187 * @tc.require: SR000H0386
188 */
189 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0001, testing::ext::TestSize.Level1)
190 {
191 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0001";
192 try {
193 Uri uri("");
194 int fd;
195 int result = g_fah->OpenFile(uri, WRITE_READ, fd);
196 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
197 GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result;
198 } catch (...) {
199 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0001 occurs an exception.";
200 }
201 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0001";
202 }
203
204 /**
205 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0002
206 * @tc.name: medialibrary_file_access_OpenFile_0002
207 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path.
208 * @tc.size: MEDIUM
209 * @tc.type: FUNC
210 * @tc.level Level 1
211 * @tc.require: SR000H0386
212 */
213 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0002, testing::ext::TestSize.Level1)
214 {
215 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0002";
216 try {
217 Uri uri("storage/media/100/local/files/Download/medialibrary_file_access_OpenFile_0002.txt");
218 int fd;
219 int result = g_fah->OpenFile(uri, WRITE_READ, fd);
220 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
221 GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result;
222 } catch (...) {
223 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0002 occurs an exception.";
224 }
225 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0002";
226 }
227
228 /**
229 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0003
230 * @tc.name: medialibrary_file_access_OpenFile_0003
231 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols.
232 * @tc.size: MEDIUM
233 * @tc.type: FUNC
234 * @tc.level Level 1
235 * @tc.require: SR000H0386
236 */
237 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0003, testing::ext::TestSize.Level1)
238 {
239 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0003";
240 try {
241 Uri uri("~!@#$%^&*()_");
242 int fd;
243 int result = g_fah->OpenFile(uri, WRITE_READ, fd);
244 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
245 GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result;
246 } catch (...) {
247 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0003 occurs an exception.";
248 }
249 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0003";
250 }
251
252 /**
253 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0004
254 * @tc.name: medialibrary_file_access_OpenFile_0004
255 * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1.
256 * @tc.size: MEDIUM
257 * @tc.type: FUNC
258 * @tc.level Level 1
259 * @tc.require: SR000H0386
260 */
261 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0004, testing::ext::TestSize.Level1)
262 {
263 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0004";
264 try {
265 Uri newFileUri("");
266 int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0004.txt", newFileUri);
267 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
268 int fd;
269 int flag = -1;
270 result = g_fah->OpenFile(newFileUri, flag, fd);
271 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
272 GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result;
273 result = g_fah->Delete(newFileUri);
274 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
275 } catch (...) {
276 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0004 occurs an exception.";
277 }
278 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0004";
279 }
280
281 /**
282 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0005
283 * @tc.name: medialibrary_file_access_OpenFile_0005
284 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0.
285 * @tc.size: MEDIUM
286 * @tc.type: FUNC
287 * @tc.level Level 1
288 * @tc.require: SR000H0386
289 */
290 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0005, testing::ext::TestSize.Level1)
291 {
292 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0005";
293 try {
294 Uri newFileUri("");
295 int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0005.txt", newFileUri);
296 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
297 int fd;
298 result = g_fah->OpenFile(newFileUri, READ, fd);
299 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
300 GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result;
301 close(fd);
302 result = g_fah->Delete(newFileUri);
303 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
304 } catch (...) {
305 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0005 occurs an exception.";
306 }
307 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0005";
308 }
309
310 /**
311 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0006
312 * @tc.name: medialibrary_file_access_OpenFile_0006
313 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1.
314 * @tc.size: MEDIUM
315 * @tc.type: FUNC
316 * @tc.level Level 1
317 * @tc.require: SR000H0386
318 */
319 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0006, testing::ext::TestSize.Level1)
320 {
321 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0006";
322 try {
323 Uri newFileUri("");
324 int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0006.txt", newFileUri);
325 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
326 int fd;
327 result = g_fah->OpenFile(newFileUri, WRITE, fd);
328 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
329 GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result;
330 close(fd);
331 result = g_fah->Delete(newFileUri);
332 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
333 } catch (...) {
334 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0006 occurs an exception.";
335 }
336 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0006";
337 }
338
339 /**
340 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0007
341 * @tc.name: medialibrary_file_access_OpenFile_0007
342 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2.
343 * @tc.size: MEDIUM
344 * @tc.type: FUNC
345 * @tc.level Level 1
346 * @tc.require: SR000H0386
347 */
348 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0007, testing::ext::TestSize.Level1)
349 {
350 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0007";
351 try {
352 Uri newFileUri("");
353 int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0007.txt", newFileUri);
354 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
355 int fd;
356 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
357 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
358 GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result;
359 close(fd);
360 result = g_fah->Delete(newFileUri);
361 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
362 } catch (...) {
363 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0007 occurs an exception.";
364 }
365 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0007";
366 }
367
OpenFileTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,int flag,int fd)368 static void OpenFileTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, int flag, int fd)
369 {
370 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFileTdd";
371 int ret = fahs->OpenFile(uri, flag, fd);
372 if (ret != OHOS::FileAccessFwk::ERR_OK) {
373 GTEST_LOG_(ERROR) << "OpenFileTdd get result error, code:" << ret;
374 return;
375 }
376 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
377 EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK);
378 g_num++;
379 close(fd);
380 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFileTdd";
381 }
382
383 /**
384 * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0008
385 * @tc.name: medialibrary_file_access_OpenFile_0008
386 * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent.
387 * @tc.size: MEDIUM
388 * @tc.type: FUNC
389 * @tc.level Level 1
390 * @tc.require: SR000H0386
391 */
392 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0008, testing::ext::TestSize.Level1)
393 {
394 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0008";
395 try {
396 Uri newFileUri("");
397 int fd;
398 g_num = 0;
399 std::string displayName = "test1.txt";
400 int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri);
401 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
402 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
403 std::thread execthread(OpenFileTdd, g_fah, newFileUri, WRITE_READ, fd);
404 execthread.join();
405 }
406 EXPECT_EQ(g_num, INIT_THREADS_NUMBER);
407 result = g_fah->Delete(newFileUri);
408 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
409 } catch (...) {
410 GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0008 occurs an exception.";
411 }
412 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0008";
413 }
414
415 /**
416 * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0000
417 * @tc.name: medialibrary_file_access_CreateFile_0000
418 * @tc.desc: Test function of CreateFile interface for SUCCESS.
419 * @tc.size: MEDIUM
420 * @tc.type: FUNC
421 * @tc.level Level 1
422 * @tc.require: SR000H0386
423 */
424 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0000, testing::ext::TestSize.Level1)
425 {
426 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0000";
427 try {
428 Uri newFileUri("");
429 int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_CreateFile_0000.txt", newFileUri);
430 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
431 GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result;
432 result = g_fah->Delete(newFileUri);
433 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
434 } catch (...) {
435 GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0000 occurs an exception.";
436 }
437 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0000";
438 }
439
440 /**
441 * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0001
442 * @tc.name: medialibrary_file_access_CreateFile_0001
443 * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null.
444 * @tc.size: MEDIUM
445 * @tc.type: FUNC
446 * @tc.level Level 1
447 * @tc.require: SR000H0386
448 */
449 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0001, testing::ext::TestSize.Level1)
450 {
451 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0001";
452 try {
453 Uri newFileUri("");
454 Uri parentUri("");
455 int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0001.txt", newFileUri);
456 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
457 GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result;
458 } catch (...) {
459 GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0001 occurs an exception.";
460 }
461 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0001";
462 }
463
464 /**
465 * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0002
466 * @tc.name: medialibrary_file_access_CreateFile_0002
467 * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path.
468 * @tc.size: MEDIUM
469 * @tc.type: FUNC
470 * @tc.level Level 1
471 * @tc.require: SR000H0386
472 */
473 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0002, testing::ext::TestSize.Level1)
474 {
475 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002";
476 try {
477 Uri newFileUri("");
478 Uri parentUri("storage/media/100/local/files/Download");
479 int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0002.txt", newFileUri);
480 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
481 GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result;
482 } catch (...) {
483 GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0002 occurs an exception.";
484 }
485 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0002";
486 }
487
488 /**
489 * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0003
490 * @tc.name: medialibrary_file_access_CreateFile_0003
491 * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols.
492 * @tc.size: MEDIUM
493 * @tc.type: FUNC
494 * @tc.level Level 1
495 * @tc.require: SR000H0386
496 */
497 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0003, testing::ext::TestSize.Level1)
498 {
499 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002";
500 try {
501 Uri newFileUri("");
502 Uri parentUri("~!@#$%^&*()_");
503 int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0003.txt", newFileUri);
504 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
505 GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result;
506 } catch (...) {
507 GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0003 occurs an exception.";
508 }
509 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0003";
510 }
511
512 /**
513 * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0004
514 * @tc.name: medialibrary_file_access_CreateFile_0004
515 * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null.
516 * @tc.size: MEDIUM
517 * @tc.type: FUNC
518 * @tc.level Level 1
519 * @tc.require: SR000H0386
520 */
521 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0004, testing::ext::TestSize.Level1)
522 {
523 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0004";
524 try {
525 Uri newFileUri("");
526 string displayName = "";
527 int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri);
528 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
529 GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result;
530 } catch (...) {
531 GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0004 occurs an exception.";
532 }
533 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0004";
534 }
535
CreateFileTdd(shared_ptr<FileAccessHelper> fahs,Uri parent,std::string displayName,Uri newDir)536 static void CreateFileTdd(shared_ptr<FileAccessHelper> fahs, Uri parent, std::string displayName, Uri newDir)
537 {
538 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFileTdd";
539 int ret = fahs->CreateFile(parent, displayName, newDir);
540 if (ret != OHOS::FileAccessFwk::ERR_OK) {
541 GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret;
542 return;
543 }
544 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
545 EXPECT_NE(newDir.ToString(), "");
546 g_num++;
547 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFileTdd";
548 }
549
550 /**
551 * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0005
552 * @tc.name: medialibrary_file_access_CreateFile_0005
553 * @tc.desc: Test function of CreateFile interface for SUCCESS while Concurrent.
554 * @tc.size: MEDIUM
555 * @tc.type: FUNC
556 * @tc.level Level 1
557 * @tc.require: SR000H0386
558 */
559 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0005, testing::ext::TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0005";
562 try {
563 Uri newFileUri1("");
564 Uri newFileUri2("");
565 Uri newFileUri3("");
566 std::string displayName1 = "test1";
567 std::string displayName2 = "test2";
568 std::string displayName3 = "test3.txt";
569 int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1);
570 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
571 result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2);
572 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
573 g_num = 0;
574 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
575 std::thread execthread(CreateFileTdd, g_fah, newFileUri2, displayName3, newFileUri3);
576 execthread.join();
577 }
578 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
579 GTEST_LOG_(INFO) << "g_newDirUri.ToString() =" << g_newDirUri.ToString();
580 result = g_fah->Delete(newFileUri1);
581 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
582 } catch (...) {
583 GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0005 occurs an exception.";
584 }
585 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0005";
586 }
587
588 /**
589 * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0000
590 * @tc.name: medialibrary_file_access_Mkdir_0000
591 * @tc.desc: Test function of Mkdir interface for SUCCESS.
592 * @tc.size: MEDIUM
593 * @tc.type: FUNC
594 * @tc.level Level 1
595 * @tc.require: SR000H0386
596 */
597 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0000, testing::ext::TestSize.Level1)
598 {
599 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0000";
600 try {
601 Uri newDirUriTest("");
602 int result = g_fah->Mkdir(g_newDirUri, "medialibrary_file_access_Mkdir_0000", newDirUriTest);
603 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
604 GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result;
605 result = g_fah->Delete(newDirUriTest);
606 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
607 } catch (...) {
608 GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0000 occurs an exception.";
609 }
610 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0000";
611 }
612
613 /**
614 * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0001
615 * @tc.name: medialibrary_file_access_Mkdir_0001
616 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null.
617 * @tc.size: MEDIUM
618 * @tc.type: FUNC
619 * @tc.level Level 1
620 * @tc.require: SR000H0386
621 */
622 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0001, testing::ext::TestSize.Level1)
623 {
624 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0001";
625 try {
626 Uri newDirUriTest("");
627 Uri parentUri("");
628 int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0001", newDirUriTest);
629 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
630 GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result;
631 } catch (...) {
632 GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0001 occurs an exception.";
633 }
634 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0001";
635 }
636
637 /**
638 * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0002
639 * @tc.name: medialibrary_file_access_Mkdir_0002
640 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path.
641 * @tc.size: MEDIUM
642 * @tc.type: FUNC
643 * @tc.level Level 1
644 * @tc.require: SR000H0386
645 */
646 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0002, testing::ext::TestSize.Level1)
647 {
648 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002";
649 try {
650 Uri newDirUriTest("");
651 Uri parentUri("storage/media/100/local/files/Download");
652 int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0002", newDirUriTest);
653 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
654 GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result;
655 } catch (...) {
656 GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0002 occurs an exception.";
657 }
658 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0002";
659 }
660
661 /**
662 * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0003
663 * @tc.name: medialibrary_file_access_Mkdir_0003
664 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols.
665 * @tc.size: MEDIUM
666 * @tc.type: FUNC
667 * @tc.level Level 1
668 * @tc.require: SR000H0386
669 */
670 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0003, testing::ext::TestSize.Level1)
671 {
672 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002";
673 try {
674 Uri newDirUriTest("");
675 Uri parentUri("~!@#$%^&*()_");
676 int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0003", newDirUriTest);
677 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
678 GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result;
679 } catch (...) {
680 GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0003 occurs an exception.";
681 }
682 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0003";
683 }
684
685 /**
686 * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0004
687 * @tc.name: medialibrary_file_access_Mkdir_0004
688 * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null.
689 * @tc.size: MEDIUM
690 * @tc.type: FUNC
691 * @tc.level Level 1
692 * @tc.require: SR000H0386
693 */
694 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0004, testing::ext::TestSize.Level1)
695 {
696 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0004";
697 try {
698 Uri newDirUriTest("");
699 string displayName = "";
700 int result = g_fah->Mkdir(g_newDirUri, displayName, newDirUriTest);
701 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
702 GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result;
703 } catch (...) {
704 GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0004 occurs an exception.";
705 }
706 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0004";
707 }
708
MkdirTdd(shared_ptr<FileAccessHelper> fahs,Uri parent,std::string displayName,Uri newDir)709 static void MkdirTdd(shared_ptr<FileAccessHelper> fahs, Uri parent, std::string displayName, Uri newDir)
710 {
711 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MkdirTdd";
712 int ret = fahs->Mkdir(parent, displayName, newDir);
713 if (ret != OHOS::FileAccessFwk::ERR_OK) {
714 GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret;
715 return;
716 }
717 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
718 EXPECT_NE(newDir.ToString(), "");
719 g_num++;
720 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MkdirTdd";
721 }
722
723 /**
724 * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0005
725 * @tc.name: medialibrary_file_access_Mkdir_0005
726 * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent.
727 * @tc.size: MEDIUM
728 * @tc.type: FUNC
729 * @tc.level Level 1
730 * @tc.require: SR000H0386
731 */
732 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0005, testing::ext::TestSize.Level1)
733 {
734 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0005";
735 try {
736 Uri newFileUri1("");
737 Uri newFileUri2("");
738 Uri newFileUri3("");
739 std::string displayName1 = "test1";
740 std::string displayName2 = "test2";
741 std::string displayName3 = "test3";
742 int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1);
743 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
744 result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2);
745 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
746 g_num = 0;
747 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
748 std::thread execthread(MkdirTdd, g_fah, newFileUri2, displayName3, newFileUri3);
749 execthread.join();
750 }
751 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
752 result = g_fah->Delete(newFileUri1);
753 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
754 } catch (...) {
755 GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0005 occurs an exception.";
756 }
757 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0005";
758 }
759
760 /**
761 * @tc.number: user_file_service_medialibrary_file_access_Delete_0000
762 * @tc.name: medialibrary_file_access_Delete_0000
763 * @tc.desc: Test function of Delete interface for SUCCESS which delete file.
764 * @tc.size: MEDIUM
765 * @tc.type: FUNC
766 * @tc.level Level 1
767 * @tc.require: SR000H0386
768 */
769 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0000, testing::ext::TestSize.Level1)
770 {
771 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0000";
772 try {
773 Uri newDirUriTest("");
774 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
775 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
776 Uri newFileUri("");
777 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0000.txt", newFileUri);
778 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
779 result = g_fah->Delete(newFileUri);
780 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
781 GTEST_LOG_(INFO) << "Delete_0000 result:" << result;
782 result = g_fah->Delete(newDirUriTest);
783 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
784 } catch (...) {
785 GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0000 occurs an exception.";
786 }
787 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0000";
788 }
789
790 /**
791 * @tc.number: user_file_service_medialibrary_file_access_Delete_0001
792 * @tc.name: medialibrary_file_access_Delete_0001
793 * @tc.desc: Test function of Delete interface for SUCCESS which delete folder.
794 * @tc.size: MEDIUM
795 * @tc.type: FUNC
796 * @tc.level Level 1
797 * @tc.require: SR000H0386
798 */
799 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0001, testing::ext::TestSize.Level1)
800 {
801 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0001";
802 try {
803 Uri newDirUriTest("");
804 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
805 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
806 result = g_fah->Delete(newDirUriTest);
807 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
808 GTEST_LOG_(INFO) << "Delete_0001 result:" << result;
809 } catch (...) {
810 GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0001 occurs an exception.";
811 }
812 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0001";
813 }
814
815 /**
816 * @tc.number: user_file_service_medialibrary_file_access_Delete_0002
817 * @tc.name: medialibrary_file_access_Delete_0002
818 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null.
819 * @tc.size: MEDIUM
820 * @tc.type: FUNC
821 * @tc.level Level 1
822 * @tc.require: SR000H0386
823 */
824 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0002, testing::ext::TestSize.Level1)
825 {
826 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0002";
827 try {
828 Uri selectFileUri("");
829 int result = g_fah->Delete(selectFileUri);
830 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
831 GTEST_LOG_(INFO) << "Delete_0002 result:" << result;
832 } catch (...) {
833 GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0002 occurs an exception.";
834 }
835 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0002";
836 }
837
838 /**
839 * @tc.number: user_file_service_medialibrary_file_access_Delete_0003
840 * @tc.name: medialibrary_file_access_Delete_0003
841 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path.
842 * @tc.size: MEDIUM
843 * @tc.type: FUNC
844 * @tc.level Level 1
845 * @tc.require: SR000H0386
846 */
847 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0003, testing::ext::TestSize.Level1)
848 {
849 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0003";
850 try {
851 Uri newDirUriTest("");
852 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
853 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
854 Uri selectFileUri("storage/media/100/local/files/Download/test");
855 result = g_fah->Delete(selectFileUri);
856 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
857 result = g_fah->Delete(newDirUriTest);
858 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
859 GTEST_LOG_(INFO) << "Delete_0003 result:" << result;
860 } catch (...) {
861 GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0003 occurs an exception.";
862 }
863 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0003";
864 }
865
866 /**
867 * @tc.number: user_file_service_medialibrary_file_access_Delete_0004
868 * @tc.name: medialibrary_file_access_Delete_0004
869 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols.
870 * @tc.size: MEDIUM
871 * @tc.type: FUNC
872 * @tc.level Level 1
873 * @tc.require: SR000H0386
874 */
875 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0004, testing::ext::TestSize.Level1)
876 {
877 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0004";
878 try {
879 Uri selectFileUri("!@#$%^&*()");
880 int result = g_fah->Delete(selectFileUri);
881 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
882 GTEST_LOG_(INFO) << "Delete_0004 result:" << result;
883 } catch (...) {
884 GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0004 occurs an exception.";
885 }
886 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0004";
887 }
888
DeleteTdd(shared_ptr<FileAccessHelper> fahs,Uri selectFile)889 static void DeleteTdd(shared_ptr<FileAccessHelper> fahs, Uri selectFile)
890 {
891 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_DeleteTdd";
892 int ret = fahs->Delete(selectFile);
893 if (ret < OHOS::FileAccessFwk::ERR_OK) {
894 GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret;
895 return;
896 }
897 EXPECT_GE(ret, OHOS::FileAccessFwk::ERR_OK);
898 g_num++;
899 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_DeleteTdd";
900 }
901
902 /**
903 * @tc.number: user_file_service_medialibrary_file_access_Delete_0005
904 * @tc.name: medialibrary_file_access_Delete_0005
905 * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent.
906 * @tc.size: MEDIUM
907 * @tc.type: FUNC
908 * @tc.level Level 1
909 * @tc.require: SR000H0386
910 */
911 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0005, testing::ext::TestSize.Level1)
912 {
913 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0005";
914 try {
915 Uri newDirUriTest("");
916 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
917 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
918 Uri newFileUri("");
919 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0005.txt", newFileUri);
920 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
921 Uri testUri("");
922 std::string displayName = "test1.txt";
923 Uri testUri2("");
924 result = g_fah->CreateFile(newDirUriTest, displayName, testUri);
925 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
926 g_num = 0;
927 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
928 std::thread execthread(DeleteTdd, g_fah, testUri);
929 execthread.join();
930 }
931 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
932 result = g_fah->Delete(newDirUriTest);
933 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
934 } catch (...) {
935 GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0005 occurs an exception.";
936 }
937 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0005";
938 }
939
940 /**
941 * @tc.number: user_file_service_medialibrary_file_access_Move_0000
942 * @tc.name: medialibrary_file_access_Move_0000
943 * @tc.desc: Test function of Move interface for SUCCESS which move file.
944 * @tc.size: MEDIUM
945 * @tc.type: FUNC
946 * @tc.level Level 1
947 * @tc.require: SR000H0386
948 */
949 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0000, testing::ext::TestSize.Level1)
950 {
951 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0000";
952 try {
953 Uri newDirUriTest1("");
954 Uri newDirUriTest2("");
955 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
956 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
957 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
958 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
959 Uri testUri("");
960 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
961 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
962 Uri testUri2("");
963 result = g_fah->Move(testUri, newDirUriTest2, testUri2);
964 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
965 GTEST_LOG_(INFO) << "Move_0000 result:" << result;
966 result = g_fah->Delete(newDirUriTest1);
967 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
968 result = g_fah->Delete(newDirUriTest2);
969 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
970 } catch (...) {
971 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0000 occurs an exception.";
972 }
973 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0000";
974 }
975
976 /**
977 * @tc.number: user_file_service_medialibrary_file_access_Move_0001
978 * @tc.name: medialibrary_file_access_Move_0001
979 * @tc.desc: Test function of Move interface for SUCCESS which move folder.
980 * @tc.size: MEDIUM
981 * @tc.type: FUNC
982 * @tc.level Level 1
983 * @tc.require: SR000H0386
984 */
985 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0001, testing::ext::TestSize.Level1)
986 {
987 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0001";
988 try {
989 Uri newDirUriTest1("");
990 Uri newDirUriTest2("");
991 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
992 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
993 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
994 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
995 Uri testUri("");
996 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
997 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
998 Uri testUri2("");
999 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1000 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1001 GTEST_LOG_(INFO) << "Move_0001 result:" << result;
1002 result = g_fah->Delete(newDirUriTest1);
1003 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1004 result = g_fah->Delete(newDirUriTest2);
1005 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1006 } catch (...) {
1007 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0001 occurs an exception.";
1008 }
1009 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0001";
1010 }
1011
1012 /**
1013 * @tc.number: user_file_service_medialibrary_file_access_Move_0002
1014 * @tc.name: medialibrary_file_access_Move_0002
1015 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null.
1016 * @tc.size: MEDIUM
1017 * @tc.type: FUNC
1018 * @tc.level Level 1
1019 * @tc.require: SR000H0386
1020 */
1021 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0002, testing::ext::TestSize.Level1)
1022 {
1023 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0002";
1024 try {
1025 Uri newDirUriTest("");
1026 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1027 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1028 Uri testUri("");
1029 Uri sourceFileUri("");
1030 result = g_fah->Move(sourceFileUri, newDirUriTest, testUri);
1031 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1032 GTEST_LOG_(INFO) << "Move_0002 result:" << result;
1033 result = g_fah->Delete(newDirUriTest);
1034 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1035 } catch (...) {
1036 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0002 occurs an exception.";
1037 }
1038 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0002";
1039 }
1040
1041 /**
1042 * @tc.number: user_file_service_medialibrary_file_access_Move_0003
1043 * @tc.name: medialibrary_file_access_Move_0003
1044 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path.
1045 * @tc.size: MEDIUM
1046 * @tc.type: FUNC
1047 * @tc.level Level 1
1048 * @tc.require: SR000H0386
1049 */
1050 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0003, testing::ext::TestSize.Level1)
1051 {
1052 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0003";
1053 try {
1054 Uri newDirUriTest1("");
1055 Uri newDirUriTest2("");
1056 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1057 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1058 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1059 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1060 Uri testUri("");
1061 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1062 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1063 Uri testUri2("");
1064 Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt");
1065 result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2);
1066 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1067 GTEST_LOG_(INFO) << "Move_0003 result:" << result;
1068 result = g_fah->Delete(newDirUriTest1);
1069 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1070 result = g_fah->Delete(newDirUriTest2);
1071 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1072 } catch (...) {
1073 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0003 occurs an exception.";
1074 }
1075 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0003";
1076 }
1077
1078 /**
1079 * @tc.number: user_file_service_medialibrary_file_access_Move_0004
1080 * @tc.name: medialibrary_file_access_Move_0004
1081 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols.
1082 * @tc.size: MEDIUM
1083 * @tc.type: FUNC
1084 * @tc.level Level 1
1085 * @tc.require: SR000H0386
1086 */
1087 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0004, testing::ext::TestSize.Level1)
1088 {
1089 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0004";
1090 try {
1091 Uri newDirUriTest("");
1092 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1093 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1094 Uri testUri("");
1095 Uri sourceFileUri("~!@#$%^&*()_");
1096 result = g_fah->Move(sourceFileUri, newDirUriTest, testUri);
1097 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1098 GTEST_LOG_(INFO) << "Move_0004 result:" << result;
1099 result = g_fah->Delete(newDirUriTest);
1100 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1101 } catch (...) {
1102 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0004 occurs an exception.";
1103 }
1104 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0004";
1105 }
1106
1107 /**
1108 * @tc.number: user_file_service_medialibrary_file_access_Move_0005
1109 * @tc.name: medialibrary_file_access_Move_0005
1110 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null.
1111 * @tc.size: MEDIUM
1112 * @tc.type: FUNC
1113 * @tc.level Level 1
1114 * @tc.require: SR000H0386
1115 */
1116 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0005, testing::ext::TestSize.Level1)
1117 {
1118 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0005";
1119 try {
1120 Uri newDirUriTest("");
1121 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest);
1122 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1123 Uri testUri("");
1124 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
1125 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1126 Uri testUri2("");
1127 Uri targetParentUri("");
1128 result = g_fah->Move(testUri, targetParentUri, testUri2);
1129 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1130 GTEST_LOG_(INFO) << "Move_0005 result:" << result;
1131 result = g_fah->Delete(newDirUriTest);
1132 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1133 } catch (...) {
1134 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0005 occurs an exception.";
1135 }
1136 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0005";
1137 }
1138
1139 /**
1140 * @tc.number: user_file_service_medialibrary_file_access_Move_0006
1141 * @tc.name: medialibrary_file_access_Move_0006
1142 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path.
1143 * @tc.size: MEDIUM
1144 * @tc.type: FUNC
1145 * @tc.level Level 1
1146 * @tc.require: SR000H0386
1147 */
1148 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0006, testing::ext::TestSize.Level1)
1149 {
1150 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0006";
1151 try {
1152 Uri newDirUriTest1("");
1153 Uri newDirUriTest2("");
1154 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1155 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1156 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1157 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1158 Uri testUri("");
1159 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1160 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1161 Uri testUri2("");
1162 Uri targetParentUri("storage/media/100/local/files/Download/test2");
1163 result = g_fah->Move(testUri, targetParentUri, testUri2);
1164 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1165 GTEST_LOG_(INFO) << "Move_0006 result:" << result;
1166 result = g_fah->Delete(newDirUriTest1);
1167 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1168 result = g_fah->Delete(newDirUriTest2);
1169 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1170 } catch (...) {
1171 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0006 occurs an exception.";
1172 }
1173 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0006";
1174 }
1175
1176 /**
1177 * @tc.number: user_file_service_medialibrary_file_access_Move_0007
1178 * @tc.name: medialibrary_file_access_Move_0007
1179 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols.
1180 * @tc.size: MEDIUM
1181 * @tc.type: FUNC
1182 * @tc.level Level 1
1183 * @tc.require: SR000H0386
1184 */
1185 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0007, testing::ext::TestSize.Level1)
1186 {
1187 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0007";
1188 try {
1189 Uri newDirUriTest1("");
1190 Uri newDirUriTest2("");
1191 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1192 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1193 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1194 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1195 Uri testUri("");
1196 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1197 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1198 Uri testUri2("");
1199 Uri targetParentUri("~!@#$^%&*()_");
1200 result = g_fah->Move(testUri, targetParentUri, testUri2);
1201 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1202 GTEST_LOG_(INFO) << "Move_0007 result:" << result;
1203 result = g_fah->Delete(newDirUriTest1);
1204 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1205 result = g_fah->Delete(newDirUriTest2);
1206 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1207 } catch (...) {
1208 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0007 occurs an exception.";
1209 }
1210 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0007";
1211 }
1212
1213 /**
1214 * @tc.number: user_file_service_medialibrary_file_access_Move_0008
1215 * @tc.name: medialibrary_file_access_Move_0008
1216 * @tc.desc: Test function of Move interface for SUCCESS which move empty folder.
1217 * @tc.size: MEDIUM
1218 * @tc.type: FUNC
1219 * @tc.level Level 1
1220 * @tc.require: SR000H0386
1221 */
1222 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0008, testing::ext::TestSize.Level1)
1223 {
1224 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0008";
1225 try {
1226 Uri newDirUriTest1("");
1227 Uri newDirUriTest2("");
1228 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1229 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1230 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1231 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1232 Uri testUri2("");
1233 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1234 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1235 GTEST_LOG_(INFO) << "Move_0008 result:" << result;
1236 result = g_fah->Delete(newDirUriTest1);
1237 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1238 result = g_fah->Delete(newDirUriTest2);
1239 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1240 } catch (...) {
1241 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0008 occurs an exception.";
1242 }
1243 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0008";
1244 }
1245
1246 /**
1247 * @tc.number: user_file_service_medialibrary_file_access_Move_0009
1248 * @tc.name: medialibrary_file_access_Move_0009
1249 * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder.
1250 * @tc.size: MEDIUM
1251 * @tc.type: FUNC
1252 * @tc.level Level 1
1253 * @tc.require: SR000H0386
1254 */
1255 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0009, testing::ext::TestSize.Level1)
1256 {
1257 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0009";
1258 try {
1259 Uri newDirUriTest1("");
1260 Uri newDirUriTest2("");
1261 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1262 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1263 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1264 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1265 Uri testUri("");
1266 size_t fileNumbers = 2000;
1267 for (size_t i = 0; i < fileNumbers; i++) {
1268 string fileName = "test" + ToString(i) + ".txt";
1269 result = g_fah->CreateFile(newDirUriTest1, fileName, testUri);
1270 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1271 }
1272 Uri testUri2("");
1273 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1274 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1275 GTEST_LOG_(INFO) << "Move_0009 result:" << result;
1276 result = g_fah->Delete(newDirUriTest1);
1277 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1278 result = g_fah->Delete(newDirUriTest2);
1279 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1280 } catch (...) {
1281 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0009 occurs an exception.";
1282 }
1283 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0009";
1284 }
1285
1286 /**
1287 * @tc.number: user_file_service_medialibrary_file_access_Move_0010
1288 * @tc.name: medialibrary_file_access_Move_0010
1289 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder.
1290 * @tc.size: MEDIUM
1291 * @tc.type: FUNC
1292 * @tc.level Level 1
1293 * @tc.require: SR000H0386
1294 */
1295 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0010, testing::ext::TestSize.Level1)
1296 {
1297 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0010";
1298 try {
1299 Uri newDirUriTest1("");
1300 Uri newDirUriTest2("");
1301 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1302 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1303 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1304 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1305 Uri testUri("");
1306 result = g_fah->Mkdir(newDirUriTest1, "test", testUri);
1307 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1308 size_t directoryNumbers = 50;
1309 for (size_t i = 0; i < directoryNumbers; i++) {
1310 result = g_fah->Mkdir(testUri, "test", testUri);
1311 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1312 }
1313 Uri testUri2("");
1314 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1315 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1316 GTEST_LOG_(INFO) << "Move_0010 result:" << result;
1317 result = g_fah->Delete(newDirUriTest1);
1318 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1319 result = g_fah->Delete(newDirUriTest2);
1320 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1321 } catch (...) {
1322 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0010 occurs an exception.";
1323 }
1324 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0010";
1325 }
1326
MoveTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,Uri targetParent,Uri newFile)1327 static void MoveTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, Uri targetParent, Uri newFile)
1328 {
1329 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MoveTdd";
1330 int ret = fahs->Move(sourceFile, targetParent, newFile);
1331 if (ret != OHOS::FileAccessFwk::ERR_OK) {
1332 GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret;
1333 return;
1334 }
1335 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1336 EXPECT_NE(newFile.ToString(), "");
1337 g_num++;
1338 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MoveTdd";
1339 }
1340
1341 /**
1342 * @tc.number: user_file_service_medialibrary_file_access_Move_0011
1343 * @tc.name: medialibrary_file_access_Move_0011
1344 * @tc.desc: Test function of Move interface for SUCCESS which Concurrent.
1345 * @tc.size: MEDIUM
1346 * @tc.type: FUNC
1347 * @tc.level Level 1
1348 * @tc.require: SR000H0386
1349 */
1350 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0011, testing::ext::TestSize.Level1)
1351 {
1352 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0011";
1353 try {
1354 Uri newDirUriTest1("");
1355 Uri newDirUriTest2("");
1356 int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1);
1357 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1358 result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2);
1359 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1360 Uri testUri{""};
1361 Uri testUri2("");
1362 std::string displayName = "test1.txt";
1363 result = g_fah->CreateFile(newDirUriTest1, displayName, testUri);
1364 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1365 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
1366 std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2);
1367 execthread.join();
1368 }
1369 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
1370 result = g_fah->Delete(newDirUriTest1);
1371 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1372 result = g_fah->Delete(newDirUriTest2);
1373 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1374 } catch (...) {
1375 GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0011 occurs an exception.";
1376 }
1377 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0011";
1378 }
1379
1380 /**
1381 * @tc.number: user_file_service_medialibrary_file_access_Copy_0000
1382 * @tc.name: medialibrary_file_access_Copy_0000
1383 * @tc.desc: Test function of Copy interface, copy a file and argument of force is false
1384 * @tc.size: MEDIUM
1385 * @tc.type: FUNC
1386 * @tc.level Level 1
1387 * @tc.require: I6UI3H
1388 */
1389 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0000, testing::ext::TestSize.Level1)
1390 {
1391 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0000";
1392 try {
1393 Uri srcUri("");
1394 int result = g_fah->Mkdir(g_newDirUri, "Copy_0000_src", srcUri);
1395 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1396 Uri aFileUri("");
1397 result = g_fah->CreateFile(srcUri, "a.txt", aFileUri);
1398 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1399 int fd;
1400 result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1401 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1402 std::string aFileBuff = "Copy test content for a.txt";
1403 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1404 close(fd);
1405 EXPECT_EQ(aFileSize, aFileBuff.size());
1406
1407 Uri destUri("");
1408 result = g_fah->Mkdir(g_newDirUri, "Copy_0000_dest", destUri);
1409 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1410
1411 vector<CopyResult> copyResult;
1412 result = g_fah->Copy(aFileUri, destUri, copyResult, false);
1413 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1414
1415 result = g_fah->Delete(srcUri);
1416 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1417 result = g_fah->Delete(destUri);
1418 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1419 } catch (...) {
1420 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0000 occurs an exception.";
1421 }
1422 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0000";
1423 }
1424
1425 /**
1426 * @tc.number: user_file_service_medialibrary_file_access_Copy_0001
1427 * @tc.name: medialibrary_file_access_Copy_0001
1428 * @tc.desc: Test function of Copy interface, copy a directory and argument of force is false
1429 * @tc.size: MEDIUM
1430 * @tc.type: FUNC
1431 * @tc.level Level 1
1432 * @tc.require: I6UI3H
1433 */
1434 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0001, testing::ext::TestSize.Level1)
1435 {
1436 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0001";
1437 try {
1438 Uri srcUri("");
1439 int result = g_fah->Mkdir(g_newDirUri, "Copy_0001_src", srcUri);
1440 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1441 Uri aFileUri("");
1442 result = g_fah->CreateFile(srcUri, "a.txt", aFileUri);
1443 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1444 int fd;
1445 result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1446 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1447 std::string aFileBuff = "Copy test content for a.txt";
1448 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1449 close(fd);
1450 EXPECT_EQ(aFileSize, aFileBuff.size());
1451
1452 Uri bFileUri("");
1453 result = g_fah->CreateFile(srcUri, "b.txt", bFileUri);
1454 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1455 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1456 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1457 std::string bFileBuff = "Copy test content for b.txt";
1458 ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1459 close(fd);
1460 EXPECT_EQ(bFileSize, bFileBuff.size());
1461
1462 Uri destUri("");
1463 result = g_fah->Mkdir(g_newDirUri, "Copy_0001_dest", destUri);
1464 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1465
1466 vector<CopyResult> copyResult;
1467 result = g_fah->Copy(srcUri, destUri, copyResult, false);
1468 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1469
1470 result = g_fah->Delete(srcUri);
1471 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1472 result = g_fah->Delete(destUri);
1473 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1474 } catch (...) {
1475 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0001 occurs an exception.";
1476 }
1477 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0001";
1478 }
1479
1480 /**
1481 * @tc.number: user_file_service_medialibrary_file_access_Copy_0002
1482 * @tc.name: medialibrary_file_access_Copy_0002
1483 * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is false
1484 * @tc.size: MEDIUM
1485 * @tc.type: FUNC
1486 * @tc.level Level 1
1487 * @tc.require: I6UI3H
1488 */
1489 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0002, testing::ext::TestSize.Level1)
1490 {
1491 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0002";
1492 try {
1493 Uri srcUri("");
1494 int result = g_fah->Mkdir(g_newDirUri, "Copy_0002_src", srcUri);
1495 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1496 Uri srcFileUri("");
1497 result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri);
1498 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1499 int fd;
1500 result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd);
1501 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1502 std::string aFileBuff = "Copy test content for a.txt";
1503 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1504 close(fd);
1505 EXPECT_EQ(aFileSize, aFileBuff.size());
1506
1507 Uri destUri("");
1508 result = g_fah->Mkdir(g_newDirUri, "Copy_0002_dest_false", destUri);
1509 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1510 Uri destFileUri("");
1511 result = g_fah->CreateFile(destUri, "a.txt", destFileUri);
1512 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1513
1514 vector<CopyResult> copyResult;
1515 result = g_fah->Copy(srcFileUri, destUri, copyResult, false);
1516 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1517 EXPECT_GT(copyResult.size(), 0);
1518
1519 result = g_fah->Delete(srcUri);
1520 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1521 result = g_fah->Delete(destUri);
1522 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1523 } catch (...) {
1524 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0002 occurs an exception.";
1525 }
1526 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0002";
1527 }
1528
1529 /**
1530 * @tc.number: user_file_service_medialibrary_file_access_Copy_0003
1531 * @tc.name: medialibrary_file_access_Copy_0003
1532 * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is true
1533 * @tc.size: MEDIUM
1534 * @tc.type: FUNC
1535 * @tc.level Level 1
1536 * @tc.require: I6UI3H
1537 */
1538 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0003, testing::ext::TestSize.Level1)
1539 {
1540 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0003";
1541 try {
1542 Uri srcUri("");
1543 int result = g_fah->Mkdir(g_newDirUri, "Copy_0003_src", srcUri);
1544 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1545 Uri srcFileUri("");
1546 result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri);
1547 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1548 int fd;
1549 result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd);
1550 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1551 std::string aFileBuff = "Copy test content for a.txt";
1552 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1553 close(fd);
1554 EXPECT_EQ(aFileSize, aFileBuff.size());
1555
1556 Uri destUri("");
1557 result = g_fah->Mkdir(g_newDirUri, "Copy_0003_dest_true", destUri);
1558 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1559 Uri destFileUri("");
1560 result = g_fah->CreateFile(destUri, "a.txt", destFileUri);
1561 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1562
1563 vector<CopyResult> copyResult;
1564 result = g_fah->Copy(srcFileUri, destUri, copyResult, true);
1565 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1566
1567 result = g_fah->Delete(srcUri);
1568 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1569 result = g_fah->Delete(destUri);
1570 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1571 } catch (...) {
1572 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0003 occurs an exception.";
1573 }
1574 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0003";
1575 }
1576
1577 /**
1578 * @tc.number: user_file_service_medialibrary_file_access_Copy_0004
1579 * @tc.name: medialibrary_file_access_Copy_0004
1580 * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is false
1581 * @tc.size: MEDIUM
1582 * @tc.type: FUNC
1583 * @tc.level Level 1
1584 * @tc.require: I6UI3H
1585 */
1586 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0004, testing::ext::TestSize.Level1)
1587 {
1588 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0004";
1589 try {
1590 Uri srcUri("");
1591 int result = g_fah->Mkdir(g_newDirUri, "Copy_0004_src", srcUri);
1592 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1593
1594 Uri aFileUri("");
1595 result = g_fah->CreateFile(srcUri, "a.txt", aFileUri);
1596 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1597 int fd;
1598 result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1599 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1600 std::string aFileBuff = "Copy test content for a.txt";
1601 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1602 close(fd);
1603 EXPECT_EQ(aFileSize, aFileBuff.size());
1604
1605 Uri bFileUri("");
1606 result = g_fah->CreateFile(srcUri, "b.txt", bFileUri);
1607 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1608 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1609 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1610 std::string bFileBuff = "Copy test content for b.txt";
1611 ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1612 close(fd);
1613 EXPECT_EQ(bFileSize, bFileBuff.size());
1614
1615 Uri destUri("");
1616 result = g_fah->Mkdir(g_newDirUri, "Copy_0004_dest_false", destUri);
1617 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1618 Uri destSrcUri("");
1619 result = g_fah->Mkdir(destUri, "Copy_0004_src", destSrcUri);
1620 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1621 Uri destSrcAUri("");
1622 result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri);
1623 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1624
1625 vector<CopyResult> copyResult;
1626 result = g_fah->Copy(srcUri, destUri, copyResult, false);
1627 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1628 EXPECT_GT(copyResult.size(), 0);
1629
1630 result = g_fah->Delete(srcUri);
1631 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1632 result = g_fah->Delete(destUri);
1633 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1634 } catch (...) {
1635 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0004 occurs an exception.";
1636 }
1637 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0004";
1638 }
1639
1640 /**
1641 * @tc.number: user_file_service_medialibrary_file_access_Copy_0005
1642 * @tc.name: medialibrary_file_access_Copy_0005
1643 * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is true
1644 * @tc.size: MEDIUM
1645 * @tc.type: FUNC
1646 * @tc.level Level 1
1647 * @tc.require: I6UI3H
1648 */
1649 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0005, testing::ext::TestSize.Level1)
1650 {
1651 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0005";
1652 try {
1653 Uri srcUri("");
1654 int result = g_fah->Mkdir(g_newDirUri, "Copy_0005_src", srcUri);
1655 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1656
1657 Uri aFileUri("");
1658 result = g_fah->CreateFile(srcUri, "a.txt", aFileUri);
1659 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1660 int fd;
1661 result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1662 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1663 std::string aFileBuff = "Copy test content for a.txt";
1664 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1665 close(fd);
1666 EXPECT_EQ(aFileSize, aFileBuff.size());
1667
1668 Uri bFileUri("");
1669 result = g_fah->CreateFile(srcUri, "b.txt", bFileUri);
1670 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1671 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1672 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1673 std::string bFileBuff = "Copy test content for b.txt";
1674 ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1675 close(fd);
1676 EXPECT_EQ(bFileSize, bFileBuff.size());
1677
1678 Uri destUri("");
1679 result = g_fah->Mkdir(g_newDirUri, "Copy_0005_dest_true", destUri);
1680 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1681 Uri destSrcUri("");
1682 result = g_fah->Mkdir(destUri, "Copy_0005_src", destSrcUri);
1683 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1684 Uri destSrcAUri("");
1685 result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri);
1686 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1687
1688 vector<CopyResult> copyResult;
1689 result = g_fah->Copy(srcUri, destUri, copyResult, true);
1690 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1691
1692 result = g_fah->Delete(srcUri);
1693 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1694 result = g_fah->Delete(destUri);
1695 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1696 } catch (...) {
1697 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0005 occurs an exception.";
1698 }
1699 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0005";
1700 }
1701
1702 /**
1703 * @tc.number: user_file_service_medialibrary_file_access_Copy_0006
1704 * @tc.name: medialibrary_file_access_Copy_0006
1705 * @tc.desc: Test function of Copy interface, copy a file with the same name
1706 * @tc.size: MEDIUM
1707 * @tc.type: FUNC
1708 * @tc.level Level 1
1709 * @tc.require: I6UI3H
1710 */
1711 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0006, testing::ext::TestSize.Level1)
1712 {
1713 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0006";
1714 try {
1715 Uri srcUri("");
1716 int result = g_fah->Mkdir(g_newDirUri, "Copy_0006_src", srcUri);
1717 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1718 Uri srcFileUri("");
1719 result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri);
1720 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1721 int fd;
1722 result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd);
1723 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1724 std::string aFileBuff = "Copy test content for a.txt";
1725 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1726 close(fd);
1727 EXPECT_EQ(aFileSize, aFileBuff.size());
1728
1729 Uri destUri("");
1730 result = g_fah->Mkdir(g_newDirUri, "Copy_0006_dest_false", destUri);
1731 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1732 Uri destFileUri("");
1733 result = g_fah->CreateFile(destUri, "a.txt", destFileUri);
1734 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1735
1736 vector<CopyResult> copyResult;
1737 result = g_fah->Copy(srcFileUri, destUri, copyResult);
1738 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1739 EXPECT_GT(copyResult.size(), 0);
1740
1741 result = g_fah->Delete(srcUri);
1742 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1743 result = g_fah->Delete(destUri);
1744 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1745 } catch (...) {
1746 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0006 occurs an exception.";
1747 }
1748 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0006";
1749 }
1750
1751 /**
1752 * @tc.number: user_file_service_medialibrary_file_access_Copy_0007
1753 * @tc.name: medialibrary_file_access_Copy_0007
1754 * @tc.desc: Test function of Copy interface, copy a directory with the same name
1755 * @tc.size: MEDIUM
1756 * @tc.type: FUNC
1757 * @tc.level Level 1
1758 * @tc.require: I6UI3H
1759 */
1760 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0007, testing::ext::TestSize.Level1)
1761 {
1762 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0007";
1763 try {
1764 Uri srcUri("");
1765 int result = g_fah->Mkdir(g_newDirUri, "Copy_0007_src", srcUri);
1766 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1767
1768 Uri aFileUri("");
1769 result = g_fah->CreateFile(srcUri, "a.txt", aFileUri);
1770 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1771 int fd;
1772 result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
1773 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1774 std::string aFileBuff = "Copy test content for a.txt";
1775 ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size());
1776 close(fd);
1777 EXPECT_EQ(aFileSize, aFileBuff.size());
1778
1779 Uri bFileUri("");
1780 result = g_fah->CreateFile(srcUri, "b.txt", bFileUri);
1781 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1782 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
1783 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1784 std::string bFileBuff = "Copy test content for b.txt";
1785 ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size());
1786 close(fd);
1787 EXPECT_EQ(bFileSize, bFileBuff.size());
1788
1789 Uri destUri("");
1790 result = g_fah->Mkdir(g_newDirUri, "Copy_0007_dest_false", destUri);
1791 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1792 Uri destSrcUri("");
1793 result = g_fah->Mkdir(destUri, "Copy_0007_src", destSrcUri);
1794 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1795 Uri destSrcAUri("");
1796 result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri);
1797 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1798
1799 vector<CopyResult> copyResult;
1800 result = g_fah->Copy(srcUri, destUri, copyResult);
1801 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1802 EXPECT_GT(copyResult.size(), 0);
1803
1804 result = g_fah->Delete(srcUri);
1805 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1806 result = g_fah->Delete(destUri);
1807 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1808 } catch (...) {
1809 GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0007 occurs an exception.";
1810 }
1811 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0007";
1812 }
1813
1814 /**
1815 * @tc.number: user_file_service_medialibrary_file_access_Rename_0000
1816 * @tc.name: medialibrary_file_access_Rename_0000
1817 * @tc.desc: Test function of Rename interface for SUCCESS which rename file.
1818 * @tc.size: MEDIUM
1819 * @tc.type: FUNC
1820 * @tc.level Level 1
1821 * @tc.require: SR000H0386
1822 */
1823 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0000, testing::ext::TestSize.Level1)
1824 {
1825 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0000";
1826 try {
1827 Uri newDirUriTest("");
1828 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1829 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1830 Uri testUri("");
1831 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
1832 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1833 Uri renameUri("");
1834 result = g_fah->Rename(testUri, "test2.txt", renameUri);
1835 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1836 GTEST_LOG_(INFO) << "Rename_0000 result:" << result;
1837 result = g_fah->Delete(newDirUriTest);
1838 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1839 } catch (...) {
1840 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0000 occurs an exception.";
1841 }
1842 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0000";
1843 }
1844
1845 /**
1846 * @tc.number: user_file_service_medialibrary_file_access_Rename_0001
1847 * @tc.name: medialibrary_file_access_Rename_0001
1848 * @tc.desc: Test function of Rename interface for SUCCESS which rename folder.
1849 * @tc.size: MEDIUM
1850 * @tc.type: FUNC
1851 * @tc.level Level 1
1852 * @tc.require: SR000H0386
1853 */
1854 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0001, testing::ext::TestSize.Level1)
1855 {
1856 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0001";
1857 try {
1858 Uri newDirUriTest("");
1859 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1860 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1861 Uri renameUri("");
1862 result = g_fah->Rename(newDirUriTest, "testRename", renameUri);
1863 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1864 GTEST_LOG_(INFO) << "Rename_0001 result:" << result;
1865 result = g_fah->Delete(renameUri);
1866 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1867 } catch (...) {
1868 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0001 occurs an exception.";
1869 }
1870 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0001";
1871 }
1872
1873 /**
1874 * @tc.number: user_file_service_medialibrary_file_access_Rename_0002
1875 * @tc.name: medialibrary_file_access_Rename_0002
1876 * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null.
1877 * @tc.size: MEDIUM
1878 * @tc.type: FUNC
1879 * @tc.level Level 1
1880 * @tc.require: SR000H0386
1881 */
1882 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0002, testing::ext::TestSize.Level1)
1883 {
1884 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0002";
1885 try {
1886 Uri renameUri("");
1887 Uri sourceFileUri("");
1888 int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri);
1889 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1890 GTEST_LOG_(INFO) << "Rename_0002 result:" << result;
1891 } catch (...) {
1892 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0002 occurs an exception.";
1893 }
1894 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0002";
1895 }
1896
1897 /**
1898 * @tc.number: user_file_service_medialibrary_file_access_Rename_0003
1899 * @tc.name: medialibrary_file_access_Rename_0003
1900 * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path.
1901 * @tc.size: MEDIUM
1902 * @tc.type: FUNC
1903 * @tc.level Level 1
1904 * @tc.require: SR000H0386
1905 */
1906 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0003, testing::ext::TestSize.Level1)
1907 {
1908 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0003";
1909 try {
1910 Uri newDirUriTest("");
1911 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1912 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1913 Uri testUri("");
1914 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
1915 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1916 Uri renameUri("");
1917 Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt");
1918 result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri);
1919 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1920 GTEST_LOG_(INFO) << "Rename_0003 result:" << result;
1921 result = g_fah->Delete(newDirUriTest);
1922 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1923 } catch (...) {
1924 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0003 occurs an exception.";
1925 }
1926 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0003";
1927 }
1928
1929 /**
1930 * @tc.number: user_file_service_medialibrary_file_access_Rename_0004
1931 * @tc.name: medialibrary_file_access_Rename_0004
1932 * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols.
1933 * @tc.size: MEDIUM
1934 * @tc.type: FUNC
1935 * @tc.level Level 1
1936 * @tc.require: SR000H0386
1937 */
1938 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0004, testing::ext::TestSize.Level1)
1939 {
1940 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0004";
1941 try {
1942 Uri renameUri("");
1943 Uri sourceFileUri("~!@#$%^&*()_");
1944 int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri);
1945 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1946 GTEST_LOG_(INFO) << "Rename_0004 result:" << result;
1947 } catch (...) {
1948 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0004 occurs an exception.";
1949 }
1950 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0004";
1951 }
1952
1953 /**
1954 * @tc.number: user_file_service_medialibrary_file_access_Rename_0005
1955 * @tc.name: medialibrary_file_access_Rename_0005
1956 * @tc.desc: Test function of Rename interface for ERROR which displayName is null.
1957 * @tc.size: MEDIUM
1958 * @tc.type: FUNC
1959 * @tc.level Level 1
1960 * @tc.require: SR000H0386
1961 */
1962 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0005, testing::ext::TestSize.Level1)
1963 {
1964 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0005";
1965 try {
1966 Uri newDirUriTest("");
1967 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
1968 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1969 Uri testUri("");
1970 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
1971 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1972 Uri renameUri("");
1973 result = g_fah->Rename(testUri, "", renameUri);
1974 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1975 GTEST_LOG_(INFO) << "Rename_0005 result:" << result;
1976 result = g_fah->Delete(newDirUriTest);
1977 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
1978 } catch (...) {
1979 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0005 occurs an exception.";
1980 }
1981 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0005";
1982 }
1983
RenameTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,std::string displayName,Uri newFile)1984 static void RenameTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, std::string displayName, Uri newFile)
1985 {
1986 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_RenameTdd";
1987 int ret = fahs->Rename(sourceFile, displayName, newFile);
1988 if (ret != OHOS::FileAccessFwk::ERR_OK) {
1989 GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret;
1990 return;
1991 }
1992 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1993 EXPECT_NE(newFile.ToString(), "");
1994 g_num++;
1995 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_RenameTdd";
1996 }
1997
1998 /**
1999 * @tc.number: user_file_service_medialibrary_file_access_Rename_0006
2000 * @tc.name: medialibrary_file_access_Rename_0006
2001 * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent.
2002 * @tc.size: MEDIUM
2003 * @tc.type: FUNC
2004 * @tc.level Level 1
2005 * @tc.require: SR000H0386
2006 */
2007 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0006, testing::ext::TestSize.Level1)
2008 {
2009 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0006";
2010 try {
2011 Uri newDirUriTest("");
2012 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2013 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2014 Uri testUri{""};
2015 std::string displayName1 = "test1.txt";
2016 std::string displayName2 = "test2.txt";
2017 Uri renameUri("");
2018 result = g_fah->CreateFile(newDirUriTest, displayName1, testUri);
2019 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2020 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
2021 std::thread execthread(RenameTdd, g_fah, testUri, displayName2, renameUri);
2022 execthread.join();
2023 }
2024 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
2025 result = g_fah->Delete(newDirUriTest);
2026 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2027 } catch (...) {
2028 GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0006 occurs an exception.";
2029 }
2030 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0006";
2031 }
2032
2033 /**
2034 * @tc.number: user_file_service_medialibrary_file_access_ListFile_0000
2035 * @tc.name: medialibrary_file_access_ListFile_0000
2036 * @tc.desc: Test function of ListFile interface for SUCCESS.
2037 * @tc.size: MEDIUM
2038 * @tc.type: FUNC
2039 * @tc.level Level 1
2040 * @tc.require: SR000H0386
2041 */
2042 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0000, testing::ext::TestSize.Level1)
2043 {
2044 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0000";
2045 try {
2046 Uri newDirUriTest("");
2047 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2048 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2049 Uri testUri("");
2050 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0000.txt", testUri);
2051 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2052 FileInfo fileInfo;
2053 fileInfo.uri = newDirUriTest.ToString();
2054 int64_t offset = 0;
2055 int64_t maxCount = 1000;
2056 std::vector<FileInfo> fileInfoVec;
2057 FileFilter filter;
2058 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2059 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2060 EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
2061 GTEST_LOG_(INFO) << "ListFile_0000 result:" << fileInfoVec.size() << endl;
2062 result = g_fah->Delete(newDirUriTest);
2063 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2064 } catch (...) {
2065 GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0000 occurs an exception.";
2066 }
2067 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0000";
2068 }
2069
2070 /**
2071 * @tc.number: user_file_service_medialibrary_file_access_ListFile_0001
2072 * @tc.name: medialibrary_file_access_ListFile_0001
2073 * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr.
2074 * @tc.size: MEDIUM
2075 * @tc.type: FUNC
2076 * @tc.level Level 1
2077 * @tc.require: SR000H0386
2078 */
2079 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0001, testing::ext::TestSize.Level1)
2080 {
2081 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0001";
2082 try {
2083 Uri sourceFileUri("");
2084 FileInfo fileInfo;
2085 fileInfo.uri = sourceFileUri.ToString();
2086 int64_t offset = 0;
2087 int64_t maxCount = 1000;
2088 vector<FileAccessFwk::FileInfo> fileInfoVec;
2089 FileFilter filter({}, {}, {}, -1, -1, false, false);
2090 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2091 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2092 EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
2093 GTEST_LOG_(INFO) << "ListFile_0001 result:" << fileInfoVec.size() << endl;
2094 } catch (...) {
2095 GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0001 occurs an exception.";
2096 }
2097 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0001";
2098 }
2099
2100 /**
2101 * @tc.number: user_file_service_medialibrary_file_access_ListFile_0002
2102 * @tc.name: medialibrary_file_access_ListFile_0002
2103 * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path.
2104 * @tc.size: MEDIUM
2105 * @tc.type: FUNC
2106 * @tc.level Level 1
2107 * @tc.require: SR000H0386
2108 */
2109 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0002, testing::ext::TestSize.Level1)
2110 {
2111 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0002";
2112 try {
2113 Uri newDirUriTest("");
2114 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2115 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2116 Uri testUri("");
2117 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
2118 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2119 Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt");
2120 FileInfo fileInfo;
2121 fileInfo.uri = sourceFileUri.ToString();
2122 int64_t offset = 0;
2123 int64_t maxCount = 1000;
2124 vector<FileAccessFwk::FileInfo> fileInfoVec;
2125 FileFilter filter({}, {}, {}, -1, -1, false, false);
2126 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2127 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2128 EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
2129 GTEST_LOG_(INFO) << "ListFile_0002 result:" << fileInfoVec.size() << endl;
2130 result = g_fah->Delete(newDirUriTest);
2131 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2132 } catch (...) {
2133 GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0002 occurs an exception.";
2134 }
2135 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0002";
2136 }
2137
2138 /**
2139 * @tc.number: user_file_service_medialibrary_file_access_ListFile_0003
2140 * @tc.name: medialibrary_file_access_ListFile_0003
2141 * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols.
2142 * @tc.size: MEDIUM
2143 * @tc.type: FUNC
2144 * @tc.level Level 1
2145 * @tc.require: SR000H0386
2146 */
2147 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0003, testing::ext::TestSize.Level1)
2148 {
2149 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0003";
2150 try {
2151 Uri sourceFileUri("~!@#$%^&*()_");
2152 FileInfo fileInfo;
2153 fileInfo.uri = sourceFileUri.ToString();
2154 int64_t offset = 0;
2155 int64_t maxCount = 1000;
2156 vector<FileAccessFwk::FileInfo> fileInfoVec;
2157 FileFilter filter;
2158 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2159 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2160 EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
2161 GTEST_LOG_(INFO) << "ListFile_0003 result:" << fileInfoVec.size() << endl;
2162 } catch (...) {
2163 GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0003 occurs an exception.";
2164 }
2165 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0003";
2166 }
2167
2168 /**
2169 * @tc.number: user_file_service_medialibrary_file_access_ListFile_0004
2170 * @tc.name: medialibrary_file_access_ListFile_0004
2171 * @tc.desc: Test function of ListFile interface for ERROR which add filter.
2172 * @tc.size: MEDIUM
2173 * @tc.type: FUNC
2174 * @tc.level Level 1
2175 * @tc.require: SR000HB855
2176 */
2177 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0004, testing::ext::TestSize.Level1)
2178 {
2179 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0004";
2180 try {
2181 Uri newDirUriTest("");
2182 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2183 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2184 Uri testUri1("");
2185 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.txt", testUri1);
2186 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2187 Uri testUri2("");
2188 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.docx", testUri2);
2189 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2190 FileInfo fileInfo;
2191 fileInfo.uri = newDirUriTest.ToString();
2192 int64_t offset = 0;
2193 int64_t maxCount = 1000;
2194 std::vector<FileInfo> fileInfoVec;
2195 FileFilter filter({".txt"}, {}, {}, -1, 1, false, true);
2196 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2197 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2198 EXPECT_EQ(fileInfoVec.size(), 1);
2199 result = g_fah->Delete(newDirUriTest);
2200 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2201 } catch (...) {
2202 GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0004 occurs an exception.";
2203 }
2204 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0004";
2205 }
2206
ListFileTdd(shared_ptr<FileAccessHelper> fahs,FileInfo fileInfo,int offset,int maxCount,FileFilter filter,std::vector<FileInfo> fileInfoVec)2207 static void ListFileTdd(shared_ptr<FileAccessHelper> fahs, FileInfo fileInfo, int offset, int maxCount,
2208 FileFilter filter, std::vector<FileInfo> fileInfoVec)
2209 {
2210 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFileTdd";
2211 int ret = fahs->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2212 if (ret != OHOS::FileAccessFwk::ERR_OK) {
2213 GTEST_LOG_(ERROR) << "ListFileTdd get result error, code:" << ret;
2214 return;
2215 }
2216 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
2217 EXPECT_EQ(fileInfoVec.size(), 1);
2218 g_num++;
2219 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFileTdd";
2220 }
2221
2222 /**
2223 * @tc.number: user_file_service_medialibrary_file_access_ListFile_0005
2224 * @tc.name: medialibrary_file_access_ListFile_0005
2225 * @tc.desc: Test function of ListFile interface for ERROR which Concurrent.
2226 * @tc.size: MEDIUM
2227 * @tc.type: FUNC
2228 * @tc.level Level 1
2229 * @tc.require: SR000H0386
2230 */
2231 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0005, testing::ext::TestSize.Level1)
2232 {
2233 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0005";
2234 try {
2235 Uri newDirUriTest("");
2236 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2237 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2238 Uri testUri1("");
2239 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.txt", testUri1);
2240 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2241 Uri testUri2("");
2242 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.docx", testUri2);
2243 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2244 FileInfo fileInfo;
2245 fileInfo.uri = newDirUriTest.ToString();
2246 int64_t offset = 0;
2247 int64_t maxCount = 1000;
2248 std::vector<FileInfo> fileInfoVec;
2249 g_num = 0;
2250 FileFilter filter({".txt"}, {}, {}, -1, -1, false, true);
2251 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
2252 std::thread execthread(ListFileTdd, g_fah, fileInfo, offset, maxCount, filter, fileInfoVec);
2253 execthread.join();
2254 }
2255 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
2256 result = g_fah->Delete(newDirUriTest);
2257 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2258 } catch (...) {
2259 GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0005 occurs an exception.";
2260 }
2261 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0005";
2262 }
2263
2264 /**
2265 * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0000
2266 * @tc.name: medialibrary_file_access_ScanFile_0000
2267 * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with filter.
2268 * @tc.size: MEDIUM
2269 * @tc.type: FUNC
2270 * @tc.level Level 1
2271 * @tc.require: SR000HB866
2272 */
2273 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0000, testing::ext::TestSize.Level1)
2274 {
2275 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0000";
2276 try {
2277 Uri newDirUriTest("");
2278 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2279 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2280 Uri testUri("");
2281 FileInfo fileInfo;
2282 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4", testUri);
2283 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2284 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri);
2285 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2286 fileInfo.uri = "file://media/root";
2287 int64_t offset = 0;
2288 int64_t maxCount = 1000;
2289 std::vector<FileInfo> fileInfoVec;
2290 FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
2291 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2292 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2293 EXPECT_GE(fileInfoVec.size(), 1);
2294 GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl;
2295 result = g_fah->Delete(newDirUriTest);
2296 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2297 } catch (...) {
2298 GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0000 occurs an exception.";
2299 }
2300 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0000";
2301 }
2302
2303 /**
2304 * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0001
2305 * @tc.name: medialibrary_file_access_ScanFile_0001
2306 * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with no filter.
2307 * @tc.size: MEDIUM
2308 * @tc.type: FUNC
2309 * @tc.level Level 1
2310 * @tc.require: SR000HB866
2311 */
2312 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0001, testing::ext::TestSize.Level1)
2313 {
2314 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0001";
2315 try {
2316 Uri newDirUriTest("");
2317 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2318 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2319 Uri testUri("");
2320 FileInfo fileInfo;
2321 fileInfo.uri = "file://media/root";
2322 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.q1w2e3r4", testUri);
2323 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2324 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.txt", testUri);
2325 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2326 int64_t offset = 0;
2327 int64_t maxCount = 1000;
2328 std::vector<FileInfo> fileInfoVec;
2329 FileFilter filter({}, {}, {}, -1, -1, false, false);
2330 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2331 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2332 EXPECT_GE(fileInfoVec.size(), 2);
2333 GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl;
2334 result = g_fah->Delete(newDirUriTest);
2335 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2336 } catch (...) {
2337 GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0001 occurs an exception.";
2338 }
2339 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0001";
2340 }
2341
2342 /**
2343 * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0002
2344 * @tc.name: medialibrary_file_access_ScanFile_0002
2345 * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter.
2346 * @tc.size: MEDIUM
2347 * @tc.type: FUNC
2348 * @tc.level Level 1
2349 * @tc.require: SR000HB866
2350 */
2351 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0002, testing::ext::TestSize.Level1)
2352 {
2353 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0002";
2354 try {
2355 Uri newDirUriTest("");
2356 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2357 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2358 Uri testUri("");
2359 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0002.q1w2e3r4", testUri);
2360 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2361 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri);
2362 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2363 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.docx", testUri);
2364 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2365 FileInfo fileInfo;
2366 fileInfo.uri = newDirUriTest.ToString();
2367 int64_t offset = 0;
2368 int64_t maxCount = 1000;
2369 std::vector<FileInfo> fileInfoVec;
2370 FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
2371 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2372 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2373 EXPECT_EQ(fileInfoVec.size(), 1);
2374 FileFilter filter1({".q1w2e3r4", ".txt"}, {}, {}, -1, -1, false, true);
2375 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter1, fileInfoVec);
2376 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2377 EXPECT_EQ(fileInfoVec.size(), 2);
2378 GTEST_LOG_(INFO) << "ScanFile_0002 result:" << fileInfoVec.size() << endl;
2379 result = g_fah->Delete(newDirUriTest);
2380 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2381 } catch (...) {
2382 GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0002 occurs an exception.";
2383 }
2384 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0002";
2385 }
2386
2387 /**
2388 * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0003
2389 * @tc.name: medialibrary_file_access_ScanFile_0003
2390 * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter.
2391 * @tc.size: MEDIUM
2392 * @tc.type: FUNC
2393 * @tc.level Level 1
2394 * @tc.require: SR000HB866
2395 */
2396 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0003, testing::ext::TestSize.Level1)
2397 {
2398 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0003";
2399 try {
2400 Uri newDirUriTest("");
2401 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2402 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2403 Uri testUri("");
2404 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0003.q1w2e3r4", testUri);
2405 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2406 FileInfo fileInfo;
2407 fileInfo.uri = newDirUriTest.ToString();
2408 int64_t offset = 0;
2409 int64_t maxCount = 1000;
2410 std::vector<FileInfo> fileInfoVec;
2411 FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
2412 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2413 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2414 EXPECT_EQ(fileInfoVec.size(), 1);
2415 GTEST_LOG_(INFO) << "ScanFile_0003 result:" << fileInfoVec.size() << endl;
2416 result = g_fah->Delete(newDirUriTest);
2417 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2418 } catch (...) {
2419 GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0003 occurs an exception.";
2420 }
2421 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0003";
2422 }
2423
ScanFileTdd(FileInfo fileInfo,int offset,int maxCount,FileFilter filter,std::vector<FileInfo> fileInfoVec)2424 static void ScanFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter,
2425 std::vector<FileInfo> fileInfoVec)
2426 {
2427 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFileTdd";
2428 int ret = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2429 if (ret != OHOS::FileAccessFwk::ERR_OK) {
2430 GTEST_LOG_(ERROR) << "ScanFileTdd get result error, code:" << ret;
2431 return;
2432 }
2433 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
2434 EXPECT_EQ(fileInfoVec.size(), 1);
2435 g_num++;
2436 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFileTdd";
2437 }
2438
2439 /**
2440 * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0004
2441 * @tc.name: medialibrary_file_access_ScanFile_0004
2442 * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with Concurrent.
2443 * @tc.size: MEDIUM
2444 * @tc.type: FUNC
2445 * @tc.level Level 1
2446 * @tc.require: SR000HB866
2447 */
2448 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0004, testing::ext::TestSize.Level1)
2449 {
2450 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0004";
2451 try {
2452 Uri newDirUriTest("");
2453 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2454 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2455 Uri testUri("");
2456 FileInfo fileInfo;
2457 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4", testUri);
2458 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2459 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri);
2460 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2461 fileInfo.uri = "file://media/root";
2462 int64_t offset = 0;
2463 int64_t maxCount = 1000;
2464 std::vector<FileInfo> fileInfoVec;
2465 FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
2466 g_num = 0;
2467 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
2468 std::thread execthread(ScanFileTdd, fileInfo, offset, maxCount, filter, fileInfoVec);
2469 execthread.join();
2470 }
2471 EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
2472 result = g_fah->Delete(newDirUriTest);
2473 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2474 } catch (...) {
2475 GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0004 occurs an exception.";
2476 }
2477 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0004";
2478 }
2479
ReplaceBundleNameFromPath(std::string & path,const std::string & newName)2480 static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName)
2481 {
2482 Uri uri(path);
2483 std::string scheme = uri.GetScheme();
2484 if (scheme == FILE_SCHEME_NAME) {
2485 std::string curName = uri.GetAuthority();
2486 if (curName.empty()) {
2487 return false;
2488 }
2489 path.replace(path.find(curName), curName.length(), newName);
2490 return true;
2491 }
2492
2493 std::string tPath = Uri(path).GetPath();
2494 if (tPath.empty()) {
2495 GTEST_LOG_(INFO) << "Uri path error.";
2496 return false;
2497 }
2498
2499 if (tPath.front() != '/') {
2500 GTEST_LOG_(INFO) << "Uri path format error.";
2501 return false;
2502 }
2503
2504 auto index = tPath.substr(1).find_first_of("/");
2505 auto bundleName = tPath.substr(1, index);
2506 if (bundleName.empty()) {
2507 GTEST_LOG_(INFO) << "bundleName empty.";
2508 return false;
2509 }
2510
2511 path.replace(path.find(bundleName), bundleName.length(), newName);
2512 return true;
2513 }
2514
2515 /**
2516 * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0005
2517 * @tc.name: medialibrary_file_access_ScanFile_0005
2518 * @tc.desc: Test function of ScanFile interface for FAILED because of GetProxyByUri failed.
2519 * @tc.size: MEDIUM
2520 * @tc.type: FUNC
2521 * @tc.level Level 1
2522 * @tc.require: SR000HB866
2523 */
2524 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0005, testing::ext::TestSize.Level1)
2525 {
2526 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0005";
2527 try {
2528 Uri newDirUriTest("");
2529 int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest);
2530 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2531 Uri testUri("");
2532 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0005.q1w2e3r4", testUri);
2533 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2534
2535 std::string str = testUri.ToString();
2536 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
2537 GTEST_LOG_(INFO) << "replace BundleName failed.";
2538 EXPECT_TRUE(false);
2539 }
2540 FileInfo fileInfo;
2541 fileInfo.uri = str;
2542 int64_t offset = 0;
2543 int64_t maxCount = 1000;
2544 std::vector<FileInfo> fileInfoVec;
2545 FileFilter filter({".q1w2e3r4"}, {}, {}, -1, -1, false, true);
2546 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2547 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
2548 EXPECT_EQ(fileInfoVec.size(), 0);
2549 GTEST_LOG_(INFO) << "ScanFile_0005 result:" << fileInfoVec.size() << endl;
2550 result = g_fah->Delete(newDirUriTest);
2551 EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK);
2552 } catch (...) {
2553 GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0005 occurs an exception.";
2554 }
2555 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0005";
2556 }
2557
2558 /**
2559 * @tc.number: user_file_service_medialibrary_file_access_GetRoots_0000
2560 * @tc.name: medialibrary_file_access_GetRoots_0000
2561 * @tc.desc: Test function of GetRoots interface for SUCCESS.
2562 * @tc.size: MEDIUM
2563 * @tc.type: FUNC
2564 * @tc.level Level 1
2565 * @tc.require: SR000H0386
2566 */
2567 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetRoots_0000, testing::ext::TestSize.Level1)
2568 {
2569 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetRoots_0000";
2570 try {
2571 vector<RootInfo> info;
2572 int result = g_fah->GetRoots(info);
2573 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2574 EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK);
2575 if (info.size() > OHOS::FileAccessFwk::ERR_OK) {
2576 GTEST_LOG_(INFO) << info[0].uri;
2577 GTEST_LOG_(INFO) << info[0].displayName;
2578 GTEST_LOG_(INFO) << info[0].deviceType;
2579 GTEST_LOG_(INFO) << info[0].deviceFlags;
2580 }
2581 string uri = "file://media/root";
2582 string displayName = "LOCAL";
2583 EXPECT_EQ(info[0].uri, uri);
2584 EXPECT_EQ(info[0].displayName, displayName);
2585 EXPECT_EQ(info[0].deviceType, DEVICE_LOCAL_DISK);
2586 EXPECT_EQ(info[0].deviceFlags, DEVICE_FLAG_SUPPORTS_READ | DEVICE_FLAG_SUPPORTS_WRITE);
2587 } catch (...) {
2588 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetRoots_0000 occurs an exception.";
2589 }
2590 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetRoots_0000";
2591 }
2592
2593 /**
2594 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0000
2595 * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0000
2596 * @tc.desc: Test function of GetFileInfoFromUri interface.
2597 * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS.
2598 * @tc.size: MEDIUM
2599 * @tc.type: FUNC
2600 * @tc.level Level 1
2601 * @tc.require: SR000HRLBS
2602 */
2603 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1)
2604 {
2605 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0000";
2606 try {
2607 vector<RootInfo> infos;
2608 int result = g_fah->GetRoots(infos);
2609 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2610 for (size_t i = 0; i < infos.size(); i++) {
2611 Uri parentUri(infos[i].uri);
2612 FileInfo fileinfo;
2613 result = g_fah->GetFileInfoFromUri(parentUri, fileinfo);
2614 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2615
2616 int64_t offset = 0;
2617 int64_t maxCount = 1000;
2618 FileFilter filter;
2619 std::vector<FileInfo> fileInfoVecTemp;
2620 result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
2621 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2622 EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
2623 }
2624 } catch (...) {
2625 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0000 occurs an exception.";
2626 }
2627 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0000";
2628 }
2629
2630 /**
2631 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0001
2632 * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0001
2633 * @tc.desc: Test function of GetFileInfoFromUri interface.
2634 * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS.
2635 * @tc.size: MEDIUM
2636 * @tc.type: FUNC
2637 * @tc.level Level 1
2638 * @tc.require: SR000HRLBS
2639 */
2640 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1)
2641 {
2642 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0001";
2643 try {
2644 Uri newDirUriTest("");
2645 int result = g_fah->Mkdir(g_newDirUri, "testDir", newDirUriTest);
2646 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2647
2648 FileInfo dirInfo;
2649 result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo);
2650 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2651
2652 int64_t offset = 0;
2653 int64_t maxCount = 1000;
2654 FileFilter filter;
2655 std::vector<FileInfo> fileInfoVec;
2656 result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec);
2657 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2658 EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
2659
2660 result = g_fah->Delete(newDirUriTest);
2661 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2662 } catch (...) {
2663 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0001 occurs an exception.";
2664 }
2665 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0001";
2666 }
2667
2668 /**
2669 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0002
2670 * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0002
2671 * @tc.desc: Test function of GetFileInfoFromUri interface.
2672 * @tc.desc: convert the regular file uri to fileinfo and call listfile for ERROR.
2673 * @tc.size: MEDIUM
2674 * @tc.type: FUNC
2675 * @tc.level Level 1
2676 * @tc.require: SR000HRLBS
2677 */
2678 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1)
2679 {
2680 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0002";
2681 try {
2682 Uri newDirUriTest("");
2683 int result = g_fah->Mkdir(g_newDirUri, "testDir", newDirUriTest);
2684 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2685 Uri newFileUri("");
2686 result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_GetFileInfoFromUri_0002.txt", newFileUri);
2687 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2688
2689 FileInfo fileinfo;
2690 result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo);
2691 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2692
2693 int64_t offset = 0;
2694 int64_t maxCount = 1000;
2695 FileFilter filter;
2696 std::vector<FileInfo> fileInfoVecTemp;
2697 result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
2698 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2699 EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
2700
2701 result = g_fah->Delete(newDirUriTest);
2702 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2703 } catch (...) {
2704 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0002 occurs an exception.";
2705 }
2706 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0002";
2707 }
2708
2709 /**
2710 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0003
2711 * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0003
2712 * @tc.desc: Test function of GetFileInfoFromUri interface.
2713 * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed.
2714 * @tc.size: MEDIUM
2715 * @tc.type: FUNC
2716 * @tc.level Level 1
2717 * @tc.require: SR000HRLBS
2718 */
2719 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1)
2720 {
2721 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0003";
2722 try {
2723 vector<RootInfo> info;
2724 int result = g_fah->GetRoots(info);
2725 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2726 for (size_t i = 0; i < info.size(); i++) {
2727 Uri parentUri(std::string("\?\?\?\?/") + info[i].uri);
2728 FileInfo fileinfo;
2729 result = g_fah->GetFileInfoFromUri(parentUri, fileinfo);
2730 EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
2731 }
2732 } catch (...) {
2733 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0003 occurs an exception.";
2734 }
2735 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0003";
2736 }
2737
2738 /**
2739 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0004
2740 * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0004
2741 * @tc.desc: Test function of GetFileInfoFromUri interface.
2742 * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed.
2743 * @tc.size: MEDIUM
2744 * @tc.type: FUNC
2745 * @tc.level Level 1
2746 * @tc.require: SR000HRLBS
2747 */
2748 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1)
2749 {
2750 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0004";
2751 try {
2752 vector<RootInfo> info;
2753 int result = g_fah->GetRoots(info);
2754 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2755 for (size_t i = 0; i < info.size(); i++) {
2756 std::string str = info[i].uri;
2757 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
2758 GTEST_LOG_(ERROR) << "replace BundleName failed.";
2759 EXPECT_TRUE(false);
2760 }
2761 Uri parentUri(str);
2762 FileInfo fileinfo;
2763 result = g_fah->GetFileInfoFromUri(parentUri, fileinfo);
2764 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
2765 }
2766 } catch (...) {
2767 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0004 occurs an exception.";
2768 }
2769 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0004";
2770 }
2771
2772 /**
2773 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0005
2774 * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0005
2775 * @tc.desc: Test function of GetFileInfoFromUri interface.
2776 * @tc.desc: convert the invalid uri to fileinfo failed.
2777 * @tc.size: MEDIUM
2778 * @tc.type: FUNC
2779 * @tc.level Level 1
2780 * @tc.require: SR000HRLBS
2781 */
2782 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1)
2783 {
2784 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0005";
2785 try {
2786 Uri uri("~!@#$%^&*()_");
2787 FileInfo fileInfo;
2788 int result = g_fah->GetFileInfoFromUri(uri, fileInfo);
2789 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2790
2791 uri = Uri("/");
2792 result = g_fah->GetFileInfoFromUri(uri, fileInfo);
2793 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2794
2795 uri = Uri("");
2796 result = g_fah->GetFileInfoFromUri(uri, fileInfo);
2797 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2798 } catch (...) {
2799 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0005 occurs an exception.";
2800 }
2801 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0005";
2802 }
2803
2804 /**
2805 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0000
2806 * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0000
2807 * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
2808 * @tc.desc: convert the general directory relativePath to fileinfo for SUCCESS.
2809 * @tc.size: MEDIUM
2810 * @tc.type: FUNC
2811 * @tc.level Level 1
2812 * @tc.require: SR000HRLBS
2813 */
2814 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0000, testing::ext::TestSize.Level1)
2815 {
2816 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0000";
2817 try {
2818 FileInfo fileInfo;
2819 string relativePath = "";
2820 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2821 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2822
2823 relativePath = "Audios/";
2824 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2825 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2826
2827 relativePath = "Camera/";
2828 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2829 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2830
2831 relativePath = "Documents/";
2832 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2833 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2834
2835 relativePath = "Download";
2836 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2837 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2838
2839 relativePath = "Pictures";
2840 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2841 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2842
2843 relativePath = "Videos";
2844 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2845 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2846 } catch (...) {
2847 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0000 occurs an exception.";
2848 }
2849 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0000";
2850 }
2851
2852 /**
2853 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0001
2854 * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0001
2855 * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
2856 * @tc.desc: convert the general directory relativePath to fileinfo for failed.
2857 * @tc.size: MEDIUM
2858 * @tc.type: FUNC
2859 * @tc.level Level 1
2860 * @tc.require: SR000HRLBS
2861 */
2862 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0001, testing::ext::TestSize.Level1)
2863 {
2864 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0001";
2865 try {
2866 FileInfo fileInfo;
2867 string relativePath = "test/";
2868 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2869 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2870
2871 relativePath = "/";
2872 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2873 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2874
2875 relativePath = "~!@#$%^&*()_";
2876 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2877 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2878
2879 relativePath = "/d";
2880 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2881 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2882 } catch (...) {
2883 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0001 occurs an exception.";
2884 }
2885 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0001";
2886 }
2887
2888 /**
2889 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0002
2890 * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0002
2891 * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
2892 * @tc.desc: convert the general directory relativePath to fileinfo and call listfile for SUCCESS.
2893 * @tc.size: MEDIUM
2894 * @tc.type: FUNC
2895 * @tc.level Level 1
2896 * @tc.require: SR000HRLBS
2897 */
2898 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0002, testing::ext::TestSize.Level1)
2899 {
2900 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0002";
2901 try {
2902 FileInfo fileInfo;
2903 string relativePath = "Download/";
2904 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2905 ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2906
2907 Uri parentUri(fileInfo.uri);
2908 Uri newFile("");
2909 result = g_fah->CreateFile(parentUri, "GetFileInfoFromRelativePath_0002.jpg", newFile);
2910 ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2911
2912 int64_t offset = 0;
2913 int64_t maxCount = 1000;
2914 FileFilter filter;
2915 std::vector<FileInfo> fileInfoVec;
2916 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2917 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2918 EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
2919
2920 result = g_fah->Delete(newFile);
2921 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2922 } catch (...) {
2923 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0002 occurs an exception.";
2924 }
2925 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0002";
2926 }
2927
2928 /**
2929 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0003
2930 * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0003
2931 * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
2932 * @tc.desc: convert the relative file path to fileinfo and call listfile for failed.
2933 * @tc.size: MEDIUM
2934 * @tc.type: FUNC
2935 * @tc.level Level 1
2936 * @tc.require: SR000HRLBS
2937 */
2938 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0003, testing::ext::TestSize.Level1)
2939 {
2940 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0003";
2941 try {
2942 FileInfo fileInfo;
2943 string relativePath = "Download/";
2944 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2945 ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2946
2947 Uri parentUri(fileInfo.uri);
2948 Uri newFile("");
2949 result = g_fah->CreateFile(parentUri, "GetFileInfoFromRelativePath_0003.jpg", newFile);
2950 ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2951
2952 relativePath = "Download/GetFileInfoFromRelativePath_0003.jpg";
2953 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2954 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2955
2956 int64_t offset = 0;
2957 int64_t maxCount = 1000;
2958 FileFilter filter;
2959 std::vector<FileInfo> fileInfoVec;
2960 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
2961 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2962
2963 result = g_fah->Delete(newFile);
2964 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2965 } catch (...) {
2966 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0003 occurs an exception.";
2967 }
2968 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0003";
2969 }
2970
2971 /**
2972 * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0004
2973 * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0004
2974 * @tc.desc: Test function of GetFileInfoFromRelativePath interface.
2975 * @tc.desc: convert the relative directory path to fileinfo and call listfile for SUCCESS.
2976 * @tc.size: MEDIUM
2977 * @tc.type: FUNC
2978 * @tc.level Level 1
2979 * @tc.require: SR000HRLBS
2980 */
2981 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0004, testing::ext::TestSize.Level1)
2982 {
2983 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0004";
2984 try {
2985 FileInfo fileInfo;
2986 string relativePath = "Download/";
2987 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
2988 ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2989
2990 Uri parentUri(fileInfo.uri);
2991 Uri newDir("");
2992 result = g_fah->Mkdir(parentUri, "DirGetFileInfoFromRelativePath_0004", newDir);
2993 ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2994
2995 Uri fileUri("");
2996 result = g_fah->CreateFile(newDir, "file1.jpg", fileUri);
2997 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2998
2999 result = g_fah->CreateFile(newDir, "file2.jpg", fileUri);
3000 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3001
3002 relativePath = "Download/DirGetFileInfoFromRelativePath_0004";
3003 result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
3004 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3005
3006 int64_t offset = 0;
3007 int64_t maxCount = 1000;
3008 FileFilter filter;
3009 std::vector<FileInfo> fileInfoVec;
3010 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3011 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3012 EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
3013
3014 result = g_fah->Delete(newDir);
3015 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3016 } catch (...) {
3017 GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0004 occurs an exception.";
3018 }
3019 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0004";
3020 }
3021
3022 /**
3023 * @tc.number: user_file_service_medialibrary_file_access_Query_0000
3024 * @tc.name: medialibrary_file_access_Query_0000
3025 * @tc.desc: Test function of Query directory for SUCCESS.
3026 * @tc.size: MEDIUM
3027 * @tc.type: FUNC
3028 * @tc.level Level 1
3029 * @tc.require: I6S4VV
3030 */
3031 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0000, testing::ext::TestSize.Level1)
3032 {
3033 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0000";
3034 try {
3035 FileAccessFwk::FileInfo fileInfo;
3036 std::string relativePath = "Documents/";
3037 std::string displayName = "Documents";
3038 int targetSize = 46;
3039 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
3040 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3041 Uri dirUriTest(fileInfo.uri);
3042
3043 json testJson = {
3044 {RELATIVE_PATH, " "},
3045 {DISPLAY_NAME, " "},
3046 {FILE_SIZE, " "},
3047 {DATE_MODIFIED, " "},
3048 {DATE_ADDED, " "}
3049 };
3050 auto testJsonString = testJson.dump();
3051 int ret = g_fah->Query(dirUriTest, testJsonString);
3052 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3053 auto jsonObject = json::parse(testJsonString);
3054 EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
3055 EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize);
3056 ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
3057 ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
3058 GTEST_LOG_(INFO) << testJsonString;
3059 } catch (...) {
3060 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0000 occurs an exception.";
3061 }
3062 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0000";
3063 }
3064
3065 /**
3066 * @tc.number: user_file_service_medialibrary_file_access_Query_0001
3067 * @tc.name: medialibrary_file_access_Query_0001
3068 * @tc.desc: Test function of Query file for SUCCESS.
3069 * @tc.size: MEDIUM
3070 * @tc.type: FUNC
3071 * @tc.level Level 1
3072 * @tc.require: I6S4VV
3073 */
3074 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0001, testing::ext::TestSize.Level1)
3075 {
3076 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0001";
3077 try {
3078 FileAccessFwk::FileInfo fileInfo;
3079 std::string relativePath = "Documents/Test/";
3080 std::string displayName = "CreateQueryTest_002.txt";
3081 int targetSize = 23;
3082 std::string filePath = "Documents/Test/CreateQueryTest_002.txt";
3083 int ret = g_fah->GetFileInfoFromRelativePath(filePath, fileInfo);
3084 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3085 Uri testUri(fileInfo.uri);
3086
3087 json testJson = {
3088 {RELATIVE_PATH, " "},
3089 {DISPLAY_NAME, " "},
3090 {FILE_SIZE, " "},
3091 {DATE_MODIFIED, " "},
3092 {DATE_ADDED, " "}
3093 };
3094 auto testJsonString = testJson.dump();
3095 ret = g_fah->Query(testUri, testJsonString);
3096 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3097 GTEST_LOG_(INFO) << testJsonString;
3098 auto jsonObject = json::parse(testJsonString);
3099 EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath);
3100 EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
3101 EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize);
3102 ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
3103 ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
3104 } catch (...) {
3105 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0001 occurs an exception.";
3106 }
3107 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0001";
3108 }
3109
3110 /**
3111 * @tc.number: user_file_service_medialibrary_file_access_Query_0002
3112 * @tc.name: medialibrary_file_access_Query_0002
3113 * @tc.desc: Test function of Query directory size for SUCCESS.
3114 * @tc.size: MEDIUM
3115 * @tc.type: FUNC
3116 * @tc.level Level 1
3117 * @tc.require:
3118 */
3119 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0002, testing::ext::TestSize.Level1)
3120 {
3121 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0002";
3122 try {
3123 FileAccessFwk::FileInfo fileInfo;
3124 std::string relativePath = "Documents/";
3125 std::string displayName = "Documents";
3126 int targetSize = 46;
3127 int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo);
3128 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3129 Uri dirUriTest(fileInfo.uri);
3130
3131 json testJson = {
3132 {FILE_SIZE, " "}
3133 };
3134 auto testJsonString = testJson.dump();
3135 int ret = g_fah->Query(dirUriTest, testJsonString);
3136 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3137 auto jsonObject = json::parse(testJsonString);
3138 EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize);
3139 GTEST_LOG_(INFO) << testJsonString;
3140 } catch (...) {
3141 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0002 occurs an exception.";
3142 }
3143 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0002";
3144 }
3145
3146 /**
3147 * @tc.number: user_file_service_medialibrary_file_access_Query_0003
3148 * @tc.name: medialibrary_file_access_Query_0003
3149 * @tc.desc: Test function of Query interface for ERROR which Uri is unreadable code.
3150 * @tc.size: MEDIUM
3151 * @tc.type: FUNC
3152 * @tc.level Level 1
3153 * @tc.require: I6S4VV
3154 */
3155 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0003, testing::ext::TestSize.Level1)
3156 {
3157 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0003";
3158 try {
3159 Uri testUri("&*()*/?");
3160 json testJson = {
3161 {RELATIVE_PATH, " "},
3162 {DISPLAY_NAME, " "}
3163 };
3164 auto testJsonString = testJson.dump();
3165 int ret = g_fah->Query(testUri, testJsonString);
3166 EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
3167 } catch (...) {
3168 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception.";
3169 }
3170 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0003";
3171 }
3172
3173 /**
3174 * @tc.number: user_file_service_medialibrary_file_access_Query_0004
3175 * @tc.name: medialibrary_file_access_Query_0004
3176 * @tc.desc: Test function of Query interface for which all column nonexistence.
3177 * @tc.size: MEDIUM
3178 * @tc.type: FUNC
3179 * @tc.level Level 1
3180 * @tc.require: I6S4VV
3181 */
3182 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0004, testing::ext::TestSize.Level1)
3183 {
3184 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0004";
3185 try {
3186 Uri newDirUriTest("");
3187 std::string fileName = "test.txt";
3188 int ret = g_fah->Mkdir(g_newDirUri, "Query004", newDirUriTest);
3189 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3190 Uri testUri("");
3191 ret = g_fah->CreateFile(newDirUriTest, fileName, testUri);
3192 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3193 json testJson = {
3194 {"001", " "},
3195 {"#", " "},
3196 {"test", " "},
3197 {"target", " "}
3198 };
3199 auto testJsonString = testJson.dump();
3200 ret = g_fah->Query(testUri, testJsonString);
3201 EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
3202 ret = g_fah->Delete(newDirUriTest);
3203 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3204 } catch (...) {
3205 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception.";
3206 }
3207 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0004";
3208 }
3209
3210 /**
3211 * @tc.number: user_file_service_medialibrary_file_access_Query_0005
3212 * @tc.name: medialibrary_file_access_Query_0005
3213 * @tc.desc: Test function of Query interface for which part of column nonexistence.
3214 * @tc.size: MEDIUM
3215 * @tc.type: FUNC
3216 * @tc.level Level 1
3217 * @tc.require: I6S4VV
3218 */
3219 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0005, testing::ext::TestSize.Level1)
3220 {
3221 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0005";
3222 try {
3223 Uri newDirUriTest("");
3224 std::string fileName = "test.txt";
3225 int ret = g_fah->Mkdir(g_newDirUri, "Query005", newDirUriTest);
3226 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3227 Uri testUri("");
3228 ret = g_fah->CreateFile(newDirUriTest, fileName, testUri);
3229 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3230 json testJson = {
3231 {RELATIVE_PATH, " "},
3232 {DISPLAY_NAME, " "},
3233 {"test", " "}
3234 };
3235 auto testJsonString = testJson.dump();
3236 ret = g_fah->Query(testUri, testJsonString);
3237 EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
3238 ret = g_fah->Delete(newDirUriTest);
3239 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3240 } catch (...) {
3241 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0005 occurs an exception.";
3242 }
3243 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0005";
3244 }
3245
3246 /**
3247 * @tc.number: user_file_service_medialibrary_file_access_Query_0006
3248 * @tc.name: medialibrary_file_access_Query_0006
3249 * @tc.desc: Test function of Query interface for which column is null.
3250 * @tc.size: MEDIUM
3251 * @tc.type: FUNC
3252 * @tc.level Level 1
3253 * @tc.require: I6S4VV
3254 */
3255 HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0006, testing::ext::TestSize.Level1)
3256 {
3257 GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0006";
3258 try {
3259 Uri newDirUriTest("");
3260 std::string fileName = "test.txt";
3261 std::string relativePath = "test/test.txt";
3262 int ret = g_fah->Mkdir(g_newDirUri, "Query006", newDirUriTest);
3263 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3264 Uri testUri("");
3265 ret = g_fah->CreateFile(newDirUriTest, fileName, testUri);
3266 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3267 json testJson;
3268 auto testJsonString = testJson.dump();
3269 ret = g_fah->Query(testUri, testJsonString);
3270 EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK);
3271 ret = g_fah->Delete(newDirUriTest);
3272 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3273 } catch (...) {
3274 GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0006 occurs an exception.";
3275 }
3276 GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0006";
3277 }
3278 } // namespace
3279
