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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "directory_ex.h"
20 #include "meta_file.h"
21 #include "dfs_error.h"
22 #include "base_interface_lib_mock.h"
23
24 namespace OHOS::FileManagement::CloudSync::Test {
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace std;
28 constexpr uint32_t TEST_USER_ID = 201;
29 constexpr uint64_t TEST_ISIZE = 1024;
30
31 class CloudDiskDentryMetaFileTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
SetUpTestCase(void)38 void CloudDiskDentryMetaFileTest::SetUpTestCase(void)
39 {
40 GTEST_LOG_(INFO) << "SetUpTestCase";
41 }
42
TearDownTestCase(void)43 void CloudDiskDentryMetaFileTest::TearDownTestCase(void)
44 {
45 GTEST_LOG_(INFO) << "TearDownTestCase";
46 }
47
SetUp(void)48 void CloudDiskDentryMetaFileTest::SetUp(void)
49 {
50 GTEST_LOG_(INFO) << "SetUp";
51 }
52
TearDown(void)53 void CloudDiskDentryMetaFileTest::TearDown(void)
54 {
55 GTEST_LOG_(INFO) << "TearDown";
56 }
57
58 /**
59 * @tc.name: CloudDiskMetaFileHandleFileByFd001
60 * @tc.desc: Verify the MetaFile::HandleFileByFd function
61 * @tc.type: FUNC
62 * @tc.require: SR000HRKKA
63 */
64 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileHandleFileByFd001, TestSize.Level1)
65 {
66 MetaFile mFile(TEST_USER_ID, "/");
67 unsigned long endBlock = 0;
68 uint32_t level = 0;
69 int ret = mFile.HandleFileByFd(endBlock, level);
70 EXPECT_EQ(ret, EINVAL);
71 }
72
73 /**
74 * @tc.name: CloudDiskMetaFileHandleFileByFd002
75 * @tc.desc: Verify the MetaFile::HandleFileByFd function
76 * @tc.type: FUNC
77 * @tc.require: SR000HRKKA
78 */
79 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileHandleFileByFd002, TestSize.Level1)
80 {
81 uint32_t userId = 100;
82 CloudDiskMetaFile mFile(userId, "/", "id1");
83 unsigned long endBlock = 0;
84 uint32_t level = 64;
85 int ret = mFile.HandleFileByFd(endBlock, level);
86 EXPECT_EQ(ret, 0);
87 }
88
89 /**
90 * @tc.name: CloudDiskMetaFileHandleFileByFd003
91 * @tc.desc: Verify the MetaFile::HandleFileByFd function
92 * @tc.type: FUNC
93 * @tc.require: SR000HRKKA
94 */
95 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileHandleFileByFd003, TestSize.Level1)
96 {
97 uint32_t userId = 100;
98 CloudDiskMetaFile mFile(userId, "/", "id1");
99 unsigned long endBlock = 0;
100 uint32_t level = 0;
101 int ret = mFile.HandleFileByFd(endBlock, level);
102 EXPECT_EQ(ret, 0);
103 }
104
105 /**
106 * @tc.name: CloudDiskMetaFileDoChildUpdateTest
107 * @tc.desc: Verify the CloudDiskMetaFile::DoChildUpdate function
108 * @tc.type: FUNC
109 * @tc.require: SR000HRKKC
110 */
111 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileDoChildUpdateTest, TestSize.Level1)
112 {
113 CloudDiskMetaFile mFile(TEST_USER_ID, "/", "id1");
114 string name = "";
115 CloudDiskMetaFile::CloudDiskMetaFileCallBack callback;
116 int ret = mFile.DoChildUpdate(name, callback);
117 EXPECT_EQ(ret, 2);
118 }
119
120 /**
121 * @tc.name: DoLookupAndRemoveTest
122 * @tc.desc: Verify the CloudDiskMetaFile::DoLookupAndRemove function
123 * @tc.type: FUNC
124 * @tc.require: SR000HRKKA
125 */
126 HWTEST_F(CloudDiskDentryMetaFileTest, DoLookupAndRemoveTest, TestSize.Level1)
127 {
128 CloudDiskMetaFile mFile(100, "com.ohos.photos", "rootId");
129 MetaBase mBase1(".trash", "rootId");
130 int ret = mFile.DoLookupAndRemove(mBase1);
131 EXPECT_EQ(ret, 0);
132 }
133
134 /**
135 * @tc.name: CloudDiskDentryFileCreateTest
136 * @tc.desc: Verify the CloudDiskMetaFile::DoCreate function
137 * @tc.type: FUNC
138 * @tc.require: SR000HRKKA
139 */
140 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskDentryFileCreateTest, TestSize.Level1)
141 {
142 std::string cacheDir =
143 "/data/service/el2/" + std::to_string(TEST_USER_ID) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
144 ForceRemoveDirectory(cacheDir);
145
146 string CloudId = "";
147 CloudDiskMetaFile mFile(TEST_USER_ID, "/", "id1");
148 MetaBase mBase1("file1", "id1");
149 mBase1.size = TEST_ISIZE;
150 int ret = mFile.DoCreate(mBase1);
151 EXPECT_EQ(ret, 0);
152 }
153
154 /**
155 * @tc.name: CloudDiskMetaFileLookupTest
156 * @tc.desc: Verify the CloudDiskMetaFile::DoLookup function
157 * @tc.type: FUNC
158 * @tc.require: SR000HRKKA
159 */
160 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileLookupTest, TestSize.Level1)
161 {
162 CloudDiskMetaFile mFile(TEST_USER_ID, "/", "id1");
163 MetaBase mBase1("file1");
164 int ret = mFile.DoCreate(mBase1);
165 ret = mFile.DoLookup(mBase1);
166 EXPECT_EQ(ret, 0);
167 EXPECT_EQ(mBase1.size, TEST_ISIZE);
168 }
169
170 /**
171 * @tc.name: CloudDiskMetaFileUpdateTest
172 * @tc.desc: Verify the CloudDiskMetaFile::DoUpdate function
173 * @tc.type: FUNC
174 * @tc.require: SR000HRKKC
175 */
176 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileUpdateTest, TestSize.Level1)
177 {
178 CloudDiskMetaFile mFile(TEST_USER_ID, "/", "id1");
179 MetaBase mBase1("file1", "id1");
180 mBase1.size = 0;
181 int ret = mFile.DoCreate(mBase1);
182 ret = mFile.DoUpdate(mBase1);
183 EXPECT_EQ(ret, 0);
184 MetaBase mBase2("file1", "id1");
185 ret = mFile.DoLookup(mBase2);
186 EXPECT_EQ(ret, 0);
187 EXPECT_EQ(mBase2.size, 0);
188 }
189
190 /**
191 * @tc.name: CloudDiskMetaFileRemoveTest
192 * @tc.desc: Verify the CloudDiskMetaFile::DoRemove function
193 * @tc.type: FUNC
194 * @tc.require: SR000HRKJB
195 */
196 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileRemoveTest, TestSize.Level1)
197 {
198 CloudDiskMetaFile mFile(TEST_USER_ID, "/", "id1");
199 MetaBase mBase1("file1", "id1");
200 int ret = mFile.DoCreate(mBase1);
201 ret = mFile.DoRemove(mBase1);
202 EXPECT_EQ(ret, 0);
203 MetaBase mBase2("file1", "id1");
204 ret = mFile.DoLookup(mBase2);
205 EXPECT_EQ(ret, ENOENT);
206 }
207
208 /**
209 * @tc.name:LoadChildrenTest
210 * @tc.desc: Verify the CloudDiskMetaFile::LoadChildren function
211 * @tc.type: FUNC
212 * @tc.require: SR000HRKJB
213 */
214 HWTEST_F(CloudDiskDentryMetaFileTest, LoadChildrenTest, TestSize.Level1)
215 {
216 CloudDiskMetaFile mFile(100, "/", "id1");
217 MetaBase mBase1("file1", "id1");
218 std::vector<MetaBase> bases;
219 bases.push_back(mBase1);
220 int32_t ret = mFile.LoadChildren(bases);
221 EXPECT_EQ(ret, 0);
222 }
223
224 /**
225 * @tc.name: CloudDiskMetaFileMgrTest001
226 * @tc.desc: Verify the MetaFileMgr
227 * @tc.type: FUNC
228 * @tc.require: SR000HRKJB
229 */
230 HWTEST_F(CloudDiskDentryMetaFileTest, CloudDiskMetaFileMgrTest001, TestSize.Level1)
231 {
232 GTEST_LOG_(INFO) << "CloudDiskMetaFileMgrTest001 Start";
233 try {
234 auto m = MetaFileMgr::GetInstance().GetCloudDiskMetaFile(TEST_USER_ID, "/o/p/q/r/s/t", "id1");
235 EXPECT_NE(m, nullptr);
236 m = nullptr;
237 MetaFileMgr::GetInstance().CloudDiskClearAll();
238 } catch (...) {
239 EXPECT_FALSE(false);
240 GTEST_LOG_(INFO) << "CloudDiskMetaFileMgrTest001 ERROR";
241 }
242 GTEST_LOG_(INFO) << "CloudDiskMetaFileMgrTest001 End";
243 }
244
245 /**
246 * @tc.name: CreateRecycleDentryTest001
247 * @tc.desc: Verify the CreateRecycleDentry
248 * @tc.type: FUNC
249 * @tc.require: SR000HRKJB
250 */
251 HWTEST_F(CloudDiskDentryMetaFileTest, CreateRecycleDentryTest001, TestSize.Level1)
252 {
253 GTEST_LOG_(INFO) << "CreateRecycleDentryTest001 Start";
254 try {
255 uint32_t userId = 100;
256 string bundleName = "com.ohos.photos";
257 int32_t ret = MetaFileMgr::GetInstance().CreateRecycleDentry(userId, bundleName);
258 EXPECT_EQ(ret, 0);
259 MetaFileMgr::GetInstance().CloudDiskClearAll();
260 } catch (...) {
261 EXPECT_FALSE(false);
262 GTEST_LOG_(INFO) << "CreateRecycleDentryTest001 ERROR";
263 }
264 GTEST_LOG_(INFO) << "CreateRecycleDentryTest001 End";
265 }
266
267 /**
268 * @tc.name: MoveIntoRecycleDentryfileTest001
269 * @tc.desc: Verify the MoveIntoRecycleDentryfile
270 * @tc.type: FUNC
271 * @tc.require: SR000HRKJB
272 */
273 HWTEST_F(CloudDiskDentryMetaFileTest, MoveIntoRecycleDentryfileTest001, TestSize.Level1)
274 {
275 GTEST_LOG_(INFO) << "MoveIntoRecycleDentryfileTest001 Start";
276 try {
277 uint32_t userId = 100;
278 string bundleName = "com.ohos.photos";
279 string name = ".trash";
280 string parentCloudId = "rootId";
281 int64_t rowId = 0;
282 int32_t ret = MetaFileMgr::GetInstance().MoveIntoRecycleDentryfile(userId, bundleName,
283 name, parentCloudId, rowId);
284 EXPECT_EQ(ret, 0);
285 MetaFileMgr::GetInstance().CloudDiskClearAll();
286 } catch (...) {
287 EXPECT_FALSE(false);
288 GTEST_LOG_(INFO) << "MoveIntoRecycleDentryfileTest001 ERROR";
289 }
290 GTEST_LOG_(INFO) << "MoveIntoRecycleDentryfileTest001 End";
291 }
292
293 /**
294 * @tc.name: RemoveFromRecycleDentryfileTest001
295 * @tc.desc: Verify the RemoveFromRecycleDentryfile
296 * @tc.type: FUNC
297 * @tc.require: SR000HRKJB
298 */
299 HWTEST_F(CloudDiskDentryMetaFileTest, RemoveFromRecycleDentryfileTest001, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO) << "RemoveFromRecycleDentryfileTest001 Start";
302 try {
303 uint32_t userId = 100;
304 string bundleName = "com.ohos.photos";
305 string name = ".trash";
306 string parentCloudId = "rootId";
307 int64_t rowId = 0;
308 struct RestoreInfo restoreInfo = {name, parentCloudId, name, rowId};
309 int32_t ret = MetaFileMgr::GetInstance().RemoveFromRecycleDentryfile(userId, bundleName, restoreInfo);
310 EXPECT_EQ(ret, 0);
311 MetaFileMgr::GetInstance().CloudDiskClearAll();
312 } catch (...) {
313 EXPECT_FALSE(false);
314 GTEST_LOG_(INFO) << "RemoveFromRecycleDentryfileTest001 ERROR";
315 }
316 GTEST_LOG_(INFO) << "RemoveFromRecycleDentryfileTest001 End";
317 }
318
319
320 HWTEST_F(CloudDiskDentryMetaFileTest, DfsService_GetDentryFilePath_001, TestSize.Level1)
321 {
322 GTEST_LOG_(INFO) << "DfsService_GetDentryFilePath_001 Start";
323 try {
324 CloudDiskMetaFile mFile(100, "/", "id1");
325 string cacheFilePath = mFile.GetDentryFilePath();
326 EXPECT_EQ((cacheFilePath != ""), true);
327 } catch (...) {
328 EXPECT_FALSE(false);
329 GTEST_LOG_(INFO) << "DfsService_GetDentryFilePath_001 ERROR";
330 }
331 GTEST_LOG_(INFO) << "DfsService_GetDentryFilePath_001 End";
332 }
333
334 HWTEST_F(CloudDiskDentryMetaFileTest, DfsService_DoLookupAndUpdate_001, TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "DfsService_DoLookupAndUpdate_001 Start";
337 try {
338 string fileName = "testLongLongfileName";
339 string cloudId = "testLongLongfileName";
340 uint64_t size = 0x6b6b6b6b00000000;
341 MetaBase metaBase(fileName, cloudId);
342 metaBase.size = size;
__anonbe8cc26f0102(MetaBase &m) 343 auto callback = [&metaBase] (MetaBase &m) {
344 m.size = metaBase.size;
345 };
346
347 auto metaFile = MetaFileMgr::GetInstance().GetCloudDiskMetaFile(TEST_USER_ID, "/o/p/q/r/s/t", "id1");
348 int32_t ret = metaFile->DoLookupAndUpdate(fileName, callback);
349 EXPECT_EQ(ret, E_OK);
350 } catch (...) {
351 EXPECT_FALSE(false);
352 GTEST_LOG_(INFO) << "DfsService_DoLookupAndUpdate_001 ERROR";
353 }
354 GTEST_LOG_(INFO) << "DfsService_DoLookupAndUpdate_001 End";
355 }
356
357 HWTEST_F(CloudDiskDentryMetaFileTest, DfsService_DoChildUpdate_001, TestSize.Level1)
358 {
359 GTEST_LOG_(INFO) << "DfsService_DoChildUpdate_001 Start";
360 try {
361 string name = "testName";
362 CloudDiskMetaFile mFile(100, "/", "id1");
363 CloudDiskMetaFile::CloudDiskMetaFileCallBack updateFunc;
364
365 int32_t ret = mFile.DoChildUpdate(name, updateFunc);
366 EXPECT_EQ(ret, E_INVAL_ARG);
367 } catch (...) {
368 EXPECT_FALSE(false);
369 GTEST_LOG_(INFO) << "DfsService_DoChildUpdate_001 ERROR";
370 }
371 GTEST_LOG_(INFO) << "DfsService_DoChildUpdate_001 End";
372 }
373
374 HWTEST_F(CloudDiskDentryMetaFileTest, DfsService_DoLookupAndRemove_001, TestSize.Level1)
375 {
376 GTEST_LOG_(INFO) << "DfsService_DoLookupAndRemove_001 Start";
377 try {
378 CloudDiskMetaFile mFile(100, "com.ohos.photos", "rootId");
379 MetaBase mBase1(".trash", "rootId");
380
381 int32_t ret = mFile.DoLookupAndRemove(mBase1);
382 EXPECT_EQ(ret, E_OK);
383 } catch (...) {
384 EXPECT_FALSE(false);
385 GTEST_LOG_(INFO) << "DfsService_DoLookupAndRemove_001 ERROR";
386 }
387 GTEST_LOG_(INFO) << "DfsService_DoLookupAndRemove_001 End";
388 }
389
390 HWTEST_F(CloudDiskDentryMetaFileTest, DoCreate_001, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "DoCreate_001 Start";
393 try {
394 CloudDiskMetaFile mFile(100, "", "");
395 MetaBase mBase1("file1", "id1");
396 int32_t ret = mFile.DoCreate(mBase1);
397 EXPECT_EQ(ret, E_EINVAL);
398 } catch (...) {
399 EXPECT_FALSE(false);
400 GTEST_LOG_(INFO) << "DoCreate_001 ERROR";
401 }
402 GTEST_LOG_(INFO) << "DoCreate_001 End";
403 }
404
405 HWTEST_F(CloudDiskDentryMetaFileTest, DoRemove_001, TestSize.Level1)
406 {
407 GTEST_LOG_(INFO) << "DoRemove_001 Start";
408 try {
409 CloudDiskMetaFile mFile(100, "", "");
410 MetaBase mBase1("file1", "id1");
411 int32_t ret = mFile.DoRemove(mBase1);
412 EXPECT_EQ(ret, E_EINVAL);
413 } catch (...) {
414 EXPECT_FALSE(false);
415 GTEST_LOG_(INFO) << "DoRemove_001 ERROR";
416 }
417 GTEST_LOG_(INFO) << "DoRemove_001 End";
418 }
419
420 HWTEST_F(CloudDiskDentryMetaFileTest, DoLookup_001, TestSize.Level1)
421 {
422 GTEST_LOG_(INFO) << "DoLookup_001 Start";
423 try {
424 CloudDiskMetaFile mFile(100, "", "");
425 MetaBase mBase1("file1", "id1");
426 int32_t ret = mFile.DoLookup(mBase1);
427 EXPECT_EQ(ret, E_EINVAL);
428 } catch (...) {
429 EXPECT_FALSE(false);
430 GTEST_LOG_(INFO) << "DoLookup_001 ERROR";
431 }
432 GTEST_LOG_(INFO) << "DoLookup_001 End";
433 }
434
435 HWTEST_F(CloudDiskDentryMetaFileTest, DoUpdate_001, TestSize.Level1)
436 {
437 GTEST_LOG_(INFO) << "DoUpdate_001 Start";
438 try {
439 CloudDiskMetaFile mFile(100, "", "");
440 MetaBase mBase1("file1", "id1");
441 int32_t ret = mFile.DoUpdate(mBase1);
442 EXPECT_EQ(ret, E_EINVAL);
443 } catch (...) {
444 EXPECT_FALSE(false);
445 GTEST_LOG_(INFO) << "DoUpdate_001 ERROR";
446 }
447 GTEST_LOG_(INFO) << "DoUpdate_001 End";
448 }
449
450 HWTEST_F(CloudDiskDentryMetaFileTest, LoadChildren_001, TestSize.Level1)
451 {
452 GTEST_LOG_(INFO) << "LoadChildren_001 Start";
453 try {
454 CloudDiskMetaFile mFile(100, "", "");
455 MetaBase mBase1("file1", "id1");
456 std::vector<MetaBase> bases;
457 bases.push_back(mBase1);
458 int32_t ret = mFile.LoadChildren(bases);
459 EXPECT_EQ(ret, E_EINVAL);
460 } catch (...) {
461 EXPECT_FALSE(false);
462 GTEST_LOG_(INFO) << "LoadChildren_001 ERROR";
463 }
464 GTEST_LOG_(INFO) << "LoadChildren_001 End";
465 }
466
467 HWTEST_F(CloudDiskDentryMetaFileTest, DoLookupAndUpdate_002, TestSize.Level1)
468 {
469 GTEST_LOG_(INFO) << "DoLookupAndUpdate_002 Start";
470 try {
471 string fileName = "";
472 string cloudId = "id1";
473 uint64_t size = 0x6b6b6b6b00000000;
474 MetaBase metaBase(fileName, cloudId);
475 metaBase.size = size;
__anonbe8cc26f0202(MetaBase &m) 476 auto callback = [&metaBase] (MetaBase &m) {
477 m.size = metaBase.size;
478 };
479
480 auto metaFile = MetaFileMgr::GetInstance().GetCloudDiskMetaFile(100, "/o/p/q/r/s/t", "id1");
481 int32_t ret = metaFile->DoLookupAndUpdate(fileName, callback);
482 EXPECT_EQ(ret, E_SUCCESS);
483 } catch (...) {
484 EXPECT_FALSE(false);
485 GTEST_LOG_(INFO) << "DoLookupAndUpdate_002 ERROR";
486 }
487 GTEST_LOG_(INFO) << "DoLookupAndUpdate_002 End";
488 }
489
490 HWTEST_F(CloudDiskDentryMetaFileTest, DoLookupAndUpdate_003, TestSize.Level1)
491 {
492 GTEST_LOG_(INFO) << "DoLookupAndUpdate_003 Start";
493 try {
494 uint64_t size = 0x6b6b6b6b000000ff;
495 CloudDiskMetaFile mFile(100, "", "");
496 MetaBase metaBase("file1", "id1");
497 metaBase.size = size;
__anonbe8cc26f0302(MetaBase &m) 498 auto callback = [&metaBase] (MetaBase &m) {
499 m.size = metaBase.size;
500 };
501
502 int32_t ret = mFile.DoUpdate(metaBase);
503 EXPECT_EQ(ret, E_EINVAL);
504 ret = mFile.DoLookupAndUpdate("file1", callback);
505 EXPECT_EQ(ret, E_EINVAL);
506 } catch (...) {
507 EXPECT_FALSE(false);
508 GTEST_LOG_(INFO) << "DoLookupAndUpdate_003 ERROR";
509 }
510 GTEST_LOG_(INFO) << "DoLookupAndUpdate_003 End";
511 }
512
513 HWTEST_F(CloudDiskDentryMetaFileTest, DoLookupAndUpdate_004, TestSize.Level1)
514 {
515 GTEST_LOG_(INFO) << "DoLookupAndUpdate_004 Start";
516 try {
517 uint64_t size = 0x6b6b6b6b0000006f;
518 CloudDiskMetaFile mFile(100, "/", "id1");
519 MetaBase metaBase("file1", "id1");
520 metaBase.size = size;
__anonbe8cc26f0402(MetaBase &m) 521 auto callback = [&metaBase] (MetaBase &m) {
522 m.size = metaBase.size;
523 };
524
525 int32_t ret = mFile.DoLookupAndUpdate("file1", callback);
526 EXPECT_EQ(ret, E_SUCCESS);
527 } catch (...) {
528 EXPECT_FALSE(false);
529 GTEST_LOG_(INFO) << "DoLookupAndUpdate_004 ERROR";
530 }
531 GTEST_LOG_(INFO) << "DoLookupAndUpdate_004 End";
532 }
533
534 HWTEST_F(CloudDiskDentryMetaFileTest, DoRename_001, TestSize.Level1)
535 {
536 GTEST_LOG_(INFO) << "DoRename_001 Start";
537 try {
538 CloudDiskMetaFile mFile(100, "", "");
539 MetaBase mBase1("file1", "id1");
540 std::shared_ptr<CloudDiskMetaFile> newMetaFile =
541 make_shared<CloudDiskMetaFile>(TEST_USER_ID, "/", "id1");
542
543 int ret = mFile.DoCreate(mBase1);
544 ret = mFile.DoRename(mBase1, "id2", newMetaFile);
545 EXPECT_EQ(ret, EINVAL);
546 MetaBase mBase2("id2");
547 ret = mFile.DoLookup(mBase2);
548 EXPECT_EQ(ret, E_EINVAL);
549 } catch (...) {
550 EXPECT_FALSE(false);
551 GTEST_LOG_(INFO) << "DoRename_001 ERROR";
552 }
553 GTEST_LOG_(INFO) << "DoRename_001 End";
554 }
555
556 HWTEST_F(CloudDiskDentryMetaFileTest, DoRename_002, TestSize.Level1)
557 {
558 GTEST_LOG_(INFO) << "DoRename_002 Start";
559 try {
560 CloudDiskMetaFile mFile(100, "", "");
561 MetaBase mBase1("file1", "id1");
562 std::shared_ptr<CloudDiskMetaFile> newMetaFile =
563 make_shared<CloudDiskMetaFile>(TEST_USER_ID, "", "");
564
565 int ret = mFile.DoCreate(mBase1);
566 ret = mFile.DoRename(mBase1, "id2", newMetaFile);
567 EXPECT_EQ(ret, E_EINVAL);
568 MetaBase mBase2("id2");
569 ret = mFile.DoLookup(mBase2);
570 EXPECT_EQ(ret, E_EINVAL);
571 } catch (...) {
572 EXPECT_FALSE(false);
573 GTEST_LOG_(INFO) << "DoRename_002 ERROR";
574 }
575 GTEST_LOG_(INFO) << "DoRename_002 End";
576 }
577
578 /**
579 * @tc.name: RemoveFromRecycleDentryfileTest001
580 * @tc.desc: Verify the DoLookupAndCreate
581 * @tc.type: FUNC
582 * @tc.require: SR000HRKJB
583 */
584 HWTEST_F(CloudDiskDentryMetaFileTest, DfsService_DoLookupAndCreate_001, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO) << "DfsService_DoLookupAndUpdate_001 Start";
587 try {
588 string fileName = "testLongLongfileName";
589 string cloudId = "testLongLongfileName";
590 uint64_t size = 0x6b6b6b6b00000000;
591 MetaBase metaBase(fileName, cloudId);
592 metaBase.size = size;
__anonbe8cc26f0502(MetaBase &m) 593 auto callback = [&metaBase] (MetaBase &m) {
594 m.size = metaBase.size;
595 };
596
597 auto metaFile = MetaFileMgr::GetInstance().GetCloudDiskMetaFile(TEST_USER_ID, "/o/p/q/r/s/t", "id1");
598 int32_t ret = metaFile->DoLookupAndCreate(fileName, callback);
599 EXPECT_EQ(ret, E_OK);
600 } catch (...) {
601 EXPECT_FALSE(false);
602 GTEST_LOG_(INFO) << "DfsService_DoLookupAndUpdate_001 ERROR";
603 }
604 GTEST_LOG_(INFO) << "DfsService_DoLookupAndUpdate_001 End";
605 }
606 } // namespace OHOS::FileManagement::CloudSync::Test