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