1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdio>
17 #include <thread>
18 #include <unistd.h>
19
20 #include <gtest/gtest.h>
21 #include <nlohmann/json.hpp>
22
23 #include "accesstoken_kit.h"
24 #include "context_impl.h"
25 #include "file_access_framework_errno.h"
26 #include "iservice_registry.h"
27 #include "nativetoken_kit.h"
28 #include "token_setproc.h"
29
30 #define private public
31 #include "file_access_helper.h"
32 #undef private
33
34 namespace {
35 using namespace std;
36 using namespace OHOS;
37 using namespace FileAccessFwk;
38 using json = nlohmann::json;
39 const int ABILITY_ID = 5003;
40 const int INIT_THREADS_NUMBER = 4;
41 const int ACTUAL_SUCCESS_THREADS_NUMBER = 1;
42 shared_ptr<FileAccessHelper> g_fah = nullptr;
43 int g_num = 0;
44 const int UID_TRANSFORM_TMP = 20000000;
45 const int UID_DEFAULT = 0;
46 shared_ptr<OHOS::AbilityRuntime::Context> g_context = nullptr;
47 const int FILE_COUNT_1 = 1;
48 const int FILE_COUNT_2 = 2;
49 const int FILE_COUNT_3 = 3;
50 const int FILE_COUNT_4 = 4;
51 const int FILE_COUNT_5 = 5;
52 const int FILE_COUNT_6 = 6;
53 const int SLEEP_TIME = 2;
54
SetNativeToken()55 void SetNativeToken()
56 {
57 uint64_t tokenId;
58 const char **perms = new const char *[1];
59 perms[0] = "ohos.permission.FILE_ACCESS_MANAGER";
60 NativeTokenInfoParams infoInstance = {
61 .dcapsNum = 0,
62 .permsNum = 1,
63 .aclsNum = 0,
64 .dcaps = nullptr,
65 .perms = perms,
66 .acls = nullptr,
67 .aplStr = "system_core",
68 };
69
70 infoInstance.processName = "SetUpTestCase";
71 tokenId = GetAccessTokenId(&infoInstance);
72 const uint64_t systemAppMask = (static_cast<uint64_t>(1) << 32);
73 tokenId |= systemAppMask;
74 SetSelfTokenID(tokenId);
75 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
76 delete[] perms;
77 }
78
79 class FileExtensionHelperTest : public testing::Test {
80 public:
SetUpTestCase(void)81 static void SetUpTestCase(void)
82 {
83 cout << "FileExtensionHelperTest code test" << endl;
84 SetNativeToken();
85 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
86 auto remoteObj = saManager->GetSystemAbility(ABILITY_ID);
87 g_context = make_shared<OHOS::AbilityRuntime::ContextImpl>();
88 g_context->SetToken(remoteObj);
89 AAFwk::Want want;
90 vector<AAFwk::Want> wantVec;
91 setuid(UID_TRANSFORM_TMP);
92 int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec);
93 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
94 bool sus = false;
95 for (size_t i = 0; i < wantVec.size(); i++) {
96 auto element = wantVec[i].GetElement();
97 if (element.GetBundleName() == "com.ohos.UserFile.ExternalFileManager" &&
98 element.GetAbilityName() == "FileExtensionAbility") {
99 want = wantVec[i];
100 sus = true;
101 break;
102 }
103 }
104 EXPECT_TRUE(sus);
105 vector<AAFwk::Want> wants{want};
106 g_fah = FileAccessHelper::Creator(remoteObj, wants);
107 if (g_fah == nullptr) {
108 GTEST_LOG_(ERROR) << "external_file_access_test g_fah is nullptr";
109 exit(1);
110 }
111 setuid(UID_DEFAULT);
112 }
TearDownTestCase()113 static void TearDownTestCase()
114 {
115 g_fah->Release();
116 g_fah = nullptr;
117 };
SetUp()118 void SetUp(){};
TearDown()119 void TearDown(){};
120 };
121
122 /**
123 * @tc.number: user_file_service_external_file_access_OpenFile_0000
124 * @tc.name: external_file_access_OpenFile_0000
125 * @tc.desc: Test function of OpenFile interface for SUCCESS.
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_OpenFile_0000, testing::ext::TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0000";
134 try {
135 vector<RootInfo> info;
136 int result = g_fah->GetRoots(info);
137 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
138 for (size_t i = 0; i < info.size(); i++) {
139 Uri parentUri(info[i].uri);
140 GTEST_LOG_(INFO) << parentUri.ToString();
141 Uri newDirUriTest1("");
142 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
143 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
144 Uri newFileUri("");
145 result = g_fah->CreateFile(newDirUriTest1, "external_file_access_OpenFile_0000.txt", newFileUri);
146 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
147 int fd;
148 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
149 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
150 GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result;
151 close(fd);
152 result = g_fah->Delete(newDirUriTest1);
153 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
154 }
155 } catch (...) {
156 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0000 occurs an exception.";
157 }
158 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0000";
159 }
160
161 /**
162 * @tc.number: user_file_service_external_file_access_OpenFile_0001
163 * @tc.name: external_file_access_OpenFile_0001
164 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null.
165 * @tc.size: MEDIUM
166 * @tc.type: FUNC
167 * @tc.level Level 1
168 * @tc.require: SR000H0386
169 */
170 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0001, testing::ext::TestSize.Level1)
171 {
172 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0001";
173 try {
174 Uri uri("");
175 int fd;
176 int result = g_fah->OpenFile(uri, WRITE_READ, fd);
177 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
178 GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result;
179 } catch (...) {
180 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0001 occurs an exception.";
181 }
182 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0001";
183 }
184
185 /**
186 * @tc.number: user_file_service_external_file_access_OpenFile_0002
187 * @tc.name: external_file_access_OpenFile_0002
188 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path.
189 * @tc.size: MEDIUM
190 * @tc.type: FUNC
191 * @tc.level Level 1
192 * @tc.require: SR000H0386
193 */
194 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0002, testing::ext::TestSize.Level1)
195 {
196 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0002";
197 try {
198 vector<RootInfo> info;
199 int result = g_fah->GetRoots(info);
200 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
201 for (size_t i = 0; i < info.size(); i++) {
202 Uri parentUri(info[i].uri);
203 Uri newFileUri("");
204 result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0002.txt", newFileUri);
205 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
206 Uri uri("storage/media/100/local/files/Download/external_file_access_OpenFile_0002.txt");
207 int fd;
208 result = g_fah->OpenFile(uri, WRITE_READ, fd);
209 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
210 GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result;
211 result = g_fah->Delete(newFileUri);
212 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
213 }
214 } catch (...) {
215 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0002 occurs an exception.";
216 }
217 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0002";
218 }
219
220 /**
221 * @tc.number: user_file_service_external_file_access_OpenFile_0003
222 * @tc.name: external_file_access_OpenFile_0003
223 * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols.
224 * @tc.size: MEDIUM
225 * @tc.type: FUNC
226 * @tc.level Level 1
227 * @tc.require: SR000H0386
228 */
229 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0003, testing::ext::TestSize.Level1)
230 {
231 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0003";
232 try {
233 Uri uri("~!@#$%^&*()_");
234 int fd;
235 int result = g_fah->OpenFile(uri, WRITE_READ, fd);
236 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
237 GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result;
238 } catch (...) {
239 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0003 occurs an exception.";
240 }
241 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0003";
242 }
243
244 /**
245 * @tc.number: user_file_service_external_file_access_OpenFile_0004
246 * @tc.name: external_file_access_OpenFile_0004
247 * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1.
248 * @tc.size: MEDIUM
249 * @tc.type: FUNC
250 * @tc.level Level 1
251 * @tc.require: SR000H0386
252 */
253 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0004, testing::ext::TestSize.Level1)
254 {
255 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0004";
256 try {
257 vector<RootInfo> info;
258 int result = g_fah->GetRoots(info);
259 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
260 for (size_t i = 0; i < info.size(); i++) {
261 Uri parentUri(info[i].uri);
262 Uri newFileUri("");
263 result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0004.txt", newFileUri);
264 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
265 int fd;
266 int flag = -1;
267 result = g_fah->OpenFile(newFileUri, flag, fd);
268 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
269 GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result;
270 result = g_fah->Delete(newFileUri);
271 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
272 }
273 } catch (...) {
274 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0004 occurs an exception.";
275 }
276 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0004";
277 }
278
279 /**
280 * @tc.number: user_file_service_external_file_access_OpenFile_0005
281 * @tc.name: external_file_access_OpenFile_0005
282 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0.
283 * @tc.size: MEDIUM
284 * @tc.type: FUNC
285 * @tc.level Level 1
286 * @tc.require: SR000H0386
287 */
288 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0005, testing::ext::TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0005";
291 try {
292 vector<RootInfo> info;
293 int result = g_fah->GetRoots(info);
294 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
295 for (size_t i = 0; i < info.size(); i++) {
296 Uri parentUri(info[i].uri);
297 Uri newFileUri("");
298 result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0005.txt", newFileUri);
299 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
300 int fd;
301 result = g_fah->OpenFile(newFileUri, READ, fd);
302 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
303 GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result;
304 close(fd);
305 result = g_fah->Delete(newFileUri);
306 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
307 }
308 } catch (...) {
309 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0005 occurs an exception.";
310 }
311 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0005";
312 }
313
314 /**
315 * @tc.number: user_file_service_external_file_access_OpenFile_0006
316 * @tc.name: external_file_access_OpenFile_0006
317 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1.
318 * @tc.size: MEDIUM
319 * @tc.type: FUNC
320 * @tc.level Level 1
321 * @tc.require: SR000H0386
322 */
323 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0006, testing::ext::TestSize.Level1)
324 {
325 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0006";
326 try {
327 vector<RootInfo> info;
328 int result = g_fah->GetRoots(info);
329 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
330 for (size_t i = 0; i < info.size(); i++) {
331 Uri parentUri(info[i].uri);
332 Uri newFileUri("");
333 result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0006.txt", newFileUri);
334 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
335 int fd;
336 result = g_fah->OpenFile(newFileUri, WRITE, fd);
337 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
338 GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result;
339 close(fd);
340 result = g_fah->Delete(newFileUri);
341 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
342 }
343 } catch (...) {
344 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0006 occurs an exception.";
345 }
346 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0006";
347 }
348
349 /**
350 * @tc.number: user_file_service_external_file_access_OpenFile_0007
351 * @tc.name: external_file_access_OpenFile_0007
352 * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2.
353 * @tc.size: MEDIUM
354 * @tc.type: FUNC
355 * @tc.level Level 1
356 * @tc.require: SR000H0386
357 */
358 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0007, testing::ext::TestSize.Level1)
359 {
360 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0007";
361 try {
362 vector<RootInfo> info;
363 int result = g_fah->GetRoots(info);
364 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
365 for (size_t i = 0; i < info.size(); i++) {
366 Uri parentUri(info[i].uri);
367 Uri newFileUri("");
368 result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0007.txt", newFileUri);
369 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
370 int fd;
371 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
372 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
373 GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result;
374 close(fd);
375 result = g_fah->Delete(newFileUri);
376 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
377 }
378 } catch (...) {
379 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0007 occurs an exception.";
380 }
381 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0007";
382 }
383
OpenFileTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,int flag,int fd)384 static void OpenFileTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, int flag, int fd)
385 {
386 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFileTdd";
387 int ret = fahs->OpenFile(uri, flag, fd);
388 if (ret != OHOS::FileAccessFwk::ERR_OK) {
389 GTEST_LOG_(ERROR) << "OpenFile get result error, code:" << ret;
390 return;
391 }
392 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
393 EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK);
394 g_num++;
395 close(fd);
396 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFileTdd";
397 }
398
399 /**
400 * @tc.number: user_file_service_external_file_access_OpenFile_0008
401 * @tc.name: external_file_access_OpenFile_0008
402 * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent.
403 * @tc.size: MEDIUM
404 * @tc.type: FUNC
405 * @tc.level Level 1
406 * @tc.require: SR000H0386
407 */
408 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0008, testing::ext::TestSize.Level1)
409 {
410 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0008";
411 try {
412 vector<RootInfo> info;
413 int result = g_fah->GetRoots(info);
414 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
415 for (size_t i = 0; i < info.size(); i++) {
416 Uri parentUri(info[i].uri);
417 Uri newFileUri("");
418 int fd;
419 std::string displayName = "test1.txt";
420 g_num = 0;
421 result = g_fah->CreateFile(parentUri, displayName, newFileUri);
422 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
423 for (size_t j = 0; j < INIT_THREADS_NUMBER; j++) {
424 std::thread execthread(OpenFileTdd, g_fah, newFileUri, WRITE_READ, fd);
425 execthread.join();
426 }
427 EXPECT_EQ(g_num, INIT_THREADS_NUMBER);
428 result = g_fah->Delete(newFileUri);
429 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
430 }
431 } catch (...) {
432 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0008 occurs an exception.";
433 }
434 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0008";
435 }
436
ReplaceBundleNameFromPath(std::string & path,const std::string & newName)437 static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName)
438 {
439 Uri uri(path);
440 std::string scheme = uri.GetScheme();
441 if (scheme == FILE_SCHEME_NAME) {
442 std::string curName = uri.GetAuthority();
443 if (curName.empty()) {
444 return false;
445 }
446 path.replace(path.find(curName), curName.length(), newName);
447 return true;
448 }
449
450 std::string tPath = uri.GetPath();
451 if (tPath.empty()) {
452 GTEST_LOG_(INFO) << "Uri path error.";
453 return false;
454 }
455
456 if (tPath.front() != '/') {
457 GTEST_LOG_(INFO) << "Uri path format error.";
458 return false;
459 }
460
461 auto index = tPath.substr(1).find_first_of("/");
462 auto bundleName = tPath.substr(1, index);
463 if (bundleName.empty()) {
464 GTEST_LOG_(INFO) << "bundleName empty.";
465 return false;
466 }
467
468 path.replace(path.find(bundleName), bundleName.length(), newName);
469 return true;
470 }
471
472 /**
473 * @tc.number: user_file_service_external_file_access_OpenFile_0009
474 * @tc.name: external_file_access_OpenFile_0009
475 * @tc.desc: Test function of OpenFile interface for FAILED because of GetProxyByUri failed.
476 * @tc.size: MEDIUM
477 * @tc.type: FUNC
478 * @tc.level Level 1
479 * @tc.require: SR000H0386
480 */
481 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0009, testing::ext::TestSize.Level1)
482 {
483 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0009";
484 try {
485 vector<RootInfo> info;
486 int result = g_fah->GetRoots(info);
487 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
488 for (size_t i = 0; i < info.size(); i++) {
489 std::string str = info[i].uri;
490 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
491 GTEST_LOG_(ERROR) << "replace BundleName failed.";
492 EXPECT_TRUE(false);
493 }
494 int fd;
495 Uri newFileUri(str + "/NotExistFile.txt");
496 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
497 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
498 GTEST_LOG_(INFO) << "OpenFile_0009 result:" << result;
499 }
500 } catch (...) {
501 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0009 occurs an exception.";
502 }
503 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0009";
504 }
505
506 /**
507 * @tc.number: user_file_service_external_file_access_OpenFile_0010
508 * @tc.name: external_file_access_OpenFile_0010
509 * @tc.desc: Test function of OpenFile interface for SUCCESS, the file name is chinese.
510 * @tc.size: MEDIUM
511 * @tc.type: FUNC
512 * @tc.level Level 1
513 * @tc.require: I70SX9
514 */
515 HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0010, testing::ext::TestSize.Level1)
516 {
517 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0010";
518 try {
519 vector<RootInfo> info;
520 int result = g_fah->GetRoots(info);
521 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
522 for (size_t i = 0; i < info.size(); i++) {
523 Uri parentUri(info[i].uri);
524 GTEST_LOG_(INFO) << parentUri.ToString();
525 Uri newDirUriTest1("");
526 result = g_fah->Mkdir(parentUri, "测试目录", newDirUriTest1);
527 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
528 EXPECT_EQ(newDirUriTest1.ToString().find("测试目录"), std::string::npos);
529 Uri newFileUri("");
530 result = g_fah->CreateFile(newDirUriTest1, "打开文件.txt", newFileUri);
531 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
532 EXPECT_EQ(newFileUri.ToString().find("打开文件.txt"), std::string::npos);
533 int fd;
534 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
535 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
536 GTEST_LOG_(INFO) << "OpenFile_0010 result:" << result;
537 close(fd);
538 result = g_fah->Delete(newDirUriTest1);
539 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
540 }
541 } catch (...) {
542 GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0010 occurs an exception.";
543 }
544 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0010";
545 }
546
547 /**
548 * @tc.number: user_file_service_external_file_access_CreateFile_0000
549 * @tc.name: external_file_access_CreateFile_0000
550 * @tc.desc: Test function of CreateFile interface for SUCCESS.
551 * @tc.size: MEDIUM
552 * @tc.type: FUNC
553 * @tc.level Level 1
554 * @tc.require: SR000H0386
555 */
556 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0000, testing::ext::TestSize.Level1)
557 {
558 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0000";
559 try {
560 vector<RootInfo> info;
561 int result = g_fah->GetRoots(info);
562 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
563 for (size_t i = 0; i < info.size(); i++) {
564 Uri parentUri(info[i].uri);
565 Uri newFileUri("");
566 result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0000.txt", newFileUri);
567 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
568 GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result;
569 result = g_fah->Delete(newFileUri);
570 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
571 }
572 } catch (...) {
573 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0000 occurs an exception.";
574 }
575 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0000";
576 }
577
578 /**
579 * @tc.number: user_file_service_external_file_access_CreateFile_0001
580 * @tc.name: external_file_access_CreateFile_0001
581 * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null.
582 * @tc.size: MEDIUM
583 * @tc.type: FUNC
584 * @tc.level Level 1
585 * @tc.require: SR000H0386
586 */
587 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0001, testing::ext::TestSize.Level1)
588 {
589 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0001";
590 try {
591 Uri newFileUri("");
592 Uri parentUri("");
593 int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0001.txt", newFileUri);
594 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
595 GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result;
596 } catch (...) {
597 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0001 occurs an exception.";
598 }
599 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0001";
600 }
601
602 /**
603 * @tc.number: user_file_service_external_file_access_CreateFile_0002
604 * @tc.name: external_file_access_CreateFile_0002
605 * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path.
606 * @tc.size: MEDIUM
607 * @tc.type: FUNC
608 * @tc.level Level 1
609 * @tc.require: SR000H0386
610 */
611 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0002, testing::ext::TestSize.Level1)
612 {
613 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002";
614 try {
615 Uri newFileUri("");
616 Uri parentUri("storage/media/100/local/files/Download");
617 int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0002.txt", newFileUri);
618 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
619 GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result;
620 } catch (...) {
621 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0002 occurs an exception.";
622 }
623 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0002";
624 }
625
626 /**
627 * @tc.number: user_file_service_external_file_access_CreateFile_0003
628 * @tc.name: external_file_access_CreateFile_0003
629 * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols.
630 * @tc.size: MEDIUM
631 * @tc.type: FUNC
632 * @tc.level Level 1
633 * @tc.require: SR000H0386
634 */
635 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0003, testing::ext::TestSize.Level1)
636 {
637 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002";
638 try {
639 Uri newFileUri("");
640 Uri parentUri("~!@#$%^&*()_");
641 int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0003.txt", newFileUri);
642 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
643 GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result;
644 } catch (...) {
645 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0003 occurs an exception.";
646 }
647 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0003";
648 }
649
650 /**
651 * @tc.number: user_file_service_external_file_access_CreateFile_0004
652 * @tc.name: external_file_access_CreateFile_0004
653 * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null.
654 * @tc.size: MEDIUM
655 * @tc.type: FUNC
656 * @tc.level Level 1
657 * @tc.require: SR000H0386
658 */
659 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0004, testing::ext::TestSize.Level1)
660 {
661 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0004";
662 try {
663 vector<RootInfo> info;
664 int result = g_fah->GetRoots(info);
665 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
666 for (size_t i = 0; i < info.size(); i++) {
667 Uri parentUri(info[i].uri);
668 Uri newFileUri("");
669 string displayName = "";
670 result = g_fah->CreateFile(parentUri, displayName, newFileUri);
671 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
672 GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result;
673 }
674 } catch (...) {
675 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0004 occurs an exception.";
676 }
677 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0004";
678 }
679
CreateFileTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,std::string displayName,Uri newFile)680 static void CreateFileTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, std::string displayName, Uri newFile)
681 {
682 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFileTdd";
683 int ret = fahs->CreateFile(uri, displayName, newFile);
684 if (ret != OHOS::FileAccessFwk::ERR_OK) {
685 GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret;
686 return;
687 }
688 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
689 EXPECT_NE(newFile.ToString(), "");
690 g_num++;
691 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFileTdd";
692 }
693
694 /**
695 * @tc.number: user_file_service_external_file_access_CreateFile_0005
696 * @tc.name: external_file_access_CreateFile_0005
697 * @tc.desc: Test function of CreateFile interface for ERROR which Concurrent.
698 * @tc.size: MEDIUM
699 * @tc.type: FUNC
700 * @tc.level Level 1
701 * @tc.require: SR000H0386
702 */
703 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0005, testing::ext::TestSize.Level1)
704 {
705 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0005";
706 try {
707 vector<RootInfo> info;
708 int result = g_fah->GetRoots(info);
709 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
710 for (size_t i = 0; i < info.size(); i++) {
711 Uri parentUri(info[i].uri);
712 Uri newFileUri("");
713 std::string displayName = "test1.txt";
714 g_num = 0;
715 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
716 std::thread execthread(CreateFileTdd, g_fah, parentUri, displayName, newFileUri);
717 execthread.join();
718 }
719 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
720 Uri newDelete(info[i].uri + "/" + displayName);
721 result = g_fah->Delete(newDelete);
722 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
723 }
724 } catch (...) {
725 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0005 occurs an exception.";
726 }
727 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0005";
728 }
729
730 /**
731 * @tc.number: user_file_service_external_file_access_CreateFile_0006
732 * @tc.name: external_file_access_CreateFile_0006
733 * @tc.desc: Test function of CreateFile interface for ERROR because of GetProxyByUri failed.
734 * @tc.size: MEDIUM
735 * @tc.type: FUNC
736 * @tc.level Level 1
737 * @tc.require: SR000H0386
738 */
739 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0006, testing::ext::TestSize.Level1)
740 {
741 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0006";
742 try {
743 vector<RootInfo> info;
744 int result = g_fah->GetRoots(info);
745 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
746 for (size_t i = 0; i < info.size(); i++) {
747 std::string str = info[i].uri;
748 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
749 GTEST_LOG_(ERROR) << "replace BundleName failed.";
750 EXPECT_TRUE(false);
751 }
752 Uri parentUri(str);
753 Uri newFileUri("");
754 string displayName = "test.txt";
755 result = g_fah->CreateFile(parentUri, displayName, newFileUri);
756 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
757 GTEST_LOG_(INFO) << "CreateFile_0006 result:" << result;
758 }
759 } catch (...) {
760 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0006 occurs an exception.";
761 }
762 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0006";
763 }
764
765 /**
766 * @tc.number: user_file_service_external_file_access_CreateFile_0007
767 * @tc.name: external_file_access_CreateFile_0007
768 * @tc.desc: Test function of CreateFile interface for SUCCESS, the file name is chinese.
769 * @tc.size: MEDIUM
770 * @tc.type: FUNC
771 * @tc.level Level 1
772 * @tc.require: I70SX9
773 */
774 HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0007, testing::ext::TestSize.Level1)
775 {
776 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0007";
777 try {
778 vector<RootInfo> info;
779 int result = g_fah->GetRoots(info);
780 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
781 for (size_t i = 0; i < info.size(); i++) {
782 Uri parentUri(info[i].uri);
783 Uri newFileUri("");
784 result = g_fah->CreateFile(parentUri, "新建文件.txt", newFileUri);
785 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
786 EXPECT_EQ(newFileUri.ToString().find("新建文件.txt"), std::string::npos);
787 GTEST_LOG_(INFO) << "CreateFile_0007 result:" << result;
788 result = g_fah->Delete(newFileUri);
789 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
790 }
791 } catch (...) {
792 GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0007 occurs an exception.";
793 }
794 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0007";
795 }
796
797 /**
798 * @tc.number: user_file_service_external_file_access_Mkdir_0000
799 * @tc.name: external_file_access_Mkdir_0000
800 * @tc.desc: Test function of Mkdir interface for SUCCESS.
801 * @tc.size: MEDIUM
802 * @tc.type: FUNC
803 * @tc.level Level 1
804 * @tc.require: SR000H0386
805 */
806 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0000, testing::ext::TestSize.Level1)
807 {
808 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0000";
809 try {
810 vector<RootInfo> info;
811 int result = g_fah->GetRoots(info);
812 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
813 for (size_t i = 0; i < info.size(); i++) {
814 Uri parentUri(info[i].uri);
815 Uri newDirUriTest("");
816 result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0000", newDirUriTest);
817 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
818 GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result;
819 result = g_fah->Delete(newDirUriTest);
820 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
821 }
822 } catch (...) {
823 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0000 occurs an exception.";
824 }
825 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0000";
826 }
827
828 /**
829 * @tc.number: user_file_service_external_file_access_Mkdir_0001
830 * @tc.name: external_file_access_Mkdir_0001
831 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null.
832 * @tc.size: MEDIUM
833 * @tc.type: FUNC
834 * @tc.level Level 1
835 * @tc.require: SR000H0386
836 */
837 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0001, testing::ext::TestSize.Level1)
838 {
839 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0001";
840 try {
841 Uri newDirUriTest("");
842 Uri parentUri("");
843 int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0001", newDirUriTest);
844 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
845 GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result;
846 } catch (...) {
847 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0001 occurs an exception.";
848 }
849 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0001";
850 }
851
852 /**
853 * @tc.number: user_file_service_external_file_access_Mkdir_0002
854 * @tc.name: external_file_access_Mkdir_0002
855 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path.
856 * @tc.size: MEDIUM
857 * @tc.type: FUNC
858 * @tc.level Level 1
859 * @tc.require: SR000H0386
860 */
861 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0002, testing::ext::TestSize.Level1)
862 {
863 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002";
864 try {
865 Uri newDirUriTest("");
866 Uri parentUri("storage/media/100/local/files/Download");
867 int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0002", newDirUriTest);
868 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
869 GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result;
870 } catch (...) {
871 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0002 occurs an exception.";
872 }
873 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0002";
874 }
875
876 /**
877 * @tc.number: user_file_service_external_file_access_Mkdir_0003
878 * @tc.name: external_file_access_Mkdir_0003
879 * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols.
880 * @tc.size: MEDIUM
881 * @tc.type: FUNC
882 * @tc.level Level 1
883 * @tc.require: SR000H0386
884 */
885 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0003, testing::ext::TestSize.Level1)
886 {
887 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002";
888 try {
889 Uri newDirUriTest("");
890 Uri parentUri("~!@#$%^&*()_");
891 int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0003", newDirUriTest);
892 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
893 GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result;
894 } catch (...) {
895 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0003 occurs an exception.";
896 }
897 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0003";
898 }
899
900 /**
901 * @tc.number: user_file_service_external_file_access_Mkdir_0004
902 * @tc.name: external_file_access_Mkdir_0004
903 * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null.
904 * @tc.size: MEDIUM
905 * @tc.type: FUNC
906 * @tc.level Level 1
907 * @tc.require: SR000H0386
908 */
909 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0004, testing::ext::TestSize.Level1)
910 {
911 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0004";
912 try {
913 vector<RootInfo> info;
914 int result = g_fah->GetRoots(info);
915 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
916 for (size_t i = 0; i < info.size(); i++) {
917 Uri parentUri(info[i].uri);
918 Uri newDirUriTest("");
919 string displayName = "";
920 result = g_fah->Mkdir(parentUri, displayName, newDirUriTest);
921 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
922 GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result;
923 }
924 } catch (...) {
925 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0004 occurs an exception.";
926 }
927 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0004";
928 }
929
MkdirTdd(shared_ptr<FileAccessHelper> fahs,Uri uri,std::string displayName,Uri newFile)930 static void MkdirTdd(shared_ptr<FileAccessHelper> fahs, Uri uri, std::string displayName, Uri newFile)
931 {
932 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MkdirTdd";
933 int ret = fahs->Mkdir(uri, displayName, newFile);
934 if (ret != OHOS::FileAccessFwk::ERR_OK) {
935 GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret;
936 return;
937 }
938 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
939 EXPECT_NE(newFile.ToString(), "");
940 g_num++;
941 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MkdirTdd";
942 }
943
944 /**
945 * @tc.number: user_file_service_external_file_access_Mkdir_0005
946 * @tc.name: external_file_access_Mkdir_0005
947 * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent.
948 * @tc.size: MEDIUM
949 * @tc.type: FUNC
950 * @tc.level Level 1
951 * @tc.require: SR000H0386
952 */
953 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0005, testing::ext::TestSize.Level1)
954 {
955 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0005";
956 try {
957 vector<RootInfo> info;
958 int result = g_fah->GetRoots(info);
959 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
960 for (size_t i = 0; i < info.size(); i++) {
961 Uri parentUri(info[i].uri);
962 Uri newDirUriTest("");
963 std::string displayName = "test1";
964 g_num = 0;
965 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
966 std::thread execthread(MkdirTdd, g_fah, parentUri, displayName, newDirUriTest);
967 execthread.join();
968 }
969 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
970 Uri newDelete(info[i].uri + "/" + displayName);
971 result = g_fah->Delete(newDelete);
972 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
973 }
974 } catch (...) {
975 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0005 occurs an exception.";
976 }
977 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0005";
978 }
979
980 /**
981 * @tc.number: user_file_service_external_file_access_Mkdir_0006
982 * @tc.name: external_file_access_Mkdir_0006
983 * @tc.desc: Test function of Mkdir interface for ERROR because of GetProxyByUri failed.
984 * @tc.size: MEDIUM
985 * @tc.type: FUNC
986 * @tc.level Level 1
987 * @tc.require: SR000H0386
988 */
989 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0006, testing::ext::TestSize.Level1)
990 {
991 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0006";
992 try {
993 vector<RootInfo> info;
994 int result = g_fah->GetRoots(info);
995 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
996 for (size_t i = 0; i < info.size(); i++) {
997 std::string str = info[i].uri;
998 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
999 GTEST_LOG_(ERROR) << "replace BundleName failed.";
1000 EXPECT_TRUE(false);
1001 }
1002 Uri parentUri(str);
1003 Uri newDirUriTest("");
1004 string displayName = "";
1005 result = g_fah->Mkdir(parentUri, displayName, newDirUriTest);
1006 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
1007 GTEST_LOG_(INFO) << "Mkdir_0006 result:" << result;
1008 }
1009 } catch (...) {
1010 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0006 occurs an exception.";
1011 }
1012 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0006";
1013 }
1014
1015 /**
1016 * @tc.number: user_file_service_external_file_access_Mkdir_0007
1017 * @tc.name: external_file_access_Mkdir_0007
1018 * @tc.desc: Test function of Mkdir interface for SUCCESS，the folder name is chinese.
1019 * @tc.size: MEDIUM
1020 * @tc.type: FUNC
1021 * @tc.level Level 1
1022 * @tc.require: I70SX9
1023 */
1024 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0007, testing::ext::TestSize.Level1)
1025 {
1026 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0007";
1027 try {
1028 vector<RootInfo> info;
1029 int result = g_fah->GetRoots(info);
1030 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1031 for (size_t i = 0; i < info.size(); i++) {
1032 Uri parentUri(info[i].uri);
1033 Uri newDirUriTest("");
1034 result = g_fah->Mkdir(parentUri, "新建目录", newDirUriTest);
1035 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1036 EXPECT_EQ(newDirUriTest.ToString().find("新建目录"), std::string::npos);
1037 GTEST_LOG_(INFO) << "Mkdir_0007 result:" << result;
1038 result = g_fah->Delete(newDirUriTest);
1039 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1040 }
1041 } catch (...) {
1042 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0007 occurs an exception.";
1043 }
1044 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0007";
1045 }
1046
1047 /**
1048 * @tc.number: user_file_service_external_file_access_Mkdir_0008
1049 * @tc.name: external_file_access_Mkdir_0008
1050 * @tc.desc: Test function of Mkdir interface for FAIL，the folder name is Documents.
1051 * @tc.size: MEDIUM
1052 * @tc.type: FUNC
1053 * @tc.level Level 1
1054 * @tc.require: I7MQMD
1055 */
1056 HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0008, testing::ext::TestSize.Level1)
1057 {
1058 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0008";
1059 try {
1060 vector<RootInfo> info;
1061 int result = g_fah->GetRoots(info);
1062 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1063 EXPECT_GE(info.size(), 2);
1064 Uri parentUri(info[0].uri);
1065 Uri newDirUriTest("");
1066 result = g_fah->Mkdir(parentUri, "Documents", newDirUriTest);
1067 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1068 result = g_fah->Mkdir(parentUri, "Download", newDirUriTest);
1069 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1070 result = g_fah->Mkdir(parentUri, "Desktop", newDirUriTest);
1071 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1072 } catch (...) {
1073 GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0008 occurs an exception.";
1074 }
1075 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0008";
1076 }
1077
1078 /**
1079 * @tc.number: user_file_service_external_file_access_Delete_0000
1080 * @tc.name: external_file_access_Delete_0000
1081 * @tc.desc: Test function of Delete interface for SUCCESS which delete file.
1082 * @tc.size: MEDIUM
1083 * @tc.type: FUNC
1084 * @tc.level Level 1
1085 * @tc.require: SR000H0386
1086 */
1087 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0000, testing::ext::TestSize.Level1)
1088 {
1089 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0000";
1090 try {
1091 vector<RootInfo> info;
1092 int result = g_fah->GetRoots(info);
1093 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1094 for (size_t i = 0; i < info.size(); i++) {
1095 Uri parentUri(info[i].uri);
1096 Uri newDirUriTest("");
1097 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
1098 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1099 Uri newFileUri("");
1100 result = g_fah->CreateFile(newDirUriTest, "external_file_access_Delete_0000.txt", newFileUri);
1101 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1102 result = g_fah->Delete(newFileUri);
1103 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1104 GTEST_LOG_(INFO) << "Delete_0000 result:" << result;
1105 result = g_fah->Delete(newDirUriTest);
1106 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1107 }
1108 } catch (...) {
1109 GTEST_LOG_(ERROR) << "external_file_access_Delete_0000 occurs an exception.";
1110 }
1111 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0000";
1112 }
1113
1114 /**
1115 * @tc.number: user_file_service_external_file_access_Delete_0001
1116 * @tc.name: external_file_access_Delete_0001
1117 * @tc.desc: Test function of Delete interface for SUCCESS which delete folder.
1118 * @tc.size: MEDIUM
1119 * @tc.type: FUNC
1120 * @tc.level Level 1
1121 * @tc.require: SR000H0386
1122 */
1123 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0001, testing::ext::TestSize.Level1)
1124 {
1125 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0001";
1126 try {
1127 vector<RootInfo> info;
1128 int result = g_fah->GetRoots(info);
1129 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1130 for (size_t i = 0; i < info.size(); i++) {
1131 Uri parentUri(info[i].uri);
1132 Uri newDirUriTest("");
1133 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
1134 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1135 result = g_fah->Delete(newDirUriTest);
1136 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1137 GTEST_LOG_(INFO) << "Delete_0001 result:" << result;
1138 }
1139 } catch (...) {
1140 GTEST_LOG_(ERROR) << "external_file_access_Delete_0001 occurs an exception.";
1141 }
1142 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0001";
1143 }
1144
1145 /**
1146 * @tc.number: user_file_service_external_file_access_Delete_0002
1147 * @tc.name: external_file_access_Delete_0002
1148 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null.
1149 * @tc.size: MEDIUM
1150 * @tc.type: FUNC
1151 * @tc.level Level 1
1152 * @tc.require: SR000H0386
1153 */
1154 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0002, testing::ext::TestSize.Level1)
1155 {
1156 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0002";
1157 try {
1158 Uri selectFileUri("");
1159 int result = g_fah->Delete(selectFileUri);
1160 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1161 GTEST_LOG_(INFO) << "Delete_0002 result:" << result;
1162 } catch (...) {
1163 GTEST_LOG_(ERROR) << "external_file_access_Delete_0002 occurs an exception.";
1164 }
1165 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0002";
1166 }
1167
1168 /**
1169 * @tc.number: user_file_service_external_file_access_Delete_0003
1170 * @tc.name: external_file_access_Delete_0003
1171 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path.
1172 * @tc.size: MEDIUM
1173 * @tc.type: FUNC
1174 * @tc.level Level 1
1175 * @tc.require: SR000H0386
1176 */
1177 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0003, testing::ext::TestSize.Level1)
1178 {
1179 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0003";
1180 try {
1181 vector<RootInfo> info;
1182 int result = g_fah->GetRoots(info);
1183 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1184 for (size_t i = 0; i < info.size(); i++) {
1185 Uri parentUri(info[i].uri);
1186 Uri newDirUriTest("");
1187 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
1188 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1189 Uri selectFileUri("storage/media/100/local/files/Download/test");
1190 result = g_fah->Delete(selectFileUri);
1191 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1192 result = g_fah->Delete(newDirUriTest);
1193 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1194 GTEST_LOG_(INFO) << "Delete_0003 result:" << result;
1195 }
1196 } catch (...) {
1197 GTEST_LOG_(ERROR) << "external_file_access_Delete_0003 occurs an exception.";
1198 }
1199 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0003";
1200 }
1201
1202 /**
1203 * @tc.number: user_file_service_external_file_access_Delete_0004
1204 * @tc.name: external_file_access_Delete_0004
1205 * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols.
1206 * @tc.size: MEDIUM
1207 * @tc.type: FUNC
1208 * @tc.level Level 1
1209 * @tc.require: SR000H0386
1210 */
1211 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0004, testing::ext::TestSize.Level1)
1212 {
1213 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0004";
1214 try {
1215 Uri selectFileUri("!@#$%^&*()");
1216 int result = g_fah->Delete(selectFileUri);
1217 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1218 GTEST_LOG_(INFO) << "Delete_0004 result:" << result;
1219 } catch (...) {
1220 GTEST_LOG_(ERROR) << "external_file_access_Delete_0004 occurs an exception.";
1221 }
1222 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0004";
1223 }
1224
DeleteTdd(shared_ptr<FileAccessHelper> fahs,Uri selectFile)1225 static void DeleteTdd(shared_ptr<FileAccessHelper> fahs, Uri selectFile)
1226 {
1227 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_DeleteTdd";
1228 int ret = fahs->Delete(selectFile);
1229 if (ret != OHOS::FileAccessFwk::ERR_OK) {
1230 GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret;
1231 return;
1232 }
1233 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1234 g_num++;
1235 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_DeleteTdd";
1236 }
1237
1238 /**
1239 * @tc.number: user_file_service_external_file_access_Delete_0005
1240 * @tc.name: external_file_access_Delete_0005
1241 * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent.
1242 * @tc.size: MEDIUM
1243 * @tc.type: FUNC
1244 * @tc.level Level 1
1245 * @tc.require: SR000H0386
1246 */
1247 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0005, testing::ext::TestSize.Level1)
1248 {
1249 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0005";
1250 try {
1251 vector<RootInfo> info;
1252 int result = g_fah->GetRoots(info);
1253 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1254 for (size_t i = 0; i < info.size(); i++) {
1255 Uri parentUri(info[i].uri);
1256 Uri newDirUriTest("");
1257 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
1258 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1259 Uri newFileUri("");
1260 std::string displayName = "test1.txt";
1261 result = g_fah->CreateFile(newDirUriTest, displayName, newFileUri);
1262 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1263 g_num = 0;
1264 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
1265 std::thread execthread(DeleteTdd, g_fah, newFileUri);
1266 execthread.join();
1267 }
1268 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
1269 result = g_fah->Delete(newDirUriTest);
1270 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1271 }
1272 } catch (...) {
1273 GTEST_LOG_(ERROR) << "external_file_access_Delete_0005 occurs an exception.";
1274 }
1275 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0005";
1276 }
1277
1278 /**
1279 * @tc.number: user_file_service_external_file_access_Delete_0006
1280 * @tc.name: external_file_access_Delete_0006
1281 * @tc.desc: Test function of Delete interface for ERROR because of GetProxyByUri failed.
1282 * @tc.size: MEDIUM
1283 * @tc.type: FUNC
1284 * @tc.level Level 1
1285 * @tc.require: SR000H0386
1286 */
1287 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0006, testing::ext::TestSize.Level1)
1288 {
1289 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0006";
1290 try {
1291 vector<RootInfo> info;
1292 int result = g_fah->GetRoots(info);
1293 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1294 for (size_t i = 0; i < info.size(); i++) {
1295 std::string str = info[i].uri;
1296 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
1297 GTEST_LOG_(ERROR) << "replace BundleName failed.";
1298 EXPECT_TRUE(false);
1299 }
1300 Uri selectFileUri(str);
1301 int result = g_fah->Delete(selectFileUri);
1302 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
1303 GTEST_LOG_(INFO) << "Delete_0006 result:" << result;
1304 }
1305 } catch (...) {
1306 GTEST_LOG_(ERROR) << "external_file_access_Delete_0006 occurs an exception.";
1307 }
1308 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0006";
1309 }
1310
1311 /**
1312 * @tc.number: user_file_service_external_file_access_Delete_0007
1313 * @tc.name: external_file_access_Delete_0007
1314 * @tc.desc: Test function of Delete interface for SUCCESS which delete file, the file name is chinese.
1315 * @tc.size: MEDIUM
1316 * @tc.type: FUNC
1317 * @tc.level Level 1
1318 * @tc.require: I70SX9
1319 */
1320 HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0007, testing::ext::TestSize.Level1)
1321 {
1322 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0007";
1323 try {
1324 vector<RootInfo> info;
1325 int result = g_fah->GetRoots(info);
1326 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1327 for (size_t i = 0; i < info.size(); i++) {
1328 Uri parentUri(info[i].uri);
1329 Uri newDirUriTest("");
1330 result = g_fah->Mkdir(parentUri, "测试目录", newDirUriTest);
1331 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1332 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
1333 Uri newFileUri("");
1334 result = g_fah->CreateFile(newDirUriTest, "删除文件.txt", newFileUri);
1335 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1336 EXPECT_EQ(newFileUri.ToString().find("删除文件.txt"), std::string::npos);
1337 result = g_fah->Delete(newFileUri);
1338 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1339 GTEST_LOG_(INFO) << "Delete_0007 result:" << result;
1340 result = g_fah->Delete(newDirUriTest);
1341 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1342 }
1343 } catch (...) {
1344 GTEST_LOG_(ERROR) << "external_file_access_Delete_0007 occurs an exception.";
1345 }
1346 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0007";
1347 }
1348
1349 /**
1350 * @tc.number: user_file_service_external_file_access_Move_0000
1351 * @tc.name: external_file_access_Move_0000
1352 * @tc.desc: Test function of Move interface for SUCCESS which move file.
1353 * @tc.size: MEDIUM
1354 * @tc.type: FUNC
1355 * @tc.level Level 1
1356 * @tc.require: SR000H0387
1357 */
1358 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0000, testing::ext::TestSize.Level1)
1359 {
1360 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0000";
1361 try {
1362 vector<RootInfo> info;
1363 int result = g_fah->GetRoots(info);
1364 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1365 for (size_t i = 0; i < info.size(); i++) {
1366 Uri parentUri(info[i].uri);
1367 Uri newDirUriTest1("");
1368 Uri newDirUriTest2("");
1369 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1370 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1371 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1372 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1373 Uri testUri("");
1374 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1375 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1376 Uri testUri2("");
1377 result = g_fah->Move(testUri, newDirUriTest2, testUri2);
1378 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1379 GTEST_LOG_(INFO) << "Move_0000 result:" << result;
1380 result = g_fah->Delete(newDirUriTest1);
1381 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1382 result = g_fah->Delete(newDirUriTest2);
1383 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1384 }
1385 } catch (...) {
1386 GTEST_LOG_(ERROR) << "external_file_access_Move_0000 occurs an exception.";
1387 }
1388 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0000";
1389 }
1390
1391 /**
1392 * @tc.number: user_file_service_external_file_access_Move_0001
1393 * @tc.name: external_file_access_Move_0001
1394 * @tc.desc: Test function of Move interface for SUCCESS which move folder.
1395 * @tc.size: MEDIUM
1396 * @tc.type: FUNC
1397 * @tc.level Level 1
1398 * @tc.require: SR000H0387
1399 */
1400 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0001, testing::ext::TestSize.Level1)
1401 {
1402 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0001";
1403 try {
1404 vector<RootInfo> info;
1405 int result = g_fah->GetRoots(info);
1406 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1407 for (size_t i = 0; i < info.size(); i++) {
1408 Uri parentUri(info[i].uri);
1409 Uri newDirUriTest1("");
1410 Uri newDirUriTest2("");
1411 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1412 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1413 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1414 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1415 Uri testUri("");
1416 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1417 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1418 Uri testUri2("");
1419 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1420 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1421 GTEST_LOG_(INFO) << "Move_0001 result:" << result;
1422 result = g_fah->Delete(newDirUriTest2);
1423 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1424 }
1425 } catch (...) {
1426 GTEST_LOG_(ERROR) << "external_file_access_Move_0001 occurs an exception.";
1427 }
1428 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0001";
1429 }
1430
1431 /**
1432 * @tc.number: user_file_service_external_file_access_Move_0002
1433 * @tc.name: external_file_access_Move_0002
1434 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null.
1435 * @tc.size: MEDIUM
1436 * @tc.type: FUNC
1437 * @tc.level Level 1
1438 * @tc.require: SR000H0387
1439 */
1440 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0002, testing::ext::TestSize.Level1)
1441 {
1442 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0002";
1443 try {
1444 vector<RootInfo> info;
1445 int result = g_fah->GetRoots(info);
1446 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1447 for (size_t i = 0; i < info.size(); i++) {
1448 Uri parentUri(info[i].uri);
1449 Uri newDirUriTest("");
1450 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
1451 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1452 Uri testUri("");
1453 Uri sourceFileUri("");
1454 result = g_fah->Move(sourceFileUri, newDirUriTest, testUri);
1455 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1456 GTEST_LOG_(INFO) << "Move_0002 result:" << result;
1457 result = g_fah->Delete(newDirUriTest);
1458 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1459 }
1460 } catch (...) {
1461 GTEST_LOG_(ERROR) << "external_file_access_Move_0002 occurs an exception.";
1462 }
1463 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0002";
1464 }
1465
1466 /**
1467 * @tc.number: user_file_service_external_file_access_Move_0003
1468 * @tc.name: external_file_access_Move_0003
1469 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path.
1470 * @tc.size: MEDIUM
1471 * @tc.type: FUNC
1472 * @tc.level Level 1
1473 * @tc.require: SR000H0386
1474 */
1475 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0003, testing::ext::TestSize.Level1)
1476 {
1477 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0003";
1478 try {
1479 vector<RootInfo> info;
1480 int result = g_fah->GetRoots(info);
1481 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1482 for (size_t i = 0; i < info.size(); i++) {
1483 Uri parentUri(info[i].uri);
1484 Uri newDirUriTest1("");
1485 Uri newDirUriTest2("");
1486 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1487 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1488 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1489 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1490 Uri testUri("");
1491 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1492 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1493 Uri testUri2("");
1494 Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt");
1495 result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2);
1496 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1497 GTEST_LOG_(INFO) << "Move_0003 result:" << result;
1498 result = g_fah->Delete(newDirUriTest1);
1499 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1500 result = g_fah->Delete(newDirUriTest2);
1501 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1502 }
1503 } catch (...) {
1504 GTEST_LOG_(ERROR) << "external_file_access_Move_0003 occurs an exception.";
1505 }
1506 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0003";
1507 }
1508
1509 /**
1510 * @tc.number: user_file_service_external_file_access_Move_0004
1511 * @tc.name: external_file_access_Move_0004
1512 * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols.
1513 * @tc.size: MEDIUM
1514 * @tc.type: FUNC
1515 * @tc.level Level 1
1516 * @tc.require: SR000H0387
1517 */
1518 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0004, testing::ext::TestSize.Level1)
1519 {
1520 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0004";
1521 try {
1522 vector<RootInfo> info;
1523 int result = g_fah->GetRoots(info);
1524 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1525 for (size_t i = 0; i < info.size(); i++) {
1526 Uri parentUri(info[i].uri);
1527 Uri newDirUriTest("");
1528 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
1529 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1530 Uri testUri("");
1531 Uri sourceFileUri("~!@#$%^&*()_");
1532 result = g_fah->Move(sourceFileUri, newDirUriTest, testUri);
1533 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1534 GTEST_LOG_(INFO) << "Move_0004 result:" << result;
1535 result = g_fah->Delete(newDirUriTest);
1536 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1537 }
1538 } catch (...) {
1539 GTEST_LOG_(ERROR) << "external_file_access_Move_0004 occurs an exception.";
1540 }
1541 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0004";
1542 }
1543
1544 /**
1545 * @tc.number: user_file_service_external_file_access_Move_0005
1546 * @tc.name: external_file_access_Move_0005
1547 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null.
1548 * @tc.size: MEDIUM
1549 * @tc.type: FUNC
1550 * @tc.level Level 1
1551 * @tc.require: SR000H0387
1552 */
1553 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0005, testing::ext::TestSize.Level1)
1554 {
1555 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0005";
1556 try {
1557 vector<RootInfo> info;
1558 int result = g_fah->GetRoots(info);
1559 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1560 for (size_t i = 0; i < info.size(); i++) {
1561 Uri parentUri(info[i].uri);
1562 Uri newDirUriTest("");
1563 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest);
1564 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1565 Uri testUri("");
1566 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
1567 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1568 Uri testUri2("");
1569 Uri targetParentUri("");
1570 result = g_fah->Move(testUri, targetParentUri, testUri2);
1571 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1572 GTEST_LOG_(INFO) << "Move_0005 result:" << result;
1573 result = g_fah->Delete(newDirUriTest);
1574 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1575 }
1576 } catch (...) {
1577 GTEST_LOG_(ERROR) << "external_file_access_Move_0005 occurs an exception.";
1578 }
1579 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0005";
1580 }
1581
1582 /**
1583 * @tc.number: user_file_service_external_file_access_Move_0006
1584 * @tc.name: external_file_access_Move_0006
1585 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path.
1586 * @tc.size: MEDIUM
1587 * @tc.type: FUNC
1588 * @tc.level Level 1
1589 * @tc.require: SR000H0387
1590 */
1591 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0006, testing::ext::TestSize.Level1)
1592 {
1593 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0006";
1594 try {
1595 vector<RootInfo> info;
1596 int result = g_fah->GetRoots(info);
1597 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1598 for (size_t i = 0; i < info.size(); i++) {
1599 Uri parentUri(info[i].uri);
1600 Uri newDirUriTest1("");
1601 Uri newDirUriTest2("");
1602 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1603 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1604 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1605 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1606 Uri testUri("");
1607 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1608 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1609 Uri testUri2("");
1610 Uri targetParentUri("storage/media/100/local/files/Download/test2");
1611 result = g_fah->Move(testUri, targetParentUri, testUri2);
1612 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1613 GTEST_LOG_(INFO) << "Move_0006 result:" << result;
1614 result = g_fah->Delete(newDirUriTest1);
1615 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1616 result = g_fah->Delete(newDirUriTest2);
1617 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1618 }
1619 } catch (...) {
1620 GTEST_LOG_(ERROR) << "external_file_access_Move_0006 occurs an exception.";
1621 }
1622 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0006";
1623 }
1624
1625 /**
1626 * @tc.number: user_file_service_external_file_access_Move_0007
1627 * @tc.name: external_file_access_Move_0007
1628 * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols.
1629 * @tc.size: MEDIUM
1630 * @tc.type: FUNC
1631 * @tc.level Level 1
1632 * @tc.require: SR000H0387
1633 */
1634 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0007, testing::ext::TestSize.Level1)
1635 {
1636 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0007";
1637 try {
1638 vector<RootInfo> info;
1639 int result = g_fah->GetRoots(info);
1640 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1641 for (size_t i = 0; i < info.size(); i++) {
1642 Uri parentUri(info[i].uri);
1643 Uri newDirUriTest1("");
1644 Uri newDirUriTest2("");
1645 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1646 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1647 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1648 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1649 Uri testUri("");
1650 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1651 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1652 Uri testUri2("");
1653 Uri targetParentUri("~!@#$^%&*()_");
1654 result = g_fah->Move(testUri, targetParentUri, testUri2);
1655 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1656 GTEST_LOG_(INFO) << "Move_0007 result:" << result;
1657 result = g_fah->Delete(newDirUriTest1);
1658 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1659 result = g_fah->Delete(newDirUriTest2);
1660 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1661 }
1662 } catch (...) {
1663 GTEST_LOG_(ERROR) << "external_file_access_Move_0007 occurs an exception.";
1664 }
1665 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0007";
1666 }
1667
1668 /**
1669 * @tc.number: user_file_service_external_file_access_Move_0008
1670 * @tc.name: external_file_access_Move_0008
1671 * @tc.desc: Test function of Move interface for SUCCESS which move empty folder.
1672 * @tc.size: MEDIUM
1673 * @tc.type: FUNC
1674 * @tc.level Level 1
1675 * @tc.require: SR000H0387
1676 */
1677 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0008, testing::ext::TestSize.Level1)
1678 {
1679 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0008";
1680 try {
1681 vector<RootInfo> info;
1682 int result = g_fah->GetRoots(info);
1683 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1684 for (size_t i = 0; i < info.size(); i++) {
1685 Uri parentUri(info[i].uri);
1686 Uri newDirUriTest1("");
1687 Uri newDirUriTest2("");
1688 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1689 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1690 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1691 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1692 Uri testUri("");
1693 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri);
1694 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1695 GTEST_LOG_(INFO) << "Move_0008 result:" << result;
1696 result = g_fah->Delete(newDirUriTest2);
1697 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1698 }
1699 } catch (...) {
1700 GTEST_LOG_(ERROR) << "external_file_access_Move_0008 occurs an exception.";
1701 }
1702 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0008";
1703 }
1704
1705 /**
1706 * @tc.number: user_file_service_external_file_access_Move_0009
1707 * @tc.name: external_file_access_Move_0009
1708 * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder.
1709 * @tc.size: MEDIUM
1710 * @tc.type: FUNC
1711 * @tc.level Level 1
1712 * @tc.require: SR000H0387
1713 */
1714 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0009, testing::ext::TestSize.Level1)
1715 {
1716 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0009";
1717 try {
1718 vector<RootInfo> info;
1719 int result = g_fah->GetRoots(info);
1720 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1721 for (size_t i = 0; i < info.size(); i++) {
1722 Uri parentUri(info[i].uri);
1723 Uri newDirUriTest1("");
1724 Uri newDirUriTest2("");
1725 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1726 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1727 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1728 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1729 Uri testUri("");
1730 size_t fileNumbers = 2000;
1731 for (size_t j = 0; j < fileNumbers; j++) {
1732 string fileName = "test" + ToString(j) + ".txt";
1733 result = g_fah->CreateFile(newDirUriTest1, fileName, testUri);
1734 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1735 }
1736 Uri testUri2("");
1737 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1738 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1739 GTEST_LOG_(INFO) << "Move_0009 result:" << result;
1740 result = g_fah->Delete(newDirUriTest2);
1741 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1742 }
1743 } catch (...) {
1744 GTEST_LOG_(ERROR) << "external_file_access_Move_0009 occurs an exception.";
1745 }
1746 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0009";
1747 }
1748
1749 /**
1750 * @tc.number: user_file_service_external_file_access_Move_0010
1751 * @tc.name: external_file_access_Move_0010
1752 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder.
1753 * @tc.size: MEDIUM
1754 * @tc.type: FUNC
1755 * @tc.level Level 1
1756 * @tc.require: SR000H0387
1757 */
1758 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0010, testing::ext::TestSize.Level1)
1759 {
1760 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0010";
1761 try {
1762 vector<RootInfo> info;
1763 int result = g_fah->GetRoots(info);
1764 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1765 for (size_t i = 0; i < info.size(); i++) {
1766 Uri parentUri(info[i].uri);
1767 Uri newDirUriTest1("");
1768 Uri newDirUriTest2("");
1769 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1770 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1771 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1772 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1773 Uri testUri("");
1774 result = g_fah->Mkdir(newDirUriTest1, "test", testUri);
1775 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1776 size_t directoryNumbers = 64;
1777 for (size_t j = 0; j < directoryNumbers; j++) {
1778 result = g_fah->Mkdir(testUri, "test", testUri);
1779 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1780 }
1781 Uri testUri2("");
1782 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
1783 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1784 GTEST_LOG_(INFO) << "Move_0010 result:" << result;
1785 result = g_fah->Delete(newDirUriTest2);
1786 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1787 }
1788 } catch (...) {
1789 GTEST_LOG_(ERROR) << "external_file_access_Move_0010 occurs an exception.";
1790 }
1791 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0010";
1792 }
1793
1794 /**
1795 * @tc.number: user_file_service_external_file_access_Move_0011
1796 * @tc.name: external_file_access_Move_0011
1797 * @tc.desc: Test function of Move interface for SUCCESS which move other equipment file.
1798 * @tc.size: MEDIUM
1799 * @tc.type: FUNC
1800 * @tc.level Level 1
1801 * @tc.require: SR000H0387
1802 */
1803 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0011, testing::ext::TestSize.Level1)
1804 {
1805 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0011";
1806 try {
1807 vector<RootInfo> info;
1808 int result = g_fah->GetRoots(info);
1809 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1810 for (size_t i = 0; i < info.size(); i++) {
1811 Uri parentUri(info[i].uri);
1812 Uri newDirUriTest1("");
1813 Uri newDirUriTest2("");
1814 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1815 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1816 Uri testUri("");
1817 result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri);
1818 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1819 for (size_t j = i + 1; j < info.size(); j++) {
1820 Uri otherUri(info[j].uri);
1821 result = g_fah->Mkdir(otherUri, "test2", newDirUriTest2);
1822 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1823 result = g_fah->Move(testUri, newDirUriTest2, testUri);
1824 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1825 result = g_fah->Move(testUri, newDirUriTest1, testUri);
1826 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1827 GTEST_LOG_(INFO) << "Move_0011 result:" << result;
1828 result = g_fah->Delete(newDirUriTest2);
1829 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1830 }
1831 result = g_fah->Delete(newDirUriTest1);
1832 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1833 }
1834 } catch (...) {
1835 GTEST_LOG_(ERROR) << "external_file_access_Move_0011 occurs an exception.";
1836 }
1837 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0011";
1838 }
1839
MoveTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,Uri targetParent,Uri newFile)1840 static void MoveTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, Uri targetParent, Uri newFile)
1841 {
1842 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MoveTdd";
1843 int ret = fahs->Move(sourceFile, targetParent, newFile);
1844 if (ret != OHOS::FileAccessFwk::ERR_OK) {
1845 GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret;
1846 return;
1847 }
1848 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
1849 g_num++;
1850 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MoveTdd";
1851 }
1852
1853 /**
1854 * @tc.number: user_file_service_external_file_access_Move_0012
1855 * @tc.name: external_file_access_Move_0012
1856 * @tc.desc: Test function of Move interface for SUCCESS which Concurrent.
1857 * @tc.size: MEDIUM
1858 * @tc.type: FUNC
1859 * @tc.level Level 1
1860 * @tc.require: SR000H0386
1861 */
1862 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0012, testing::ext::TestSize.Level1)
1863 {
1864 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0012";
1865 try {
1866 vector<RootInfo> info;
1867 int result = g_fah->GetRoots(info);
1868 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1869 for (size_t i = 0; i < info.size(); i++) {
1870 Uri parentUri(info[i].uri);
1871 Uri newDirUriTest1("");
1872 Uri newDirUriTest2("");
1873 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1874 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1875 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1876 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1877 Uri testUri("");
1878 std::string displayName = "test3.txt";
1879 result = g_fah->CreateFile(newDirUriTest1, displayName, testUri);
1880 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1881 Uri testUri2("");
1882 g_num = 0;
1883 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
1884 std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2);
1885 execthread.join();
1886 }
1887 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
1888 result = g_fah->Delete(newDirUriTest1);
1889 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1890 result = g_fah->Delete(newDirUriTest2);
1891 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1892 }
1893 } catch (...) {
1894 GTEST_LOG_(ERROR) << "external_file_access_Move_0012 occurs an exception.";
1895 }
1896 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0012";
1897 }
1898
1899 /**
1900 * @tc.number: user_file_service_external_file_access_Move_0013
1901 * @tc.name: external_file_access_Move_0013
1902 * @tc.desc: Test function of Move interface for FAILED because of GetProxyByUri failed.
1903 * @tc.size: MEDIUM
1904 * @tc.type: FUNC
1905 * @tc.level Level 1
1906 * @tc.require: SR000H0387
1907 */
1908 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0013, testing::ext::TestSize.Level1)
1909 {
1910 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0013";
1911 try {
1912 vector<RootInfo> info;
1913 int result = g_fah->GetRoots(info);
1914 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1915 Uri parentUri(info[0].uri);
1916 Uri newDirUriTest1("");
1917 Uri newDirUriTest2("");
1918 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
1919 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1920 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
1921 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1922 Uri testUri("");
1923 result = g_fah->Mkdir(newDirUriTest1, "test", testUri);
1924 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1925 std::string str = newDirUriTest1.ToString();
1926 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
1927 GTEST_LOG_(ERROR) << "replace BundleName failed.";
1928 EXPECT_TRUE(false);
1929 }
1930 Uri uri(str);
1931 Uri testUri2("");
1932 result = g_fah->Move(uri, newDirUriTest2, testUri2);
1933 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
1934 GTEST_LOG_(INFO) << "Move_0013 result:" << result;
1935 result = g_fah->Delete(newDirUriTest1);
1936 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1937 result = g_fah->Delete(newDirUriTest2);
1938 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1939 } catch (...) {
1940 GTEST_LOG_(ERROR) << "external_file_access_Move_0013 occurs an exception.";
1941 }
1942 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0013";
1943 }
1944
1945 /**
1946 * @tc.number: user_file_service_external_file_access_Move_0014
1947 * @tc.name: external_file_access_Move_0014
1948 * @tc.desc: Test function of Move interface for SUCCESS which move file, the file name is chinese.
1949 * @tc.size: MEDIUM
1950 * @tc.type: FUNC
1951 * @tc.level Level 1
1952 * @tc.require: I70SX9
1953 */
1954 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0014, testing::ext::TestSize.Level1)
1955 {
1956 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0014";
1957 try {
1958 vector<RootInfo> info;
1959 int result = g_fah->GetRoots(info);
1960 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1961 for (size_t i = 0; i < info.size(); i++) {
1962 Uri parentUri(info[i].uri);
1963 Uri newDirUriTest1("");
1964 Uri newDirUriTest2("");
1965 result = g_fah->Mkdir(parentUri, "测试目录1", newDirUriTest1);
1966 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1967 EXPECT_EQ(newDirUriTest1.ToString().find("测试目录1"), std::string::npos);
1968 result = g_fah->Mkdir(parentUri, "测试目录2", newDirUriTest2);
1969 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1970 EXPECT_EQ(newDirUriTest2.ToString().find("测试目录2"), std::string::npos);
1971 Uri testUri("");
1972 result = g_fah->CreateFile(newDirUriTest1, "移动文件.txt", testUri);
1973 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1974 EXPECT_EQ(testUri.ToString().find("移动文件.txt"), std::string::npos);
1975 Uri testUri2("");
1976 result = g_fah->Move(testUri, newDirUriTest2, testUri2);
1977 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1978 GTEST_LOG_(INFO) << "Move_0014 result:" << result;
1979 result = g_fah->Delete(newDirUriTest1);
1980 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1981 result = g_fah->Delete(newDirUriTest2);
1982 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
1983 }
1984 } catch (...) {
1985 GTEST_LOG_(ERROR) << "external_file_access_Move_0014 occurs an exception.";
1986 }
1987 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0014";
1988 }
1989
1990 /**
1991 * @tc.number: user_file_service_external_file_access_Move_0015
1992 * @tc.name: external_file_access_Move_0015
1993 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder，
1994 * the folder name is chinese.
1995 * @tc.size: MEDIUM
1996 * @tc.type: FUNC
1997 * @tc.level Level 1
1998 * @tc.require: I70SX9
1999 */
2000 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0015, testing::ext::TestSize.Level1)
2001 {
2002 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0015";
2003 try {
2004 vector<RootInfo> info;
2005 int result = g_fah->GetRoots(info);
2006 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2007 for (size_t i = 0; i < info.size(); i++) {
2008 Uri parentUri(info[i].uri);
2009 Uri newDirUriTest1("");
2010 Uri newDirUriTest2("");
2011 result = g_fah->Mkdir(parentUri, "移动目录", newDirUriTest1);
2012 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2013 EXPECT_EQ(newDirUriTest1.ToString().find("移动目录"), std::string::npos);
2014 result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2);
2015 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2016 Uri testUri2("");
2017 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
2018 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2019 GTEST_LOG_(INFO) << "Move_0015 result:" << result;
2020 result = g_fah->Delete(newDirUriTest2);
2021 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2022 }
2023 } catch (...) {
2024 GTEST_LOG_(ERROR) << "external_file_access_Move_0015 occurs an exception.";
2025 }
2026 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0015";
2027 }
2028
2029 /**
2030 * @tc.number: user_file_service_external_file_access_Move_0016
2031 * @tc.name: external_file_access_Move_0016
2032 * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder，
2033 * the folder name is chinese.
2034 * @tc.size: MEDIUM
2035 * @tc.type: FUNC
2036 * @tc.level Level 1
2037 * @tc.require: I70SX9
2038 */
2039 HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0016, testing::ext::TestSize.Level1)
2040 {
2041 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0016";
2042 try {
2043 vector<RootInfo> info;
2044 int result = g_fah->GetRoots(info);
2045 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2046 for (size_t i = 0; i < info.size(); i++) {
2047 Uri parentUri(info[i].uri);
2048 Uri newDirUriTest1("");
2049 Uri newDirUriTest2("");
2050 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1);
2051 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2052 result = g_fah->Mkdir(parentUri, "移动目录", newDirUriTest2);
2053 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2054 Uri testUri2("");
2055 result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2);
2056 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2057 GTEST_LOG_(INFO) << "Move_0016 result:" << result;
2058 result = g_fah->Delete(newDirUriTest2);
2059 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2060 }
2061 } catch (...) {
2062 GTEST_LOG_(ERROR) << "external_file_access_Move_0016 occurs an exception.";
2063 }
2064 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0016";
2065 }
2066
2067 /**
2068 * @tc.number: user_file_service_external_file_access_Copy_0000
2069 * @tc.name: external_file_access_Copy_0000
2070 * @tc.desc: Test function of Copy interface, copy a file and argument of force is false
2071 * @tc.size: MEDIUM
2072 * @tc.type: FUNC
2073 * @tc.level Level 1
2074 * @tc.require: I7QXVD
2075 */
2076 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0000, testing::ext::TestSize.Level1)
2077 {
2078 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0000";
2079 try {
2080 vector<RootInfo> info;
2081 int result = g_fah->GetRoots(info);
2082 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2083
2084 for (size_t i = 0; i < info.size(); i++) {
2085 Uri parentUri(info[i].uri);
2086 Uri srcDir("");
2087 result = g_fah->Mkdir(parentUri, "Copy_0000_src", srcDir);
2088 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2089 Uri srcFile("");
2090 result = g_fah->CreateFile(srcDir, "a.txt", srcFile);
2091 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2092 int fd = -1;
2093 result = g_fah->OpenFile(srcFile, WRITE_READ, fd);
2094 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2095 char buff[] = "Copy test content for a.txt";
2096 ssize_t srcFileSize = write(fd, buff, sizeof(buff));
2097 EXPECT_EQ(srcFileSize, sizeof(buff));
2098 close(fd);
2099
2100 Uri destDir("");
2101 result = g_fah->Mkdir(parentUri, "Copy_0000_dest", destDir);
2102 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2103
2104 std::vector<CopyResult> copyResult;
2105 result = g_fah->Copy(srcFile, destDir, copyResult, false);
2106 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2107 EXPECT_EQ(copyResult.size(), 0);
2108
2109 Uri destFileUri(destDir.ToString() + "/" + "a.txt");
2110 result = g_fah->OpenFile(destFileUri, WRITE_READ, fd);
2111 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2112 ssize_t destFileSize = read(fd, buff, sizeof(buff));
2113 EXPECT_EQ(srcFileSize, destFileSize);
2114 close(fd);
2115
2116 result = g_fah->Delete(srcDir);
2117 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2118 result = g_fah->Delete(destDir);
2119 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2120 }
2121 } catch (...) {
2122 GTEST_LOG_(ERROR) << "external_file_access_Copy_0000 occurs an exception.";
2123 }
2124 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0000";
2125 }
2126
2127 /**
2128 * @tc.number: user_file_service_external_file_access_Copy_0001
2129 * @tc.name: external_file_access_Copy_0001
2130 * @tc.desc: Test function of Copy interface, copy a directory and argument of force is false
2131 * @tc.size: MEDIUM
2132 * @tc.type: FUNC
2133 * @tc.level Level 1
2134 * @tc.require: I7QXVD
2135 */
2136 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0001, testing::ext::TestSize.Level1)
2137 {
2138 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0001";
2139 try {
2140 vector<RootInfo> info;
2141 int result = g_fah->GetRoots(info);
2142 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2143 for (size_t i = 0; i < info.size(); i++) {
2144 Uri parentUri(info[i].uri);
2145 Uri srcDir("");
2146 Uri destDir("");
2147 result = g_fah->Mkdir(parentUri, "Copy_0001_src", srcDir);
2148 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2149 Uri aFileUri("");
2150 result = g_fah->CreateFile(srcDir, "a.txt", aFileUri);
2151 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2152 int fd = -1;
2153 result = g_fah->OpenFile(aFileUri, WRITE_READ, fd);
2154 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2155 char buff[] = "Copy test content for a.txt";
2156 ssize_t aFileSize = write(fd, buff, sizeof(buff));
2157 EXPECT_EQ(aFileSize, sizeof(buff));
2158 close(fd);
2159 Uri bFileUri("");
2160 result = g_fah->CreateFile(srcDir, "b.txt", bFileUri);
2161 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2162 result = g_fah->Mkdir(parentUri, "Copy_0001_dest", destDir);
2163 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2164
2165 std::vector<CopyResult> copyResult;
2166 result = g_fah->Copy(srcDir, destDir, copyResult, false);
2167 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2168 EXPECT_EQ(copyResult.size(), 0);
2169
2170 result = g_fah->Delete(srcDir);
2171 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2172 result = g_fah->Delete(destDir);
2173 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2174 }
2175 } catch (...) {
2176 GTEST_LOG_(ERROR) << "external_file_access_Copy_0001 occurs an exception.";
2177 }
2178 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0001";
2179 }
2180
2181 /**
2182 * @tc.number: user_file_service_external_file_access_Copy_0002
2183 * @tc.name: external_file_access_Copy_0002
2184 * @tc.desc: Test function of Copy interface, copy a empty directory
2185 * @tc.size: MEDIUM
2186 * @tc.type: FUNC
2187 * @tc.level Level 1
2188 * @tc.require: I7QXVD
2189 */
2190 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0002, testing::ext::TestSize.Level1)
2191 {
2192 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0002";
2193 try {
2194 vector<RootInfo> info;
2195 int result = g_fah->GetRoots(info);
2196 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2197 for (size_t i = 0; i < info.size(); i++) {
2198 Uri parentUri(info[i].uri);
2199 Uri srcDir("");
2200 result = g_fah->Mkdir(parentUri, "Copy_0002_src", srcDir);
2201 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2202 Uri destDir("");
2203 result = g_fah->Mkdir(parentUri, "Copy_0002_dest", destDir);
2204 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2205
2206 std::vector<CopyResult> copyResult;
2207 result = g_fah->Copy(srcDir, destDir, copyResult, false);
2208 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2209 EXPECT_EQ(copyResult.size(), 0);
2210
2211 result = g_fah->Delete(srcDir);
2212 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2213 result = g_fah->Delete(destDir);
2214 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2215 }
2216 } catch (...) {
2217 GTEST_LOG_(ERROR) << "external_file_access_Copy_0002 occurs an exception.";
2218 }
2219 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0002";
2220 }
2221
2222 /**
2223 * @tc.number: user_file_service_external_file_access_Copy_0003
2224 * @tc.name: external_file_access_Copy_0003
2225 * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is true
2226 * @tc.size: MEDIUM
2227 * @tc.type: FUNC
2228 * @tc.level Level 1
2229 * @tc.require: I7QXVD
2230 */
2231 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0003, testing::ext::TestSize.Level1)
2232 {
2233 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0003";
2234 try {
2235 vector<RootInfo> info;
2236 int result = g_fah->GetRoots(info);
2237 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2238 for (size_t i = 0; i < info.size(); i++) {
2239 Uri parentUri(info[i].uri);
2240 Uri srcDir("");
2241 result = g_fah->Mkdir(parentUri, "Copy_0003_src", srcDir);
2242 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2243 Uri srcFile("");
2244 result = g_fah->CreateFile(srcDir, "a.txt", srcFile);
2245 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2246 int fd = -1;
2247 result = g_fah->OpenFile(srcFile, WRITE_READ, fd);
2248 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2249 char buff[] = "Copy test content for a.txt";
2250 ssize_t srcFileSize = write(fd, buff, sizeof(buff));
2251 EXPECT_EQ(srcFileSize, sizeof(buff));
2252 close(fd);
2253
2254 Uri destDir("");
2255 result = g_fah->Mkdir(parentUri, "Copy_0003_dest", destDir);
2256 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2257 Uri existFile("");
2258 result = g_fah->CreateFile(destDir, "a.txt", existFile);
2259 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2260
2261 std::vector<CopyResult> copyResult;
2262 result = g_fah->Copy(srcFile, destDir, copyResult, true);
2263 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2264 EXPECT_EQ(copyResult.size(), 0);
2265
2266 result = g_fah->OpenFile(existFile, WRITE_READ, fd);
2267 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2268 ssize_t destFileSize = read(fd, buff, sizeof(buff));
2269 EXPECT_EQ(srcFileSize, destFileSize);
2270 close(fd);
2271
2272 result = g_fah->Delete(srcDir);
2273 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2274 result = g_fah->Delete(destDir);
2275 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2276 }
2277 } catch (...) {
2278 GTEST_LOG_(ERROR) << "external_file_access_Copy_0003 occurs an exception.";
2279 }
2280 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0003";
2281 }
2282
2283 /**
2284 * @tc.number: user_file_service_external_file_access_Copy_0004
2285 * @tc.name: external_file_access_Copy_0004
2286 * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is false
2287 * @tc.size: MEDIUM
2288 * @tc.type: FUNC
2289 * @tc.level Level 1
2290 * @tc.require: I7QXVD
2291 */
2292 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0004, testing::ext::TestSize.Level1)
2293 {
2294 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0004";
2295 try {
2296 vector<RootInfo> info;
2297 int result = g_fah->GetRoots(info);
2298 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2299 for (size_t i = 0; i < info.size(); i++) {
2300 Uri parentUri(info[i].uri);
2301 Uri srcDir("");
2302 result = g_fah->Mkdir(parentUri, "Copy_0004_src", srcDir);
2303 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2304 Uri srcFile("");
2305 result = g_fah->CreateFile(srcDir, "a.txt", srcFile);
2306 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2307 int fd = -1;
2308 result = g_fah->OpenFile(srcFile, WRITE_READ, fd);
2309 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2310 char buff[] = "Copy test content for a.txt";
2311 ssize_t srcFileSize = write(fd, buff, sizeof(buff));
2312 EXPECT_EQ(srcFileSize, sizeof(buff));
2313 close(fd);
2314
2315 Uri destDir("");
2316 result = g_fah->Mkdir(parentUri, "Copy_0004_dest", destDir);
2317 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2318 Uri existFile("");
2319 result = g_fah->CreateFile(destDir, "a.txt", existFile);
2320 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2321
2322 std::vector<CopyResult> copyResult;
2323 result = g_fah->Copy(srcFile, destDir, copyResult, false);
2324 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2325 EXPECT_EQ(copyResult.size(), 1);
2326
2327 result = g_fah->OpenFile(existFile, WRITE_READ, fd);
2328 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2329 ssize_t destFileSize = read(fd, buff, sizeof(buff));
2330 EXPECT_EQ(destFileSize, 0);
2331 close(fd);
2332
2333 result = g_fah->Delete(srcDir);
2334 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2335 result = g_fah->Delete(destDir);
2336 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2337 }
2338 } catch (...) {
2339 GTEST_LOG_(ERROR) << "external_file_access_Copy_0004 occurs an exception.";
2340 }
2341 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0004";
2342 }
2343
2344 /**
2345 * @tc.number: user_file_service_external_file_access_Copy_0005
2346 * @tc.name: external_file_access_Copy_0005
2347 * @tc.desc: Test function of Copy interface, copy a file with the same name and no force argument
2348 * @tc.size: MEDIUM
2349 * @tc.type: FUNC
2350 * @tc.level Level 1
2351 * @tc.require: I7QXVD
2352 */
2353 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0005, testing::ext::TestSize.Level1)
2354 {
2355 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0005";
2356 try {
2357 vector<RootInfo> info;
2358 int result = g_fah->GetRoots(info);
2359 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2360 for (size_t i = 0; i < info.size(); i++) {
2361 Uri parentUri(info[i].uri);
2362 Uri srcDir("");
2363 result = g_fah->Mkdir(parentUri, "Copy_0005_src", srcDir);
2364 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2365 Uri srcFile("");
2366 result = g_fah->CreateFile(srcDir, "a.txt", srcFile);
2367 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2368 int fd = -1;
2369 result = g_fah->OpenFile(srcFile, WRITE_READ, fd);
2370 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2371 char buff[] = "Copy test content for a.txt";
2372 ssize_t srcFileSize = write(fd, buff, sizeof(buff));
2373 EXPECT_EQ(srcFileSize, sizeof(buff));
2374 close(fd);
2375
2376 Uri destDir("");
2377 result = g_fah->Mkdir(parentUri, "Copy_0005_dest", destDir);
2378 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2379 Uri existFile("");
2380 result = g_fah->CreateFile(destDir, "a.txt", existFile);
2381 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2382
2383 std::vector<CopyResult> copyResult;
2384 result = g_fah->Copy(srcFile, destDir, copyResult);
2385 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2386 EXPECT_GT(copyResult.size(), 0);
2387
2388 result = g_fah->OpenFile(existFile, WRITE_READ, fd);
2389 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2390 ssize_t destFileSize = read(fd, buff, sizeof(buff));
2391 EXPECT_EQ(destFileSize, 0);
2392 close(fd);
2393
2394 result = g_fah->Delete(srcDir);
2395 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2396 result = g_fah->Delete(destDir);
2397 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2398 }
2399 } catch (...) {
2400 GTEST_LOG_(ERROR) << "external_file_access_Copy_0005 occurs an exception.";
2401 }
2402 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0005";
2403 }
2404
2405 /**
2406 * @tc.number: user_file_service_external_file_access_Copy_0006
2407 * @tc.name: external_file_access_Copy_0006
2408 * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is true
2409 * @tc.size: MEDIUM
2410 * @tc.type: FUNC
2411 * @tc.level Level 1
2412 * @tc.require: I7QXVD
2413 */
2414 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0006, testing::ext::TestSize.Level1)
2415 {
2416 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0006";
2417 try {
2418 vector<RootInfo> info;
2419 int result = g_fah->GetRoots(info);
2420 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2421 for (size_t i = 0; i < info.size(); i++) {
2422 Uri parentUri(info[i].uri);
2423 Uri srcDir("");
2424 result = g_fah->Mkdir(parentUri, "Copy_0006_src", srcDir);
2425 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2426 Uri aFileUri("");
2427 result = g_fah->CreateFile(srcDir, "a.txt", aFileUri);
2428 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2429 Uri bFileUri("");
2430 result = g_fah->CreateFile(srcDir, "b.txt", bFileUri);
2431 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2432 int fd = -1;
2433 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
2434 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2435 char buff[] = "Copy test content for b.txt";
2436 ssize_t srcFileSize = write(fd, buff, sizeof(buff));
2437 EXPECT_EQ(srcFileSize, sizeof(buff));
2438 close(fd);
2439
2440 Uri destDir("");
2441 result = g_fah->Mkdir(parentUri, "Copy_0006_dest", destDir);
2442 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2443 Uri destSrcDir("");
2444 result = g_fah->Mkdir(destDir, "Copy_0006_src", destSrcDir);
2445 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2446 result = g_fah->CreateFile(destSrcDir, "b.txt", bFileUri);
2447 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2448
2449 std::vector<CopyResult> copyResult;
2450 result = g_fah->Copy(srcDir, destDir, copyResult, true);
2451 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2452 EXPECT_EQ(copyResult.size(), 0);
2453
2454 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
2455 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2456 ssize_t destFileSize = read(fd, buff, sizeof(buff));
2457 EXPECT_EQ(destFileSize, srcFileSize);
2458 close(fd);
2459
2460 result = g_fah->Delete(srcDir);
2461 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2462 result = g_fah->Delete(destDir);
2463 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2464 }
2465 } catch (...) {
2466 GTEST_LOG_(ERROR) << "external_file_access_Copy_0006 occurs an exception.";
2467 }
2468 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0006";
2469 }
2470
2471 /**
2472 * @tc.number: user_file_service_external_file_access_Copy_0007
2473 * @tc.name: external_file_access_Copy_0007
2474 * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is false
2475 * @tc.size: MEDIUM
2476 * @tc.type: FUNC
2477 * @tc.level Level 1
2478 * @tc.require: I7QXVD
2479 */
2480 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0007, testing::ext::TestSize.Level1)
2481 {
2482 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0007";
2483 try {
2484 vector<RootInfo> info;
2485 int result = g_fah->GetRoots(info);
2486 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2487 for (size_t i = 0; i < info.size(); i++) {
2488 Uri parentUri(info[i].uri);
2489 Uri srcDir("");
2490 result = g_fah->Mkdir(parentUri, "Copy_0007_src", srcDir);
2491 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2492 Uri aFileUri("");
2493 result = g_fah->CreateFile(srcDir, "a.txt", aFileUri);
2494 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2495 Uri bFileUri("");
2496 result = g_fah->CreateFile(srcDir, "b.txt", bFileUri);
2497 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2498 int fd = -1;
2499 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
2500 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2501 char buff[] = "Copy test content for b.txt";
2502 ssize_t bFileSize = write(fd, buff, sizeof(buff));
2503 EXPECT_EQ(bFileSize, sizeof(buff));
2504 close(fd);
2505
2506 Uri destDir("");
2507 result = g_fah->Mkdir(parentUri, "Copy_0007_dest", destDir);
2508 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2509 Uri destSrcDir("");
2510 result = g_fah->Mkdir(destDir, "Copy_0007_src", destSrcDir);
2511 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2512 Uri destFileUri("");
2513 result = g_fah->CreateFile(destSrcDir, "b.txt", destFileUri);
2514 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2515
2516 std::vector<CopyResult> copyResult;
2517 result = g_fah->Copy(srcDir, destDir, copyResult, false);
2518 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2519 EXPECT_EQ(copyResult.size(), 1);
2520 EXPECT_EQ(copyResult[0].sourceUri, bFileUri.ToString());
2521 EXPECT_EQ(copyResult[0].destUri, destFileUri.ToString());
2522
2523 result = g_fah->Delete(srcDir);
2524 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2525 result = g_fah->Delete(destDir);
2526 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2527 }
2528 } catch (...) {
2529 GTEST_LOG_(ERROR) << "external_file_access_Copy_0007 occurs an exception.";
2530 }
2531 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0007";
2532 }
2533
2534 /**
2535 * @tc.number: user_file_service_external_file_access_Copy_0008
2536 * @tc.name: external_file_access_Copy_0008
2537 * @tc.desc: Test function of Copy interface, copy a directory with the same name and no force argument
2538 * @tc.size: MEDIUM
2539 * @tc.type: FUNC
2540 * @tc.level Level 1
2541 * @tc.require: I7QXVD
2542 */
2543 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0008, testing::ext::TestSize.Level1)
2544 {
2545 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0008";
2546 try {
2547 vector<RootInfo> info;
2548 int result = g_fah->GetRoots(info);
2549 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2550 for (size_t i = 0; i < info.size(); i++) {
2551 Uri parentUri(info[i].uri);
2552 Uri srcDir("");
2553 result = g_fah->Mkdir(parentUri, "Copy_0008_src", srcDir);
2554 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2555 Uri aFileUri("");
2556 result = g_fah->CreateFile(srcDir, "a.txt", aFileUri);
2557 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2558 Uri bFileUri("");
2559 result = g_fah->CreateFile(srcDir, "b.txt", bFileUri);
2560 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2561
2562 Uri destDir("");
2563 result = g_fah->Mkdir(parentUri, "Copy_0008_dest", destDir);
2564 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2565 Uri destSrcDir("");
2566 result = g_fah->Mkdir(destDir, "Copy_0008_src", destSrcDir);
2567 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2568 result = g_fah->CreateFile(destSrcDir, "b.txt", bFileUri);
2569 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2570
2571 std::vector<CopyResult> copyResult;
2572 result = g_fah->Copy(srcDir, destDir, copyResult);
2573 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2574 EXPECT_EQ(copyResult.size(), 1);
2575
2576 result = g_fah->Delete(srcDir);
2577 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2578 result = g_fah->Delete(destDir);
2579 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2580 }
2581 } catch (...) {
2582 GTEST_LOG_(ERROR) << "external_file_access_Copy_0008 occurs an exception.";
2583 }
2584 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0008";
2585 }
2586
2587 /**
2588 * @tc.number: user_file_service_external_file_access_Copy_0009
2589 * @tc.name: external_file_access_Copy_0009
2590 * @tc.desc: Test function of Copy interface, copy directory and file between different disks
2591 * @tc.size: MEDIUM
2592 * @tc.type: FUNC
2593 * @tc.level Level 1
2594 * @tc.require: I7QXVD
2595 */
2596 HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0009, testing::ext::TestSize.Level1)
2597 {
2598 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0009";
2599 try {
2600 vector<RootInfo> info;
2601 int result = g_fah->GetRoots(info);
2602 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2603 for (size_t i = 0; i < info.size(); i++) {
2604 Uri parentUri(info[i].uri);
2605 Uri srcDir("");
2606 result = g_fah->Mkdir(parentUri, "Copy_0009_src", srcDir);
2607 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2608 Uri aFileUri("");
2609 result = g_fah->CreateFile(srcDir, "a.txt", aFileUri);
2610 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2611 Uri bFileUri("");
2612 result = g_fah->CreateFile(srcDir, "b.txt", bFileUri);
2613 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2614 int fd = -1;
2615 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
2616 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2617 char buff[] = "Copy test content for b.txt";
2618 ssize_t srcFileSize = write(fd, buff, sizeof(buff));
2619 EXPECT_EQ(srcFileSize, sizeof(buff));
2620 close(fd);
2621
2622 for (size_t j = i + 1; j < info.size(); j++) {
2623 Uri targetUri(info[j].uri);
2624 Uri destDir("");
2625 result = g_fah->Mkdir(targetUri, "Copy_0009_dest", destDir);
2626 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2627 Uri destSrcDir("");
2628 result = g_fah->Mkdir(destDir, "Copy_0009_src", destSrcDir);
2629 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2630 result = g_fah->CreateFile(destSrcDir, "b.txt", bFileUri);
2631 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2632
2633 std::vector<CopyResult> copyResult;
2634 result = g_fah->Copy(srcDir, destDir, copyResult, true);
2635 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2636 EXPECT_EQ(copyResult.size(), 0);
2637
2638 result = g_fah->OpenFile(bFileUri, WRITE_READ, fd);
2639 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2640 ssize_t destFileSize = read(fd, buff, sizeof(buff));
2641 EXPECT_EQ(destFileSize, srcFileSize);
2642 close(fd);
2643
2644 result = g_fah->Delete(destDir);
2645 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2646 }
2647 result = g_fah->Delete(srcDir);
2648 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2649 }
2650 } catch (...) {
2651 GTEST_LOG_(ERROR) << "external_file_access_Copy_0009 occurs an exception.";
2652 }
2653 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0009";
2654 }
2655
2656 /**
2657 * @tc.number: user_file_service_external_file_access_Rename_0000
2658 * @tc.name: external_file_access_Rename_0000
2659 * @tc.desc: Test function of Rename interface for SUCCESS which rename file.
2660 * @tc.size: MEDIUM
2661 * @tc.type: FUNC
2662 * @tc.level Level 1
2663 * @tc.require: SR000H0387
2664 */
2665 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0000, testing::ext::TestSize.Level1)
2666 {
2667 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0000";
2668 try {
2669 vector<RootInfo> info;
2670 int result = g_fah->GetRoots(info);
2671 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2672 for (size_t i = 0; i < info.size(); i++) {
2673 Uri parentUri(info[i].uri);
2674 Uri newDirUriTest("");
2675 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
2676 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2677 Uri testUri("");
2678 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
2679 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2680 Uri renameUri("");
2681 result = g_fah->Rename(testUri, "test2.txt", renameUri);
2682 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2683 GTEST_LOG_(INFO) << "Rename_0000 result:" << result;
2684 result = g_fah->Delete(newDirUriTest);
2685 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2686 }
2687 } catch (...) {
2688 GTEST_LOG_(ERROR) << "external_file_access_Rename_0000 occurs an exception.";
2689 }
2690 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0000";
2691 }
2692
2693 /**
2694 * @tc.number: user_file_service_external_file_access_Rename_0001
2695 * @tc.name: external_file_access_Rename_0001
2696 * @tc.desc: Test function of Rename interface for SUCCESS which rename folder.
2697 * @tc.size: MEDIUM
2698 * @tc.type: FUNC
2699 * @tc.level Level 1
2700 * @tc.require: SR000H0387
2701 */
2702 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0001, testing::ext::TestSize.Level1)
2703 {
2704 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0001";
2705 try {
2706 vector<RootInfo> info;
2707 int result = g_fah->GetRoots(info);
2708 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2709 for (size_t i = 0; i < info.size(); i++) {
2710 Uri parentUri(info[i].uri);
2711 Uri newDirUriTest("");
2712 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
2713 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2714 Uri renameUri("");
2715 result = g_fah->Rename(newDirUriTest, "testRename", renameUri);
2716 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2717 GTEST_LOG_(INFO) << "Rename_0001 result:" << result;
2718 result = g_fah->Delete(renameUri);
2719 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2720 }
2721 } catch (...) {
2722 GTEST_LOG_(ERROR) << "external_file_access_Rename_0001 occurs an exception.";
2723 }
2724 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0001";
2725 }
2726
2727 /**
2728 * @tc.number: user_file_service_external_file_access_Rename_0002
2729 * @tc.name: external_file_access_Rename_0002
2730 * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null.
2731 * @tc.size: MEDIUM
2732 * @tc.type: FUNC
2733 * @tc.level Level 1
2734 * @tc.require: SR000H0387
2735 */
2736 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0002, testing::ext::TestSize.Level1)
2737 {
2738 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0002";
2739 try {
2740 Uri renameUri("");
2741 Uri sourceFileUri("");
2742 int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri);
2743 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2744 GTEST_LOG_(INFO) << "Rename_0002 result:" << result;
2745 } catch (...) {
2746 GTEST_LOG_(ERROR) << "external_file_access_Rename_0002 occurs an exception.";
2747 }
2748 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0002";
2749 }
2750
2751 /**
2752 * @tc.number: user_file_service_external_file_access_Rename_0003
2753 * @tc.name: external_file_access_Rename_0003
2754 * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path.
2755 * @tc.size: MEDIUM
2756 * @tc.type: FUNC
2757 * @tc.level Level 1
2758 * @tc.require: SR000H0387
2759 */
2760 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0003, testing::ext::TestSize.Level1)
2761 {
2762 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0003";
2763 try {
2764 vector<RootInfo> info;
2765 int result = g_fah->GetRoots(info);
2766 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2767 for (size_t i = 0; i < info.size(); i++) {
2768 Uri parentUri(info[i].uri);
2769 Uri newDirUriTest("");
2770 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
2771 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2772 Uri testUri("");
2773 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
2774 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2775 Uri renameUri("");
2776 Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt");
2777 result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri);
2778 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2779 GTEST_LOG_(INFO) << "Rename_0003 result:" << result;
2780 result = g_fah->Delete(newDirUriTest);
2781 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2782 }
2783 } catch (...) {
2784 GTEST_LOG_(ERROR) << "external_file_access_Rename_0003 occurs an exception.";
2785 }
2786 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0003";
2787 }
2788
2789 /**
2790 * @tc.number: user_file_service_external_file_access_Rename_0004
2791 * @tc.name: external_file_access_Rename_0004
2792 * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols.
2793 * @tc.size: MEDIUM
2794 * @tc.type: FUNC
2795 * @tc.level Level 1
2796 * @tc.require: SR000H0387
2797 */
2798 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0004, testing::ext::TestSize.Level1)
2799 {
2800 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0004";
2801 try {
2802 Uri renameUri("");
2803 Uri sourceFileUri("~!@#$%^&*()_");
2804 int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri);
2805 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2806 GTEST_LOG_(INFO) << "Rename_0004 result:" << result;
2807 } catch (...) {
2808 GTEST_LOG_(ERROR) << "external_file_access_Rename_0004 occurs an exception.";
2809 }
2810 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0004";
2811 }
2812
2813 /**
2814 * @tc.number: user_file_service_external_file_access_Rename_0005
2815 * @tc.name: external_file_access_Rename_0005
2816 * @tc.desc: Test function of Rename interface for ERROR which displayName is null.
2817 * @tc.size: MEDIUM
2818 * @tc.type: FUNC
2819 * @tc.level Level 1
2820 * @tc.require: SR000H0387
2821 */
2822 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0005, testing::ext::TestSize.Level1)
2823 {
2824 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0005";
2825 try {
2826 vector<RootInfo> info;
2827 int result = g_fah->GetRoots(info);
2828 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2829 for (size_t i = 0; i < info.size(); i++) {
2830 Uri parentUri(info[i].uri);
2831 Uri newDirUriTest("");
2832 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
2833 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2834 Uri testUri("");
2835 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
2836 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2837 Uri renameUri("");
2838 result = g_fah->Rename(testUri, "", renameUri);
2839 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
2840 GTEST_LOG_(INFO) << "Rename_0005 result:" << result;
2841 result = g_fah->Delete(newDirUriTest);
2842 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2843 }
2844 } catch (...) {
2845 GTEST_LOG_(ERROR) << "external_file_access_Rename_0005 occurs an exception.";
2846 }
2847 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0005";
2848 }
2849
RenameTdd(shared_ptr<FileAccessHelper> fahs,Uri sourceFile,std::string displayName,Uri newFile)2850 static void RenameTdd(shared_ptr<FileAccessHelper> fahs, Uri sourceFile, std::string displayName, Uri newFile)
2851 {
2852 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_RenameTdd";
2853 int ret = fahs->Rename(sourceFile, displayName, newFile);
2854 if (ret != OHOS::FileAccessFwk::ERR_OK) {
2855 GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret;
2856 return;
2857 }
2858 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
2859 g_num++;
2860 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_RenameTdd";
2861 }
2862
2863 /**
2864 * @tc.number: user_file_service_external_file_access_Rename_0006
2865 * @tc.name: external_file_access_Rename_0006
2866 * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent.
2867 * @tc.size: MEDIUM
2868 * @tc.type: FUNC
2869 * @tc.level Level 1
2870 * @tc.require: SR000H0386
2871 */
2872 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0006, testing::ext::TestSize.Level1)
2873 {
2874 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0006";
2875 try {
2876 vector<RootInfo> info;
2877 int result = g_fah->GetRoots(info);
2878 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2879 for (size_t i = 0; i < info.size(); i++) {
2880 Uri parentUri(info[i].uri);
2881 Uri newDirUriTest("");
2882 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
2883 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2884 Uri testUri("");
2885 std::string displayName1 = "test1.txt";
2886 std::string displayName2 = "test2.txt";
2887 Uri renameUri("");
2888 result = g_fah->CreateFile(newDirUriTest, displayName1, testUri);
2889 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2890 g_num = 0;
2891 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
2892 std::thread execthread(RenameTdd, g_fah, testUri, displayName2, renameUri);
2893 execthread.join();
2894 }
2895 EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER);
2896 result = g_fah->Delete(newDirUriTest);
2897 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2898 }
2899 } catch (...) {
2900 GTEST_LOG_(ERROR) << "external_file_access_Rename_0006 occurs an exception.";
2901 }
2902 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0006";
2903 }
2904
2905 /**
2906 * @tc.number: user_file_service_external_file_access_Rename_0007
2907 * @tc.name: external_file_access_Rename_0007
2908 * @tc.desc: Test function of Rename interface for ERROR because of GetProxyByUri failed.
2909 * @tc.size: MEDIUM
2910 * @tc.type: FUNC
2911 * @tc.level Level 1
2912 * @tc.require: SR000H0387
2913 */
2914 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0007, testing::ext::TestSize.Level1)
2915 {
2916 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0007";
2917 try {
2918 vector<RootInfo> info;
2919 int result = g_fah->GetRoots(info);
2920 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2921 for (size_t i = 0; i < info.size(); i++) {
2922 Uri parentUri(info[i].uri);
2923 Uri newDirUriTest("");
2924 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
2925 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2926
2927 std::string str = newDirUriTest.ToString();
2928 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
2929 GTEST_LOG_(ERROR) << "replace BundleName failed.";
2930 EXPECT_TRUE(false);
2931 }
2932 Uri testUri(str);
2933 Uri renameUri("");
2934 result = g_fah->Rename(testUri, "test.txt", renameUri);
2935 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
2936 GTEST_LOG_(INFO) << "Rename_0007 result:" << result;
2937 result = g_fah->Delete(newDirUriTest);
2938 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2939 }
2940 } catch (...) {
2941 GTEST_LOG_(ERROR) << "external_file_access_Rename_0007 occurs an exception.";
2942 }
2943 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0007";
2944 }
2945
2946 /**
2947 * @tc.number: user_file_service_external_file_access_Rename_0008
2948 * @tc.name: external_file_access_Rename_0008
2949 * @tc.desc: Test function of Rename interface for SUCCESS which rename file, the display name is chinese.
2950 * @tc.size: MEDIUM
2951 * @tc.type: FUNC
2952 * @tc.level Level 1
2953 * @tc.require: I70SX9
2954 */
2955 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0008, testing::ext::TestSize.Level1)
2956 {
2957 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0008";
2958 try {
2959 vector<RootInfo> info;
2960 int result = g_fah->GetRoots(info);
2961 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2962 for (size_t i = 0; i < info.size(); i++) {
2963 Uri parentUri(info[i].uri);
2964 Uri newDirUriTest("");
2965 result = g_fah->Mkdir(parentUri, "测试目录", newDirUriTest);
2966 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2967 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
2968 Uri testUri("");
2969 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
2970 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2971 Uri renameUri("");
2972 result = g_fah->Rename(testUri, "测试文件.txt", renameUri);
2973 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2974 EXPECT_EQ(renameUri.ToString().find("测试文件.txt"), std::string::npos);
2975 GTEST_LOG_(INFO) << "Rename_0008 result:" << result;
2976 result = g_fah->Delete(newDirUriTest);
2977 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
2978 }
2979 } catch (...) {
2980 GTEST_LOG_(ERROR) << "external_file_access_Rename_0008 occurs an exception.";
2981 }
2982 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0008";
2983 }
2984
2985 /**
2986 * @tc.number: user_file_service_external_file_access_Rename_0009
2987 * @tc.name: external_file_access_Rename_0009
2988 * @tc.desc: Test function of Rename interface for SUCCESS which rename folder, the display name is chinese.
2989 * @tc.size: MEDIUM
2990 * @tc.type: FUNC
2991 * @tc.level Level 1
2992 * @tc.require: I70SX9
2993 */
2994 HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0009, testing::ext::TestSize.Level1)
2995 {
2996 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0009";
2997 try {
2998 vector<RootInfo> info;
2999 int result = g_fah->GetRoots(info);
3000 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3001 for (size_t i = 0; i < info.size(); i++) {
3002 Uri parentUri(info[i].uri);
3003 Uri newDirUriTest("");
3004 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
3005 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3006 Uri testUri("");
3007 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
3008 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3009 Uri renameUri("");
3010 result = g_fah->Rename(newDirUriTest, "重命名目录", renameUri);
3011 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3012 EXPECT_EQ(renameUri.ToString().find("重命名目录"), std::string::npos);
3013 GTEST_LOG_(INFO) << "Rename_0009 result:" << result;
3014 result = g_fah->Delete(renameUri);
3015 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3016 }
3017 } catch (...) {
3018 GTEST_LOG_(ERROR) << "external_file_access_Rename_0009 occurs an exception.";
3019 }
3020 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0009";
3021 }
3022
3023 /**
3024 * @tc.number: user_file_service_external_file_access_ListFile_0000
3025 * @tc.name: external_file_access_ListFile_0000
3026 * @tc.desc: Test function of ListFile interface for SUCCESS.
3027 * @tc.size: MEDIUM
3028 * @tc.type: FUNC
3029 * @tc.level Level 1
3030 * @tc.require: SR000H0387
3031 */
3032 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0000, testing::ext::TestSize.Level1)
3033 {
3034 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0000";
3035 try {
3036 vector<RootInfo> info;
3037 int result = g_fah->GetRoots(info);
3038 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3039 for (size_t i = 0; i < info.size(); i++) {
3040 Uri parentUri(info[i].uri);
3041 Uri newDirUriTest("");
3042 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
3043 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3044 Uri testUri("");
3045 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_0000.txt", testUri);
3046 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3047 FileInfo fileInfo;
3048 fileInfo.uri = newDirUriTest.ToString();
3049 int64_t offset = 0;
3050 int64_t maxCount = 1000;
3051 std::vector<FileInfo> fileInfoVec;
3052 FileFilter filter;
3053 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3054 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3055 EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
3056 result = g_fah->Delete(newDirUriTest);
3057 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3058 }
3059 } catch (...) {
3060 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0000 occurs an exception.";
3061 }
3062 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0000";
3063 }
3064
3065 /**
3066 * @tc.number: user_file_service_external_file_access_ListFile_0001
3067 * @tc.name: external_file_access_ListFile_0001
3068 * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr.
3069 * @tc.size: MEDIUM
3070 * @tc.type: FUNC
3071 * @tc.level Level 1
3072 * @tc.require: SR000H0387
3073 */
3074 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0001, testing::ext::TestSize.Level1)
3075 {
3076 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0001";
3077 try {
3078 Uri sourceFileUri("");
3079 FileInfo fileInfo;
3080 fileInfo.uri = sourceFileUri.ToString();
3081 int64_t offset = 0;
3082 int64_t maxCount = 1000;
3083 std::vector<FileInfo> fileInfoVec;
3084 FileFilter filter;
3085 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3086 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
3087 EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
3088 } catch (...) {
3089 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0001 occurs an exception.";
3090 }
3091 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0001";
3092 }
3093
3094 /**
3095 * @tc.number: user_file_service_external_file_access_ListFile_0002
3096 * @tc.name: external_file_access_ListFile_0002
3097 * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path.
3098 * @tc.size: MEDIUM
3099 * @tc.type: FUNC
3100 * @tc.level Level 1
3101 * @tc.require: SR000H0387
3102 */
3103 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0002, testing::ext::TestSize.Level1)
3104 {
3105 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0002";
3106 try {
3107 vector<RootInfo> info;
3108 int result = g_fah->GetRoots(info);
3109 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3110 for (size_t i = 0; i < info.size(); i++) {
3111 Uri parentUri(info[i].uri);
3112 Uri newDirUriTest("");
3113 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
3114 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3115 Uri testUri("");
3116 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
3117 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3118 Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt");
3119 FileInfo fileInfo;
3120 fileInfo.uri = sourceFileUri.ToString();
3121 Uri sourceFile(fileInfo.uri);
3122 int64_t offset = 0;
3123 int64_t maxCount = 1000;
3124 std::vector<FileInfo> fileInfoVec;
3125 FileFilter filter;
3126 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3127 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
3128 EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
3129 result = g_fah->Delete(newDirUriTest);
3130 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3131 }
3132 } catch (...) {
3133 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0002 occurs an exception.";
3134 }
3135 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0002";
3136 }
3137
3138 /**
3139 * @tc.number: user_file_service_external_file_access_ListFile_0003
3140 * @tc.name: external_file_access_ListFile_0003
3141 * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols.
3142 * @tc.size: MEDIUM
3143 * @tc.type: FUNC
3144 * @tc.level Level 1
3145 * @tc.require: SR000H0387
3146 */
3147 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0003, testing::ext::TestSize.Level1)
3148 {
3149 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0003";
3150 try {
3151 Uri sourceFileUri("~!@#$%^&*()_");
3152 FileInfo fileInfo;
3153 fileInfo.uri = sourceFileUri.ToString();
3154 Uri sourceFile(fileInfo.uri);
3155 int64_t offset = 0;
3156 int64_t maxCount = 1000;
3157 std::vector<FileInfo> fileInfoVec;
3158 FileFilter filter;
3159 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3160 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
3161 EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
3162 } catch (...) {
3163 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0003 occurs an exception.";
3164 }
3165 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0003";
3166 }
3167
ListFileTdd(FileInfo fileInfo,int offset,int maxCount,FileFilter filter,std::vector<FileInfo> fileInfoVec)3168 static void ListFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter,
3169 std::vector<FileInfo> fileInfoVec)
3170 {
3171 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFileTdd";
3172 int ret = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3173 if (ret != OHOS::FileAccessFwk::ERR_OK) {
3174 GTEST_LOG_(ERROR) << "ListFile get result error, code:" << ret;
3175 return;
3176 }
3177 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
3178 g_num++;
3179 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFileTdd";
3180 }
3181
3182 /**
3183 * @tc.number: user_file_service_external_file_access_ListFile_0004
3184 * @tc.name: external_file_access_ListFile_0004
3185 * @tc.desc: Test function of ListFile interface for SUCCESS which Concurrent.
3186 * @tc.size: MEDIUM
3187 * @tc.type: FUNC
3188 * @tc.level Level 1
3189 * @tc.require: SR000H0386
3190 */
3191 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0004, testing::ext::TestSize.Level1)
3192 {
3193 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0004";
3194 try {
3195 vector<RootInfo> info;
3196 int result = g_fah->GetRoots(info);
3197 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3198 for (size_t i = 0; i < info.size(); i++) {
3199 Uri parentUri(info[i].uri);
3200 Uri newDirUriTest("");
3201 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
3202 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3203 Uri testUri("");
3204 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_0004.txt", testUri);
3205 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3206 FileInfo fileInfo;
3207 fileInfo.uri = newDirUriTest.ToString();
3208 int offset = 0;
3209 int maxCount = 1000;
3210 std::vector<FileInfo> fileInfoVec;
3211 FileFilter filter;
3212 g_num = 0;
3213 for (int j = 0; j < INIT_THREADS_NUMBER; j++) {
3214 std::thread execthread(ListFileTdd, fileInfo, offset, maxCount, filter, fileInfoVec);
3215 execthread.join();
3216 }
3217 EXPECT_EQ(g_num, INIT_THREADS_NUMBER);
3218 result = g_fah->Delete(newDirUriTest);
3219 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3220 }
3221 } catch (...) {
3222 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0004 occurs an exception.";
3223 }
3224 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0004";
3225 }
3226
3227 /**
3228 * @tc.number: user_file_service_external_file_access_ListFile_0005
3229 * @tc.name: external_file_access_ListFile_0005
3230 * @tc.desc: Test function of ListFile interface for ERROR because of GetProxyByUri failed.
3231 * @tc.size: MEDIUM
3232 * @tc.type: FUNC
3233 * @tc.level Level 1
3234 * @tc.require: SR000H0387
3235 */
3236 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0005, testing::ext::TestSize.Level1)
3237 {
3238 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0005";
3239 try {
3240 vector<RootInfo> info;
3241 int result = g_fah->GetRoots(info);
3242 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3243 for (size_t i = 0; i < info.size(); i++) {
3244 Uri parentUri(info[i].uri);
3245 Uri newDirUriTest("");
3246 result = g_fah->Mkdir(parentUri, "test", newDirUriTest);
3247 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3248 Uri testUri("");
3249 result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri);
3250 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3251
3252 std::string str = testUri.ToString();
3253 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
3254 GTEST_LOG_(ERROR) << "replace BundleName failed.";
3255 EXPECT_TRUE(false);
3256 }
3257 FileInfo fileInfo;
3258 fileInfo.uri = str;
3259 int64_t offset = 0;
3260 int64_t maxCount = 1000;
3261 std::vector<FileInfo> fileInfoVec;
3262 FileFilter filter;
3263 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3264 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
3265 result = g_fah->Delete(newDirUriTest);
3266 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3267 }
3268 } catch (...) {
3269 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0005 occurs an exception.";
3270 }
3271 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0005";
3272 }
3273
3274 /**
3275 * @tc.number: user_file_service_external_file_access_ListFile_0006
3276 * @tc.name: external_file_access_ListFile_0006
3277 * @tc.desc: Test function of ListFile interface for SUCCESS, the folder and file name is chinese.
3278 * @tc.size: MEDIUM
3279 * @tc.type: FUNC
3280 * @tc.level Level 1
3281 * @tc.require: I70SX9
3282 */
3283 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0006, testing::ext::TestSize.Level1)
3284 {
3285 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0006";
3286 try {
3287 vector<RootInfo> info;
3288 int result = g_fah->GetRoots(info);
3289 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3290 for (size_t i = 0; i < info.size(); i++) {
3291 Uri parentUri(info[i].uri);
3292 Uri newDirUriTest("");
3293 result = g_fah->Mkdir(parentUri, "测试目录", newDirUriTest);
3294 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3295 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
3296 Uri testUri("");
3297 result = g_fah->CreateFile(newDirUriTest, "测试文件.txt", testUri);
3298 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3299 EXPECT_EQ(testUri.ToString().find("测试文件.txt"), std::string::npos);
3300 FileInfo fileInfo;
3301 fileInfo.uri = newDirUriTest.ToString();
3302 int64_t offset = 0;
3303 int64_t maxCount = 1000;
3304 std::vector<FileInfo> fileInfoVec;
3305 FileFilter filter;
3306 result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3307 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3308 EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
3309 result = g_fah->Delete(newDirUriTest);
3310 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3311 }
3312 } catch (...) {
3313 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0006 occurs an exception.";
3314 }
3315 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0006";
3316 }
3317
3318
WriteData(Uri & uri)3319 static void WriteData(Uri &uri)
3320 {
3321 int fd = -1;
3322 std::string buff = "extenal_file_access_test";
3323 int result = g_fah->OpenFile(uri, WRITE_READ, fd);
3324 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3325 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
3326 close(fd);
3327 EXPECT_EQ(fileSize, buff.size());
3328 }
3329
GetTime()3330 static double GetTime()
3331 {
3332 struct timespec t{};
3333 t.tv_sec = 0;
3334 t.tv_nsec = 0;
3335 clock_gettime(CLOCK_REALTIME, &t);
3336 return static_cast<double>(t.tv_sec);
3337 }
3338
InitListFile(Uri newDirUriTest,const std::string & caseNumber,const bool & needSleep=false)3339 static double InitListFile(Uri newDirUriTest, const std::string &caseNumber, const bool &needSleep = false)
3340 {
3341 Uri testUri1("");
3342 int result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_" + caseNumber + ".txt", testUri1);
3343 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3344 Uri testUri2("");
3345 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_" + caseNumber + ".docx", testUri2);
3346 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3347 Uri testUri3("");
3348 double time = GetTime();
3349 if (needSleep) {
3350 sleep(SLEEP_TIME);
3351 }
3352 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_01_" + caseNumber + ".txt", testUri3);
3353 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3354 Uri testUri4("");
3355 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_01_" + caseNumber + ".docx", testUri4);
3356 WriteData(testUri4);
3357 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3358 Uri testUri5("");
3359 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_01_" + caseNumber + "_01.docx", testUri5);
3360 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3361 return time;
3362 }
3363
ListFileFilter7(Uri newDirUriTest)3364 static void ListFileFilter7(Uri newDirUriTest)
3365 {
3366 FileInfo fileInfo;
3367 fileInfo.uri = newDirUriTest.ToString();
3368 int64_t offset = 4;
3369 int64_t maxCount = 1;
3370 std::vector<FileInfo> fileInfoVec;
3371 FileFilter filter({".txt", ".docx"}, {}, {}, -1, -1, false, true);
3372 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3373 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3374 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_1);
3375 }
3376
3377 /**
3378 * @tc.number: user_file_service_external_file_access_ListFile_0007
3379 * @tc.name: external_file_access_ListFile_0007
3380 * @tc.desc: Test function of ListFile for Success, filter is File Extensions.
3381 * @tc.size: MEDIUM
3382 * @tc.type: FUNC
3383 * @tc.level Level 1
3384 * @tc.require: I79CSX
3385 */
3386 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0007, testing::ext::TestSize.Level1)
3387 {
3388 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0007";
3389 try {
3390 vector<RootInfo> info;
3391 int result = g_fah->GetRoots(info);
3392 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3393 for (size_t i = 0; i < info.size(); i++) {
3394 Uri parentUri(info[i].uri);
3395 Uri newDirUriTest("");
3396 result = g_fah->Mkdir(parentUri, "listfile007", newDirUriTest);
3397 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3398 InitListFile(newDirUriTest, "0007");
3399 ListFileFilter7(newDirUriTest);
3400 result = g_fah->Delete(newDirUriTest);
3401 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3402 }
3403 } catch (...) {
3404 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0007 occurs an exception.";
3405 }
3406 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0007";
3407 }
3408
InitListFileFolder(Uri newDirUriTest,const std::string & caseNumber,const bool & needSleep=false)3409 static double InitListFileFolder(Uri newDirUriTest, const std::string &caseNumber, const bool &needSleep = false)
3410 {
3411 double time = InitListFile(newDirUriTest, caseNumber, needSleep);
3412 Uri folderUri("");
3413 int result = g_fah->Mkdir(newDirUriTest, "test" + caseNumber, folderUri);
3414 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3415 Uri testUri6("");
3416 result = g_fah->CreateFile(folderUri, "external_file_access_ListFile_01_" + caseNumber + "_02.docx", testUri6);
3417 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3418 return time;
3419 }
3420
ShowInfo(const std::vector<FileInfo> & fileInfoVec,const std::string & caseNumber)3421 static void ShowInfo(const std::vector<FileInfo> &fileInfoVec, const std::string &caseNumber)
3422 {
3423 for (auto fileInfo : fileInfoVec) {
3424 GTEST_LOG_(INFO) << caseNumber << ", uri:" << fileInfo.uri << endl;
3425 }
3426 }
3427
ListFileFilter8(Uri newDirUriTest)3428 static void ListFileFilter8(Uri newDirUriTest)
3429 {
3430 FileInfo fileInfo;
3431 fileInfo.uri = newDirUriTest.ToString();
3432 int64_t offset = 0;
3433 int64_t maxCount = 1000;
3434 std::vector<FileInfo> fileInfoVec;
3435 FileFilter filter({}, {}, {}, -1, 0, false, true);
3436 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3437 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3438 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_6);
3439 ShowInfo(fileInfoVec, "external_file_access_ListFile_0008");
3440 }
3441
3442 /**
3443 * @tc.number: user_file_service_external_file_access_ListFile_0008
3444 * @tc.name: external_file_access_ListFile_0008
3445 * @tc.desc: Test function of ListFile for Success, filter is filesize >= 0
3446 * @tc.size: MEDIUM
3447 * @tc.type: FUNC
3448 * @tc.level Level 1
3449 * @tc.require: I79CSX
3450 */
3451 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0008, testing::ext::TestSize.Level1)
3452 {
3453 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0008";
3454 try {
3455 vector<RootInfo> info;
3456 int result = g_fah->GetRoots(info);
3457 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3458 for (size_t i = 0; i < info.size(); i++) {
3459 Uri parentUri(info[i].uri);
3460 Uri newDirUriTest("");
3461 result = g_fah->Mkdir(parentUri, "listfile008", newDirUriTest);
3462 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3463 InitListFileFolder(newDirUriTest, "0008");
3464 ListFileFilter8(newDirUriTest);
3465 result = g_fah->Delete(newDirUriTest);
3466 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3467 }
3468 } catch (...) {
3469 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0008 occurs an exception.";
3470 }
3471 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0008";
3472 }
3473
ListFileFilter9(Uri newDirUriTest)3474 static void ListFileFilter9(Uri newDirUriTest)
3475 {
3476 FileInfo fileInfo;
3477 fileInfo.uri = newDirUriTest.ToString();
3478 int64_t offset = 0;
3479 int64_t maxCount = 1000;
3480 std::vector<FileInfo> fileInfoVec;
3481 FileFilter filter;
3482 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3483 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3484 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_6);
3485 }
3486
3487 /**
3488 * @tc.number: user_file_service_external_file_access_ListFile_0009
3489 * @tc.name: external_file_access_ListFile_0009
3490 * @tc.desc: Test function of ListFile for Success, filter is offset from 0 and maxCount is 1000
3491 * @tc.size: MEDIUM
3492 * @tc.type: FUNC
3493 * @tc.level Level 1
3494 * @tc.require: I79CSX
3495 */
3496 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0009, testing::ext::TestSize.Level1)
3497 {
3498 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0008";
3499 try {
3500 vector<RootInfo> info;
3501 int result = g_fah->GetRoots(info);
3502 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3503 for (size_t i = 0; i < info.size(); i++) {
3504 Uri parentUri(info[i].uri);
3505 Uri newDirUriTest("");
3506 result = g_fah->Mkdir(parentUri, "listfile009", newDirUriTest);
3507 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3508 InitListFileFolder(newDirUriTest, "0009");
3509 ListFileFilter9(newDirUriTest);
3510 result = g_fah->Delete(newDirUriTest);
3511 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3512 }
3513 } catch (...) {
3514 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0009 occurs an exception.";
3515 }
3516 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0009";
3517 }
3518
ListFileFilter10(Uri newDirUriTest,const double & time)3519 static void ListFileFilter10(Uri newDirUriTest, const double &time)
3520 {
3521 FileInfo fileInfo;
3522 fileInfo.uri = newDirUriTest.ToString();
3523 int64_t offset = 0;
3524 int64_t maxCount = 1000;
3525 std::vector<FileInfo> fileInfoVec;
3526 FileFilter filter({".txt", ".docx"}, {}, {}, -1, -1, false, true);
3527 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3528 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3529 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_5);
3530
3531 FileFilter filter1({".txt", ".docx"}, {"0010.txt", "0010.docx"}, {}, -1, -1, false, true);
3532 result = g_fah->ListFile(fileInfo, offset, maxCount, filter1, fileInfoVec);
3533 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3534 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_4);
3535
3536 FileFilter filter2({".txt", ".docx"}, {"0010.txt", "0010.docx"}, {}, 0, 0, false, true);
3537 result = g_fah->ListFile(fileInfo, offset, maxCount, filter2, fileInfoVec);
3538 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3539 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_1);
3540
3541 FileFilter filter3({".txt", ".docx"}, {"0010.txt", "0010.docx"}, {}, -1, time, false, true);
3542 result = g_fah->ListFile(fileInfo, offset, maxCount, filter3, fileInfoVec);
3543 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3544 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_2);
3545
3546 double nowTime = GetTime();
3547 FileFilter filter4({".txt", ".docx"}, {"0010.txt", "0010.docx"}, {}, -1, nowTime, false, true);
3548 result = g_fah->ListFile(fileInfo, offset, maxCount, filter4, fileInfoVec);
3549 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3550 EXPECT_EQ(fileInfoVec.size(), 0);
3551 }
3552
3553 /**
3554 * @tc.number: user_file_service_external_file_access_ListFile_0010
3555 * @tc.name: external_file_access_ListFile_0010
3556 * @tc.desc: Test function of ListFile interface for SUCCESS, filter is filename, extension, file size, modify time
3557 * @tc.size: MEDIUM
3558 * @tc.type: FUNC
3559 * @tc.level Level 1
3560 * @tc.require: I79CSX
3561 */
3562 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0010, testing::ext::TestSize.Level1)
3563 {
3564 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0010";
3565 try {
3566 vector<RootInfo> info;
3567 int result = g_fah->GetRoots(info);
3568 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3569 for (size_t i = 0; i < info.size(); i++) {
3570 Uri parentUri(info[i].uri);
3571 Uri newDirUriTest("");
3572 result = g_fah->Mkdir(parentUri, "listfile0010", newDirUriTest);
3573 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3574 double time = InitListFile(newDirUriTest, "0010", true);
3575 ListFileFilter10(newDirUriTest, time);
3576 result = g_fah->Delete(newDirUriTest);
3577 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3578 }
3579 } catch (...) {
3580 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0010 occurs an exception.";
3581 }
3582 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0010";
3583 }
3584
ListFileFilter11(Uri newDirUriTest,const double & time)3585 static void ListFileFilter11(Uri newDirUriTest, const double &time)
3586 {
3587 FileInfo fileInfo;
3588 fileInfo.uri = newDirUriTest.ToString();
3589 int64_t offset = 0;
3590 int64_t maxCount = 1000;
3591 std::vector<FileInfo> fileInfoVec;
3592 FileFilter filter({".txt", ".docx"}, {}, {}, -1, -1, false, true);
3593 int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3594 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3595 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_6);
3596
3597 FileFilter filter1({".txt", ".docx"}, {"测试.txt", "测试.docx"}, {}, -1, -1, false, true);
3598 result = g_fah->ListFile(fileInfo, offset, maxCount, filter1, fileInfoVec);
3599 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3600 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_4);
3601
3602 FileFilter filter2({".txt", ".docx"}, {"测试.txt", "测试.docx"}, {}, 0, 0, false, true);
3603 result = g_fah->ListFile(fileInfo, offset, maxCount, filter2, fileInfoVec);
3604 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3605 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_1);
3606
3607 FileFilter filter3({".txt", ".docx"}, {"测试.txt", "测试.docx"}, {}, -1, time, false, true);
3608 result = g_fah->ListFile(fileInfo, offset, maxCount, filter3, fileInfoVec);
3609 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3610 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_2);
3611
3612 double nowTime = GetTime();
3613 FileFilter filter4({".txt", ".docx"}, {"测试.txt", "测试.docx"}, {}, -1, nowTime, false, true);
3614 result = g_fah->ListFile(fileInfo, offset, maxCount, filter4, fileInfoVec);
3615 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3616 EXPECT_EQ(fileInfoVec.size(), 0);
3617 }
3618
3619 /**
3620 * @tc.number: user_file_service_external_file_access_ListFile_0011
3621 * @tc.name: external_file_access_ListFile_0011
3622 * @tc.desc: Test function of ListFile interface for SUCCESS, for filename is Chinese
3623 * @tc.size: MEDIUM
3624 * @tc.type: FUNC
3625 * @tc.level Level 1
3626 * @tc.require: I79CSX
3627 */
3628 HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0011, testing::ext::TestSize.Level1)
3629 {
3630 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0011";
3631 try {
3632 vector<RootInfo> info;
3633 int result = g_fah->GetRoots(info);
3634 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3635 for (size_t i = 0; i < info.size(); i++) {
3636 Uri parentUri(info[i].uri);
3637 Uri newDirUriTest("");
3638 result = g_fah->Mkdir(parentUri, "listfile测试", newDirUriTest);
3639 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3640 double time = InitListFileFolder(newDirUriTest, "测试", true);
3641 ListFileFilter11(newDirUriTest, time);
3642 result = g_fah->Delete(newDirUriTest);
3643 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3644 }
3645 } catch (...) {
3646 GTEST_LOG_(ERROR) << "external_file_access_ListFile_0011 occurs an exception.";
3647 }
3648 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0011";
3649 }
3650
InitScanFile(Uri newDirUriTest,const std::string & caseNumber,const bool & needSleep=false)3651 static double InitScanFile(Uri newDirUriTest, const std::string &caseNumber, const bool &needSleep = false)
3652 {
3653 Uri forlderUriTest("");
3654 int result = g_fah->Mkdir(newDirUriTest, "test" + caseNumber, forlderUriTest);
3655 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3656
3657 Uri testUri1("");
3658 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ScanFile_" + caseNumber + ".txt", testUri1);
3659 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3660 Uri testUri2("");
3661 result = g_fah->CreateFile(newDirUriTest, "external_file_access_ScanFile_" + caseNumber + ".docx", testUri2);
3662 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3663 double time = GetTime();
3664 if (needSleep) {
3665 sleep(SLEEP_TIME);
3666 }
3667 Uri testUri3("");
3668 result = g_fah->CreateFile(forlderUriTest, "external_file_access_ScanFile_01_" + caseNumber + ".txt", testUri3);
3669 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3670 Uri testUri4("");
3671 result = g_fah->CreateFile(forlderUriTest, "external_file_access_ScanFile_01_" + caseNumber + ".docx", testUri4);
3672 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3673 WriteData(testUri4);
3674 Uri testUri5("");
3675 result = g_fah->CreateFile(forlderUriTest, "external_file_access_ScanFile_01_" + caseNumber + "_01.docx", testUri5);
3676 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3677 return time;
3678 }
3679
ScanFileFilter0(Uri newDirUriTest,const double & time)3680 static void ScanFileFilter0(Uri newDirUriTest, const double &time)
3681 {
3682 FileInfo fileInfo;
3683 fileInfo.uri = newDirUriTest.ToString();
3684 int64_t offset = 0;
3685 int64_t maxCount = 1000;
3686 std::vector<FileInfo> fileInfoVec;
3687 FileFilter filter({".txt", ".docx"}, {}, {}, -1, -1, false, true);
3688 int result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3689 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3690 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_5);
3691
3692 FileFilter filter1({".txt", ".docx"}, {"0000.txt", "0000.docx"}, {}, -1, -1, false, true);
3693 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter1, fileInfoVec);
3694 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3695 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_4);
3696
3697 FileFilter filter2({".txt", ".docx"}, {"0000.txt", "0000.docx"}, {}, 0, 0, false, true);
3698 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter2, fileInfoVec);
3699 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3700 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_1);
3701
3702 FileFilter filter3({".txt", ".docx"}, {"0000.txt", "0000.docx"}, {}, -1, time, false, true);
3703 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter3, fileInfoVec);
3704 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3705 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_2);
3706
3707 double nowTime = GetTime();
3708 FileFilter filter4({".txt", ".docx"}, {"0000.txt", "0000.docx"}, {}, -1, nowTime, false, true);
3709 result = g_fah->ScanFile(fileInfo, offset, maxCount, filter4, fileInfoVec);
3710 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3711 EXPECT_EQ(fileInfoVec.size(), 0);
3712 }
3713
3714 /**
3715 * @tc.number: user_file_service_external_file_access_ScanFile_0000
3716 * @tc.name: external_file_access_ScanFile_0000
3717 * @tc.desc: Test function of ScanFile interface for SUCCESS, filter is filename, extension, file size, modify time
3718 * @tc.size: MEDIUM
3719 * @tc.type: FUNC
3720 * @tc.level Level 1
3721 * @tc.require: I79CSX
3722 */
3723 HWTEST_F(FileExtensionHelperTest, external_file_access_ScanFile_0000, testing::ext::TestSize.Level1)
3724 {
3725 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ScanFile_0000";
3726 try {
3727 vector<RootInfo> info;
3728 int result = g_fah->GetRoots(info);
3729 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3730 for (size_t i = 0; i < info.size(); i++) {
3731 Uri parentUri(info[i].uri);
3732 Uri newDirUriTest("");
3733 result = g_fah->Mkdir(parentUri, "scanfile0000", newDirUriTest);
3734 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3735 double time = InitScanFile(newDirUriTest, "0000", true);
3736 ScanFileFilter0(newDirUriTest, time);
3737 result = g_fah->Delete(newDirUriTest);
3738 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3739 }
3740 } catch (...) {
3741 GTEST_LOG_(ERROR) << "external_file_access_ScanFile_0000 occurs an exception.";
3742 }
3743 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ScanFile_0000";
3744 }
3745
ScanFileFilter1(Uri newDirUriTest)3746 static void ScanFileFilter1(Uri newDirUriTest)
3747 {
3748 FileInfo fileInfo;
3749 fileInfo.uri = newDirUriTest.ToString();
3750 int64_t offset = 0;
3751 int64_t maxCount = 1000;
3752 std::vector<FileInfo> fileInfoVec;
3753 FileFilter filter;
3754 int result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3755 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3756 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_5);
3757 }
3758
3759 /**
3760 * @tc.number: user_file_service_external_file_access_ScanFile_0001
3761 * @tc.name: external_file_access_ScanFile_0001
3762 * @tc.desc: Test function of ScanFile interface for SUCCESS, the filter is offset from 0 to maxcount
3763 * @tc.size: MEDIUM
3764 * @tc.type: FUNC
3765 * @tc.level Level 1
3766 * @tc.require: I79CSX
3767 */
3768 HWTEST_F(FileExtensionHelperTest, external_file_access_ScanFile_0001, testing::ext::TestSize.Level1)
3769 {
3770 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ScanFile_0001";
3771 try {
3772 vector<RootInfo> info;
3773 int result = g_fah->GetRoots(info);
3774 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3775 for (size_t i = 0; i < info.size(); i++) {
3776 Uri parentUri(info[i].uri);
3777 Uri newDirUriTest("");
3778 result = g_fah->Mkdir(parentUri, "scanfile0001", newDirUriTest);
3779 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3780 InitScanFile(newDirUriTest, "0001");
3781 ScanFileFilter1(newDirUriTest);
3782 result = g_fah->Delete(newDirUriTest);
3783 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3784 }
3785 } catch (...) {
3786 GTEST_LOG_(ERROR) << "external_file_access_ScanFile_0001 occurs an exception.";
3787 }
3788 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ScanFile_0001";
3789 }
3790
ScanFileFilter2(Uri newDirUriTest)3791 static void ScanFileFilter2(Uri newDirUriTest)
3792 {
3793 FileInfo fileInfo;
3794 fileInfo.uri = newDirUriTest.ToString();
3795 int64_t offset = 3;
3796 int64_t maxCount = 3;
3797 std::vector<FileInfo> fileInfoVec;
3798 FileFilter filter({".txt", ".docx"}, {}, {}, -1, -1, false, true);
3799 int result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3800 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3801 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_2);
3802 }
3803
3804 /**
3805 * @tc.number: user_file_service_external_file_access_ScanFile_0002
3806 * @tc.name: external_file_access_ScanFile_0002
3807 * @tc.desc: Test function of ScanFile interface for SUCCESS, the filter is extenstion offset maxCount
3808 * @tc.size: MEDIUM
3809 * @tc.type: FUNC
3810 * @tc.level Level 1
3811 * @tc.require: I79CSX
3812 */
3813 HWTEST_F(FileExtensionHelperTest, external_file_access_ScanFile_0002, testing::ext::TestSize.Level1)
3814 {
3815 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ScanFile_0002";
3816 try {
3817 vector<RootInfo> info;
3818 int result = g_fah->GetRoots(info);
3819 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3820 for (size_t i = 0; i < info.size(); i++) {
3821 Uri parentUri(info[i].uri);
3822 Uri newDirUriTest("");
3823 result = g_fah->Mkdir(parentUri, "scanfile0002", newDirUriTest);
3824 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3825 InitScanFile(newDirUriTest, "0002");
3826 ScanFileFilter2(newDirUriTest);
3827 result = g_fah->Delete(newDirUriTest);
3828 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3829 }
3830 } catch (...) {
3831 GTEST_LOG_(ERROR) << "external_file_access_ScanFile_0002 occurs an exception.";
3832 }
3833 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ScanFile_0002";
3834 }
3835
ScanFileFilter3(Uri newDirUriTest,const double & time)3836 static void ScanFileFilter3(Uri newDirUriTest, const double &time)
3837 {
3838 FileInfo fileInfo;
3839 fileInfo.uri = newDirUriTest.ToString();
3840 int64_t offset = 0;
3841 int64_t maxCount = 1000;
3842 std::vector<FileInfo> fileInfoVec;
3843 FileFilter filter({}, {}, {}, -1, time, false, true);
3844 int result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3845 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3846 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_3);
3847 }
3848
3849 /**
3850 * @tc.number: user_file_service_external_file_access_ScanFile_0003
3851 * @tc.name: external_file_access_ScanFile_0003
3852 * @tc.desc: Test function of ScanFile interface for SUCCESS, the filter is modify time
3853 * @tc.size: MEDIUM
3854 * @tc.type: FUNC
3855 * @tc.level Level 1
3856 * @tc.require: I79CSX
3857 */
3858 HWTEST_F(FileExtensionHelperTest, external_file_access_ScanFile_0003, testing::ext::TestSize.Level1)
3859 {
3860 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ScanFile_0003";
3861 try {
3862 vector<RootInfo> info;
3863 int result = g_fah->GetRoots(info);
3864 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3865 for (size_t i = 0; i < info.size(); i++) {
3866 Uri parentUri(info[i].uri);
3867 Uri newDirUriTest("");
3868 result = g_fah->Mkdir(parentUri, "scanfile0003", newDirUriTest);
3869 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3870 double time = InitScanFile(newDirUriTest, "0003", true);
3871 ScanFileFilter3(newDirUriTest, time);
3872 result = g_fah->Delete(newDirUriTest);
3873 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3874 }
3875 } catch (...) {
3876 GTEST_LOG_(ERROR) << "external_file_access_ScanFile_0003 occurs an exception.";
3877 }
3878 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ScanFile_0003";
3879 }
3880
ScanFileFilter4(Uri newDirUriTest)3881 static void ScanFileFilter4(Uri newDirUriTest)
3882 {
3883 FileInfo fileInfo;
3884 fileInfo.uri = newDirUriTest.ToString();
3885 int64_t offset = 0;
3886 int64_t maxCount = 1000;
3887 std::vector<FileInfo> fileInfoVec;
3888 FileFilter filter;
3889 int result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3890 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3891 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_5);
3892 }
3893
3894 /**
3895 * @tc.number: user_file_service_external_file_access_ScanFile_0004
3896 * @tc.name: external_file_access_ScanFile_0004
3897 * @tc.desc: Test function of ScanFile interface for SUCCESS, the filter is offset from 0 to maxCount
3898 * @tc.size: MEDIUM
3899 * @tc.type: FUNC
3900 * @tc.level Level 1
3901 * @tc.require: I79CSX
3902 */
3903 HWTEST_F(FileExtensionHelperTest, external_file_access_ScanFile_0004, testing::ext::TestSize.Level1)
3904 {
3905 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin user_file_service_external_file_access_ScanFile_0004";
3906 try {
3907 vector<RootInfo> info;
3908 int result = g_fah->GetRoots(info);
3909 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3910 for (size_t i = 0; i < info.size(); i++) {
3911 Uri parentUri(info[i].uri);
3912 Uri newDirUriTest("");
3913 result = g_fah->Mkdir(parentUri, "scanfile0004", newDirUriTest);
3914 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3915 InitScanFile(newDirUriTest, "0004");
3916 ScanFileFilter4(newDirUriTest);
3917 result = g_fah->Delete(newDirUriTest);
3918 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3919 }
3920 } catch (...) {
3921 GTEST_LOG_(ERROR) << "user_file_service_external_file_access_ScanFile_0004 occurs an exception.";
3922 }
3923 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end user_file_service_external_file_access_ScanFile_0004";
3924 }
3925
ScanFileFilter5(Uri newDirUriTest)3926 static void ScanFileFilter5(Uri newDirUriTest)
3927 {
3928 FileInfo fileInfo;
3929 fileInfo.uri = newDirUriTest.ToString();
3930 int64_t offset = 0;
3931 int64_t maxCount = 1000;
3932 std::vector<FileInfo> fileInfoVec;
3933 FileFilter filter({".txt", ".docx"}, {"测试.txt", "测试.docx"}, {}, -1, -1, false, true);
3934 int result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
3935 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3936 EXPECT_EQ(fileInfoVec.size(), FILE_COUNT_4);
3937 }
3938
3939 /**
3940 * @tc.number: user_file_service_external_file_access_ScanFile_0005
3941 * @tc.name: external_file_access_ScanFile_0005
3942 * @tc.desc: Test function of ScanFile interface for SUCCESS, the filter is Chinese filename
3943 * @tc.size: MEDIUM
3944 * @tc.type: FUNC
3945 * @tc.level Level 1
3946 * @tc.require: I79CSX
3947 */
3948 HWTEST_F(FileExtensionHelperTest, external_file_access_ScanFile_0005, testing::ext::TestSize.Level1)
3949 {
3950 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin user_file_service_external_file_access_ScanFile_0005";
3951 try {
3952 vector<RootInfo> info;
3953 int result = g_fah->GetRoots(info);
3954 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3955 for (size_t i = 0; i < info.size(); i++) {
3956 Uri parentUri(info[i].uri);
3957 Uri newDirUriTest("");
3958 result = g_fah->Mkdir(parentUri, "scanfile测试", newDirUriTest);
3959 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3960 InitScanFile(newDirUriTest, "测试");
3961 ScanFileFilter5(newDirUriTest);
3962 result = g_fah->Delete(newDirUriTest);
3963 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3964 }
3965 } catch (...) {
3966 GTEST_LOG_(ERROR) << "user_file_service_external_file_access_ScanFile_0005 occurs an exception.";
3967 }
3968 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end user_file_service_external_file_access_ScanFile_0005";
3969 }
3970
3971 /**
3972 * @tc.number: user_file_service_external_file_access_GetRoots_0000
3973 * @tc.name: external_file_access_GetRoots_0000
3974 * @tc.desc: Test function of GetRoots interface for SUCCESS.
3975 * @tc.size: MEDIUM
3976 * @tc.type: FUNC
3977 * @tc.level Level 1
3978 * @tc.require: SR000H0387
3979 */
3980 HWTEST_F(FileExtensionHelperTest, external_file_access_GetRoots_0000, testing::ext::TestSize.Level1)
3981 {
3982 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetRoots_0000";
3983 try {
3984 vector<RootInfo> info;
3985 int result = g_fah->GetRoots(info);
3986 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
3987 EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK);
3988 GTEST_LOG_(INFO) << "GetRoots_0000 result:" << info.size() << endl;
3989 for (size_t i = 0; i < info.size(); i++) {
3990 GTEST_LOG_(INFO) << info[i].uri;
3991 GTEST_LOG_(INFO) << info[i].displayName;
3992 GTEST_LOG_(INFO) << info[i].deviceFlags;
3993 GTEST_LOG_(INFO) << info[i].deviceType;
3994 GTEST_LOG_(INFO) << info[i].relativePath;
3995 }
3996 EXPECT_GE(info.size(), 2);
3997 } catch (...) {
3998 GTEST_LOG_(ERROR) << "external_file_access_GetRoots_0000 occurs an exception.";
3999 }
4000 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetRoots_0000";
4001 }
4002
4003 /**
4004 * @tc.number: user_file_service_external_file_access_Access_0000
4005 * @tc.name: external_file_access_Access_0000
4006 * @tc.desc: Test function of Access interface for SUCCESS.
4007 * @tc.size: MEDIUM
4008 * @tc.type: FUNC
4009 * @tc.level Level 1
4010 * @tc.require: SR000H0386
4011 */
4012 HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0000, testing::ext::TestSize.Level1)
4013 {
4014 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0000";
4015 try {
4016 vector<RootInfo> info;
4017 int result = g_fah->GetRoots(info);
4018 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4019 for (size_t i = 0; i < info.size(); i++) {
4020 Uri parentUri(info[i].uri);
4021 GTEST_LOG_(INFO) << parentUri.ToString();
4022 Uri newDirUriTest("");
4023 result = g_fah->Mkdir(parentUri, "test1", newDirUriTest);
4024 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4025 Uri newFileUri("");
4026 result = g_fah->CreateFile(newDirUriTest, "external_file_access_Access_0000.txt", newFileUri);
4027 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4028 bool isExist = false;
4029 result = g_fah->Access(newDirUriTest, isExist);
4030 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4031 EXPECT_TRUE(isExist);
4032 result = g_fah->Access(newFileUri, isExist);
4033 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4034 EXPECT_TRUE(isExist);
4035 result = g_fah->Delete(newDirUriTest);
4036 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4037 result = g_fah->Access(newDirUriTest, isExist);
4038 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4039 EXPECT_FALSE(isExist);
4040 }
4041 } catch (...) {
4042 GTEST_LOG_(ERROR) << "external_file_access_Access_0000 occurs an exception.";
4043 }
4044 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0000";
4045 }
4046
4047 /**
4048 * @tc.number: user_file_service_external_file_access_Access_0001
4049 * @tc.name: external_file_access_Access_0001
4050 * @tc.desc: Test function of Access interface FAILED because of GetProxyByUri failed.
4051 * @tc.size: MEDIUM
4052 * @tc.type: FUNC
4053 * @tc.level Level 1
4054 * @tc.require: SR000H0386
4055 */
4056 HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0001, testing::ext::TestSize.Level1)
4057 {
4058 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0001";
4059 try {
4060 vector<RootInfo> info;
4061 int result = g_fah->GetRoots(info);
4062 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4063 for (size_t i = 0; i < info.size(); i++) {
4064 std::string str = info[i].uri;
4065 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
4066 GTEST_LOG_(ERROR) << "replace BundleName failed.";
4067 EXPECT_TRUE(false);
4068 }
4069 Uri newDirUriTest(str + "/test.txt");
4070 bool isExist = false;
4071 result = g_fah->Access(newDirUriTest, isExist);
4072 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
4073 EXPECT_FALSE(isExist);
4074 }
4075 } catch (...) {
4076 GTEST_LOG_(ERROR) << "external_file_access_Access_0001 occurs an exception.";
4077 }
4078 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0001";
4079 }
4080
4081 /**
4082 * @tc.number: user_file_service_external_file_access_Access_0002
4083 * @tc.name: external_file_access_Access_0002
4084 * @tc.desc: Test function of Access interface for SUCCESS, the file and folder name is chinese.
4085 * @tc.size: MEDIUM
4086 * @tc.type: FUNC
4087 * @tc.level Level 1
4088 * @tc.require: I70SX9
4089 */
4090 HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0002, testing::ext::TestSize.Level1)
4091 {
4092 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0002";
4093 try {
4094 vector<RootInfo> info;
4095 int result = g_fah->GetRoots(info);
4096 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4097 for (size_t i = 0; i < info.size(); i++) {
4098 Uri parentUri(info[i].uri);
4099 GTEST_LOG_(INFO) << parentUri.ToString();
4100 Uri newDirUriTest("");
4101 result = g_fah->Mkdir(parentUri, "访问目录", newDirUriTest);
4102 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4103 EXPECT_EQ(newDirUriTest.ToString().find("访问目录"), std::string::npos);
4104 Uri newFileUri("");
4105 result = g_fah->CreateFile(newDirUriTest, "访问文件.txt", newFileUri);
4106 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4107 EXPECT_EQ(newFileUri.ToString().find("访问文件.txt"), std::string::npos);
4108 bool isExist = false;
4109 result = g_fah->Access(newDirUriTest, isExist);
4110 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4111 EXPECT_TRUE(isExist);
4112 result = g_fah->Access(newFileUri, isExist);
4113 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4114 EXPECT_TRUE(isExist);
4115 result = g_fah->Delete(newDirUriTest);
4116 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4117 result = g_fah->Access(newDirUriTest, isExist);
4118 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4119 EXPECT_FALSE(isExist);
4120 }
4121 } catch (...) {
4122 GTEST_LOG_(ERROR) << "external_file_access_Access_0002 occurs an exception.";
4123 }
4124 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0002";
4125 }
4126
4127 /**
4128 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0000
4129 * @tc.name: external_file_access_GetFileInfoFromUri_0000
4130 * @tc.desc: Test function of GetFileInfoFromUri interface.
4131 * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS.
4132 * @tc.size: MEDIUM
4133 * @tc.type: FUNC
4134 * @tc.level Level 1
4135 * @tc.require: SR000H0386
4136 */
4137 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1)
4138 {
4139 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0000";
4140 try {
4141 vector<RootInfo> info;
4142 int result = g_fah->GetRoots(info);
4143 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4144 for (size_t i = 0; i < info.size(); i++) {
4145 Uri parentUri(info[i].uri);
4146 FileInfo fileinfo;
4147 result = g_fah->GetFileInfoFromUri(parentUri, fileinfo);
4148 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4149
4150 int64_t offset = 0;
4151 int64_t maxCount = 1000;
4152 FileFilter filter;
4153 std::vector<FileInfo> fileInfoVecTemp;
4154 result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
4155 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4156 EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
4157 }
4158 } catch (...) {
4159 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0000 occurs an exception.";
4160 }
4161 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0000";
4162 }
4163
4164 /**
4165 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0001
4166 * @tc.name: external_file_access_GetFileInfoFromUri_0001
4167 * @tc.desc: Test function of GetFileInfoFromUri interface.
4168 * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS.
4169 * @tc.size: MEDIUM
4170 * @tc.type: FUNC
4171 * @tc.level Level 1
4172 * @tc.require: SR000H0386
4173 */
4174 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1)
4175 {
4176 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0001";
4177 try {
4178 vector<RootInfo> info;
4179 int result = g_fah->GetRoots(info);
4180 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4181 for (size_t i = 0; i < info.size(); i++) {
4182 Uri parentUri(info[i].uri);
4183 Uri newDirUriTest("");
4184 result = g_fah->Mkdir(parentUri, "testDir", newDirUriTest);
4185 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4186
4187 FileInfo dirInfo;
4188 result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo);
4189 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4190
4191 int64_t offset = 0;
4192 int64_t maxCount = 1000;
4193 FileFilter filter;
4194 std::vector<FileInfo> fileInfoVec;
4195 result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec);
4196 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4197 EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
4198
4199 result = g_fah->Delete(newDirUriTest);
4200 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4201 }
4202 } catch (...) {
4203 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0001 occurs an exception.";
4204 }
4205 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0001";
4206 }
4207
4208 /**
4209 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0002
4210 * @tc.name: external_file_access_GetFileInfoFromUri_0002
4211 * @tc.desc: Test function of GetFileInfoFromUri interface.
4212 * @tc.desc: convert the general filepath uri to fileinfo and call listfile for ERROR.
4213 * @tc.size: MEDIUM
4214 * @tc.type: FUNC
4215 * @tc.level Level 1
4216 * @tc.require: SR000H0386
4217 */
4218 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1)
4219 {
4220 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0002";
4221 try {
4222 vector<RootInfo> info;
4223 int result = g_fah->GetRoots(info);
4224 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4225 for (size_t i = 0; i < info.size(); i++) {
4226 Uri parentUri(info[i].uri);
4227 Uri newDirUriTest("");
4228 result = g_fah->Mkdir(parentUri, "testDir", newDirUriTest);
4229 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4230 Uri newFileUri("");
4231 result = g_fah->CreateFile(newDirUriTest, "external_file_access_GetFileInfoFromUri_0002.txt", newFileUri);
4232 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4233
4234 FileInfo fileinfo;
4235 result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo);
4236 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4237
4238 int64_t offset = 0;
4239 int64_t maxCount = 1000;
4240 FileFilter filter;
4241 std::vector<FileInfo> fileInfoVecTemp;
4242 result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
4243 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
4244 EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
4245
4246 result = g_fah->Delete(newDirUriTest);
4247 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4248 }
4249 } catch (...) {
4250 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0002 occurs an exception.";
4251 }
4252 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0002";
4253 }
4254
4255 /**
4256 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0003
4257 * @tc.name: external_file_access_GetFileInfoFromUri_0003
4258 * @tc.desc: Test function of GetFileInfoFromUri interface.
4259 * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed.
4260 * @tc.size: MEDIUM
4261 * @tc.type: FUNC
4262 * @tc.level Level 1
4263 * @tc.require: SR000H0386
4264 */
4265 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1)
4266 {
4267 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0003";
4268 try {
4269 vector<RootInfo> info;
4270 int result = g_fah->GetRoots(info);
4271 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4272 for (size_t i = 0; i < info.size(); i++) {
4273 Uri parentUri(std::string("\?\?\?\?/") + info[i].uri);
4274 FileInfo fileinfo;
4275 result = g_fah->GetFileInfoFromUri(parentUri, fileinfo);
4276 EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS);
4277 }
4278 } catch (...) {
4279 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0003 occurs an exception.";
4280 }
4281 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0003";
4282 }
4283
4284 /**
4285 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0004
4286 * @tc.name: external_file_access_GetFileInfoFromUri_0004
4287 * @tc.desc: Test function of GetFileInfoFromUri interface.
4288 * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed.
4289 * @tc.size: MEDIUM
4290 * @tc.type: FUNC
4291 * @tc.level Level 1
4292 * @tc.require: SR000H0386
4293 */
4294 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1)
4295 {
4296 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0004";
4297 try {
4298 vector<RootInfo> info;
4299 int result = g_fah->GetRoots(info);
4300 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4301 for (size_t i = 0; i < info.size(); i++) {
4302 std::string str = info[i].uri;
4303 if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) {
4304 GTEST_LOG_(ERROR) << "replace BundleName failed.";
4305 EXPECT_TRUE(false);
4306 }
4307 Uri parentUri(str);
4308 FileInfo fileinfo;
4309 result = g_fah->GetFileInfoFromUri(parentUri, fileinfo);
4310 EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS);
4311 }
4312 } catch (...) {
4313 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0004 occurs an exception.";
4314 }
4315 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0004";
4316 }
4317
4318 /**
4319 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0005
4320 * @tc.name: external_file_access_GetFileInfoFromUri_0005
4321 * @tc.desc: Test function of GetFileInfoFromUri interface.
4322 * @tc.desc: convert the invalid uri to fileinfo failed.
4323 * @tc.size: MEDIUM
4324 * @tc.type: FUNC
4325 * @tc.level Level 1
4326 * @tc.require: SR000H0386
4327 */
4328 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1)
4329 {
4330 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0005";
4331 try {
4332 Uri uri("~!@#$%^&*()_");
4333 FileInfo fileInfo;
4334 int result = g_fah->GetFileInfoFromUri(uri, fileInfo);
4335 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
4336
4337 uri = Uri("/");
4338 result = g_fah->GetFileInfoFromUri(uri, fileInfo);
4339 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
4340
4341 uri = Uri("");
4342 result = g_fah->GetFileInfoFromUri(uri, fileInfo);
4343 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
4344 } catch (...) {
4345 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0005 occurs an exception.";
4346 }
4347 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0005";
4348 }
4349
4350 /**
4351 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0006
4352 * @tc.name: external_file_access_GetFileInfoFromUri_0006
4353 * @tc.desc: Test function of GetFileInfoFromUri interface.
4354 * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS, the folder name is chinese.
4355 * @tc.size: MEDIUM
4356 * @tc.type: FUNC
4357 * @tc.level Level 1
4358 * @tc.require: I70SX9
4359 */
4360 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0006, testing::ext::TestSize.Level1)
4361 {
4362 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0006";
4363 try {
4364 vector<RootInfo> info;
4365 int result = g_fah->GetRoots(info);
4366 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4367 for (size_t i = 0; i < info.size(); i++) {
4368 Uri parentUri(info[i].uri);
4369 Uri newDirUriTest("");
4370 result = g_fah->Mkdir(parentUri, "测试目录", newDirUriTest);
4371 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4372 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
4373
4374 FileInfo dirInfo;
4375 result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo);
4376 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4377
4378 int64_t offset = 0;
4379 int64_t maxCount = 1000;
4380 FileFilter filter;
4381 std::vector<FileInfo> fileInfoVec;
4382 result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec);
4383 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4384 EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK);
4385
4386 result = g_fah->Delete(newDirUriTest);
4387 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4388 }
4389 } catch (...) {
4390 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0006 occurs an exception.";
4391 }
4392 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0006";
4393 }
4394
4395 /**
4396 * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0007
4397 * @tc.name: external_file_access_GetFileInfoFromUri_0007
4398 * @tc.desc: Test function of GetFileInfoFromUri interface.
4399 * @tc.desc: convert the general filepath uri to fileinfo and call listfile for ERROR, the file name is chinese.
4400 * @tc.size: MEDIUM
4401 * @tc.type: FUNC
4402 * @tc.level Level 1
4403 * @tc.require: I70SX9
4404 */
4405 HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0007, testing::ext::TestSize.Level1)
4406 {
4407 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0007";
4408 try {
4409 vector<RootInfo> info;
4410 int result = g_fah->GetRoots(info);
4411 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4412 for (size_t i = 0; i < info.size(); i++) {
4413 Uri parentUri(info[i].uri);
4414 Uri newDirUriTest("");
4415 result = g_fah->Mkdir(parentUri, "测试目录", newDirUriTest);
4416 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4417 EXPECT_EQ(newDirUriTest.ToString().find("测试目录"), std::string::npos);
4418 Uri newFileUri("");
4419 result = g_fah->CreateFile(newDirUriTest, "测试文件.txt", newFileUri);
4420 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4421 EXPECT_EQ(newFileUri.ToString().find("测试文件.txt"), std::string::npos);
4422
4423 FileInfo fileinfo;
4424 result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo);
4425 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4426
4427 int64_t offset = 0;
4428 int64_t maxCount = 1000;
4429 FileFilter filter;
4430 std::vector<FileInfo> fileInfoVecTemp;
4431 result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp);
4432 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
4433 EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK);
4434
4435 result = g_fah->Delete(newDirUriTest);
4436 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4437 }
4438 } catch (...) {
4439 GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0007 occurs an exception.";
4440 }
4441 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0007";
4442 }
4443
4444 /**
4445 * @tc.number: user_file_service_external_file_access_creator_0000
4446 * @tc.name: external_file_access_creator_0000
4447 * @tc.desc: Test function of creator interface.
4448 * @tc.desc: create file access helper for SUCCESS.
4449 * @tc.size: MEDIUM
4450 * @tc.type: FUNC
4451 * @tc.level Level 1
4452 * @tc.require: SR000H0386
4453 */
4454 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0000, testing::ext::TestSize.Level1)
4455 {
4456 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0000";
4457 try {
4458 setuid(UID_TRANSFORM_TMP);
4459 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(g_context);
4460 setuid(UID_DEFAULT);
4461 ASSERT_TRUE(helper.first != nullptr);
4462 bool succ = helper.first->Release();
4463 EXPECT_TRUE(succ);
4464 } catch (...) {
4465 GTEST_LOG_(ERROR) << "external_file_access_creator_0000 occurs an exception.";
4466 }
4467 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0000";
4468 }
4469
4470 /**
4471 * @tc.number: user_file_service_external_file_access_creator_0001
4472 * @tc.name: external_file_access_creator_0001
4473 * @tc.desc: Test function of creator interface.
4474 * @tc.desc: create file access helper for SUCCESS.
4475 * @tc.size: MEDIUM
4476 * @tc.type: FUNC
4477 * @tc.level Level 1
4478 * @tc.require: SR000H0386
4479 */
4480 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0001, testing::ext::TestSize.Level1)
4481 {
4482 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0001";
4483 try {
4484 AAFwk::Want want;
4485 vector<AAFwk::Want> wantVec;
4486 setuid(UID_TRANSFORM_TMP);
4487 int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec);
4488 EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK);
4489 bool sus = false;
4490 for (size_t i = 0; i < wantVec.size(); i++) {
4491 auto element = wantVec[i].GetElement();
4492 if (element.GetBundleName() == "com.ohos.UserFile.ExternalFileManager" &&
4493 element.GetAbilityName() == "FileExtensionAbility") {
4494 want = wantVec[i];
4495 sus = true;
4496 break;
4497 }
4498 }
4499 EXPECT_TRUE(sus);
4500 vector<AAFwk::Want> wants{want};
4501 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(g_context, wants);
4502 setuid(UID_DEFAULT);
4503 ASSERT_TRUE(helper.first != nullptr);
4504 bool succ = helper.first->Release();
4505 EXPECT_TRUE(succ);
4506 } catch (...) {
4507 GTEST_LOG_(ERROR) << "external_file_access_creator_0001 occurs an exception.";
4508 }
4509 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0001";
4510 }
4511
4512 /**
4513 * @tc.number: user_file_service_external_file_access_creator_0002
4514 * @tc.name: external_file_access_creator_0002
4515 * @tc.desc: Test function of creator interface.
4516 * @tc.desc: create file access helper for FAILED.
4517 * @tc.size: MEDIUM
4518 * @tc.type: FUNC
4519 * @tc.level Level 1
4520 * @tc.require: SR000H0386
4521 */
4522 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0002, testing::ext::TestSize.Level1)
4523 {
4524 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0002";
4525 try {
4526 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
4527 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(context);
4528 ASSERT_TRUE(helper.first == nullptr);
4529 } catch (...) {
4530 GTEST_LOG_(ERROR) << "external_file_access_creator_0002 occurs an exception.";
4531 }
4532 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0002";
4533 }
4534
4535 /**
4536 * @tc.number: user_file_service_external_file_access_creator_0003
4537 * @tc.name: external_file_access_creator_0003
4538 * @tc.desc: Test function of creator interface.
4539 * @tc.desc: create file access helper for FAILED.
4540 * @tc.size: MEDIUM
4541 * @tc.type: FUNC
4542 * @tc.level Level 1
4543 * @tc.require: SR000H0386
4544 */
4545 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0003, testing::ext::TestSize.Level1)
4546 {
4547 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0003";
4548 try {
4549 std::vector<AAFwk::Want> wants;
4550 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
4551 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(context, wants);
4552 ASSERT_TRUE(helper.first == nullptr);
4553 } catch (...) {
4554 GTEST_LOG_(ERROR) << "external_file_access_creator_0003 occurs an exception.";
4555 }
4556 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0003";
4557 }
4558
4559 /**
4560 * @tc.number: user_file_service_external_file_access_creator_0004
4561 * @tc.name: external_file_access_creator_0004
4562 * @tc.desc: Test function of creator interface.
4563 * @tc.desc: create file access helper for FAILED.
4564 * @tc.size: MEDIUM
4565 * @tc.type: FUNC
4566 * @tc.level Level 1
4567 * @tc.require: SR000H0386
4568 */
4569 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0004, testing::ext::TestSize.Level1)
4570 {
4571 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0004";
4572 try {
4573 std::vector<AAFwk::Want> wants;
4574 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(g_context, wants);
4575 ASSERT_TRUE(helper.first == nullptr);
4576 } catch (...) {
4577 GTEST_LOG_(ERROR) << "external_file_access_creator_0004 occurs an exception.";
4578 }
4579 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0004";
4580 }
4581
4582 /**
4583 * @tc.number: user_file_service_external_file_access_creator_0005
4584 * @tc.name: external_file_access_creator_0005
4585 * @tc.desc: Test function of creator interface.
4586 * @tc.desc: create file access helper for FAILED.
4587 * @tc.size: MEDIUM
4588 * @tc.type: FUNC
4589 * @tc.level Level 1
4590 * @tc.require: SR000H0386
4591 */
4592 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0005, testing::ext::TestSize.Level1)
4593 {
4594 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0005";
4595 try {
4596 AAFwk::Want want;
4597 want.SetElementName("NotExistBundleName", "NotExistAbilityName");
4598 std::vector<AAFwk::Want> wants{want};
4599 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(g_context, wants);
4600 ASSERT_TRUE(helper.first == nullptr);
4601 } catch (...) {
4602 GTEST_LOG_(ERROR) << "external_file_access_creator_0005 occurs an exception.";
4603 }
4604 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0005";
4605 }
4606
4607 /**
4608 * @tc.number: user_file_service_external_file_access_creator_0006
4609 * @tc.name: external_file_access_creator_0006
4610 * @tc.desc: Test function of creator interface.
4611 * @tc.desc: create file access helper for FAILED.
4612 * @tc.size: MEDIUM
4613 * @tc.type: FUNC
4614 * @tc.level Level 1
4615 * @tc.require: SR000H0386
4616 */
4617 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0006, testing::ext::TestSize.Level1)
4618 {
4619 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0006";
4620 try {
4621 std::vector<AAFwk::Want> wants;
4622 std::shared_ptr<OHOS::AbilityRuntime::Context> context = nullptr;
4623 std::pair<shared_ptr<FileAccessHelper>, int> helper = FileAccessHelper::Creator(context, wants);
4624 ASSERT_TRUE(helper.first == nullptr);
4625 } catch (...) {
4626 GTEST_LOG_(ERROR) << "external_file_access_creator_0006 occurs an exception.";
4627 }
4628 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0006";
4629 }
4630
4631 /**
4632 * @tc.number: user_file_service_external_file_access_creator_0007
4633 * @tc.name: external_file_access_creator_0007
4634 * @tc.desc: Test function of creator interface.
4635 * @tc.desc: create file access helper for FAILED.
4636 * @tc.size: MEDIUM
4637 * @tc.type: FUNC
4638 * @tc.level Level 1
4639 * @tc.require: SR000H0386
4640 */
4641 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0007, testing::ext::TestSize.Level1)
4642 {
4643 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0007";
4644 try {
4645 std::vector<AAFwk::Want> wants;
4646 shared_ptr<FileAccessHelper> helper = FileAccessHelper::Creator(g_context->GetToken(), wants);
4647 ASSERT_TRUE(helper == nullptr);
4648 } catch (...) {
4649 GTEST_LOG_(ERROR) << "external_file_access_creator_0007 occurs an exception.";
4650 }
4651 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0007";
4652 }
4653
4654 /**
4655 * @tc.number: user_file_service_external_file_access_creator_0008
4656 * @tc.name: external_file_access_creator_0008
4657 * @tc.desc: Test function of creator interface.
4658 * @tc.desc: create file access helper for FAILED.
4659 * @tc.size: MEDIUM
4660 * @tc.type: FUNC
4661 * @tc.level Level 1
4662 * @tc.require: SR000H0386
4663 */
4664 HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0008, testing::ext::TestSize.Level1)
4665 {
4666 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0008";
4667 try {
4668 AAFwk::Want want;
4669 want.SetElementName("NotExistBundleName", "NotExistAbilityName");
4670 std::vector<AAFwk::Want> wants{want};
4671 shared_ptr<FileAccessHelper> helper = FileAccessHelper::Creator(g_context->GetToken(), wants);
4672 ASSERT_TRUE(helper == nullptr);
4673 } catch (...) {
4674 GTEST_LOG_(ERROR) << "external_file_access_creator_0008 occurs an exception.";
4675 }
4676 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0008";
4677 }
4678
4679 /**
4680 * @tc.number: user_file_service_external_file_access_GetConnectInfo_0000
4681 * @tc.name: external_file_access_GetConnectInfo_0000
4682 * @tc.desc: Test function of GetConnectInfo interface.
4683 * @tc.desc: helper invoke GetConnectInfo for FAILED.
4684 * @tc.size: MEDIUM
4685 * @tc.type: FUNC
4686 * @tc.level Level 1
4687 * @tc.require: SR000H0386
4688 */
4689 HWTEST_F(FileExtensionHelperTest, external_file_access_GetConnectInfo_0000, testing::ext::TestSize.Level1)
4690 {
4691 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetConnectInfo_0000";
4692 try {
4693 std::shared_ptr<ConnectInfo> connectInfo = g_fah->GetConnectInfo("NotExistBundleName");
4694 ASSERT_TRUE(connectInfo == nullptr);
4695 } catch (...) {
4696 GTEST_LOG_(ERROR) << "external_file_access_GetConnectInfo_0000 occurs an exception.";
4697 }
4698 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetConnectInfo_0000";
4699 }
4700
4701 /**
4702 * @tc.number: user_file_service_external_file_access_GetKeyOfWants_0000
4703 * @tc.name: external_file_access_GetKeyOfWants_0000
4704 * @tc.desc: Test function of GetKeyOfWants interface.
4705 * @tc.desc: helper invoke GetKeyOfWants for FAILED.
4706 * @tc.size: MEDIUM
4707 * @tc.type: FUNC
4708 * @tc.level Level 1
4709 * @tc.require: SR000H0386
4710 */
4711 HWTEST_F(FileExtensionHelperTest, external_file_access_GetKeyOfWants_0000, testing::ext::TestSize.Level1)
4712 {
4713 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetKeyOfWants_0000";
4714 try {
4715 AAFwk::Want want;
4716 want.SetElementName("NotExistBundleName", "NotExistAbilityName");
4717 std::string key = g_fah->GetKeyOfWants(want);
4718 ASSERT_TRUE(key.empty());
4719 } catch (...) {
4720 GTEST_LOG_(ERROR) << "external_file_access_GetKeyOfWants_0000 occurs an exception.";
4721 }
4722 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetKeyOfWants_0000";
4723 }
4724
4725 /**
4726 * @tc.number: user_file_service_external_file_access_GetProxyByUri_0000
4727 * @tc.name: external_file_access_GetProxyByUri_0000
4728 * @tc.desc: Test function of GetProxyByUri interface.
4729 * @tc.desc: helper invoke GetProxyByUri for FAILED.
4730 * @tc.size: MEDIUM
4731 * @tc.type: FUNC
4732 * @tc.level Level 1
4733 * @tc.require: SR000H0386
4734 */
4735 HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0000, testing::ext::TestSize.Level1)
4736 {
4737 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0000";
4738 try {
4739 Uri uri("");
4740 sptr<IFileAccessExtBase> proxy = g_fah->GetProxyByUri(uri);
4741 ASSERT_TRUE(proxy == nullptr);
4742 } catch (...) {
4743 GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0000 occurs an exception.";
4744 }
4745 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0000";
4746 }
4747
4748 /**
4749 * @tc.number: user_file_service_external_file_access_GetProxyByUri_0001
4750 * @tc.name: external_file_access_GetProxyByUri_0001
4751 * @tc.desc: Test function of GetProxyByUri interface.
4752 * @tc.desc: helper invoke GetProxyByUri for FAILED.
4753 * @tc.size: MEDIUM
4754 * @tc.type: FUNC
4755 * @tc.level Level 1
4756 * @tc.require: SR000H0386
4757 */
4758 HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0001, testing::ext::TestSize.Level1)
4759 {
4760 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0001";
4761 try {
4762 Uri uri("file://com.ohos.UserFile.NotExistBundleName/data/storage/el1/bundle/storage_daemon");
4763 sptr<IFileAccessExtBase> proxy = g_fah->GetProxyByUri(uri);
4764 ASSERT_TRUE(proxy == nullptr);
4765 } catch (...) {
4766 GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0001 occurs an exception.";
4767 }
4768 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0001";
4769 }
4770
4771 /**
4772 * @tc.number: user_file_service_external_file_access_Query_0000
4773 * @tc.name: external_file_access_Query_0000
4774 * @tc.desc: Test function of Query directory for SUCCESS.
4775 * @tc.size: MEDIUM
4776 * @tc.type: FUNC
4777 * @tc.level Level 1
4778 * @tc.require: I6S4VV
4779 */
4780 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0000, testing::ext::TestSize.Level1)
4781 {
4782 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0000";
4783 try {
4784 vector<RootInfo> info;
4785 int result = g_fah->GetRoots(info);
4786 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4787 Uri parentUri(info[0].uri);
4788 GTEST_LOG_(INFO) << parentUri.ToString();
4789 Uri newDirUriTest1("");
4790 Uri newDirUriTest2("");
4791 std::string displayName = "QueryTest1";
4792 std::string relativePath = "/storage/Users/currentUser/QueryTest1";
4793 result = g_fah->Mkdir(parentUri, "QueryTest1", newDirUriTest1);
4794 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4795 result = g_fah->Mkdir(newDirUriTest1, "QueryTest2", newDirUriTest2);
4796 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4797 Uri newFileUri1("");
4798 Uri newFileUri2("");
4799 std::string fileName = "external_file_access_Query_00001.txt";
4800 result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1);
4801 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4802 result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2);
4803 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4804 int fd = -1;
4805 std::string buff = "query test";
4806 result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd);
4807 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4808 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
4809 close(fd);
4810 EXPECT_EQ(fileSize, buff.size());
4811 result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd);
4812 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4813 fileSize = write(fd, buff.c_str(), buff.size());
4814 close(fd);
4815 EXPECT_EQ(fileSize, buff.size());
4816 json testJson = {
4817 {RELATIVE_PATH, " "},
4818 {DISPLAY_NAME, " "},
4819 {FILE_SIZE, " "},
4820 {DATE_MODIFIED, " "},
4821 {DATE_ADDED, " "},
4822 {HEIGHT, " "},
4823 {WIDTH, " "},
4824 {DURATION, " "}
4825 };
4826 auto testJsonString = testJson.dump();
4827 result = g_fah->Query(newDirUriTest1, testJsonString);
4828 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4829 auto jsonObject = json::parse(testJsonString);
4830 EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
4831 EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2);
4832 EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath);
4833 ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
4834 ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
4835 GTEST_LOG_(INFO) << " result" << testJsonString;
4836 result = g_fah->Delete(newDirUriTest1);
4837 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4838 } catch (...) {
4839 GTEST_LOG_(ERROR) << "external_file_access_Query_0000 occurs an exception.";
4840 }
4841 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0000";
4842 }
4843
4844 /**
4845 * @tc.number: user_file_service_external_file_access_Query_0001
4846 * @tc.name: external_file_access_Query_0001
4847 * @tc.desc: Test function of Query file for SUCCESS.
4848 * @tc.size: MEDIUM
4849 * @tc.type: FUNC
4850 * @tc.level Level 1
4851 * @tc.require: I6S4VV
4852 */
4853 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0001, testing::ext::TestSize.Level1)
4854 {
4855 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0001";
4856 try {
4857 vector<RootInfo> info;
4858 int result = g_fah->GetRoots(info);
4859 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4860 Uri parentUri(info[0].uri);
4861 GTEST_LOG_(INFO) << parentUri.ToString();
4862 Uri newDirUriTest("");
4863 result = g_fah->Mkdir(parentUri, "QueryTest3", newDirUriTest);
4864 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4865 Uri newFileUri("");
4866 std::string displayName = "external_file_access_Query_0001.txt";
4867 std::string relativePath = "/storage/Users/currentUser/QueryTest3/external_file_access_Query_0001.txt";
4868 result = g_fah->CreateFile(newDirUriTest, displayName, newFileUri);
4869 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4870 int fd = -1;
4871 result = g_fah->OpenFile(newFileUri, WRITE_READ, fd);
4872 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4873 std::string buff = "query test";
4874 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
4875 close(fd);
4876 EXPECT_EQ(fileSize, buff.size());
4877 json testJson = {
4878 {RELATIVE_PATH, " "},
4879 {DISPLAY_NAME, " "},
4880 {FILE_SIZE, " "},
4881 {DATE_MODIFIED, " "},
4882 {DATE_ADDED, " "},
4883 {HEIGHT, " "},
4884 {WIDTH, " "},
4885 {DURATION, " "}
4886 };
4887 auto testJsonString = testJson.dump();
4888 result = g_fah->Query(newFileUri, testJsonString);
4889 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4890 auto jsonObject = json::parse(testJsonString);
4891 EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
4892 EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size());
4893 EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath);
4894 ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
4895 ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
4896 GTEST_LOG_(INFO) << " result" << testJsonString;
4897 result = g_fah->Delete(newDirUriTest);
4898 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4899 } catch (...) {
4900 GTEST_LOG_(ERROR) << "external_file_access_Query_0001 occurs an exception.";
4901 }
4902 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0001";
4903 }
4904
4905 /**
4906 * @tc.number: user_file_service_external_file_access_Query_0002
4907 * @tc.name: external_file_access_Query_0002
4908 * @tc.desc: Test function of Query directory for SUCCESS.
4909 * @tc.size: MEDIUM
4910 * @tc.type: FUNC
4911 * @tc.level Level 1
4912 * @tc.require: I6S4VV
4913 */
4914 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0002, testing::ext::TestSize.Level1)
4915 {
4916 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0002";
4917 try {
4918 vector<RootInfo> info;
4919 int result = g_fah->GetRoots(info);
4920 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4921 Uri parentUri(info[0].uri);
4922 GTEST_LOG_(INFO) << parentUri.ToString();
4923 Uri newDirUriTest1("");
4924 Uri newDirUriTest2("");
4925 result = g_fah->Mkdir(parentUri, "QueryTest4", newDirUriTest1);
4926 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4927 result = g_fah->Mkdir(newDirUriTest1, "QueryTest5", newDirUriTest2);
4928 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4929 Uri newFileUri1("");
4930 Uri newFileUri2("");
4931 std::string fileName = "external_file_access_Query_00001.txt";
4932 result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1);
4933 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4934 result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2);
4935 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4936 int fd = -1;
4937 std::string buff = "query test";
4938 result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd);
4939 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4940 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
4941 close(fd);
4942 EXPECT_EQ(fileSize, buff.size());
4943 result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd);
4944 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4945 fileSize = write(fd, buff.c_str(), buff.size());
4946 close(fd);
4947 EXPECT_EQ(fileSize, buff.size());
4948 json testJson = {
4949 {FILE_SIZE, " "}
4950 };
4951 auto testJsonString = testJson.dump();
4952 result = g_fah->Query(newDirUriTest1, testJsonString);
4953 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4954 auto jsonObject = json::parse(testJsonString);
4955 EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2);
4956 GTEST_LOG_(INFO) << " result" << testJsonString;
4957 result = g_fah->Delete(newDirUriTest1);
4958 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
4959 } catch (...) {
4960 GTEST_LOG_(ERROR) << "external_file_access_Query_0002 occurs an exception.";
4961 }
4962 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0002";
4963 }
4964
4965 /**
4966 * @tc.number: user_file_service_external_file_access_Query_0003
4967 * @tc.name: external_file_access_Query_0003
4968 * @tc.desc: Test function of Query interface for which is unreadable code.
4969 * @tc.size: MEDIUM
4970 * @tc.type: FUNC
4971 * @tc.level Level 1
4972 * @tc.require: I6S4VV
4973 */
4974 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0003, testing::ext::TestSize.Level1)
4975 {
4976 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0003";
4977 try {
4978 Uri testUri("&*()*/?");
4979 json testJson = {
4980 {RELATIVE_PATH, " "},
4981 {DISPLAY_NAME, " "}
4982 };
4983 auto testJsonString = testJson.dump();
4984 int result = g_fah->Query(testUri, testJsonString);
4985 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
4986 GTEST_LOG_(INFO) << " result" << testJsonString;
4987 } catch (...) {
4988 GTEST_LOG_(ERROR) << "external_file_access_Query_0003 occurs an exception.";
4989 }
4990 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0003";
4991 }
4992
4993 /**
4994 * @tc.number: user_file_service_external_file_access_Query_0004
4995 * @tc.name: external_file_access_Query_0004
4996 * @tc.desc: Test function of Query interface for which all column nonexistence.
4997 * @tc.size: MEDIUM
4998 * @tc.type: FUNC
4999 * @tc.level Level 1
5000 * @tc.require: I6S4VV
5001 */
5002 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0004, testing::ext::TestSize.Level1)
5003 {
5004 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0004";
5005 try {
5006 vector<RootInfo> info;
5007 int result = g_fah->GetRoots(info);
5008 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5009 Uri parentUri(info[0].uri);
5010 GTEST_LOG_(INFO) << parentUri.ToString();
5011 Uri newDirUriTest("");
5012 result = g_fah->Mkdir(parentUri, "QueryTest6", newDirUriTest);
5013 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5014 json testJson = {
5015 {"001", " "},
5016 {"#", " "},
5017 {"test", " "},
5018 {"target", " "}
5019 };
5020 auto testJsonString = testJson.dump();
5021 result = g_fah->Query(newDirUriTest, testJsonString);
5022 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
5023 GTEST_LOG_(INFO) << " result" << testJsonString;
5024 result = g_fah->Delete(newDirUriTest);
5025 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5026 } catch (...) {
5027 GTEST_LOG_(ERROR) << "external_file_access_Query_0004 occurs an exception.";
5028 }
5029 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0004";
5030 }
5031
5032 /**
5033 * @tc.number: user_file_service_external_file_access_Query_0005
5034 * @tc.name: external_file_access_Query_0005
5035 * @tc.desc: Test function of Query interface for which part of column nonexistence.
5036 * @tc.size: MEDIUM
5037 * @tc.type: FUNC
5038 * @tc.level Level 1
5039 * @tc.require: I6S4VV
5040 */
5041 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0005, testing::ext::TestSize.Level1)
5042 {
5043 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0005";
5044 try {
5045 vector<RootInfo> info;
5046 int result = g_fah->GetRoots(info);
5047 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5048 Uri parentUri(info[0].uri);
5049 GTEST_LOG_(INFO) << parentUri.ToString();
5050 Uri newDirUriTest("");
5051 result = g_fah->Mkdir(parentUri, "QueryTest7", newDirUriTest);
5052 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5053 json testJson = {
5054 {RELATIVE_PATH, " "},
5055 {DISPLAY_NAME, " "},
5056 {"test", " "}
5057 };
5058 auto testJsonString = testJson.dump();
5059 result = g_fah->Query(newDirUriTest, testJsonString);
5060 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
5061 GTEST_LOG_(INFO) << " result" << testJsonString;
5062 result = g_fah->Delete(newDirUriTest);
5063 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5064 } catch (...) {
5065 GTEST_LOG_(ERROR) << "external_file_access_Query_0005 occurs an exception.";
5066 }
5067 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0005";
5068 }
5069
5070 /**
5071 * @tc.number: user_file_service_external_file_access_Query_0006
5072 * @tc.name: external_file_access_Query_0006
5073 * @tc.desc: Test function of Query interface for which column is null.
5074 * @tc.size: MEDIUM
5075 * @tc.type: FUNC
5076 * @tc.level Level 1
5077 * @tc.require: I6S4VV
5078 */
5079 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0006, testing::ext::TestSize.Level1)
5080 {
5081 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0006";
5082 try {
5083 vector<RootInfo> info;
5084 int result = g_fah->GetRoots(info);
5085 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5086 Uri parentUri(info[0].uri);
5087 GTEST_LOG_(INFO) << parentUri.ToString();
5088 Uri newDirUriTest("");
5089 result = g_fah->Mkdir(parentUri, "QueryTest8", newDirUriTest);
5090 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5091 json testJson;
5092 auto testJsonString = testJson.dump();
5093 result = g_fah->Query(newDirUriTest, testJsonString);
5094 EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK);
5095 GTEST_LOG_(INFO) << " result" << testJsonString;
5096 result = g_fah->Delete(newDirUriTest);
5097 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5098 } catch (...) {
5099 GTEST_LOG_(ERROR) << "external_file_access_Query_0006 occurs an exception.";
5100 }
5101 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0006";
5102 }
5103
5104 /**
5105 * @tc.number: user_file_service_external_file_access_Query_0007
5106 * @tc.name: external_file_access_Query_0007
5107 * @tc.desc: Test function of Query directory for SUCCESS, the folder and file name is chinese.
5108 * @tc.size: MEDIUM
5109 * @tc.type: FUNC
5110 * @tc.level Level 1
5111 * @tc.require: I70SX9
5112 */
5113 HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0007, testing::ext::TestSize.Level1)
5114 {
5115 GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0007";
5116 try {
5117 vector<RootInfo> info;
5118 int result = g_fah->GetRoots(info);
5119 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5120 Uri parentUri(info[0].uri);
5121 GTEST_LOG_(INFO) << parentUri.ToString();
5122 Uri newDirUriTest1("");
5123 Uri newDirUriTest2("");
5124 std::string displayName = "查询目录1";
5125 std::string relativePath = "/storage/Users/currentUser/查询目录1";
5126 result = g_fah->Mkdir(parentUri, displayName, newDirUriTest1);
5127 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5128 EXPECT_EQ(newDirUriTest1.ToString().find(displayName), std::string::npos);
5129 result = g_fah->Mkdir(newDirUriTest1, "查询目录2", newDirUriTest2);
5130 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5131 EXPECT_EQ(newDirUriTest2.ToString().find("查询目录2"), std::string::npos);
5132 Uri newFileUri1("");
5133 Uri newFileUri2("");
5134 std::string fileName = "查询文件.txt";
5135 result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1);
5136 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5137 EXPECT_EQ(newFileUri1.ToString().find(fileName), std::string::npos);
5138 result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2);
5139 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5140 EXPECT_EQ(newFileUri2.ToString().find(fileName), std::string::npos);
5141 int fd = -1;
5142 std::string buff = "query test";
5143 result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd);
5144 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5145 ssize_t fileSize = write(fd, buff.c_str(), buff.size());
5146 close(fd);
5147 EXPECT_EQ(fileSize, buff.size());
5148 result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd);
5149 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5150 fileSize = write(fd, buff.c_str(), buff.size());
5151 close(fd);
5152 EXPECT_EQ(fileSize, buff.size());
5153 json testJson = {
5154 {RELATIVE_PATH, " "},
5155 {DISPLAY_NAME, " "},
5156 {FILE_SIZE, " "},
5157 {DATE_MODIFIED, " "},
5158 {DATE_ADDED, " "},
5159 {HEIGHT, " "},
5160 {WIDTH, " "},
5161 {DURATION, " "}
5162 };
5163 auto testJsonString = testJson.dump();
5164 result = g_fah->Query(newDirUriTest1, testJsonString);
5165 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5166 auto jsonObject = json::parse(testJsonString);
5167 EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName);
5168 EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2);
5169 EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath);
5170 ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0);
5171 ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0);
5172 GTEST_LOG_(INFO) << " result" << testJsonString;
5173 result = g_fah->Delete(newDirUriTest1);
5174 EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK);
5175 } catch (...) {
5176 GTEST_LOG_(ERROR) << "external_file_access_Query_0007 occurs an exception.";
5177 }
5178 GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0007";
5179 }
5180 } // namespace
5181