1 /*
2 * Copyright (c) 2023 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 "directory_ex.h"
21 #include "meta_file.h"
22
23 namespace OHOS::FileManagement::CloudSync::Test {
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace std;
27 constexpr uint32_t TEST_USER_ID = 201;
28 constexpr uint64_t TEST_ISIZE = 1024;
29 const string TEST_PATH = "/data/service/el2/100/hmdfs/cache/account_cache/dentry_cache/cloud/";
30
31 class DentryMetaFileTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37
38 public:
39 static inline shared_ptr<InterfaceLibMock> interfaceLibMock_ = nullptr;
40 };
41
SetUpTestCase(void)42 void DentryMetaFileTest::SetUpTestCase(void)
43 {
44 GTEST_LOG_(INFO) << "SetUpTestCase";
45 interfaceLibMock_ = make_shared<InterfaceLibMock>();
46 InterfaceLibMock::baseInterfaceLib_ = interfaceLibMock_;
47 }
48
TearDownTestCase(void)49 void DentryMetaFileTest::TearDownTestCase(void)
50 {
51 GTEST_LOG_(INFO) << "TearDownTestCase";
52 InterfaceLibMock::baseInterfaceLib_ = nullptr;
53 interfaceLibMock_ = nullptr;
54 }
55
SetUp(void)56 void DentryMetaFileTest::SetUp(void)
57 {
58 GTEST_LOG_(INFO) << "SetUp";
59 }
60
TearDown(void)61 void DentryMetaFileTest::TearDown(void)
62 {
63 GTEST_LOG_(INFO) << "TearDown";
64 }
65
66 /**
67 * @tc.name: MetaFileHandleFileByFd001
68 * @tc.desc: Verify the MetaFile::HandleFileByFd function
69 * @tc.type: FUNC
70 * @tc.require: SR000HRKKA
71 */
72 HWTEST_F(DentryMetaFileTest, MetaFileHandleFileByFd001, TestSize.Level1)
73 {
74 MetaFile mFile(TEST_USER_ID, "/");
75 unsigned long endBlock = 0;
76 uint32_t level = 0;
77 int ret = mFile.HandleFileByFd(endBlock, level);
78 EXPECT_EQ(ret, EINVAL);
79 }
80
81 /**
82 * @tc.name: MetaFileHandleFileByFd002
83 * @tc.desc: Verify the MetaFile::HandleFileByFd function
84 * @tc.type: FUNC
85 * @tc.require: SR000HRKKA
86 */
87 HWTEST_F(DentryMetaFileTest, MetaFileHandleFileByFd002, TestSize.Level1)
88 {
89 uint32_t userId = 100;
90 MetaFile mFile(userId, "/");
91 unsigned long endBlock = 0;
92 uint32_t level = 64;
93 int ret = mFile.HandleFileByFd(endBlock, level);
94 #if defined(CLOUD_ADAPTER_ENABLED)
95 EXPECT_EQ(ret, 0);
96 #else
97 EXPECT_EQ(ret, EINVAL);
98 #endif
99 }
100
101 /**
102 * @tc.name: MetaFileHandleFileByFd003
103 * @tc.desc: Verify the MetaFile::HandleFileByFd function
104 * @tc.type: FUNC
105 * @tc.require: SR000HRKKA
106 */
107 HWTEST_F(DentryMetaFileTest, MetaFileHandleFileByFd003, TestSize.Level1)
108 {
109 uint32_t userId = 100;
110 MetaFile mFile(userId, "/");
111 unsigned long endBlock = 0;
112 uint32_t level = 0;
113 int ret = mFile.HandleFileByFd(endBlock, level);
114 #if defined(CLOUD_ADAPTER_ENABLED)
115 EXPECT_EQ(ret, 0);
116 #else
117 EXPECT_EQ(ret, EINVAL);
118 #endif
119 }
120
121 /**
122 * @tc.name: MetaFileCreate001
123 * @tc.desc: Verify the MetaFile::DoCreate function
124 * @tc.type: FUNC
125 * @tc.require: SR000HRKKA
126 */
127 HWTEST_F(DentryMetaFileTest, MetaFileCreate001, TestSize.Level1)
128 {
129 uint32_t userId = 100;
130 std::string cacheDir =
131 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
132 ForceRemoveDirectory(cacheDir);
133
134 MetaFile mFile(userId, "/");
135 MetaBase mBase1("file1", "id1");
136 mBase1.size = TEST_ISIZE;
137 int ret = mFile.DoCreate(mBase1);
138 #if defined(CLOUD_ADAPTER_ENABLED)
139 EXPECT_EQ(ret, 0);
140 #else
141 EXPECT_EQ(ret, EINVAL);
142 #endif
143 MetaBase mBase2("file2", "id2");
144 mBase2.size = TEST_ISIZE;
145 ret = mFile.DoCreate(mBase2);
146 #if defined(CLOUD_ADAPTER_ENABLED)
147 EXPECT_EQ(ret, 0);
148 #else
149 EXPECT_EQ(ret, EINVAL);
150 #endif
151 MetaFile mFile2(userId, "/a/b");
152 MetaBase mBase3("file3", "id3");
153 ret = mFile2.DoCreate(mBase3);
154 }
155
156 /**
157 * @tc.name: MetaFileCreate002
158 * @tc.desc: Verify the MetaFile::DoCreate function
159 * @tc.type: FUNC
160 * @tc.require: SR000HRKKA
161 */
162 HWTEST_F(DentryMetaFileTest, MetaFileCreate002, TestSize.Level1)
163 {
164 MetaFile mFile(TEST_USER_ID, "/");
165 MetaBase mBase1("file1", "id1");
166 int ret = mFile.DoCreate(mBase1);
167 EXPECT_EQ(ret, EINVAL);
168 }
169
170 /**
171 * @tc.name: MetaFileLookup001
172 * @tc.desc: Verify the MetaFile::DoLookup function
173 * @tc.type: FUNC
174 * @tc.require: SR000HRKKA
175 */
176 HWTEST_F(DentryMetaFileTest, MetaFileLookup001, TestSize.Level1)
177 {
178 MetaFile mFile(TEST_USER_ID, "/");
179 MetaBase mBase1("file1");
180 int ret = mFile.DoLookup(mBase1);
181 EXPECT_EQ(ret, EINVAL);
182 }
183
184 /**
185 * @tc.name: MetaFileLookup002
186 * @tc.desc: Verify the MetaFile::DoLookup002 function
187 * @tc.type: FUNC
188 * @tc.require: SR000HRKKA
189 */
190 HWTEST_F(DentryMetaFileTest, MetaFileLookup, TestSize.Level1)
191 {
192 uint32_t userId = 100;
193 MetaFile mFile(userId, "/");
194 MetaBase mBase1("file1");
195 int ret = mFile.DoLookup(mBase1);
196 #if defined(CLOUD_ADAPTER_ENABLED)
197 EXPECT_EQ(ret, 0);
198 EXPECT_EQ(mBase1.size, TEST_ISIZE);
199 #else
200 EXPECT_EQ(ret, EINVAL);
201 #endif
202 }
203
204 /**
205 * @tc.name: MetaFileUpdate001
206 * @tc.desc: Verify the MetaFile::DoUpdate function
207 * @tc.type: FUNC
208 * @tc.require: SR000HRKKC
209 */
210 HWTEST_F(DentryMetaFileTest, MetaFileUpdate001, TestSize.Level1)
211 {
212 MetaFile mFile(TEST_USER_ID, "/");
213 MetaBase mBase1("file1", "id11");
214 int ret = mFile.DoUpdate(mBase1);
215 EXPECT_EQ(ret, EINVAL);
216 }
217
218 /**
219 * @tc.name: MetaFileUpdate
220 * @tc.desc: Verify the MetaFile::DoUpdate function
221 * @tc.type: FUNC
222 * @tc.require: SR000HRKKC
223 */
224 HWTEST_F(DentryMetaFileTest, MetaFileUpdate, TestSize.Level1)
225 {
226 uint32_t userId = 100;
227 MetaFile mFile(userId, "/");
228 MetaBase mBase1("file1", "id11");
229 mBase1.size = 0;
230 int ret = mFile.DoUpdate(mBase1);
231 #if defined(CLOUD_ADAPTER_ENABLED)
232 EXPECT_EQ(ret, 0);
233 #else
234 EXPECT_EQ(ret, EINVAL);
235 #endif
236 MetaBase mBase2("file1");
237 ret = mFile.DoLookup(mBase2);
238 #if defined(CLOUD_ADAPTER_ENABLED)
239 EXPECT_EQ(ret, 0);
240 #else
241 EXPECT_EQ(ret, EINVAL);
242 #endif
243 EXPECT_EQ(mBase2.size, 0);
244 }
245
246 /**
247 * @tc.name: MetaFileRename
248 * @tc.desc: Verify the MetaFile::DoRename function
249 * @tc.type: FUNC
250 * @tc.require: SR000HRKKC
251 */
252 HWTEST_F(DentryMetaFileTest, MetaFileRename, TestSize.Level1)
253 {
254 uint32_t userId = 100;
255 MetaFile mFile(userId, "/");
256 MetaBase mBase1("file2");
257 int ret = mFile.DoRename(mBase1, "file4");
258 #if defined(CLOUD_ADAPTER_ENABLED)
259 EXPECT_EQ(ret, 0);
260 #else
261 EXPECT_EQ(ret, EINVAL);
262 #endif
263 MetaBase mBase2("file4");
264 ret = mFile.DoLookup(mBase2);
265 #if defined(CLOUD_ADAPTER_ENABLED)
266 EXPECT_EQ(ret, 0);
267 EXPECT_EQ(mBase2.size, TEST_ISIZE);
268 #else
269 EXPECT_EQ(ret, EINVAL);
270 #endif
271 }
272
273 /**
274 * @tc.name: MetaFileRemove001
275 * @tc.desc: Verify the MetaFile::DoRemove function
276 * @tc.type: FUNC
277 * @tc.require: SR000HRKJB
278 */
279 HWTEST_F(DentryMetaFileTest, MetaFileRemove001, TestSize.Level1)
280 {
281 MetaFile mFile(TEST_USER_ID, "/");
282 MetaBase mBase1("file1");
283 int ret = mFile.DoRemove(mBase1);
284 EXPECT_EQ(ret, EINVAL);
285 }
286
287 /**
288 * @tc.name: LoadChildren001
289 * @tc.desc: Verify the LoadChildren
290 * @tc.type: FUNC
291 * @tc.require: issueI7SP3A
292 */
293 HWTEST_F(DentryMetaFileTest, LoadChildren001, TestSize.Level1)
294 {
295 GTEST_LOG_(INFO) << "LoadChildren001 Start";
296 try {
297 uint32_t userId = 100;
298 MetaFile mFile(userId, "/");
299 std::vector<MetaBase> bases;
300 int ret = mFile.LoadChildren(bases);
301 #if defined(CLOUD_ADAPTER_ENABLED)
302 EXPECT_EQ(ret, 0);
303 #else
304 EXPECT_EQ(ret, EINVAL);
305 #endif
306 } catch (...) {
307 EXPECT_FALSE(false);
308 GTEST_LOG_(INFO) << "LoadChildren001 ERROR";
309 }
310 GTEST_LOG_(INFO) << "LoadChildren001 End";
311 }
312
313 /**
314 * @tc.name: LoadChildren002
315 * @tc.desc: Verify the LoadChildren
316 * @tc.type: FUNC
317 * @tc.require: issueI7SP3A
318 */
319 HWTEST_F(DentryMetaFileTest, LoadChildren002, TestSize.Level1)
320 {
321 GTEST_LOG_(INFO) << "LoadChildren002 Start";
322 try {
323 MetaFile mFile(TEST_USER_ID, "/");
324 std::vector<MetaBase> bases;
325 int ret = mFile.LoadChildren(bases);
326 EXPECT_EQ(ret, EINVAL);
327 } catch (...) {
328 EXPECT_FALSE(false);
329 GTEST_LOG_(INFO) << "LoadChildren002 ERROR";
330 }
331 GTEST_LOG_(INFO) << "LoadChildren002 End";
332 }
333
334 /**
335 * @tc.name: MetaFileMgr001
336 * @tc.desc: Verify the MetaFileMgr
337 * @tc.type: FUNC
338 * @tc.require: SR000HRKJB
339 */
340 HWTEST_F(DentryMetaFileTest, MetaFileMgr001, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "MetaFileMgr001 Start";
343 try {
344 uint32_t userId = 100;
345 auto m = MetaFileMgr::GetInstance().GetMetaFile(userId, "/o/p/q/r/s/t");
346 MetaBase mBase1("file1", "file1");
347 #if defined(CLOUD_ADAPTER_ENABLED)
348 EXPECT_EQ(m->DoCreate(mBase1), 0);
349 #else
350 EXPECT_EQ(m->DoCreate(mBase1), EINVAL);
351 #endif
352 m = nullptr;
353 MetaFileMgr::GetInstance().ClearAll();
354 } catch (...) {
355 EXPECT_FALSE(false);
356 GTEST_LOG_(INFO) << " MetaFileMgr001 ERROR";
357 }
358 GTEST_LOG_(INFO) << "MetaFileMgr001 End";
359 }
360
361 /**
362 * @tc.name: MetaFileMgr002
363 * @tc.desc: Verify the MetaFileMgr
364 * @tc.type: FUNC
365 * @tc.require: issueI7SP3A
366 */
367 HWTEST_F(DentryMetaFileTest, MetaFileMgr002, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "MetaFileMgr002 Start";
370 try {
371 uint32_t userId = 100;
372 auto m = MetaFileMgr::GetInstance().GetMetaFile(userId, "/o/p/q/r/s/t");
373 MetaBase mBase1("testLongLongfileName", "testLongLongfileName");
374 #if defined(CLOUD_ADAPTER_ENABLED)
375 EXPECT_EQ(m->DoCreate(mBase1), 0);
376 #else
377 EXPECT_EQ(m->DoCreate(mBase1), EINVAL);
378 #endif
379 m = nullptr;
380 MetaFileMgr::GetInstance().ClearAll();
381 } catch (...) {
382 EXPECT_FALSE(false);
383 GTEST_LOG_(INFO) << " MetaFileMgr002 ERROR";
384 }
385 GTEST_LOG_(INFO) << "MetaFileMgr002 End";
386 }
387
388 /**
389 * @tc.name: MetaFileMgr003
390 * @tc.desc: Verify the MetaFileMgr
391 * @tc.type: FUNC
392 * @tc.require: issueIBLAKM
393 */
394 HWTEST_F(DentryMetaFileTest, MetaFileMgr003, TestSize.Level1)
395 {
396 GTEST_LOG_(INFO) << "MetaFileMgr003 Start";
397 try {
398 uint32_t userId = 100;
399 for (int i = 0; i < MAX_META_FILE_NUM; i++) {
400 auto m = MetaFileMgr::GetInstance().GetMetaFile(userId, to_string(i));
401 }
402 auto m = MetaFileMgr::GetInstance().GetMetaFile(userId, "/o/p/q/r/s/t");
403 auto checkSize = MetaFileMgr::GetInstance().CheckMetaFileSize();
404 m = nullptr;
405 MetaFileMgr::GetInstance().ClearAll();
406 EXPECT_EQ(checkSize, MAX_META_FILE_NUM);
407 } catch (...) {
408 EXPECT_FALSE(false);
409 GTEST_LOG_(INFO) << " MetaFileMgr003 ERROR";
410 }
411 GTEST_LOG_(INFO) << "MetaFileMgr003 End";
412 }
413
414 /**
415 * @tc.name:RecordIdToCloudId001
416 * @tc.desc: Verify the RecordIdToCloudId
417 * @tc.type: FUNC
418 * @tc.require: issueI7SP3A
419 */
420 HWTEST_F(DentryMetaFileTest, RecordIdToCloudId001, TestSize.Level1)
421 {
422 GTEST_LOG_(INFO) << "RecordIdToCloudId001 Start";
423 try {
424 std::string hexStr = "";
425 string ret = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr);
426 EXPECT_EQ(ret, "");
427 MetaFileMgr::GetInstance().ClearAll();
428 } catch (...) {
429 EXPECT_FALSE(false);
430 GTEST_LOG_(INFO) << "RecordIdToCloudId001 ERROR";
431 }
432 GTEST_LOG_(INFO) << "RecordIdToCloudId001 End";
433 }
434
435 /**
436 * @tc.name:RecordIdToCloudId002
437 * @tc.desc: Verify the RecordIdToCloudId
438 * @tc.type: FUNC
439 * @tc.require: issueI7SP3A
440 */
441 HWTEST_F(DentryMetaFileTest, RecordIdToCloudId002, TestSize.Level1)
442 {
443 GTEST_LOG_(INFO) << "RecordIdToCloudId002 Start";
444 try {
445 std::string hexStr = "test";
446 string ret = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr);
447 EXPECT_EQ(ret, "");
448 MetaFileMgr::GetInstance().ClearAll();
449 } catch (...) {
450 EXPECT_FALSE(false);
451 GTEST_LOG_(INFO) << "RecordIdToCloudId002 ERROR";
452 }
453 GTEST_LOG_(INFO) << "RecordIdToCloudId002 End";
454 }
455
456 /**
457 * @tc.name: CloudIdToRecordId001
458 * @tc.desc: Verify the CloudIdToRecordId
459 * @tc.type: FUNC
460 */
461 HWTEST_F(DentryMetaFileTest, CloudIdToRecordId001, TestSize.Level1)
462 {
463 GTEST_LOG_(INFO) << "CloudIdToRecordId001 Start";
464 try {
465 std::string hexStr = "123456789";
466 string cloudId = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr, true);
467 string reocrdId = MetaFileMgr::GetInstance().CloudIdToRecordId(cloudId, true);
468 EXPECT_EQ(reocrdId, hexStr);
469 MetaFileMgr::GetInstance().ClearAll();
470 } catch (...) {
471 EXPECT_FALSE(false);
472 GTEST_LOG_(INFO) << "CloudIdToRecordId001 ERROR";
473 }
474 GTEST_LOG_(INFO) << "CloudIdToRecordId001 End";
475 }
476
477 /**
478 * @tc.name:CloudIdToRecordId002
479 * @tc.desc: Verify the CloudIdToRecordId
480 * @tc.type: FUNC
481 */
482 HWTEST_F(DentryMetaFileTest, CloudIdToRecordId002, TestSize.Level1)
483 {
484 GTEST_LOG_(INFO) << "CloudIdToRecordId002 Start";
485 try {
486 std::string hexStr = "1234567890";
487 string cloudId = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr, true);
488 string reocrdId = MetaFileMgr::GetInstance().CloudIdToRecordId(cloudId, true);
489 EXPECT_EQ(reocrdId, hexStr);
490 MetaFileMgr::GetInstance().ClearAll();
491 } catch (...) {
492 EXPECT_FALSE(false);
493 GTEST_LOG_(INFO) << "CloudIdToRecordId002 ERROR";
494 }
495 GTEST_LOG_(INFO) << "CloudIdToRecordId002 End";
496 }
497
498 /**
499 * @tc.name:CloudIdToRecordId003
500 * @tc.desc: Verify the CloudIdToRecordId
501 * @tc.type: FUNC
502 */
503 HWTEST_F(DentryMetaFileTest, CloudIdToRecordId003, TestSize.Level1)
504 {
505 GTEST_LOG_(INFO) << "CloudIdToRecordId003 Start";
506 try {
507 std::string hexStr = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
508 string cloudId = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr);
509 string reocrdId = MetaFileMgr::GetInstance().CloudIdToRecordId(cloudId, true);
510 EXPECT_EQ(reocrdId, hexStr);
511 MetaFileMgr::GetInstance().ClearAll();
512 } catch (...) {
513 EXPECT_FALSE(false);
514 GTEST_LOG_(INFO) << "CloudIdToRecordId003 ERROR";
515 }
516 GTEST_LOG_(INFO) << "CloudIdToRecordId003 End";
517 }
518
519 /**
520 * @tc.name: GetParentDir001
521 * @tc.desc: Verify the GetParentDir
522 * @tc.type: FUNC
523 * @tc.require: issueI7SP3A
524 */
525 HWTEST_F(DentryMetaFileTest, GetParentDir001, TestSize.Level1)
526 {
527 GTEST_LOG_(INFO) << "GetParentDir001 Start";
528 try {
529 string str = MetaFile::GetParentDir("");
530 EXPECT_EQ(str, "");
531 str = MetaFile::GetParentDir("/");
532 EXPECT_EQ(str, "");
533 str = MetaFile::GetParentDir("abc");
534 EXPECT_EQ(str, "/");
535 str = MetaFile::GetParentDir("/abc");
536 EXPECT_EQ(str, "/");
537 str = MetaFile::GetParentDir("/abc/def");
538 EXPECT_EQ(str, "/abc");
539 } catch (...) {
540 EXPECT_FALSE(false);
541 GTEST_LOG_(INFO) << " GetParentDir001 ERROR";
542 }
543 GTEST_LOG_(INFO) << "GetParentDir001 End";
544 }
545
546 /**
547 * @tc.name: GetFileName001
548 * @tc.desc: Verify the GetFileName
549 * @tc.type: FUNC
550 * @tc.require: issueI7SP3A
551 */
552 HWTEST_F(DentryMetaFileTest, GetFileName001, TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "GetFileName001 Start";
555 try {
556 string str = MetaFile::GetFileName("");
557 EXPECT_EQ(str, "");
558 str = MetaFile::GetFileName("/");
559 EXPECT_EQ(str, "");
560 str = MetaFile::GetFileName("abc");
561 EXPECT_EQ(str, "");
562 str = MetaFile::GetFileName("/abc/def");
563 EXPECT_EQ(str, "def");
564 } catch (...) {
565 EXPECT_FALSE(false);
566 GTEST_LOG_(INFO) << " GetFileName001 ERROR";
567 }
568 GTEST_LOG_(INFO) << "GetFileName001 End";
569 }
570
571 HWTEST_F(DentryMetaFileTest, HandleFileByFd_001, TestSize.Level1)
572 {
573 GTEST_LOG_(INFO) << "HandleFileByFd_001 Start";
574 try {
575 uint32_t userId = 100;
576 MetaFile mFile(userId, "/");
577 unsigned long endBlock = 0;
578 uint32_t level = MAX_BUCKET_LEVEL;
579 int ret = mFile.HandleFileByFd(endBlock, level);
580 #if defined(CLOUD_ADAPTER_ENABLED)
581 EXPECT_EQ(ret, 0);
582 #else
583 EXPECT_EQ(ret, EINVAL);
584 #endif
585 } catch (...) {
586 EXPECT_FALSE(false);
587 GTEST_LOG_(INFO) << " HandleFileByFd_001 ERROR";
588 }
589 GTEST_LOG_(INFO) << "HandleFileByFd_001 End";
590 }
591
592 HWTEST_F(DentryMetaFileTest, HandleFileByFd_002, TestSize.Level1)
593 {
594 GTEST_LOG_(INFO) << "HandleFileByFd_002 Start";
595 try {
596 uint32_t userId = 100;
597 MetaFile mFile(userId, "/");
598 unsigned long endBlock = DENTRY_PER_GROUP;
599 uint32_t level = MAX_BUCKET_LEVEL;
600 int ret = mFile.HandleFileByFd(endBlock, level);
601 #if defined(CLOUD_ADAPTER_ENABLED)
602 EXPECT_EQ(ret, 0);
603 #else
604 EXPECT_EQ(ret, EINVAL);
605 #endif
606 } catch (...) {
607 EXPECT_FALSE(false);
608 GTEST_LOG_(INFO) << " HandleFileByFd_002 ERROR";
609 }
610 GTEST_LOG_(INFO) << "HandleFileByFd_002 End";
611 }
612
613 HWTEST_F(DentryMetaFileTest, HandleFileByFd_003, TestSize.Level1)
614 {
615 GTEST_LOG_(INFO) << "HandleFileByFd_003 Start";
616 try {
617 uint32_t userId = 100;
618 MetaFile mFile(userId, "/");
619 unsigned long endBlock = -100;
620 uint32_t level = MAX_BUCKET_LEVEL;
621 int ret = mFile.HandleFileByFd(endBlock, level);
622 #if defined(CLOUD_ADAPTER_ENABLED)
623 EXPECT_EQ(ret, 0);
624 #else
625 EXPECT_EQ(ret, EINVAL);
626 #endif
627 } catch (...) {
628 EXPECT_FALSE(false);
629 GTEST_LOG_(INFO) << " HandleFileByFd_003 ERROR";
630 }
631 GTEST_LOG_(INFO) << "HandleFileByFd_003 End";
632 }
633
634 HWTEST_F(DentryMetaFileTest, GetDentryfileName_001, TestSize.Level1)
635 {
636 GTEST_LOG_(INFO) << "GetDentryfileName_001 Start";
637 try {
638 uint32_t userId = 100;
639 EXPECT_CALL(*interfaceLibMock_, GetDentryfileName(_, _)).WillOnce(Return("/"));
640 MetaFile mFile(userId, "/");
641
642 string path = "/test/";
643 bool caseSense = true;
644 EXPECT_TRUE(true);
645 EXPECT_EQ(interfaceLibMock_->GetDentryfileName(path, caseSense), "/");
646 } catch (...) {
647 EXPECT_FALSE(false);
648 GTEST_LOG_(INFO) << " GetDentryfileName_001 ERROR";
649 }
650 GTEST_LOG_(INFO) << "GetDentryfileName_001 End";
651 }
652
653 HWTEST_F(DentryMetaFileTest, GetOverallBucket_001, TestSize.Level1)
654 {
655 GTEST_LOG_(INFO) << "GetOverallBucket_001 Start";
656 try {
657 uint32_t userId = 100;
658 MetaFile mFile(userId, "/");
659 unsigned long endBlock = -100;
660 uint32_t level = MAX_BUCKET_LEVEL;
661
662 EXPECT_CALL(*interfaceLibMock_, GetOverallBucket(_)).WillOnce(Return(E_SUCCESS));
663 int ret = mFile.HandleFileByFd(endBlock, level);
664 #if defined(CLOUD_ADAPTER_ENABLED)
665 EXPECT_EQ(ret, 0);
666 #else
667 EXPECT_EQ(ret, EINVAL);
668 #endif
669 EXPECT_EQ(interfaceLibMock_->GetOverallBucket(MAX_BUCKET_LEVEL), E_SUCCESS);
670 } catch (...) {
671 EXPECT_FALSE(false);
672 GTEST_LOG_(INFO) << " GetOverallBucket_001 ERROR";
673 }
674 GTEST_LOG_(INFO) << "GetOverallBucket_001 End";
675 }
676
677 HWTEST_F(DentryMetaFileTest, GetBucketaddr_001, TestSize.Level1)
678 {
679 GTEST_LOG_(INFO) << "GetBucketaddr_001 Start";
680 try {
681 EXPECT_CALL(*interfaceLibMock_, GetBucketaddr(_, _)).WillOnce(Return(E_SUCCESS));
682 uint32_t userId = 100;
683 std::string cacheDir =
684 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
685 ForceRemoveDirectory(cacheDir);
686
687 MetaFile mFile(userId, "/");
688 MetaBase mBase1("file1", "id1");
689 mBase1.size = TEST_ISIZE;
690 int ret = mFile.DoCreate(mBase1);
691 #if defined(CLOUD_ADAPTER_ENABLED)
692 EXPECT_EQ(ret, E_SUCCESS);
693 #else
694 EXPECT_EQ(ret, EINVAL);
695 #endif
696 EXPECT_EQ(interfaceLibMock_->GetBucketaddr(MAX_BUCKET_LEVEL, MAX_BUCKET_LEVEL), E_SUCCESS);
697 } catch (...) {
698 EXPECT_FALSE(false);
699 GTEST_LOG_(INFO) << " GetBucketaddr_001 ERROR";
700 }
701 GTEST_LOG_(INFO) << "GetBucketaddr_001 End";
702 }
703
704 HWTEST_F(DentryMetaFileTest, GetBucketaddr_002, TestSize.Level1)
705 {
706 GTEST_LOG_(INFO) << "GetBucketaddr_002 Start";
707 try {
708 EXPECT_CALL(*interfaceLibMock_, GetBucketaddr(Eq(E_SUCCESS), _)).WillOnce(Return(E_FAIL));
709 uint32_t userId = 100;
710 std::string cacheDir =
711 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
712 ForceRemoveDirectory(cacheDir);
713
714 MetaFile mFile(userId, "/");
715 MetaBase mBase1("file1", "id1");
716 mBase1.size = TEST_ISIZE;
717 int ret = mFile.DoCreate(mBase1);
718 #if defined(CLOUD_ADAPTER_ENABLED)
719 EXPECT_EQ(ret, E_SUCCESS);
720 #else
721 EXPECT_EQ(ret, EINVAL);
722 #endif
723 EXPECT_EQ(interfaceLibMock_->GetBucketaddr(E_SUCCESS, MAX_BUCKET_LEVEL), E_FAIL);
724 } catch (...) {
725 EXPECT_FALSE(false);
726 GTEST_LOG_(INFO) << " GetBucketaddr_002 ERROR";
727 }
728 GTEST_LOG_(INFO) << "GetBucketaddr_002 End";
729 }
730
731 HWTEST_F(DentryMetaFileTest, GetBucketByLevel_001, TestSize.Level1)
732 {
733 GTEST_LOG_(INFO) << "GetBucketByLevel_001 Start";
734 try {
735 EXPECT_CALL(*interfaceLibMock_, GetBucketByLevel(_)).WillOnce(Return(E_SUCCESS));
736 uint32_t userId = 100;
737 std::string cacheDir =
738 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
739 ForceRemoveDirectory(cacheDir);
740
741 MetaFile mFile(userId, "/");
742 MetaBase mBase1("file1", "id1");
743 mBase1.size = TEST_ISIZE;
744 int ret = mFile.DoCreate(mBase1);
745 #if defined(CLOUD_ADAPTER_ENABLED)
746 EXPECT_EQ(ret, E_SUCCESS);
747 #else
748 EXPECT_EQ(ret, EINVAL);
749 #endif
750 EXPECT_EQ(interfaceLibMock_->GetBucketByLevel(E_SUCCESS), E_SUCCESS);
751 } catch (...) {
752 EXPECT_FALSE(false);
753 GTEST_LOG_(INFO) << " GetBucketByLevel_001 ERROR";
754 }
755 GTEST_LOG_(INFO) << "GetBucketByLevel_001 End";
756 }
757
758 HWTEST_F(DentryMetaFileTest, RoomForFilename_001, TestSize.Level1)
759 {
760 GTEST_LOG_(INFO) << "RoomForFilename_001 Start";
761 try {
762 EXPECT_CALL(*interfaceLibMock_, FindNextZeroBit(_, _, _)).WillOnce(Return(DENTRY_PER_GROUP));
763 uint32_t userId = 100;
764 std::string cacheDir =
765 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
766 ForceRemoveDirectory(cacheDir);
767
768 MetaFile mFile(userId, "/");
769 MetaBase mBase1("file1", "id1");
770 mBase1.size = TEST_ISIZE;
771 int ret = mFile.DoCreate(mBase1);
772 uint8_t addr[] = {0};
773 uint32_t maxSlots = DENTRY_PER_GROUP;
774 uint32_t start = DENTRY_PER_GROUP;
775 EXPECT_EQ(interfaceLibMock_->FindNextZeroBit(addr, maxSlots, start), DENTRY_PER_GROUP);
776 #if defined(CLOUD_ADAPTER_ENABLED)
777 EXPECT_EQ(ret, E_SUCCESS);
778 #else
779 EXPECT_EQ(ret, EINVAL);
780 #endif
781 } catch (...) {
782 EXPECT_FALSE(false);
783 GTEST_LOG_(INFO) << " RoomForFilename_001 ERROR";
784 }
785 GTEST_LOG_(INFO) << "RoomForFilename_001 End";
786 }
787
788 HWTEST_F(DentryMetaFileTest, RoomForFilename_002, TestSize.Level1)
789 {
790 GTEST_LOG_(INFO) << "RoomForFilename_002 Start";
791 try {
792 EXPECT_CALL(*interfaceLibMock_, FindNextZeroBit(_, _, _)).WillOnce(Return(DENTRY_PER_GROUP));
793 EXPECT_CALL(*interfaceLibMock_, FindNextBit(_, _, _)).WillOnce(Return(MAX_BUCKET_LEVEL));
794 uint32_t userId = 100;
795 std::string cacheDir =
796 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
797 ForceRemoveDirectory(cacheDir);
798
799 MetaFile mFile(userId, "/");
800 MetaBase mBase1("file1", "id1");
801 mBase1.size = TEST_ISIZE;
802 int ret = mFile.DoCreate(mBase1);
803 uint8_t addr[] = {0};
804 uint32_t maxSlots = DENTRY_PER_GROUP;
805 uint32_t start = DENTRY_PER_GROUP;
806 #if defined(CLOUD_ADAPTER_ENABLED)
807 EXPECT_EQ(ret, E_SUCCESS);
808 #else
809 EXPECT_EQ(ret, EINVAL);
810 #endif
811 EXPECT_EQ(interfaceLibMock_->FindNextZeroBit(addr, maxSlots, start), DENTRY_PER_GROUP);
812 EXPECT_EQ(interfaceLibMock_->FindNextBit(addr, maxSlots, start), MAX_BUCKET_LEVEL);
813 } catch (...) {
814 EXPECT_FALSE(false);
815 GTEST_LOG_(INFO) << " RoomForFilename_002 ERROR";
816 }
817 GTEST_LOG_(INFO) << "RoomForFilename_002 End";
818 }
819 } // namespace OHOS::FileManagement::CloudSync::Test