1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdio>
17 #include <thread>
18 #include <unistd.h>
19
20 #include <gtest/gtest.h>
21 #include <nlohmann/json.hpp>
22
23 #include "external_file_access_test.h"
24 #include "accesstoken_kit.h"
25 #include "context_impl.h"
26 #include "file_access_framework_errno.h"
27 #include "file_info_shared_memory.h"
28 #include "iservice_registry.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31
32 namespace OHOS::FileAccessFwk {
33 static int g_num = 0;
34
35 /**
36 * @tc.number: user_file_service_external_file_access_OpenFile_0000
37 * @tc.name: external_file_access_OpenFile_0000
38 * @tc.desc: Test function of OpenFile interface for SUCCESS.
39 * @tc.size: MEDIUM
40 * @tc.type: FUNC
41 * @tc.level Level 1
42 * @tc.require: SR000H0386
43 */
44 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0000, testing::ext::TestSize.Level1)
45 {
46 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0000";
47 try {
48 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
49 vector<RootInfo> info;
50 EXPECT_NE(fileAccessHelper, nullptr);
51 int result = fileAccessHelper->GetRoots(info);
52 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
53 for (size_t i = 0; i < info.size(); i++) {
54 Uri parentUri(info[i].uri);
55 GTEST_LOG_(INFO) << parentUri.ToString();
56 Uri newDirUriTest1("");
57 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
58 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
59 Uri newFileUri("");
60 result = fileAccessHelper->CreateFile(newDirUriTest1, "external_file_access_OpenFile_0000.txt", newFileUri);
61 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
62 int fd;
63 result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
64 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
65 GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result;
66 close(fd);
67 result = fileAccessHelper->Delete(newDirUriTest1);
68 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
69 }
70 } catch (...) {
71 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0000 occurs an exception.";
72 }
73 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0000";
74 }
75
76 /**
77 * @tc.number: user_file_service_external_file_access_OpenFile_0001
78 * @tc.name: external_file_access_OpenFile_0001
79 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null.
80 * @tc.size: MEDIUM
81 * @tc.type: FUNC
82 * @tc.level Level 1
83 * @tc.require: SR000H0386
84 */
85 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0001, testing::ext::TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0001";
88 try {
89 Uri uri("");
90 int fd;
91 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
92 EXPECT_NE(fileAccessHelper, nullptr);
93 int result = fileAccessHelper->OpenFile(uri, WRITE_READ, fd);
94 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
95 GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result;
96 } catch (...) {
97 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0001 occurs an exception.";
98 }
99 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0001";
100 }
101
102 /**
103 * @tc.number: user_file_service_external_file_access_OpenFile_0002
104 * @tc.name: external_file_access_OpenFile_0002
105 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path.
106 * @tc.size: MEDIUM
107 * @tc.type: FUNC
108 * @tc.level Level 1
109 * @tc.require: SR000H0386
110 */
111 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0002, testing::ext::TestSize.Level1)
112 {
113 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0002";
114 try {
115 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
116 vector<RootInfo> info;
117 EXPECT_NE(fileAccessHelper, nullptr);
118 int result = fileAccessHelper->GetRoots(info);
119 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
120 for (size_t i = 0; i < info.size(); i++) {
121 Uri parentUri(info[i].uri);
122 Uri newFileUri("");
123 result = fileAccessHelper->CreateFile(parentUri, "external_file_access_OpenFile_0002.txt", newFileUri);
124 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
125 Uri uri("storage/media/100/local/files/Download/external_file_access_OpenFile_0002.txt");
126 int fd;
127 result = fileAccessHelper->OpenFile(uri, WRITE_READ, fd);
128 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
129 GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result;
130 result = fileAccessHelper->Delete(newFileUri);
131 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
132 }
133 } catch (...) {
134 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0002 occurs an exception.";
135 }
136 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0002";
137 }
138
139 /**
140 * @tc.number: user_file_service_external_file_access_OpenFile_0003
141 * @tc.name: external_file_access_OpenFile_0003
142 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols.
143 * @tc.size: MEDIUM
144 * @tc.type: FUNC
145 * @tc.level Level 1
146 * @tc.require: SR000H0386
147 */
148 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0003, testing::ext::TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0003";
151 try {
152 Uri uri("~!@#$%^&*()_");
153 int fd;
154 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
155 EXPECT_NE(fileAccessHelper, nullptr);
156 int result = fileAccessHelper->OpenFile(uri, WRITE_READ, fd);
157 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
158 GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result;
159 } catch (...) {
160 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0003 occurs an exception.";
161 }
162 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0003";
163 }
164
165 /**
166 * @tc.number: user_file_service_external_file_access_OpenFile_0004
167 * @tc.name: external_file_access_OpenFile_0004
168 * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1.
169 * @tc.size: MEDIUM
170 * @tc.type: FUNC
171 * @tc.level Level 1
172 * @tc.require: SR000H0386
173 */
174 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0004, testing::ext::TestSize.Level1)
175 {
176 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0004";
177 try {
178 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
179 EXPECT_NE(fileAccessHelper, nullptr);
180 vector<RootInfo> info;
181 int result = fileAccessHelper->GetRoots(info);
182 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
183 for (size_t i = 0; i < info.size(); i++) {
184 Uri parentUri(info[i].uri);
185 Uri newFileUri("");
186 result = fileAccessHelper->CreateFile(parentUri, "external_file_access_OpenFile_0004.txt", newFileUri);
187 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
188 int fd;
189 int flag = -1;
190 result = fileAccessHelper->OpenFile(newFileUri, flag, fd);
191 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
192 GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result;
193 result = fileAccessHelper->Delete(newFileUri);
194 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
195 }
196 } catch (...) {
197 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0004 occurs an exception.";
198 }
199 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0004";
200 }
201
202 /**
203 * @tc.number: user_file_service_external_file_access_OpenFile_0005
204 * @tc.name: external_file_access_OpenFile_0005
205 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0.
206 * @tc.size: MEDIUM
207 * @tc.type: FUNC
208 * @tc.level Level 1
209 * @tc.require: SR000H0386
210 */
211 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0005, testing::ext::TestSize.Level1)
212 {
213 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0005";
214 try {
215 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
216 EXPECT_NE(fileAccessHelper, nullptr);
217 vector<RootInfo> info;
218 int result = fileAccessHelper->GetRoots(info);
219 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
220 for (size_t i = 0; i < info.size(); i++) {
221 Uri parentUri(info[i].uri);
222 Uri newFileUri("");
223 result = fileAccessHelper->CreateFile(parentUri, "external_file_access_OpenFile_0005.txt", newFileUri);
224 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
225 int fd;
226 result = fileAccessHelper->OpenFile(newFileUri, READ, fd);
227 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
228 GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result;
229 close(fd);
230 result = fileAccessHelper->Delete(newFileUri);
231 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
232 }
233 } catch (...) {
234 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0005 occurs an exception.";
235 }
236 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0005";
237 }
238
239 /**
240 * @tc.number: user_file_service_external_file_access_OpenFile_0006
241 * @tc.name: external_file_access_OpenFile_0006
242 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1.
243 * @tc.size: MEDIUM
244 * @tc.type: FUNC
245 * @tc.level Level 1
246 * @tc.require: SR000H0386
247 */
248 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0006, testing::ext::TestSize.Level1)
249 {
250 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0006";
251 try {
252 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
253 EXPECT_NE(fileAccessHelper, nullptr);
254 vector<RootInfo> info;
255 int result = fileAccessHelper->GetRoots(info);
256 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
257 for (size_t i = 0; i < info.size(); i++) {
258 Uri parentUri(info[i].uri);
259 Uri newFileUri("");
260 result = fileAccessHelper->CreateFile(parentUri, "external_file_access_OpenFile_0006.txt", newFileUri);
261 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
262 int fd;
263 result = fileAccessHelper->OpenFile(newFileUri, WRITE, fd);
264 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
265 GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result;
266 close(fd);
267 result = fileAccessHelper->Delete(newFileUri);
268 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
269 }
270 } catch (...) {
271 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0006 occurs an exception.";
272 }
273 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0006";
274 }
275
276 /**
277 * @tc.number: user_file_service_external_file_access_OpenFile_0007
278 * @tc.name: external_file_access_OpenFile_0007
279 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2.
280 * @tc.size: MEDIUM
281 * @tc.type: FUNC
282 * @tc.level Level 1
283 * @tc.require: SR000H0386
284 */
285 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0007, testing::ext::TestSize.Level1)
286 {
287 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0007";
288 try {
289 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
290 EXPECT_NE(fileAccessHelper, nullptr);
291 vector<RootInfo> info;
292 int result = fileAccessHelper->GetRoots(info);
293 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
294 for (size_t i = 0; i < info.size(); i++) {
295 Uri parentUri(info[i].uri);
296 Uri newFileUri("");
297 result = fileAccessHelper->CreateFile(parentUri, "external_file_access_OpenFile_0007.txt", newFileUri);
298 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
299 int fd;
300 result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
301 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
302 GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result;
303 close(fd);
304 result = fileAccessHelper->Delete(newFileUri);
305 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
306 }
307 } catch (...) {
308 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0007 occurs an exception.";
309 }
310 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0007";
311 }
312
OpenFileTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,int flag,int fd)313 static void OpenFileTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, int flag, int fd)
314 {
315 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFileTdd";
316 int ret = fahs->OpenFile(uri, flag, fd);
317 if (ret != OHOS::FileAccessFwk::ERR_OK) {
318 GTEST_LOG_(ERROR) << "OpenFile get result error, code:" << ret;
319 return;
320 }
321 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
322 EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK);
323 g_num++;
324 close(fd);
325 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFileTdd";
326 }
327
328 /**
329 * @tc.number: user_file_service_external_file_access_OpenFile_0008
330 * @tc.name: external_file_access_OpenFile_0008
331 * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent.
332 * @tc.size: MEDIUM
333 * @tc.type: FUNC
334 * @tc.level Level 1
335 * @tc.require: SR000H0386
336 */
337 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0008, testing::ext::TestSize.Level1)
338 {
339 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0008";
340 try {
341 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
342 EXPECT_NE(fileAccessHelper, nullptr);
343 vector<RootInfo> info;
344 int result = fileAccessHelper->GetRoots(info);
345 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
346 for (size_t i = 0; i < info.size(); i++) {
347 Uri parentUri(info[i].uri);
348 Uri newFileUri("");
349 int fd;
350 std::string displayName = "test1.txt";
351 g_num = 0;
352 result = fileAccessHelper->CreateFile(parentUri, displayName, newFileUri);
353 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
354 for (size_t j = 0; j < INIT_THREADS_NUMBER; j++) {
355 std::thread execthread(OpenFileTdd, fileAccessHelper, newFileUri, WRITE_READ, fd);
356 execthread.join();
357 }
358 EXPECT_EQ(g_num, INIT_THREADS_NUMBER);
359 result = fileAccessHelper->Delete(newFileUri);
360 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
361 }
362 } catch (...) {
363 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0008 occurs an exception.";
364 }
365 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0008";
366 }
367
368 /**
369 * @tc.number: user_file_service_external_file_access_OpenFile_0009
370 * @tc.name: external_file_access_OpenFile_0009
371 * @tc.desc: Test function of OpenFile interface for 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_OpenFile_0009, testing::ext::TestSize.Level1)
378 {
379 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0009";
380 try {
381 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
382 EXPECT_NE(fileAccessHelper, nullptr);
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 int fd;
390 Uri newFileUri(str + "/NotExistFile.txt");
391 result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
392 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
393 GTEST_LOG_(INFO) << "OpenFile_0009 result:" << result;
394 } else {
395 EXPECT_TRUE(false);
396 }
397 }
398 } catch (...) {
399 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0009 occurs an exception.";
400 }
401 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0009";
402 }
403
404 /**
405 * @tc.number: user_file_service_external_file_access_OpenFile_0010
406 * @tc.name: external_file_access_OpenFile_0010
407 * @tc.desc: Test function of OpenFile interface for SUCCESS, the file name is chinese.
408 * @tc.size: MEDIUM
409 * @tc.type: FUNC
410 * @tc.level Level 1
411 * @tc.require: I70SX9
412 */
413 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0010, testing::ext::TestSize.Level1)
414 {
415 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0010";
416 try {
417 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
418 EXPECT_NE(fileAccessHelper, nullptr);
419 vector<RootInfo> info;
420 int result = fileAccessHelper->GetRoots(info);
421 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
422 for (size_t i = 0; i < info.size(); i++) {
423 Uri parentUri(info[i].uri);
424 GTEST_LOG_(INFO) << parentUri.ToString();
425 Uri newDirUriTest1("");
426 result = fileAccessHelper->Mkdir(parentUri, "测试目录", newDirUriTest1);
427 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
428 EXPECT_EQ(newDirUriTest1.ToString().find("测试目录"), std::string::npos);
429 Uri newFileUri("");
430 result = fileAccessHelper->CreateFile(newDirUriTest1, "打开文件.txt", newFileUri);
431 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
432 EXPECT_EQ(newFileUri.ToString().find("打开文件.txt"), std::string::npos);
433 int fd;
434 result = fileAccessHelper->OpenFile(newFileUri, WRITE_READ, fd);
435 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
436 GTEST_LOG_(INFO) << "OpenFile_0010 result:" << result;
437 close(fd);
438 result = fileAccessHelper->Delete(newDirUriTest1);
439 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
440 }
441 } catch (...) {
442 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0010 occurs an exception.";
443 }
444 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0010";
445 }
446
447 /**
448 * @tc.number: user_file_service_external_file_access_Delete_0000
449 * @tc.name: external_file_access_Delete_0000
450 * @tc.desc: Test function of Delete interface for SUCCESS which delete file.
451 * @tc.size: MEDIUM
452 * @tc.type: FUNC
453 * @tc.level Level 1
454 * @tc.require: SR000H0386
455 */
456 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0000, testing::ext::TestSize.Level1)
457 {
458 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0000";
459 try {
460 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
461 EXPECT_NE(fileAccessHelper, nullptr);
462 vector<RootInfo> info;
463 int result = fileAccessHelper->GetRoots(info);
464 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
465 for (size_t i = 0; i < info.size(); i++) {
466 Uri parentUri(info[i].uri);
467 Uri newDirUriTest("");
468 result = fileAccessHelper->Mkdir(parentUri, "test", newDirUriTest);
469 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
470 Uri newFileUri("");
471 result = fileAccessHelper->CreateFile(newDirUriTest, "external_file_access_Delete_0000.txt", newFileUri);
472 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
473 result = fileAccessHelper->Delete(newFileUri);
474 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
475 GTEST_LOG_(INFO) << "Delete_0000 result:" << result;
476 result = fileAccessHelper->Delete(newDirUriTest);
477 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
478 }
479 } catch (...) {
480 GTEST_LOG_(ERROR) << "external_file_access_Delete_0000 occurs an exception.";
481 }
482 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0000";
483 }
484
485 /**
486 * @tc.number: user_file_service_external_file_access_Delete_0001
487 * @tc.name: external_file_access_Delete_0001
488 * @tc.desc: Test function of Delete interface for SUCCESS which delete folder.
489 * @tc.size: MEDIUM
490 * @tc.type: FUNC
491 * @tc.level Level 1
492 * @tc.require: SR000H0386
493 */
494 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0001, testing::ext::TestSize.Level1)
495 {
496 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0001";
497 try {
498 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
499 EXPECT_NE(fileAccessHelper, nullptr);
500 vector<RootInfo> info;
501 int result = fileAccessHelper->GetRoots(info);
502 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
503 for (size_t i = 0; i < info.size(); i++) {
504 Uri parentUri(info[i].uri);
505 Uri newDirUriTest("");
506 result = fileAccessHelper->Mkdir(parentUri, "test", newDirUriTest);
507 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
508 result = fileAccessHelper->Delete(newDirUriTest);
509 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
510 GTEST_LOG_(INFO) << "Delete_0001 result:" << result;
511 }
512 } catch (...) {
513 GTEST_LOG_(ERROR) << "external_file_access_Delete_0001 occurs an exception.";
514 }
515 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0001";
516 }
517
518 /**
519 * @tc.number: user_file_service_external_file_access_Delete_0002
520 * @tc.name: external_file_access_Delete_0002
521 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null.
522 * @tc.size: MEDIUM
523 * @tc.type: FUNC
524 * @tc.level Level 1
525 * @tc.require: SR000H0386
526 */
527 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0002, testing::ext::TestSize.Level1)
528 {
529 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0002";
530 try {
531 Uri selectFileUri("");
532 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
533 EXPECT_NE(fileAccessHelper, nullptr);
534 int result = fileAccessHelper->Delete(selectFileUri);
535 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
536 GTEST_LOG_(INFO) << "Delete_0002 result:" << result;
537 } catch (...) {
538 GTEST_LOG_(ERROR) << "external_file_access_Delete_0002 occurs an exception.";
539 }
540 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0002";
541 }
542
543 /**
544 * @tc.number: user_file_service_external_file_access_Delete_0003
545 * @tc.name: external_file_access_Delete_0003
546 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path.
547 * @tc.size: MEDIUM
548 * @tc.type: FUNC
549 * @tc.level Level 1
550 * @tc.require: SR000H0386
551 */
552 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0003, testing::ext::TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0003";
555 try {
556 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
557 EXPECT_NE(fileAccessHelper, nullptr);
558 vector<RootInfo> info;
559 int result = fileAccessHelper->GetRoots(info);
560 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
561 for (size_t i = 0; i < info.size(); i++) {
562 Uri parentUri(info[i].uri);
563 Uri newDirUriTest("");
564 result = fileAccessHelper->Mkdir(parentUri, "test", newDirUriTest);
565 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
566 Uri selectFileUri("storage/media/100/local/files/Download/test");
567 result = fileAccessHelper->Delete(selectFileUri);
568 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
569 result = fileAccessHelper->Delete(newDirUriTest);
570 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
571 GTEST_LOG_(INFO) << "Delete_0003 result:" << result;
572 }
573 } catch (...) {
574 GTEST_LOG_(ERROR) << "external_file_access_Delete_0003 occurs an exception.";
575 }
576 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0003";
577 }
578
579 /**
580 * @tc.number: user_file_service_external_file_access_Delete_0004
581 * @tc.name: external_file_access_Delete_0004
582 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols.
583 * @tc.size: MEDIUM
584 * @tc.type: FUNC
585 * @tc.level Level 1
586 * @tc.require: SR000H0386
587 */
588 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0004, testing::ext::TestSize.Level1)
589 {
590 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0004";
591 try {
592 Uri selectFileUri("!@#$%^&*()");
593 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
594 EXPECT_NE(fileAccessHelper, nullptr);
595 int result = fileAccessHelper->Delete(selectFileUri);
596 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
597 GTEST_LOG_(INFO) << "Delete_0004 result:" << result;
598 } catch (...) {
599 GTEST_LOG_(ERROR) << "external_file_access_Delete_0004 occurs an exception.";
600 }
601 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0004";
602 }
603
DeleteTdd(shared_ptr<FileAccessHelper> fahs,Uri selectFile)604 static void DeleteTdd(shared_ptr<FileAccessHelper> fahs, Uri selectFile)
605 {
606 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_DeleteTdd";
607 int ret = fahs->Delete(selectFile);
608 if (ret != OHOS::FileAccessFwk::ERR_OK) {
609 GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret;
610 return;
611 }
612 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
613 g_num++;
614 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_DeleteTdd";
615 }
616
617 /**
618 * @tc.number: user_file_service_external_file_access_Delete_0005
619 * @tc.name: external_file_access_Delete_0005
620 * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent.
621 * @tc.size: MEDIUM
622 * @tc.type: FUNC
623 * @tc.level Level 1
624 * @tc.require: SR000H0386
625 */
626 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0005, testing::ext::TestSize.Level1)
627 {
628 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0005";
629 try {
630 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
631 EXPECT_NE(fileAccessHelper, nullptr);
632 vector<RootInfo> info;
633 int result = fileAccessHelper->GetRoots(info);
634 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
635 for (size_t i = 0; i < info.size(); i++) {
636 Uri parentUri(info[i].uri);
637 Uri newDirUriTest("");
638 result = fileAccessHelper->Mkdir(parentUri, "test", newDirUriTest);
639 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
640 Uri newFileUri("");
641 std::string displayName = "test1.txt";
642 result = fileAccessHelper->CreateFile(newDirUriTest, displayName, newFileUri);
643 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
644 g_num = 0;
645 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
646 std::thread execthread(DeleteTdd, fileAccessHelper, newFileUri);
647 execthread.join();
648 }
649 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
650 result = fileAccessHelper->Delete(newDirUriTest);
651 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
652 }
653 } catch (...) {
654 GTEST_LOG_(ERROR) << "external_file_access_Delete_0005 occurs an exception.";
655 }
656 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0005";
657 }
658
659 /**
660 * @tc.number: user_file_service_external_file_access_Delete_0006
661 * @tc.name: external_file_access_Delete_0006
662 * @tc.desc: Test function of Delete interface for ERROR because of GetProxyByUri failed.
663 * @tc.size: MEDIUM
664 * @tc.type: FUNC
665 * @tc.level Level 1
666 * @tc.require: SR000H0386
667 */
668 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0006, testing::ext::TestSize.Level1)
669 {
670 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0006";
671 try {
672 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
673 EXPECT_NE(fileAccessHelper, nullptr);
674 vector<RootInfo> info;
675 int result = fileAccessHelper->GetRoots(info);
676 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
677 for (size_t i = 0; i < info.size(); i++) {
678 std::string str = info[i].uri;
679 if (ReplaceBundleName(str, "ohos.com.NotExistBundleName")) {
680 Uri selectFileUri(str);
681 int result = fileAccessHelper->Delete(selectFileUri);
682 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
683 GTEST_LOG_(INFO) << "Delete_0006 result:" << result;
684 } else {
685 EXPECT_TRUE(false);
686 }
687 }
688 } catch (...) {
689 GTEST_LOG_(ERROR) << "external_file_access_Delete_0006 occurs an exception.";
690 }
691 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0006";
692 }
693
694 /**
695 * @tc.number: user_file_service_external_file_access_Delete_0007
696 * @tc.name: external_file_access_Delete_0007
697 * @tc.desc: Test function of Delete interface for SUCCESS which delete file, the file name is chinese.
698 * @tc.size: MEDIUM
699 * @tc.type: FUNC
700 * @tc.level Level 1
701 * @tc.require: I70SX9
702 */
703 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0007, testing::ext::TestSize.Level1)
704 {
705 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0007";
706 try {
707 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
708 EXPECT_NE(fileAccessHelper, nullptr);
709 vector<RootInfo> info;
710 int result = fileAccessHelper->GetRoots(info);
711 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
712 for (size_t i = 0; i < info.size(); i++) {
713 Uri parentUri(info[i].uri);
714 Uri newDirUriTest("");
715 result = fileAccessHelper->Mkdir(parentUri, "测试目录", newDirUriTest);
716 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
717 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
718 Uri newFileUri("");
719 result = fileAccessHelper->CreateFile(newDirUriTest, "删除文件.txt", newFileUri);
720 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
721 EXPECT_EQ(newFileUri.ToString().find("删除文件.txt"), std::string::npos);
722 result = fileAccessHelper->Delete(newFileUri);
723 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
724 GTEST_LOG_(INFO) << "Delete_0007 result:" << result;
725 result = fileAccessHelper->Delete(newDirUriTest);
726 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
727 }
728 } catch (...) {
729 GTEST_LOG_(ERROR) << "external_file_access_Delete_0007 occurs an exception.";
730 }
731 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0007";
732 }
733
734 /**
735 * @tc.number: user_file_service_external_file_access_Move_0000
736 * @tc.name: external_file_access_Move_0000
737 * @tc.desc: Test function of Move interface for SUCCESS which move file.
738 * @tc.size: MEDIUM
739 * @tc.type: FUNC
740 * @tc.level Level 1
741 * @tc.require: SR000H0387
742 */
743 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0000, testing::ext::TestSize.Level1)
744 {
745 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0000";
746 try {
747 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
748 EXPECT_NE(fileAccessHelper, nullptr);
749 vector<RootInfo> info;
750 int result = fileAccessHelper->GetRoots(info);
751 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
752 for (size_t i = 0; i < info.size(); i++) {
753 Uri parentUri(info[i].uri);
754 Uri newDirUriTest1("");
755 Uri newDirUriTest2("");
756 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
757 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
758 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
759 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
760 Uri testUri("");
761 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
762 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
763 Uri testUri2("");
764 result = fileAccessHelper->Move(testUri, newDirUriTest2, testUri2);
765 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
766 GTEST_LOG_(INFO) << "Move_0000 result:" << result;
767 result = fileAccessHelper->Delete(newDirUriTest1);
768 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
769 result = fileAccessHelper->Delete(newDirUriTest2);
770 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
771 }
772 } catch (...) {
773 GTEST_LOG_(ERROR) << "external_file_access_Move_0000 occurs an exception.";
774 }
775 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0000";
776 }
777
778 /**
779 * @tc.number: user_file_service_external_file_access_Move_0001
780 * @tc.name: external_file_access_Move_0001
781 * @tc.desc: Test function of Move interface for SUCCESS which move folder.
782 * @tc.size: MEDIUM
783 * @tc.type: FUNC
784 * @tc.level Level 1
785 * @tc.require: SR000H0387
786 */
787 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0001, testing::ext::TestSize.Level1)
788 {
789 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0001";
790 try {
791 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
792 EXPECT_NE(fileAccessHelper, nullptr);
793 vector<RootInfo> info;
794 int result = fileAccessHelper->GetRoots(info);
795 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
796 for (size_t i = 0; i < info.size(); i++) {
797 Uri parentUri(info[i].uri);
798 Uri newDirUriTest1("");
799 Uri newDirUriTest2("");
800 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
801 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
802 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
803 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
804 Uri testUri("");
805 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
806 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
807 Uri testUri2("");
808 result = fileAccessHelper->Move(newDirUriTest1, newDirUriTest2, testUri2);
809 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
810 GTEST_LOG_(INFO) << "Move_0001 result:" << result;
811 result = fileAccessHelper->Delete(newDirUriTest2);
812 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
813 }
814 } catch (...) {
815 GTEST_LOG_(ERROR) << "external_file_access_Move_0001 occurs an exception.";
816 }
817 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0001";
818 }
819
820 /**
821 * @tc.number: user_file_service_external_file_access_Move_0002
822 * @tc.name: external_file_access_Move_0002
823 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null.
824 * @tc.size: MEDIUM
825 * @tc.type: FUNC
826 * @tc.level Level 1
827 * @tc.require: SR000H0387
828 */
829 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0002, testing::ext::TestSize.Level1)
830 {
831 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0002";
832 try {
833 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
834 EXPECT_NE(fileAccessHelper, nullptr);
835 vector<RootInfo> info;
836 int result = fileAccessHelper->GetRoots(info);
837 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
838 for (size_t i = 0; i < info.size(); i++) {
839 Uri parentUri(info[i].uri);
840 Uri newDirUriTest("");
841 result = fileAccessHelper->Mkdir(parentUri, "test", newDirUriTest);
842 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
843 Uri testUri("");
844 Uri sourceFileUri("");
845 result = fileAccessHelper->Move(sourceFileUri, newDirUriTest, testUri);
846 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
847 GTEST_LOG_(INFO) << "Move_0002 result:" << result;
848 result = fileAccessHelper->Delete(newDirUriTest);
849 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
850 }
851 } catch (...) {
852 GTEST_LOG_(ERROR) << "external_file_access_Move_0002 occurs an exception.";
853 }
854 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0002";
855 }
856
857 /**
858 * @tc.number: user_file_service_external_file_access_Move_0003
859 * @tc.name: external_file_access_Move_0003
860 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path.
861 * @tc.size: MEDIUM
862 * @tc.type: FUNC
863 * @tc.level Level 1
864 * @tc.require: SR000H0386
865 */
866 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0003, testing::ext::TestSize.Level1)
867 {
868 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0003";
869 try {
870 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
871 EXPECT_NE(fileAccessHelper, nullptr);
872 vector<RootInfo> info;
873 int result = fileAccessHelper->GetRoots(info);
874 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
875 for (size_t i = 0; i < info.size(); i++) {
876 Uri parentUri(info[i].uri);
877 Uri newDirUriTest1("");
878 Uri newDirUriTest2("");
879 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
880 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
881 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
882 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
883 Uri testUri("");
884 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
885 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
886 Uri testUri2("");
887 Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt");
888 result = fileAccessHelper->Move(sourceFileUri, newDirUriTest2, testUri2);
889 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
890 GTEST_LOG_(INFO) << "Move_0003 result:" << result;
891 result = fileAccessHelper->Delete(newDirUriTest1);
892 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
893 result = fileAccessHelper->Delete(newDirUriTest2);
894 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
895 }
896 } catch (...) {
897 GTEST_LOG_(ERROR) << "external_file_access_Move_0003 occurs an exception.";
898 }
899 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0003";
900 }
901
902 /**
903 * @tc.number: user_file_service_external_file_access_Move_0004
904 * @tc.name: external_file_access_Move_0004
905 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols.
906 * @tc.size: MEDIUM
907 * @tc.type: FUNC
908 * @tc.level Level 1
909 * @tc.require: SR000H0387
910 */
911 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0004, testing::ext::TestSize.Level1)
912 {
913 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0004";
914 try {
915 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
916 EXPECT_NE(fileAccessHelper, nullptr);
917 vector<RootInfo> info;
918 int result = fileAccessHelper->GetRoots(info);
919 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
920 for (size_t i = 0; i < info.size(); i++) {
921 Uri parentUri(info[i].uri);
922 Uri newDirUriTest("");
923 result = fileAccessHelper->Mkdir(parentUri, "test", newDirUriTest);
924 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
925 Uri testUri("");
926 Uri sourceFileUri("~!@#$%^&*()_");
927 result = fileAccessHelper->Move(sourceFileUri, newDirUriTest, testUri);
928 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
929 GTEST_LOG_(INFO) << "Move_0004 result:" << result;
930 result = fileAccessHelper->Delete(newDirUriTest);
931 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
932 }
933 } catch (...) {
934 GTEST_LOG_(ERROR) << "external_file_access_Move_0004 occurs an exception.";
935 }
936 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0004";
937 }
938
939 /**
940 * @tc.number: user_file_service_external_file_access_Move_0005
941 * @tc.name: external_file_access_Move_0005
942 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null.
943 * @tc.size: MEDIUM
944 * @tc.type: FUNC
945 * @tc.level Level 1
946 * @tc.require: SR000H0387
947 */
948 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0005, testing::ext::TestSize.Level1)
949 {
950 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0005";
951 try {
952 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
953 EXPECT_NE(fileAccessHelper, nullptr);
954 vector<RootInfo> info;
955 int result = fileAccessHelper->GetRoots(info);
956 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
957 for (size_t i = 0; i < info.size(); i++) {
958 Uri parentUri(info[i].uri);
959 Uri newDirUriTest("");
960 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest);
961 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
962 Uri testUri("");
963 result = fileAccessHelper->CreateFile(newDirUriTest, "test.txt", testUri);
964 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
965 Uri testUri2("");
966 Uri targetParentUri("");
967 result = fileAccessHelper->Move(testUri, targetParentUri, testUri2);
968 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
969 GTEST_LOG_(INFO) << "Move_0005 result:" << result;
970 result = fileAccessHelper->Delete(newDirUriTest);
971 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
972 }
973 } catch (...) {
974 GTEST_LOG_(ERROR) << "external_file_access_Move_0005 occurs an exception.";
975 }
976 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0005";
977 }
978
979 /**
980 * @tc.number: user_file_service_external_file_access_Move_0006
981 * @tc.name: external_file_access_Move_0006
982 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path.
983 * @tc.size: MEDIUM
984 * @tc.type: FUNC
985 * @tc.level Level 1
986 * @tc.require: SR000H0387
987 */
988 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0006, testing::ext::TestSize.Level1)
989 {
990 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0006";
991 try {
992 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
993 EXPECT_NE(fileAccessHelper, nullptr);
994 vector<RootInfo> info;
995 int result = fileAccessHelper->GetRoots(info);
996 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
997 for (size_t i = 0; i < info.size(); i++) {
998 Uri parentUri(info[i].uri);
999 Uri newDirUriTest1("");
1000 Uri newDirUriTest2("");
1001 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1002 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1003 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1004 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1005 Uri testUri("");
1006 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
1007 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1008 Uri testUri2("");
1009 Uri targetParentUri("storage/media/100/local/files/Download/test2");
1010 result = fileAccessHelper->Move(testUri, targetParentUri, testUri2);
1011 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1012 GTEST_LOG_(INFO) << "Move_0006 result:" << result;
1013 result = fileAccessHelper->Delete(newDirUriTest1);
1014 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1015 result = fileAccessHelper->Delete(newDirUriTest2);
1016 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1017 }
1018 } catch (...) {
1019 GTEST_LOG_(ERROR) << "external_file_access_Move_0006 occurs an exception.";
1020 }
1021 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0006";
1022 }
1023
1024 /**
1025 * @tc.number: user_file_service_external_file_access_Move_0007
1026 * @tc.name: external_file_access_Move_0007
1027 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols.
1028 * @tc.size: MEDIUM
1029 * @tc.type: FUNC
1030 * @tc.level Level 1
1031 * @tc.require: SR000H0387
1032 */
1033 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0007, testing::ext::TestSize.Level1)
1034 {
1035 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0007";
1036 try {
1037 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1038 EXPECT_NE(fileAccessHelper, nullptr);
1039 vector<RootInfo> info;
1040 int result = fileAccessHelper->GetRoots(info);
1041 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1042 for (size_t i = 0; i < info.size(); i++) {
1043 Uri parentUri(info[i].uri);
1044 Uri newDirUriTest1("");
1045 Uri newDirUriTest2("");
1046 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1047 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1048 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1049 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1050 Uri testUri("");
1051 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
1052 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1053 Uri testUri2("");
1054 Uri targetParentUri("~!@#$^%&*()_");
1055 result = fileAccessHelper->Move(testUri, targetParentUri, testUri2);
1056 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1057 GTEST_LOG_(INFO) << "Move_0007 result:" << result;
1058 result = fileAccessHelper->Delete(newDirUriTest1);
1059 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1060 result = fileAccessHelper->Delete(newDirUriTest2);
1061 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1062 }
1063 } catch (...) {
1064 GTEST_LOG_(ERROR) << "external_file_access_Move_0007 occurs an exception.";
1065 }
1066 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0007";
1067 }
1068
1069 /**
1070 * @tc.number: user_file_service_external_file_access_Move_0008
1071 * @tc.name: external_file_access_Move_0008
1072 * @tc.desc: Test function of Move interface for SUCCESS which move empty folder.
1073 * @tc.size: MEDIUM
1074 * @tc.type: FUNC
1075 * @tc.level Level 1
1076 * @tc.require: SR000H0387
1077 */
1078 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0008, testing::ext::TestSize.Level1)
1079 {
1080 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0008";
1081 try {
1082 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1083 EXPECT_NE(fileAccessHelper, nullptr);
1084 vector<RootInfo> info;
1085 int result = fileAccessHelper->GetRoots(info);
1086 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1087 for (size_t i = 0; i < info.size(); i++) {
1088 Uri parentUri(info[i].uri);
1089 Uri newDirUriTest1("");
1090 Uri newDirUriTest2("");
1091 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1092 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1093 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1094 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1095 Uri testUri("");
1096 result = fileAccessHelper->Move(newDirUriTest1, newDirUriTest2, testUri);
1097 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1098 GTEST_LOG_(INFO) << "Move_0008 result:" << result;
1099 result = fileAccessHelper->Delete(newDirUriTest2);
1100 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1101 }
1102 } catch (...) {
1103 GTEST_LOG_(ERROR) << "external_file_access_Move_0008 occurs an exception.";
1104 }
1105 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0008";
1106 }
1107
1108 /**
1109 * @tc.number: user_file_service_external_file_access_Move_0009
1110 * @tc.name: external_file_access_Move_0009
1111 * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder.
1112 * @tc.size: MEDIUM
1113 * @tc.type: FUNC
1114 * @tc.level Level 1
1115 * @tc.require: SR000H0387
1116 */
1117 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0009, testing::ext::TestSize.Level1)
1118 {
1119 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0009";
1120 try {
1121 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1122 EXPECT_NE(fileAccessHelper, nullptr);
1123 vector<RootInfo> info;
1124 int result = fileAccessHelper->GetRoots(info);
1125 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1126 for (size_t i = 0; i < info.size(); i++) {
1127 Uri parentUri(info[i].uri);
1128 Uri newDirUriTest1("");
1129 Uri newDirUriTest2("");
1130 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1131 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1132 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1133 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1134 Uri testUri("");
1135 size_t fileNumbers = 2000;
1136 for (size_t j = 0; j < fileNumbers; j++) {
1137 string fileName = "test" + ToString(j) + ".txt";
1138 result = fileAccessHelper->CreateFile(newDirUriTest1, fileName, testUri);
1139 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1140 }
1141 Uri testUri2("");
1142 result = fileAccessHelper->Move(newDirUriTest1, newDirUriTest2, testUri2);
1143 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1144 GTEST_LOG_(INFO) << "Move_0009 result:" << result;
1145 result = fileAccessHelper->Delete(newDirUriTest2);
1146 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1147 }
1148 } catch (...) {
1149 GTEST_LOG_(ERROR) << "external_file_access_Move_0009 occurs an exception.";
1150 }
1151 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0009";
1152 }
1153
1154 /**
1155 * @tc.number: user_file_service_external_file_access_Move_0010
1156 * @tc.name: external_file_access_Move_0010
1157 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder.
1158 * @tc.size: MEDIUM
1159 * @tc.type: FUNC
1160 * @tc.level Level 1
1161 * @tc.require: SR000H0387
1162 */
1163 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0010, testing::ext::TestSize.Level1)
1164 {
1165 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0010";
1166 try {
1167 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1168 EXPECT_NE(fileAccessHelper, nullptr);
1169 vector<RootInfo> info;
1170 int result = fileAccessHelper->GetRoots(info);
1171 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1172 for (size_t i = 0; i < info.size(); i++) {
1173 Uri parentUri(info[i].uri);
1174 Uri newDirUriTest1("");
1175 Uri newDirUriTest2("");
1176 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1177 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1178 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1179 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1180 Uri testUri("");
1181 result = fileAccessHelper->Mkdir(newDirUriTest1, "test", testUri);
1182 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1183 size_t directoryNumbers = 64;
1184 for (size_t j = 0; j < directoryNumbers; j++) {
1185 result = fileAccessHelper->Mkdir(testUri, "test", testUri);
1186 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1187 }
1188 Uri testUri2("");
1189 result = fileAccessHelper->Move(newDirUriTest1, newDirUriTest2, testUri2);
1190 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1191 GTEST_LOG_(INFO) << "Move_0010 result:" << result;
1192 result = fileAccessHelper->Delete(newDirUriTest2);
1193 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1194 }
1195 } catch (...) {
1196 GTEST_LOG_(ERROR) << "external_file_access_Move_0010 occurs an exception.";
1197 }
1198 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0010";
1199 }
1200
1201 /**
1202 * @tc.number: user_file_service_external_file_access_Move_0011
1203 * @tc.name: external_file_access_Move_0011
1204 * @tc.desc: Test function of Move interface for SUCCESS which move other equipment file.
1205 * @tc.size: MEDIUM
1206 * @tc.type: FUNC
1207 * @tc.level Level 1
1208 * @tc.require: SR000H0387
1209 */
1210 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0011, testing::ext::TestSize.Level1)
1211 {
1212 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0011";
1213 try {
1214 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1215 EXPECT_NE(fileAccessHelper, nullptr);
1216 vector<RootInfo> info;
1217 int result = fileAccessHelper->GetRoots(info);
1218 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1219 for (size_t i = 0; i < info.size(); i++) {
1220 Uri parentUri(info[i].uri);
1221 Uri newDirUriTest1("");
1222 Uri newDirUriTest2("");
1223 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1224 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1225 Uri testUri("");
1226 result = fileAccessHelper->CreateFile(newDirUriTest1, "test.txt", testUri);
1227 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1228 for (size_t j = i + 1; j < info.size(); j++) {
1229 Uri otherUri(info[j].uri);
1230 result = fileAccessHelper->Mkdir(otherUri, "test2", newDirUriTest2);
1231 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1232 result = fileAccessHelper->Move(testUri, newDirUriTest2, testUri);
1233 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1234 result = fileAccessHelper->Move(testUri, newDirUriTest1, testUri);
1235 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1236 GTEST_LOG_(INFO) << "Move_0011 result:" << result;
1237 result = fileAccessHelper->Delete(newDirUriTest2);
1238 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1239 }
1240 result = fileAccessHelper->Delete(newDirUriTest1);
1241 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1242 }
1243 } catch (...) {
1244 GTEST_LOG_(ERROR) << "external_file_access_Move_0011 occurs an exception.";
1245 }
1246 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0011";
1247 }
1248
MoveTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,Uri targetParent,Uri newFile)1249 static void MoveTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, Uri targetParent, Uri newFile)
1250 {
1251 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MoveTdd";
1252 int ret = fahs->Move(sourceFile, targetParent, newFile);
1253 if (ret != OHOS::FileAccessFwk::ERR_OK) {
1254 GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret;
1255 return;
1256 }
1257 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1258 g_num++;
1259 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MoveTdd";
1260 }
1261
1262 /**
1263 * @tc.number: user_file_service_external_file_access_Move_0012
1264 * @tc.name: external_file_access_Move_0012
1265 * @tc.desc: Test function of Move interface for SUCCESS which Concurrent.
1266 * @tc.size: MEDIUM
1267 * @tc.type: FUNC
1268 * @tc.level Level 1
1269 * @tc.require: SR000H0386
1270 */
1271 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0012, testing::ext::TestSize.Level1)
1272 {
1273 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0012";
1274 try {
1275 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1276 EXPECT_NE(fileAccessHelper, nullptr);
1277 vector<RootInfo> info;
1278 int result = fileAccessHelper->GetRoots(info);
1279 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1280 for (size_t i = 0; i < info.size(); i++) {
1281 Uri parentUri(info[i].uri);
1282 Uri newDirUriTest1("");
1283 Uri newDirUriTest2("");
1284 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1285 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1286 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1287 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1288 Uri testUri("");
1289 std::string displayName = "test3.txt";
1290 result = fileAccessHelper->CreateFile(newDirUriTest1, displayName, testUri);
1291 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1292 Uri testUri2("");
1293 g_num = 0;
1294 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
1295 std::thread execthread(MoveTdd, fileAccessHelper, testUri, newDirUriTest2, testUri2);
1296 execthread.join();
1297 }
1298 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
1299 result = fileAccessHelper->Delete(newDirUriTest1);
1300 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1301 result = fileAccessHelper->Delete(newDirUriTest2);
1302 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1303 }
1304 } catch (...) {
1305 GTEST_LOG_(ERROR) << "external_file_access_Move_0012 occurs an exception.";
1306 }
1307 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0012";
1308 }
1309
1310 /**
1311 * @tc.number: user_file_service_external_file_access_Move_0013
1312 * @tc.name: external_file_access_Move_0013
1313 * @tc.desc: Test function of Move interface for FAILED because of GetProxyByUri failed.
1314 * @tc.size: MEDIUM
1315 * @tc.type: FUNC
1316 * @tc.level Level 1
1317 * @tc.require: SR000H0387
1318 */
1319 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0013, testing::ext::TestSize.Level1)
1320 {
1321 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0013";
1322 try {
1323 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1324 EXPECT_NE(fileAccessHelper, nullptr);
1325 vector<RootInfo> info;
1326 int result = fileAccessHelper->GetRoots(info);
1327 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1328 Uri parentUri(info[0].uri);
1329 Uri newDirUriTest1("");
1330 Uri newDirUriTest2("");
1331 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1332 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1333 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1334 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1335 Uri testUri("");
1336 result = fileAccessHelper->Mkdir(newDirUriTest1, "test", testUri);
1337 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1338 std::string str = newDirUriTest1.ToString();
1339 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
1340 GTEST_LOG_(ERROR) << "replace BundleName failed.";
1341 EXPECT_TRUE(false);
1342 }
1343 Uri uri(str);
1344 Uri testUri2("");
1345 result = fileAccessHelper->Move(uri, newDirUriTest2, testUri2);
1346 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1347 GTEST_LOG_(INFO) << "Move_0013 result:" << result;
1348 result = fileAccessHelper->Delete(newDirUriTest1);
1349 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1350 result = fileAccessHelper->Delete(newDirUriTest2);
1351 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1352 } catch (...) {
1353 GTEST_LOG_(ERROR) << "external_file_access_Move_0013 occurs an exception.";
1354 }
1355 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0013";
1356 }
1357
1358 /**
1359 * @tc.number: user_file_service_external_file_access_Move_0014
1360 * @tc.name: external_file_access_Move_0014
1361 * @tc.desc: Test function of Move interface for SUCCESS which move file, the file name is chinese.
1362 * @tc.size: MEDIUM
1363 * @tc.type: FUNC
1364 * @tc.level Level 1
1365 * @tc.require: I70SX9
1366 */
1367 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0014, testing::ext::TestSize.Level1)
1368 {
1369 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0014";
1370 try {
1371 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1372 EXPECT_NE(fileAccessHelper, nullptr);
1373 vector<RootInfo> info;
1374 int result = fileAccessHelper->GetRoots(info);
1375 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1376 for (size_t i = 0; i < info.size(); i++) {
1377 Uri parentUri(info[i].uri);
1378 Uri newDirUriTest1("");
1379 Uri newDirUriTest2("");
1380 result = fileAccessHelper->Mkdir(parentUri, "测试目录1", newDirUriTest1);
1381 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1382 EXPECT_EQ(newDirUriTest1.ToString().find("测试目录1"), std::string::npos);
1383 result = fileAccessHelper->Mkdir(parentUri, "测试目录2", newDirUriTest2);
1384 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1385 EXPECT_EQ(newDirUriTest2.ToString().find("测试目录2"), std::string::npos);
1386 Uri testUri("");
1387 result = fileAccessHelper->CreateFile(newDirUriTest1, "移动文件.txt", testUri);
1388 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1389 EXPECT_EQ(testUri.ToString().find("移动文件.txt"), std::string::npos);
1390 Uri testUri2("");
1391 result = fileAccessHelper->Move(testUri, newDirUriTest2, testUri2);
1392 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1393 GTEST_LOG_(INFO) << "Move_0014 result:" << result;
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 }
1399 } catch (...) {
1400 GTEST_LOG_(ERROR) << "external_file_access_Move_0014 occurs an exception.";
1401 }
1402 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0014";
1403 }
1404
1405 /**
1406 * @tc.number: user_file_service_external_file_access_Move_0015
1407 * @tc.name: external_file_access_Move_0015
1408 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder，
1409 * the folder name is chinese.
1410 * @tc.size: MEDIUM
1411 * @tc.type: FUNC
1412 * @tc.level Level 1
1413 * @tc.require: I70SX9
1414 */
1415 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0015, testing::ext::TestSize.Level1)
1416 {
1417 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0015";
1418 try {
1419 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1420 EXPECT_NE(fileAccessHelper, nullptr);
1421 vector<RootInfo> info;
1422 int result = fileAccessHelper->GetRoots(info);
1423 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1424 for (size_t i = 0; i < info.size(); i++) {
1425 Uri parentUri(info[i].uri);
1426 Uri newDirUriTest1("");
1427 Uri newDirUriTest2("");
1428 result = fileAccessHelper->Mkdir(parentUri, "移动目录", newDirUriTest1);
1429 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1430 EXPECT_EQ(newDirUriTest1.ToString().find("移动目录"), std::string::npos);
1431 result = fileAccessHelper->Mkdir(parentUri, "test2", newDirUriTest2);
1432 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1433 Uri testUri2("");
1434 result = fileAccessHelper->Move(newDirUriTest1, newDirUriTest2, testUri2);
1435 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1436 GTEST_LOG_(INFO) << "Move_0015 result:" << result;
1437 result = fileAccessHelper->Delete(newDirUriTest2);
1438 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1439 }
1440 } catch (...) {
1441 GTEST_LOG_(ERROR) << "external_file_access_Move_0015 occurs an exception.";
1442 }
1443 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0015";
1444 }
1445
1446 /**
1447 * @tc.number: user_file_service_external_file_access_Move_0016
1448 * @tc.name: external_file_access_Move_0016
1449 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder，
1450 * the folder name is chinese.
1451 * @tc.size: MEDIUM
1452 * @tc.type: FUNC
1453 * @tc.level Level 1
1454 * @tc.require: I70SX9
1455 */
1456 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0016, testing::ext::TestSize.Level1)
1457 {
1458 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0016";
1459 try {
1460 shared_ptr<FileAccessHelper> fileAccessHelper = FileExtensionHelperTest::GetFileAccessHelper();
1461 EXPECT_NE(fileAccessHelper, nullptr);
1462 vector<RootInfo> info;
1463 int result = fileAccessHelper->GetRoots(info);
1464 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1465 for (size_t i = 0; i < info.size(); i++) {
1466 Uri parentUri(info[i].uri);
1467 Uri newDirUriTest1("");
1468 Uri newDirUriTest2("");
1469 result = fileAccessHelper->Mkdir(parentUri, "test1", newDirUriTest1);
1470 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1471 result = fileAccessHelper->Mkdir(parentUri, "移动目录", newDirUriTest2);
1472 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1473 Uri testUri2("");
1474 result = fileAccessHelper->Move(newDirUriTest1, newDirUriTest2, testUri2);
1475 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1476 GTEST_LOG_(INFO) << "Move_0016 result:" << result;
1477 result = fileAccessHelper->Delete(newDirUriTest2);
1478 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1479 }
1480 } catch (...) {
1481 GTEST_LOG_(ERROR) << "external_file_access_Move_0016 occurs an exception.";
1482 }
1483 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0016";
1484 }
1485
1486 /**
1487 * @tc.number: user_file_service_external_file_access_creator_0000
1488 * @tc.name: external_file_access_creator_0000
1489 * @tc.desc: Test function of creator interface.
1490 * @tc.desc: create file access helper for SUCCESS.
1491 * @tc.size: MEDIUM
1492 * @tc.type: FUNC
1493 * @tc.level Level 1
1494 * @tc.require: SR000H0386
1495 */
1496 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0000, testing::ext::TestSize.Level1)
1497 {
1498 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0000";
1499 try {
1500 setuid(UID_TRANSFORM_TMP);
1501 std::pair<shared_ptr<FileAccessHelper>, int> helper =
1502 FileAccessHelper::Creator(FileExtensionHelperTest::GetContext());
1503 setuid(UID_DEFAULT);
1504 ASSERT_TRUE(helper.first != nullptr);
1505 bool succ = helper.first->Release();
1506 EXPECT_TRUE(succ);
1507 } catch (...) {
1508 GTEST_LOG_(ERROR) << "external_file_access_creator_0000 occurs an exception.";
1509 }
1510 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0000";
1511 }
1512
1513 /**
1514 * @tc.number: user_file_service_external_file_access_creator_0001
1515 * @tc.name: external_file_access_creator_0001
1516 * @tc.desc: Test function of creator interface.
1517 * @tc.desc: create file access helper for SUCCESS.
1518 * @tc.size: MEDIUM
1519 * @tc.type: FUNC
1520 * @tc.level Level 1
1521 * @tc.require: SR000H0386
1522 */
1523 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0001, testing::ext::TestSize.Level1)
1524 {
1525 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0001";
1526 try {
1527 AAFwk::Want want;
1528 vector<AAFwk::Want> wantVec;
1529 setuid(UID_TRANSFORM_TMP);
1530 int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec);
1531 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1532 bool sus = false;
1533 for (size_t i = 0; i < wantVec.size(); i++) {
1534 auto element = wantVec[i].GetElement();
1535 if (element.GetBundleName() == "com.ohos.UserFile.ExternalFileManager" &&
1536 element.GetAbilityName() == "FileExtensionAbility") {
1537 want = wantVec[i];
1538 sus = true;
1539 break;
1540 }
1541 }
1542 EXPECT_TRUE(sus);
1543 vector<AAFwk::Want> wants{want};
1544 std::pair<shared_ptr<FileAccessHelper>, int> helper =
1545 FileAccessHelper::Creator(FileExtensionHelperTest::GetContext(), wants);
1546 setuid(UID_DEFAULT);
1547 ASSERT_TRUE(helper.first != nullptr);
1548 bool succ = helper.first->Release();
1549 EXPECT_TRUE(succ);
1550 } catch (...) {
1551 GTEST_LOG_(ERROR) << "external_file_access_creator_0001 occurs an exception.";
1552 }
1553 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0001";
1554 }
1555
1556 /**
1557 * @tc.number: user_file_service_external_file_access_creator_0002
1558 * @tc.name: external_file_access_creator_0002
1559 * @tc.desc: Test function of creator interface.
1560 * @tc.desc: create file access helper for FAILED.
1561 * @tc.size: MEDIUM
1562 * @tc.type: FUNC
1563 * @tc.level Level 1
1564 * @tc.require: SR000H0386
1565 */
1566 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0002, testing::ext::TestSize.Level1)
1567 {
1568 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0002";
1569 try {
1570 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
1571 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(context);
1572 ASSERT_TRUE(helper.first == nullptr);
1573 } catch (...) {
1574 GTEST_LOG_(ERROR) << "external_file_access_creator_0002 occurs an exception.";
1575 }
1576 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0002";
1577 }
1578
1579 /**
1580 * @tc.number: user_file_service_external_file_access_creator_0003
1581 * @tc.name: external_file_access_creator_0003
1582 * @tc.desc: Test function of creator interface.
1583 * @tc.desc: create file access helper for FAILED.
1584 * @tc.size: MEDIUM
1585 * @tc.type: FUNC
1586 * @tc.level Level 1
1587 * @tc.require: SR000H0386
1588 */
1589 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0003, testing::ext::TestSize.Level1)
1590 {
1591 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0003";
1592 try {
1593 std::vector<AAFwk::Want> wants;
1594 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
1595 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(context, wants);
1596 ASSERT_TRUE(helper.first == nullptr);
1597 } catch (...) {
1598 GTEST_LOG_(ERROR) << "external_file_access_creator_0003 occurs an exception.";
1599 }
1600 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0003";
1601 }
1602
1603 /**
1604 * @tc.number: user_file_service_external_file_access_creator_0004
1605 * @tc.name: external_file_access_creator_0004
1606 * @tc.desc: Test function of creator interface.
1607 * @tc.desc: create file access helper for FAILED.
1608 * @tc.size: MEDIUM
1609 * @tc.type: FUNC
1610 * @tc.level Level 1
1611 * @tc.require: SR000H0386
1612 */
1613 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0004, testing::ext::TestSize.Level1)
1614 {
1615 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0004";
1616 try {
1617 std::vector<AAFwk::Want> wants;
1618 std::pair<shared_ptr<FileAccessHelper>, int> helper =
1619 FileAccessHelper::Creator(FileExtensionHelperTest::GetContext(), wants);
1620 ASSERT_TRUE(helper.first == nullptr);
1621 } catch (...) {
1622 GTEST_LOG_(ERROR) << "external_file_access_creator_0004 occurs an exception.";
1623 }
1624 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0004";
1625 }
1626
1627 /**
1628 * @tc.number: user_file_service_external_file_access_creator_0005
1629 * @tc.name: external_file_access_creator_0005
1630 * @tc.desc: Test function of creator interface.
1631 * @tc.desc: create file access helper for FAILED.
1632 * @tc.size: MEDIUM
1633 * @tc.type: FUNC
1634 * @tc.level Level 1
1635 * @tc.require: SR000H0386
1636 */
1637 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0005, testing::ext::TestSize.Level1)
1638 {
1639 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0005";
1640 try {
1641 AAFwk::Want want;
1642 want.SetElementName("NotExistBundleName", "NotExistAbilityName");
1643 std::vector<AAFwk::Want> wants{want};
1644 std::pair<shared_ptr<FileAccessHelper>, int> helper =
1645 FileAccessHelper::Creator(FileExtensionHelperTest::GetContext(), wants);
1646 ASSERT_TRUE(helper.first == nullptr);
1647 } catch (...) {
1648 GTEST_LOG_(ERROR) << "external_file_access_creator_0005 occurs an exception.";
1649 }
1650 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0005";
1651 }
1652
1653 /**
1654 * @tc.number: user_file_service_external_file_access_creator_0006
1655 * @tc.name: external_file_access_creator_0006
1656 * @tc.desc: Test function of creator interface.
1657 * @tc.desc: create file access helper for FAILED.
1658 * @tc.size: MEDIUM
1659 * @tc.type: FUNC
1660 * @tc.level Level 1
1661 * @tc.require: SR000H0386
1662 */
1663 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0006, testing::ext::TestSize.Level1)
1664 {
1665 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0006";
1666 try {
1667 std::vector<AAFwk::Want> wants;
1668 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
1669 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(context, wants);
1670 ASSERT_TRUE(helper.first == nullptr);
1671 } catch (...) {
1672 GTEST_LOG_(ERROR) << "external_file_access_creator_0006 occurs an exception.";
1673 }
1674 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0006";
1675 }
1676
1677 /**
1678 * @tc.number: user_file_service_external_file_access_creator_0007
1679 * @tc.name: external_file_access_creator_0007
1680 * @tc.desc: Test function of creator interface.
1681 * @tc.desc: create file access helper for FAILED.
1682 * @tc.size: MEDIUM
1683 * @tc.type: FUNC
1684 * @tc.level Level 1
1685 * @tc.require: SR000H0386
1686 */
1687 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0007, testing::ext::TestSize.Level1)
1688 {
1689 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0007";
1690 try {
1691 std::vector<AAFwk::Want> wants;
1692 shared_ptr<FileAccessHelper> helper =
1693 FileAccessHelper::Creator(FileExtensionHelperTest::GetContext()->GetToken(), wants);
1694 ASSERT_TRUE(helper == nullptr);
1695 } catch (...) {
1696 GTEST_LOG_(ERROR) << "external_file_access_creator_0007 occurs an exception.";
1697 }
1698 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0007";
1699 }
1700
1701 /**
1702 * @tc.number: user_file_service_external_file_access_creator_0008
1703 * @tc.name: external_file_access_creator_0008
1704 * @tc.desc: Test function of creator interface.
1705 * @tc.desc: create file access helper for FAILED.
1706 * @tc.size: MEDIUM
1707 * @tc.type: FUNC
1708 * @tc.level Level 1
1709 * @tc.require: SR000H0386
1710 */
1711 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0008, testing::ext::TestSize.Level1)
1712 {
1713 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0008";
1714 try {
1715 AAFwk::Want want;
1716 want.SetElementName("NotExistBundleName", "NotExistAbilityName");
1717 std::vector<AAFwk::Want> wants{want};
1718 shared_ptr<FileAccessHelper> helper =
1719 FileAccessHelper::Creator(FileExtensionHelperTest::GetContext()->GetToken(), wants);
1720 ASSERT_TRUE(helper == nullptr);
1721 } catch (...) {
1722 GTEST_LOG_(ERROR) << "external_file_access_creator_0008 occurs an exception.";
1723 }
1724 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0008";
1725 }
1726 }
1727