1 /*
2 * Copyright (C) 2025 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 "copy_core.h"
17
18 #include <fcntl.h>
19 #include <filesystem>
20 #include <gtest/gtest.h>
21
22 namespace OHOS::FileManagement::ModuleFileIO::Test {
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace std;
26
27 class CopyCoreTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33
34 static const string testDir;
35 static const string copyCoreDir;
36 static const string srcDir;
37 static const string destDir;
38 static const string srcFile;
39 static const string destFile;
40
41 private:
42 // rwxr-xr-x
43 static constexpr mode_t permission0755 = 0755;
44 // rw-r--r--
45 static constexpr mode_t permission0644 = 0644;
46 };
47
48 const string CopyCoreTest::testDir = "/data/test";
49 const string CopyCoreTest::copyCoreDir = testDir + "/CopyCoreTest";
50 const string CopyCoreTest::srcDir = copyCoreDir + "/src";
51 const string CopyCoreTest::destDir = copyCoreDir + "/dest";
52 const string CopyCoreTest::srcFile = srcDir + "/src.txt";
53 const string CopyCoreTest::destFile = destDir + "/dest.txt";
54
SetUpTestCase(void)55 void CopyCoreTest::SetUpTestCase(void)
56 {
57 GTEST_LOG_(INFO) << "SetUpTestCase";
58 mkdir(testDir.c_str(), permission0755);
59 mkdir(copyCoreDir.c_str(), permission0755);
60 mkdir(srcDir.c_str(), permission0755);
61 mkdir(destDir.c_str(), permission0755);
62 int32_t fd = open(srcFile.c_str(), O_CREAT | O_RDWR, permission0644);
63 if (fd < 0) {
64 EXPECT_TRUE(false);
65 }
66 close(fd);
67 }
68
TearDownTestCase(void)69 void CopyCoreTest::TearDownTestCase(void)
70 {
71 GTEST_LOG_(INFO) << "TearDownTestCase";
72 int ret = remove(srcFile.c_str());
73 EXPECT_TRUE(ret == 0);
74 rmdir(srcDir.c_str());
75 rmdir(destDir.c_str());
76 rmdir(testDir.c_str());
77 }
78
SetUp(void)79 void CopyCoreTest::SetUp(void)
80 {
81 GTEST_LOG_(INFO) << "SetUp";
82 }
83
TearDown(void)84 void CopyCoreTest::TearDown(void)
85 {
86 CopyCore::callbackMap_.clear();
87 GTEST_LOG_(INFO) << "TearDown";
88 }
89
90 inline const int32_t EXPECTED_WD = 100;
91 inline const int32_t UNEXPECTED_WD = 200;
92
93 /**
94 * @tc.name: CopyCoreTest_IsValidUri_001
95 * @tc.desc: Test function of CopyCore::IsValidUri interface for TRUE.
96 * @tc.size: MEDIUM
97 * @tc.type: FUNC
98 * @tc.level Level 1
99 */
100 HWTEST_F(CopyCoreTest, CopyCoreTest_IsValidUri_001, testing::ext::TestSize.Level1)
101 {
102 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsValidUri_001";
103
104 string validUri = "file://data/test/file.txt";
105 auto res = CopyCore::IsValidUri(validUri);
106 EXPECT_EQ(res, true);
107
108 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsValidUri_001";
109 }
110
111 /**
112 * @tc.name: CopyCoreTest_IsValidUri_002
113 * @tc.desc: Test function of CopyCore::IsValidUri interface for FALSE.
114 * @tc.size: MEDIUM
115 * @tc.type: FUNC
116 * @tc.level Level 1
117 */
118 HWTEST_F(CopyCoreTest, CopyCoreTest_IsValidUri_002, testing::ext::TestSize.Level1)
119 {
120 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsValidUri_002";
121
122 string invalidUri = "invalid://data/test/CopyCoreTest_IsValidUri_002/file.txt";
123 auto res = CopyCore::IsValidUri(invalidUri);
124 EXPECT_EQ(res, false);
125
126 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsValidUri_002";
127 }
128
129 /**
130 * @tc.name: CopyCoreTest_IsRemoteUri_001
131 * @tc.desc: Test function of CopyCore::IsRemoteUri interface for TRUE.
132 * @tc.size: MEDIUM
133 * @tc.type: FUNC
134 * @tc.level Level 1
135 */
136 HWTEST_F(CopyCoreTest, CopyCoreTest_IsRemoteUri_001, testing::ext::TestSize.Level1)
137 {
138 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsRemoteUri_001";
139
140 string remoteUri = "file://data/test/file.txt?networkid=123";
141 auto res = CopyCore::IsRemoteUri(remoteUri);
142 EXPECT_EQ(res, true);
143
144 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsRemoteUri_001";
145 }
146
147 /**
148 * @tc.name: CopyCoreTest_IsRemoteUri_002
149 * @tc.desc: Test function of CopyCore::IsRemoteUri interface for FALSE.
150 * @tc.size: MEDIUM
151 * @tc.type: FUNC
152 * @tc.level Level 1
153 */
154 HWTEST_F(CopyCoreTest, CopyCoreTest_IsRemoteUri_002, testing::ext::TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsRemoteUri_002";
157
158 string localUri = "file://data/test/file.txt";
159 auto res = CopyCore::IsRemoteUri(localUri);
160 EXPECT_EQ(res, false);
161
162 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsRemoteUri_002";
163 }
164
165 /**
166 * @tc.name: CopyCoreTest_IsDirectory_001
167 * @tc.desc: Test function of CopyCore::IsDirectory interface for TRUE.
168 * @tc.size: MEDIUM
169 * @tc.type: FUNC
170 * @tc.level Level 1
171 */
172 HWTEST_F(CopyCoreTest, CopyCoreTest_IsDirectory_001, testing::ext::TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsDirectory_001";
175
176 auto res = CopyCore::IsDirectory(srcDir);
177 EXPECT_EQ(res, true);
178
179 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsDirectory_001";
180 }
181
182 /**
183 * @tc.name: CopyCoreTest_IsDirectory_002
184 * @tc.desc: Test function of CopyCore::IsDirectory interface for FALSE.
185 * @tc.size: MEDIUM
186 * @tc.type: FUNC
187 * @tc.level Level 1
188 */
189 HWTEST_F(CopyCoreTest, CopyCoreTest_IsDirectory_002, testing::ext::TestSize.Level1)
190 {
191 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsDirectory_002";
192
193 auto res = CopyCore::IsDirectory(srcFile);
194 EXPECT_EQ(res, false);
195
196 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsDirectory_002";
197 }
198
199 /**
200 * @tc.name: CopyCoreTest_IsFile_001
201 * @tc.desc: Test function of CopyCore::IsFile interface for TRUE.
202 * @tc.size: MEDIUM
203 * @tc.type: FUNC
204 * @tc.level Level 1
205 */
206 HWTEST_F(CopyCoreTest, CopyCoreTest_IsFile_001, testing::ext::TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsFile_001";
209
210 auto res = CopyCore::IsFile(srcFile);
211 EXPECT_EQ(res, true);
212
213 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsFile_001";
214 }
215
216 /**
217 * @tc.name: CopyCoreTest_IsFile_002
218 * @tc.desc: Test function of CopyCore::IsFile interface for FALSE.
219 * @tc.size: MEDIUM
220 * @tc.type: FUNC
221 * @tc.level Level 1
222 */
223 HWTEST_F(CopyCoreTest, CopyCoreTest_IsFile_002, testing::ext::TestSize.Level1)
224 {
225 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsFile_002";
226
227 auto res = CopyCore::IsFile(srcDir);
228 EXPECT_EQ(res, false);
229
230 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsFile_002";
231 }
232
233 /**
234 * @tc.name: CopyCoreTest_IsMediaUri_001
235 * @tc.desc: Test function of CopyCore::IsMediaUri interface for FALSE.
236 * @tc.size: MEDIUM
237 * @tc.type: FUNC
238 * @tc.level Level 1
239 */
240 HWTEST_F(CopyCoreTest, CopyCoreTest_IsMediaUri_001, testing::ext::TestSize.Level1)
241 {
242 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_IsMediaUri_001";
243
244 auto res = CopyCore::IsMediaUri(srcFile);
245 EXPECT_EQ(res, false);
246
247 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_IsMediaUri_001";
248 }
249
250 /**
251 * @tc.name: CopyCoreTest_GetFileSize_001
252 * @tc.desc: Test function of CopyCore::GetFileSize interface for TRUE.
253 * @tc.size: MEDIUM
254 * @tc.type: FUNC
255 * @tc.level Level 1
256 */
257 HWTEST_F(CopyCoreTest, CopyCoreTest_GetFileSize_001, testing::ext::TestSize.Level1)
258 {
259 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetFileSize_001";
260
261 auto [err, size] = CopyCore::GetFileSize(srcFile);
262 EXPECT_EQ(err, ERRNO_NOERR);
263 EXPECT_GE(size, 0);
264
265 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetFileSize_001";
266 }
267
268 /**
269 * @tc.name: CopyCoreTest_GetFileSize_002
270 * @tc.desc: Test function of CopyCore::GetFileSize interface for FALSE.
271 * @tc.size: MEDIUM
272 * @tc.type: FUNC
273 * @tc.level Level 1
274 */
275 HWTEST_F(CopyCoreTest, CopyCoreTest_GetFileSize_002, testing::ext::TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetFileSize_002";
278
279 string nonExistentFile = "/data/test/non_existent.txt";
280 auto [err, size] = CopyCore::GetFileSize(nonExistentFile);
281 EXPECT_NE(err, ERRNO_NOERR);
282 EXPECT_EQ(size, 0);
283
284 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetFileSize_002";
285 }
286
287 /**
288 * @tc.name: CopyCoreTest_CheckOrCreatePath_001
289 * @tc.desc: Test function of CopyCore::CheckOrCreatePath interface for TRUE.
290 * @tc.size: MEDIUM
291 * @tc.type: FUNC
292 * @tc.level Level 1
293 */
294 HWTEST_F(CopyCoreTest, CopyCoreTest_CheckOrCreatePath_001, testing::ext::TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CheckOrCreatePath_001";
297
298 auto res = CopyCore::CheckOrCreatePath(srcFile);
299 EXPECT_EQ(res, ERRNO_NOERR);
300
301 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CheckOrCreatePath_001";
302 }
303
304 /**
305 * @tc.name: CopyCoreTest_CheckOrCreatePath_002
306 * @tc.desc: Test function of CopyCore::CheckOrCreatePath interface for TRUE.
307 * @tc.size: MEDIUM
308 * @tc.type: FUNC
309 * @tc.level Level 1
310 */
311 HWTEST_F(CopyCoreTest, CopyCoreTest_CheckOrCreatePath_002, testing::ext::TestSize.Level1)
312 {
313 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CheckOrCreatePath_002";
314
315 string newFile = destDir + "/new_file.txt";
316 auto res = CopyCore::CheckOrCreatePath(newFile);
317 EXPECT_EQ(res, ERRNO_NOERR);
318 EXPECT_TRUE(CopyCore::IsFile(newFile));
319
320 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CheckOrCreatePath_002";
321 }
322
323 /**
324 * @tc.name: CopyCoreTest_MakeDir_001
325 * @tc.desc: Test function of CopyCore::MakeDir interface for TRUE.
326 * @tc.size: MEDIUM
327 * @tc.type: FUNC
328 * @tc.level Level 1
329 */
330 HWTEST_F(CopyCoreTest, CopyCoreTest_MakeDir_001, testing::ext::TestSize.Level1)
331 {
332 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_MakeDir_001";
333
334 string newDir = destDir + "/new_dir";
335 auto res = CopyCore::MakeDir(newDir);
336 EXPECT_EQ(res, ERRNO_NOERR);
337 EXPECT_TRUE(CopyCore::IsDirectory(newDir));
338
339 rmdir(newDir.c_str());
340 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_MakeDir_001";
341 }
342
343 /**
344 * @tc.name: CopyCoreTest_MakeDir_002
345 * @tc.desc: Test function of CopyCore::MakeDir interface for TRUE.
346 * @tc.size: SMALL
347 * @tc.type: FUNC
348 * @tc.level Level 1
349 */
350 HWTEST_F(CopyCoreTest, CopyCoreTest_MakeDir_002, testing::ext::TestSize.Level1)
351 {
352 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_MakeDir_002";
353
354 auto res = CopyCore::MakeDir(srcDir);
355 EXPECT_EQ(res, ERRNO_NOERR);
356
357 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_MakeDir_002";
358 }
359
360 /**
361 * @tc.name: CopyCoreTest_MakeDir_003
362 * @tc.desc: Test function of CopyCore::MakeDir interface for FALSE.
363 * @tc.size: SMALL
364 * @tc.type: FUNC
365 * @tc.level Level 1
366 */
367 HWTEST_F(CopyCoreTest, CopyCoreTest_MakeDir_003, testing::ext::TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_MakeDir_003";
370
371 string invalidPath = "/invalid/path/dir";
372 auto res = CopyCore::MakeDir(invalidPath);
373 EXPECT_NE(res, ERRNO_NOERR);
374
375 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_MakeDir_003";
376 }
377
378 /**
379 * @tc.name: CopyCoreTest_ValidParams_001
380 * @tc.desc: Test function of CopyCore::ValidParams interface for FALSE.
381 * @tc.size: MEDIUM
382 * @tc.type: FUNC
383 * @tc.level Level 1
384 */
385 HWTEST_F(CopyCoreTest, CopyCoreTest_ValidParams_001, testing::ext::TestSize.Level1)
386 {
387 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_ValidParams_001";
388
389 string srcFile = "invalid://data/test/src.txt";
390
391 auto res = CopyCore::ValidParams(srcFile, destFile);
392 EXPECT_EQ(res, false);
393
394 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_ValidParams_001";
395 }
396
397 /**
398 * @tc.name: CopyCoreTest_ValidParams_002
399 * @tc.desc: Test function of CopyCore::ValidParams interface for FALSE.
400 * @tc.size: MEDIUM
401 * @tc.type: FUNC
402 * @tc.level Level 1
403 */
404 HWTEST_F(CopyCoreTest, CopyCoreTest_ValidParams_002, testing::ext::TestSize.Level1)
405 {
406 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_ValidParams_002";
407
408 string destFile = "invalid://data/test/dest.txt";
409
410 auto res = CopyCore::ValidParams(srcFile, destFile);
411 EXPECT_EQ(res, false);
412
413 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_ValidParams_002";
414 }
415
416 /**
417 * @tc.name: CopyCoreTest_ValidParams_003
418 * @tc.desc: Test function of CopyCore::ValidParams interface for FALSE.
419 * @tc.size: MEDIUM
420 * @tc.type: FUNC
421 * @tc.level Level 1
422 */
423 HWTEST_F(CopyCoreTest, CopyCoreTest_ValidParams_003, testing::ext::TestSize.Level1)
424 {
425 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_ValidParams_003";
426
427 string src = "file://data/test/src.txt";
428 string dest = "file://data/test/dest.txt";
429
430 auto res = CopyCore::ValidParams(src, dest);
431 EXPECT_EQ(res, true);
432
433 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_ValidParams_003";
434 }
435
436 /**
437 * @tc.name: CopyCoreTest_CreateFileInfos_001
438 * @tc.desc: Test function of CopyCore::CreateFileInfos interface for TRUE.
439 * @tc.size: MEDIUM
440 * @tc.type: FUNC
441 * @tc.level Level 1
442 */
443 HWTEST_F(CopyCoreTest, CopyCoreTest_CreateFileInfos_001, testing::ext::TestSize.Level1)
444 {
445 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CreateFileInfos_001";
446
447 optional<CopyOptions> options = std::make_optional<CopyOptions>();
448
449 auto [errCode, infos] = CopyCore::CreateFileInfos(srcFile, destFile, options);
450 EXPECT_EQ(errCode, ERRNO_NOERR);
451 EXPECT_NE(infos, nullptr);
452 if (infos) {
453 EXPECT_FALSE(infos->hasListener);
454 EXPECT_EQ(infos->listener, nullptr);
455 EXPECT_EQ(infos->taskSignal, nullptr);
456 }
457
458 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CreateFileInfos_001";
459 }
460
461 /**
462 * @tc.name: CopyCoreTest_CopySubDir_001
463 * @tc.desc: Test function of CopyCore::CopySubDir interface for TRUE.
464 * @tc.size: MEDIUM
465 * @tc.type: FUNC
466 * @tc.level Level 1
467 */
468 HWTEST_F(CopyCoreTest, CopyCoreTest_CopySubDir_001, testing::ext::TestSize.Level1)
469 {
470 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CopySubDir_001";
471
472 string subDir = srcDir + "/CopyCoreTest_CopySubDir_001_sub_dir";
473 mkdir(subDir.c_str(), permission0755);
474 string subFile = subDir + "/sub_file.txt";
475 int fd = open(subFile.c_str(), O_CREAT | O_RDWR, permission0644);
476 if (fd < 0) {
477 EXPECT_TRUE(false);
478 }
479 close(fd);
480
481 string destSubDir = destDir + "/sub_dir";
482 auto infos = make_shared<FsFileInfos>();
483 auto res = CopyCore::CopySubDir(subDir, destSubDir, infos);
484 string destSubFile = destSubDir + "/sub_file.txt";
485 EXPECT_EQ(res, ERRNO_NOERR);
486 EXPECT_TRUE(CopyCore::IsDirectory(destSubDir));
487 EXPECT_TRUE(CopyCore::IsFile(destSubFile));
488
489 remove(subFile.c_str());
490 rmdir(subDir.c_str());
491 remove(destSubFile.c_str());
492 rmdir(destSubDir.c_str());
493 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CopySubDir_001";
494 }
495
496 /**
497 * @tc.name: CopyCoreTest_CopySubDir_002
498 * @tc.desc: Test function of CopyCore::CopySubDir interface for TRUE.
499 * @tc.size: MEDIUM
500 * @tc.type: FUNC
501 * @tc.level Level 1
502 */
503 HWTEST_F(CopyCoreTest, CopyCoreTest_CopySubDir_002, testing::ext::TestSize.Level1)
504 {
505 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CopySubDir_002";
506
507 string subDir = srcDir + "/sub_dir";
508 mkdir(subDir.c_str(), permission0755);
509 string subFile = subDir + "/sub_file.txt";
510 int fd = open(subFile.c_str(), O_CREAT | O_RDWR, permission0644);
511 if (fd < 0) {
512 EXPECT_TRUE(false);
513 }
514 close(fd);
515
516 string destSubDir = destDir + "/sub_dir";
517 auto infos = make_shared<FsFileInfos>();
518 infos->notifyFd = 1;
519 auto res = CopyCore::CopySubDir(subDir, destSubDir, infos);
520 EXPECT_EQ(res, errno);
521
522 remove(subFile.c_str());
523 rmdir(subDir.c_str());
524 rmdir(destSubDir.c_str());
525 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CopySubDir_002";
526 }
527
528 /**
529 * @tc.name: CopyCoreTest_RecurCopyDir_001
530 * @tc.desc: Test function of CopyCore::RecurCopyDir interface for TRUE.
531 * @tc.size: MEDIUM
532 * @tc.type: FUNC
533 * @tc.level Level 1
534 */
535 HWTEST_F(CopyCoreTest, CopyCoreTest_RecurCopyDir_001, testing::ext::TestSize.Level1)
536 {
537 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_RecurCopyDir_001";
538
539 string subDir = srcDir + "/sub_dir";
540 mkdir(subDir.c_str(), permission0755);
541 string subFile = subDir + "/sub_file.txt";
542 int fd = open(subFile.c_str(), O_CREAT | O_RDWR, permission0644);
543 if (fd < 0) {
544 EXPECT_TRUE(false);
545 }
546 close(fd);
547
548 string destSubDir = destDir + "/sub_dir";
549 auto infos = make_shared<FsFileInfos>();
550 auto res = CopyCore::RecurCopyDir(srcDir, destDir, infos);
551 string destSubFile = destSubDir + "/sub_file.txt";
552 EXPECT_EQ(res, ERRNO_NOERR);
553 EXPECT_TRUE(CopyCore::IsDirectory(destSubDir));
554 EXPECT_TRUE(CopyCore::IsFile(destSubDir + "/sub_file.txt"));
555
556 remove(subFile.c_str());
557 rmdir(subDir.c_str());
558 remove(destSubFile.c_str());
559 rmdir(destSubDir.c_str());
560 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_RecurCopyDir_001";
561 }
562
563 /**
564 * @tc.name: CopyCoreTest_CopyDirFunc_001
565 * @tc.desc: Test function of CopyCore::CopyDirFunc interface for TRUE.
566 * @tc.size: MEDIUM
567 * @tc.type: FUNC
568 * @tc.level Level 1
569 */
570 HWTEST_F(CopyCoreTest, CopyCoreTest_CopyDirFunc_001, testing::ext::TestSize.Level1)
571 {
572 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CopyDirFunc_001";
573
574 string subDir = srcDir + "/sub_dir";
575 mkdir(subDir.c_str(), permission0755);
576 string subFile = subDir + "/sub_file.txt";
577 int fd = open(subFile.c_str(), O_CREAT | O_RDWR, permission0644);
578 if (fd < 0) {
579 EXPECT_TRUE(false);
580 }
581 close(fd);
582
583 string destSubDir = destDir + "/src/sub_dir";
584 string destSubFile = destSubDir + "/sub_file.txt";
585 string destSrcDir = destDir + "/src";
586 auto infos = make_shared<FsFileInfos>();
587 auto res = CopyCore::CopyDirFunc(srcDir, destDir, infos);
588 EXPECT_EQ(res, ERRNO_NOERR);
589 EXPECT_EQ(CopyCore::IsDirectory(destSubDir), false);
590 EXPECT_EQ(CopyCore::IsFile(destSubDir + "/sub_file.txt"), false);
591
592 remove(subFile.c_str());
593 rmdir(subDir.c_str());
594 remove(destSubFile.c_str());
595 rmdir(destSubDir.c_str());
596 rmdir(destSrcDir.c_str());
597 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CopyDirFunc_001";
598 }
599
600 /**
601 * @tc.name: CopyCoreTest_ExecLocal_001
602 * @tc.desc: Test function of CopyCore::ExecLocal interface for TRUE.
603 * @tc.size: MEDIUM
604 * @tc.type: FUNC
605 * @tc.level Level 1
606 */
607 HWTEST_F(CopyCoreTest, CopyCoreTest_ExecLocal_001, testing::ext::TestSize.Level1)
608 {
609 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_ExecLocal_001";
610
611 auto infos = make_shared<FsFileInfos>();
612 infos->isFile = true;
613 infos->srcPath = srcFile;
614 infos->destPath = destFile;
615 auto callback = make_shared<FsCallbackObject>(nullptr);
616
617 auto res = CopyCore::ExecLocal(infos, callback);
618 EXPECT_EQ(res, ERRNO_NOERR);
619 EXPECT_TRUE(CopyCore::IsFile(destFile));
620 int ret = remove(destFile.c_str());
621 EXPECT_TRUE(ret == 0);
622
623 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_ExecLocal_001";
624 }
625
626 /**
627 * @tc.name: CopyCoreTest_ExecLocal_002
628 * @tc.desc: Test function of CopyCore::ExecLocal interface for FALSE.
629 * @tc.size: MEDIUM
630 * @tc.type: FUNC
631 * @tc.level Level 1
632 */
633 HWTEST_F(CopyCoreTest, CopyCoreTest_ExecLocal_002, testing::ext::TestSize.Level1)
634 {
635 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_ExecLocal_002";
636
637 auto infos = make_shared<FsFileInfos>();
638 infos->isFile = true;
639 infos->srcPath = srcFile;
640 infos->destPath = srcFile;
641 auto callback = make_shared<FsCallbackObject>(nullptr);
642
643 auto res = CopyCore::ExecLocal(infos, callback);
644 EXPECT_EQ(res, EINVAL);
645
646 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_ExecLocal_002";
647 }
648
649 /**
650 * @tc.name: CopyCoreTest_RegisterListener_001
651 * @tc.desc: Test function of CopyCore::RegisterListener interface for TRUE.
652 * @tc.size: MEDIUM
653 * @tc.type: FUNC
654 * @tc.level Level 1
655 */
656 HWTEST_F(CopyCoreTest, CopyCoreTest_RegisterListener_001, testing::ext::TestSize.Level1)
657 {
658 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_RegisterListener_001";
659
660 auto infos = make_shared<FsFileInfos>();
661 auto callback = CopyCore::RegisterListener(infos);
662 EXPECT_NE(callback, nullptr);
663
664 {
665 std::lock_guard<std::recursive_mutex> lock(CopyCore::mutex_);
666 auto iter = CopyCore::callbackMap_.find(*infos);
667 EXPECT_NE(iter, CopyCore::callbackMap_.end());
668 }
669
670 CopyCore::UnregisterListener(infos);
671 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_RegisterListener_001";
672 }
673
674 /**
675 * @tc.name: CopyCoreTest_RegisterListener_002
676 * @tc.desc: Test function of CopyCore::RegisterListener interface for the case when the info already exists in
677 * callbackMap_.
678 * @tc.size: MEDIUM
679 * @tc.type: FUNC
680 * @tc.level Level 1
681 */
682 HWTEST_F(CopyCoreTest, CopyCoreTest_RegisterListener_002, testing::ext::TestSize.Level1)
683 {
684 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_RegisterListener_002";
685
686 auto infos = make_shared<FsFileInfos>();
687 auto firstCallback = CopyCore::RegisterListener(infos);
688 EXPECT_NE(firstCallback, nullptr);
689 auto secondCallback = CopyCore::RegisterListener(infos);
690 EXPECT_EQ(secondCallback, nullptr);
691
692 {
693 std::lock_guard<std::recursive_mutex> lock(CopyCore::mutex_);
694 auto iter = CopyCore::callbackMap_.find(*infos);
695 EXPECT_NE(iter, CopyCore::callbackMap_.end());
696 }
697
698 CopyCore::UnregisterListener(infos);
699 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_RegisterListener_002";
700 }
701
702 /**
703 * @tc.name: CopyCoreTest_UnregisterListener_001
704 * @tc.desc: Test function of CopyCore::UnregisterListener interface for TRUE.
705 * @tc.size: MEDIUM
706 * @tc.type: FUNC
707 * @tc.level Level 1
708 */
709 HWTEST_F(CopyCoreTest, CopyCoreTest_UnregisterListener_001, testing::ext::TestSize.Level1)
710 {
711 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_UnregisterListener_001";
712
713 auto infos = make_shared<FsFileInfos>();
714 auto callback = CopyCore::RegisterListener(infos);
715 EXPECT_NE(callback, nullptr);
716
717 CopyCore::UnregisterListener(infos);
718
719 {
720 std::lock_guard<std::recursive_mutex> lock(CopyCore::mutex_);
721 auto iter = CopyCore::callbackMap_.find(*infos);
722 EXPECT_EQ(iter, CopyCore::callbackMap_.end());
723 }
724
725 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_UnregisterListener_001";
726 }
727
728 /**
729 * @tc.name: CopyCoreTest_UnregisterListener_002
730 * @tc.desc: Test function of CopyCore::UnregisterListener interface for the case when the info is not registered in
731 * callbackMap_.
732 * @tc.size: MEDIUM
733 * @tc.type: FUNC
734 * @tc.level Level 1
735 */
736 HWTEST_F(CopyCoreTest, CopyCoreTest_UnregisterListener_002, testing::ext::TestSize.Level1)
737 {
738 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_UnregisterListener_002";
739
740 auto infos = make_shared<FsFileInfos>();
741
742 CopyCore::UnregisterListener(infos);
743
744 {
745 std::lock_guard<std::recursive_mutex> lock(CopyCore::mutex_);
746 auto iter = CopyCore::callbackMap_.find(*infos);
747 EXPECT_EQ(iter, CopyCore::callbackMap_.end());
748 }
749
750 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_UnregisterListener_002";
751 }
752
753 /**
754 * @tc.name: CopyCoreTest_DoCopy_001
755 * @tc.desc: Test function of CopyCore::DoCopy interface for FALSE.
756 * @tc.size: MEDIUM
757 * @tc.type: FUNC
758 * @tc.level Level 1
759 */
760 HWTEST_F(CopyCoreTest, CopyCoreTest_DoCopy_001, testing::ext::TestSize.Level1)
761 {
762 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_DoCopy_001";
763
764 string src = "invalid:/" + srcFile;
765 string dest = "invalid:/" + destFile;
766 optional<CopyOptions> options;
767
768 auto res = CopyCore::DoCopy(src, dest, options);
769 EXPECT_FALSE(res.IsSuccess());
770 auto err = res.GetError();
771 EXPECT_EQ(err.GetErrNo(), E_PARAMS);
772
773 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_DoCopy_001";
774 }
775
776 /**
777 * @tc.name: CopyCoreTest_DoCopy_002
778 * @tc.desc: Test function of CopyCore::DoCopy interface for TRUE.
779 * @tc.size: MEDIUM
780 * @tc.type: FUNC
781 * @tc.level Level 1
782 */
783 HWTEST_F(CopyCoreTest, CopyCoreTest_DoCopy_002, testing::ext::TestSize.Level1)
784 {
785 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_DoCopy_002";
786
787 string src = "file:///data/test/src/src.txt";
788 string dest = "file:///data/test/dest/dest.txt";
789 optional<CopyOptions> options;
790
791 auto res = CopyCore::DoCopy(src, dest, options);
792 EXPECT_FALSE(res.IsSuccess());
793
794 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_DoCopy_002";
795 }
796
797 /**
798 * @tc.name: CopyCoreTest_GetDirSize_001
799 * @tc.desc: Test function of CopyCore::GetDirSize interface for TRUE.
800 * @tc.size: MEDIUM
801 * @tc.type: FUNC
802 * @tc.level Level 1
803 */
804 HWTEST_F(CopyCoreTest, CopyCoreTest_GetDirSize_001, testing::ext::TestSize.Level1)
805 {
806 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetDirSize_001";
807
808 auto infos = make_shared<FsFileInfos>();
809 infos->isFile = true;
810 infos->srcPath = srcFile;
811 infos->destPath = destFile;
812
813 auto res = CopyCore::GetDirSize(infos, srcDir);
814 EXPECT_EQ(res, 0);
815
816 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetDirSize_001";
817 }
818
819 /**
820 * @tc.name: CopyCoreTest_GetUVEntry_001
821 * @tc.desc: Test function of CopyCore::GetUVEntry interface for FALSE.
822 * @tc.size: MEDIUM
823 * @tc.type: FUNC
824 * @tc.level Level 1
825 */
826 HWTEST_F(CopyCoreTest, CopyCoreTest_GetUVEntry_001, testing::ext::TestSize.Level1)
827 {
828 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetUVEntry_001";
829
830 auto infos = make_shared<FsFileInfos>();
831 auto res = CopyCore::GetUVEntry(infos);
832 EXPECT_EQ(res, nullptr);
833
834 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetUVEntry_001";
835 }
836
837 /**
838 * @tc.name: CopyCoreTest_CheckFileValid_001
839 * @tc.desc: Test function of CopyCore::CheckFileValid interface for FALSE.
840 * @tc.size: MEDIUM
841 * @tc.type: FUNC
842 * @tc.level Level 1
843 */
844 HWTEST_F(CopyCoreTest, CopyCoreTest_CheckFileValid_001, testing::ext::TestSize.Level1)
845 {
846 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CheckFileValid_001";
847
848 auto infos = make_shared<FsFileInfos>();
849 infos->isFile = true;
850 infos->srcPath = srcFile;
851 infos->destPath = destFile;
852
853 auto res = CopyCore::CheckFileValid(srcFile, infos);
854 EXPECT_EQ(res, false);
855
856 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CheckFileValid_001";
857 }
858
859 /**
860 * @tc.name: CopyCoreTest_UpdateProgressSize_001
861 * @tc.desc: Test function of CopyCore::UpdateProgressSize interface for TRUE.
862 * @tc.size: MEDIUM
863 * @tc.type: FUNC
864 * @tc.level Level 1
865 */
866 HWTEST_F(CopyCoreTest, CopyCoreTest_UpdateProgressSize_001, testing::ext::TestSize.Level1)
867 {
868 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_UpdateProgressSize_001";
869
870 auto receivedInfo = make_shared<ReceiveInfo>();
871 auto callback = make_shared<FsCallbackObject>(nullptr);
872
873 auto res = CopyCore::UpdateProgressSize(srcFile, receivedInfo, callback);
874 EXPECT_EQ(res, ERRNO_NOERR);
875
876 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_UpdateProgressSize_001";
877 }
878
879 /**
880 * @tc.name: CopyCoreTest_GetRegisteredListener_001
881 * @tc.desc: Test function of CopyCore::GetRegisteredListener interface for FALSE.
882 * @tc.size: MEDIUM
883 * @tc.type: FUNC
884 * @tc.level Level 1
885 */
886 HWTEST_F(CopyCoreTest, CopyCoreTest_GetRegisteredListener_001, testing::ext::TestSize.Level1)
887 {
888 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetRegisteredListener_001";
889
890 auto infos = make_shared<FsFileInfos>();
891 infos->isFile = true;
892 infos->srcPath = srcFile;
893 infos->destPath = destFile;
894
895 auto res = CopyCore::GetRegisteredListener(infos);
896 EXPECT_EQ(res, nullptr);
897
898 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetRegisteredListener_001";
899 }
900
901 /**
902 * @tc.name: CopyCoreTest_SubscribeLocalListener_001
903 * @tc.desc: Test function of CopyCore::SubscribeLocalListener interface for FALSE.
904 * @tc.size: MEDIUM
905 * @tc.type: FUNC
906 * @tc.level Level 1
907 */
908 HWTEST_F(CopyCoreTest, CopyCoreTest_SubscribeLocalListener_001, testing::ext::TestSize.Level1)
909 {
910 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_SubscribeLocalListener_001";
911
912 auto infos = make_shared<FsFileInfos>();
913 infos->isFile = true;
914 infos->srcPath = srcFile;
915 infos->destPath = destFile;
916 auto callback = make_shared<FsCallbackObject>(nullptr);
917
918 auto res = CopyCore::SubscribeLocalListener(infos, callback);
919 EXPECT_EQ(res, errno);
920
921 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_SubscribeLocalListener_001";
922 }
923
924 /**
925 * @tc.name: CopyCoreTest_GetRealPath_001
926 * @tc.desc: Test function of CopyCore::GetRealPath interface for TRUE.
927 * @tc.size: MEDIUM
928 * @tc.type: FUNC
929 * @tc.level Level 1
930 */
931 HWTEST_F(CopyCoreTest, CopyCoreTest_GetRealPath_001, testing::ext::TestSize.Level1)
932 {
933 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetRealPath_001";
934
935 string path = "./data/test/src/src.txt";
936
937 auto res = CopyCore::GetRealPath(path);
938 EXPECT_EQ(res, "data/test/src/src.txt");
939
940 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetRealPath_001";
941 }
942
943 /**
944 * @tc.name: CopyCoreTest_GetRealPath_002
945 * @tc.desc: Test function of CopyCore::GetRealPath interface for TRUE.
946 * @tc.size: MEDIUM
947 * @tc.type: FUNC
948 * @tc.level Level 1
949 */
950 HWTEST_F(CopyCoreTest, CopyCoreTest_GetRealPath_002, testing::ext::TestSize.Level1)
951 {
952 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_GetRealPath_002";
953
954 string path = "../data/test/src/src.txt";
955
956 auto res = CopyCore::GetRealPath(path);
957 EXPECT_EQ(res, "data/test/src/src.txt");
958
959 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_GetRealPath_002";
960 }
961
962 /**
963 * @tc.name: CopyCoreTest_ExecCopy_001
964 * @tc.desc: Test function of CopyCore::ExecCopy interface for FALSE.
965 * @tc.size: MEDIUM
966 * @tc.type: FUNC
967 * @tc.level Level 1
968 */
969 HWTEST_F(CopyCoreTest, CopyCoreTest_ExecCopy_001, testing::ext::TestSize.Level1)
970 {
971 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_ExecCopy_001";
972
973 auto infos = make_shared<FsFileInfos>();
974 infos->isFile = false;
975 infos->srcPath = "/data/test/src";
976 infos->destPath = "/data/test/dest";
977
978 auto res = CopyCore::ExecCopy(infos);
979 EXPECT_EQ(res, EINVAL);
980
981 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_ExecCopy_001";
982 }
983
984 /**
985 * @tc.name: CopyCoreTest_CopyFile_001
986 * @tc.desc: Test function of CopyCore::CopyFile interface for file copy FALSE.
987 * @tc.size: MEDIUM
988 * @tc.type: FUNC
989 * @tc.level Level 1
990 */
991 HWTEST_F(CopyCoreTest, CopyCoreTest_CopyFile_001, testing::ext::TestSize.Level1)
992 {
993 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_CopyFile_001";
994
995 string src = "datashare:///media/src_test.jpg";
996 string dest = "datashare:///media/dest_test.jpg";
997 auto infos = make_shared<FsFileInfos>();
998 infos->isFile = true;
999 infos->srcPath = src;
1000 infos->destPath = dest;
1001
1002 auto res = CopyCore::CopyFile(src, dest, infos);
1003 EXPECT_EQ(res, errno);
1004
1005 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_CopyFile_001";
1006 }
1007
1008 /**
1009 * @tc.name: CopyCoreTest_HandleProgress_001
1010 * @tc.desc: Test function of CopyCore::HandleProgress interface for FALSE.
1011 * @tc.size: MEDIUM
1012 * @tc.type: FUNC
1013 * @tc.level Level 1
1014 */
1015 HWTEST_F(CopyCoreTest, CopyCoreTest_HandleProgress_001, testing::ext::TestSize.Level1)
1016 {
1017 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_HandleProgress_001";
1018
1019 auto infos = make_shared<FsFileInfos>();
1020 infos->isFile = false;
1021 infos->srcPath = "/data/test/src";
1022 infos->destPath = "/data/test/dest";
1023
1024 auto event = make_unique<inotify_event>();
1025 event->wd = EXPECTED_WD;
1026 event->mask = IN_MODIFY;
1027 event->len = 0;
1028 auto [continueProcess, errCode, needSend] = CopyCore::HandleProgress(event.get(), infos, nullptr);
1029
1030 EXPECT_TRUE(continueProcess);
1031 EXPECT_EQ(errCode, EINVAL);
1032 EXPECT_FALSE(needSend);
1033
1034 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_HandleProgress_001";
1035 }
1036
1037 /**
1038 * @tc.name: CopyCoreTest_HandleProgress_002
1039 * @tc.desc: Test function of CopyCore::HandleProgress interface for FALSE.
1040 * @tc.size: MEDIUM
1041 * @tc.type: FUNC
1042 * @tc.level Level 1
1043 */
1044 HWTEST_F(CopyCoreTest, CopyCoreTest_HandleProgress_002, testing::ext::TestSize.Level1)
1045 {
1046 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_HandleProgress_002";
1047
1048 auto infos = make_shared<FsFileInfos>();
1049 infos->srcPath = srcDir;
1050 infos->destPath = destDir;
1051 infos->isFile = true;
1052
1053 auto callback = make_shared<FsCallbackObject>(nullptr);
1054
1055 auto receiveInfo = make_shared<ReceiveInfo>();
1056 receiveInfo->path = testDir;
1057 callback->wds.push_back({ UNEXPECTED_WD, receiveInfo });
1058
1059 auto event = make_unique<inotify_event>();
1060 event->wd = EXPECTED_WD;
1061 event->mask = IN_MODIFY;
1062 event->len = 0;
1063
1064 auto [continueProcess, errCode, needSend] = CopyCore::HandleProgress(event.get(), infos, callback);
1065
1066 EXPECT_TRUE(continueProcess);
1067 EXPECT_EQ(errCode, EINVAL);
1068 EXPECT_FALSE(needSend);
1069
1070 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_HandleProgress_002";
1071 }
1072
1073 /**
1074 * @tc.name: CopyCoreTest_HandleProgress_003
1075 * @tc.desc: Test function of CopyCore::HandleProgress interface for FALSE.
1076 * @tc.size: MEDIUM
1077 * @tc.type: FUNC
1078 * @tc.level Level 1
1079 */
1080 HWTEST_F(CopyCoreTest, CopyCoreTest_HandleProgress_003, testing::ext::TestSize.Level1)
1081 {
1082 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_HandleProgress_003";
1083
1084 auto infos = make_shared<FsFileInfos>();
1085 infos->srcPath = srcDir;
1086 infos->destPath = destDir;
1087 infos->isFile = true;
1088
1089 auto callback = make_shared<FsCallbackObject>(nullptr);
1090
1091 auto receiveInfo = make_shared<ReceiveInfo>();
1092 receiveInfo->path = srcFile;
1093 callback->wds.push_back({ EXPECTED_WD, receiveInfo });
1094
1095 auto event = make_unique<inotify_event>();
1096 event->wd = EXPECTED_WD;
1097 event->mask = IN_MODIFY;
1098 event->len = 0;
1099
1100 auto [continueProcess, errCode, needSend] = CopyCore::HandleProgress(event.get(), infos, callback);
1101
1102 EXPECT_TRUE(continueProcess);
1103 EXPECT_EQ(errCode, ERRNO_NOERR);
1104 EXPECT_TRUE(needSend);
1105
1106 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_HandleProgress_003";
1107 }
1108
1109 /**
1110 * @tc.name: CopyCoreTest_OnFileReceive_001
1111 * @tc.desc: Test function of CopyCore::OnFileReceive interface fails.
1112 * @tc.size: MEDIUM
1113 * @tc.type: FUNC
1114 * @tc.level Level 1
1115 */
1116 HWTEST_F(CopyCoreTest, CopyCoreTest_OnFileReceive_001, testing::ext::TestSize.Level1)
1117 {
1118 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_OnFileReceive_001";
1119
1120 auto infos = make_shared<FsFileInfos>();
1121 CopyCore::OnFileReceive(infos);
1122 EXPECT_TRUE(CopyCore::callbackMap_.empty());
1123
1124 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_OnFileReceive_001";
1125 }
1126
1127 /**
1128 * @tc.name: CopyCoreTest_OnFileReceive_002
1129 * @tc.desc: Test function of CopyCore::OnFileReceive interface when listener is nullptr.
1130 * @tc.size: MEDIUM
1131 * @tc.type: FUNC
1132 * @tc.level Level 1
1133 */
1134 HWTEST_F(CopyCoreTest, CopyCoreTest_OnFileReceive_002, testing::ext::TestSize.Level1)
1135 {
1136 GTEST_LOG_(INFO) << "CopyCoreTest-begin CopyCoreTest_OnFileReceive_002";
1137
1138 auto infos = make_shared<FsFileInfos>();
1139 auto callback = CopyCore::RegisterListener(infos);
1140 CopyCore::OnFileReceive(infos);
1141 EXPECT_NE(callback, nullptr);
1142 if (callback) {
1143 EXPECT_EQ(callback->listener, nullptr);
1144 }
1145 GTEST_LOG_(INFO) << "CopyCoreTest-end CopyCoreTest_OnFileReceive_002";
1146 }
1147
1148 } // namespace OHOS::FileManagement::ModuleFileIO::Test
1149
