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