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