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