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 "fuse_operations.h"
20 #include "cloud_disk_inode.h"
21 #include "cloud_file_utils.h"
22 #include "file_operations_helper.h"
23 #include "file_operations_base.h"
24 #include "file_operations_cloud.h"
25 #include "parameters.h"
26 #include "utils_log.h"
27 #include "assistant.h"
28
29 namespace OHOS::FileManagement::CloudDisk::Test {
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace std;
33
34 class FuseOperationsHelperTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 static inline shared_ptr<FileOperationsHelper> fuseoperationshelper_ = nullptr;
41 static inline shared_ptr<AssistantMock> insMock = nullptr;
42 };
43
SetUpTestCase(void)44 void FuseOperationsHelperTest::SetUpTestCase(void)
45 {
46 GTEST_LOG_(INFO) << "SetUpTestCase";
47 fuseoperationshelper_ = make_shared<FileOperationsHelper>();
48 insMock = make_shared<AssistantMock>();
49 Assistant::ins = insMock;
50 }
51
TearDownTestCase(void)52 void FuseOperationsHelperTest::TearDownTestCase(void)
53 {
54 GTEST_LOG_(INFO) << "TearDownTestCase";
55 fuseoperationshelper_ = nullptr;
56 Assistant::ins = nullptr;
57 insMock = nullptr;
58 }
59
SetUp(void)60 void FuseOperationsHelperTest::SetUp(void)
61 {
62 GTEST_LOG_(INFO) << "SetUp";
63 }
64
TearDown(void)65 void FuseOperationsHelperTest::TearDown(void)
66 {
67 GTEST_LOG_(INFO) << "TearDown";
68 }
69
70 /**
71 * @tc.name: AddDirEntryTest001
72 * @tc.desc: Verify the AddDirEntry function
73 * @tc.type: FUNC
74 * @tc.require: issuesIB4SSZ
75 */
76 HWTEST_F(FuseOperationsHelperTest, AddDirEntryPathTest001, TestSize.Level1)
77 {
78 GTEST_LOG_(INFO) << "AddDirEntryTest001 start";
79 try {
80 fuse_req_t req = nullptr;
81 std::string buffer = "";
82 size_t size = 0;
83 const char *name = "testAddDir";
84 auto ino = std::make_shared<CloudDiskInode>();
85 fuseoperationshelper_->AddDirEntry(req, buffer, size, name, ino);
86 EXPECT_GT(size, 0);
87 EXPECT_EQ(buffer.size(), size);
88 } catch (...) {
89 EXPECT_TRUE(false);
90 GTEST_LOG_(INFO) << "AddDirEntryTest001 failed";
91 }
92 GTEST_LOG_(INFO) << "AddDirEntryTest001 end";
93 }
94
95 /**
96 * @tc.name: GetCloudDiskLocalPathTest001
97 * @tc.desc: Verify the GetCloudDiskLocalPath function
98 * @tc.type: FUNC
99 * @tc.require: issuesI92WQP
100 */
101 HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest001, TestSize.Level1)
102 {
103 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest001 Start";
104 try {
105 int32_t userId = 100;
106 string fileName = "data";
107
108 string ret = fuseoperationshelper_->GetCloudDiskLocalPath(userId, fileName);
109 EXPECT_EQ(ret, "/data/service/el2/100/hmdfs/cloud/data/");
110 EXPECT_TRUE(true);
111 } catch (...) {
112 EXPECT_TRUE(false);
113 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest001 ERROR";
114 }
115 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest001 End";
116 }
117
118 /**
119 * @tc.name: GetCloudDiskLocalPathTest002
120 * @tc.desc: Verify the GetCloudDiskLocalPath function
121 * @tc.type: FUNC
122 * @tc.require: issuesI92WQP
123 */
124 HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest002, TestSize.Level1)
125 {
126 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest002 Start";
127 try {
128 int32_t userId = 100;
129 string fileName = "/";
130
131 string ret = fuseoperationshelper_->GetCloudDiskLocalPath(userId, fileName);
132 EXPECT_EQ(ret, "/data/service/el2/100/hmdfs/cloud/");
133 EXPECT_TRUE(true);
134 } catch (...) {
135 EXPECT_TRUE(false);
136 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest002 ERROR";
137 }
138 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest002 End";
139 }
140
141 /**
142 * @tc.name: GetCloudDiskLocalPathTest003
143 * @tc.desc: Verify the GetCloudDiskLocalPath function
144 * @tc.type: FUNC
145 * @tc.require: issuesI92WQP
146 */
147 HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest003, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest003 Start";
150 try {
151 int32_t userId = 100;
152 string fileName = "test";
153
154 string ret = fuseoperationshelper_->GetCloudDiskLocalPath(userId, fileName);
155 EXPECT_EQ(ret, "/data/service/el2/100/hmdfs/cloud/data/test");
156 EXPECT_TRUE(true);
157 } catch (...) {
158 EXPECT_TRUE(false);
159 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest003 ERROR";
160 }
161 GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest003 End";
162 }
163
164 /**
165 * @tc.name: GetInodeAttrTest001
166 * @tc.desc: Verify the GetInodeAttr function
167 * @tc.type: FUNC
168 * @tc.require: issuesI92WQP
169 */
170 HWTEST_F(FuseOperationsHelperTest, GetInodeAttrTest001, TestSize.Level1)
171 {
172 GTEST_LOG_(INFO) << "GetInodeAttrTest001 Start";
173 try {
174 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
175 struct stat statBuf;
176 inoPtr->stat.st_mode |= S_IFREG;
177
178 fuseoperationshelper_->GetInodeAttr(inoPtr, &statBuf);
179 EXPECT_TRUE(true);
180 } catch (...) {
181 EXPECT_TRUE(false);
182 GTEST_LOG_(INFO) << "GetInodeAttrTest001 ERROR";
183 }
184 GTEST_LOG_(INFO) << "GetInodeAttrTest001 End";
185 }
186
187 /**
188 * @tc.name: GetInodeAttrTest002
189 * @tc.desc: Verify the GetInodeAttr function
190 * @tc.type: FUNC
191 * @tc.require: issuesI92WQP
192 */
193 HWTEST_F(FuseOperationsHelperTest, GetInodeAttrTest002, TestSize.Level1)
194 {
195 GTEST_LOG_(INFO) << "GetInodeAttrTest002 Start";
196 try {
197 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
198 struct stat statBuf;
199 inoPtr->stat.st_mode |= S_IFMT;
200
201 fuseoperationshelper_->GetInodeAttr(inoPtr, &statBuf);
202 EXPECT_TRUE(true);
203 } catch (...) {
204 EXPECT_TRUE(false);
205 GTEST_LOG_(INFO) << "GetInodeAttrTest002 ERROR";
206 }
207 GTEST_LOG_(INFO) << "GetInodeAttrTest002 End";
208 }
209
210 /**
211 * @tc.name: GetNextLayerTest001
212 * @tc.desc: Verify the GetNextLayer function
213 * @tc.type: FUNC
214 * @tc.require: issuesI92WQP
215 */
216 HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest001, TestSize.Level1)
217 {
218 GTEST_LOG_(INFO) << "GetNextLayerTest001 Start";
219 try {
220 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
221 fuse_ino_t ino = FUSE_ROOT_ID;
222
223 int ret = fuseoperationshelper_->GetNextLayer(inoPtr, ino);
224 EXPECT_EQ(ret, CLOUD_DISK_INODE_ZERO_LAYER);
225 EXPECT_TRUE(true);
226 } catch (...) {
227 EXPECT_TRUE(false);
228 GTEST_LOG_(INFO) << "GetNextLayerTest001 ERROR";
229 }
230 GTEST_LOG_(INFO) << "GetNextLayerTest001 End";
231 }
232
233 /**
234 * @tc.name: GetNextLayerTest002
235 * @tc.desc: Verify the GetNextLayer function
236 * @tc.type: FUNC
237 * @tc.require: issuesI92WQP
238 */
239 HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest002, TestSize.Level1)
240 {
241 GTEST_LOG_(INFO) << "GetNextLayerTest002 Start";
242 try {
243 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
244 inoPtr->layer = CLOUD_DISK_INODE_OTHER_LAYER;
245 fuse_ino_t ino = 0;
246
247 int ret = fuseoperationshelper_->GetNextLayer(inoPtr, ino);
248 EXPECT_EQ(ret, CLOUD_DISK_INODE_OTHER_LAYER);
249 EXPECT_TRUE(true);
250 } catch (...) {
251 EXPECT_TRUE(false);
252 GTEST_LOG_(INFO) << "GetNextLayerTest002 ERROR";
253 }
254 GTEST_LOG_(INFO) << "GetNextLayerTest002 End";
255 }
256
257 /**
258 * @tc.name: GetNextLayerTest003
259 * @tc.desc: Verify the GetNextLayer function
260 * @tc.type: FUNC
261 * @tc.require: issuesI92WQP
262 */
263 HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest003, TestSize.Level1)
264 {
265 GTEST_LOG_(INFO) << "GetNextLayerTest003 Start";
266 try {
267 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
268 inoPtr->layer = CLOUD_DISK_INODE_FIRST_LAYER;
269 fuse_ino_t ino = 0;
270
271 int ret = fuseoperationshelper_->GetNextLayer(inoPtr, ino);
272 EXPECT_EQ(ret, CLOUD_DISK_INODE_OTHER_LAYER);
273 EXPECT_TRUE(true);
274 } catch (...) {
275 EXPECT_TRUE(false);
276 GTEST_LOG_(INFO) << "GetNextLayerTest003 ERROR";
277 }
278 GTEST_LOG_(INFO) << "GetNextLayerTest003 End";
279 }
280
281 /**
282 * @tc.name: GetFixedLayerRootIdTest001
283 * @tc.desc: Verify the GetFixedLayerRootId function
284 * @tc.type: FUNC
285 * @tc.require: issuesI92WQP
286 */
287 HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest001, TestSize.Level1)
288 {
289 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest001 Start";
290 try {
291 int32_t layer = CLOUD_DISK_INODE_ZERO_LAYER;
292
293 int ret = fuseoperationshelper_->GetFixedLayerRootId(layer);
294 EXPECT_EQ(ret, CLOUD_DISK_INODE_ZERO_LAYER_LOCALID);
295 EXPECT_TRUE(true);
296 } catch (...) {
297 EXPECT_TRUE(false);
298 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest001 ERROR";
299 }
300 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest001 End";
301 }
302
303 /**
304 * @tc.name: GetFixedLayerRootIdTest002
305 * @tc.desc: Verify the GetFixedLayerRootId function
306 * @tc.type: FUNC
307 * @tc.require: issuesI92WQP
308 */
309 HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest002, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest002 Start";
312 try {
313 int32_t layer = CLOUD_DISK_INODE_FIRST_LAYER;
314
315 int ret = fuseoperationshelper_->GetFixedLayerRootId(layer);
316 EXPECT_EQ(ret, CLOUD_DISK_INODE_FIRST_LAYER_LOCALID);
317 EXPECT_TRUE(true);
318 } catch (...) {
319 EXPECT_TRUE(false);
320 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest002 ERROR";
321 }
322 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest002 End";
323 }
324
325 /**
326 * @tc.name: GetFixedLayerRootIdTest003
327 * @tc.desc: Verify the GetFixedLayerRootId function
328 * @tc.type: FUNC
329 * @tc.require: issuesI92WQP
330 */
331 HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest003, TestSize.Level1)
332 {
333 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest003 Start";
334 try {
335 int32_t layer = CLOUD_DISK_INODE_OTHER_LAYER;
336
337 int ret = fuseoperationshelper_->GetFixedLayerRootId(layer);
338 EXPECT_EQ(ret, CLOUD_DISK_INODE_LAYER_LOCALID_UNKNOWN);
339 EXPECT_TRUE(true);
340 } catch (...) {
341 EXPECT_TRUE(false);
342 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest003 ERROR";
343 }
344 GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest003 End";
345 }
346
347 /**
348 * @tc.name: FindCloudDiskInodeTest001
349 * @tc.desc: Verify the FindCloudDiskInode function
350 * @tc.type: FUNC
351 * @tc.require: issuesI92WQP
352 */
353 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskInodeTest001, TestSize.Level1)
354 {
355 GTEST_LOG_(INFO) << "FindCloudDiskInodeTest001 Start";
356 try {
357 struct CloudDiskFuseData *data = new CloudDiskFuseData;
358 std::shared_ptr<CloudDiskInode> inode = std::make_shared<CloudDiskInode>();
359 data->inodeCache.insert(std::make_pair(1, inode));
360 int64_t key = 1;
361
362 fuseoperationshelper_->FindCloudDiskInode(data, key);
363 delete data;
364 EXPECT_TRUE(true);
365 } catch (...) {
366 EXPECT_TRUE(false);
367 GTEST_LOG_(INFO) << "FindCloudDiskInodeTest001 ERROR";
368 }
369 GTEST_LOG_(INFO) << "FindCloudDiskInodeTest001 End";
370 }
371
372 /**
373 * @tc.name: FindCloudDiskInodeTest002
374 * @tc.desc: Verify the FindCloudDiskInode function
375 * @tc.type: FUNC
376 * @tc.require: issuesI92WQP
377 */
378 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskInodeTest002, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "FindCloudDiskInodeTest002 Start";
381 try {
382 struct CloudDiskFuseData *data = new CloudDiskFuseData;
383 int64_t key = 0;
384
385 fuseoperationshelper_->FindCloudDiskInode(data, key);
386 delete data;
387 EXPECT_TRUE(true);
388 } catch (...) {
389 EXPECT_TRUE(false);
390 GTEST_LOG_(INFO) << "FindCloudDiskInodeTest002 ERROR";
391 }
392 GTEST_LOG_(INFO) << "FindCloudDiskInodeTest002 End";
393 }
394
395 /**
396 * @tc.name: FindCloudDiskFileTest001
397 * @tc.desc: Verify the FindCloudDiskFile function
398 * @tc.type: FUNC
399 * @tc.require: issuesI92WQP
400 */
401 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskFileTest001, TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "FindCloudDiskFileTest001 Start";
404 try {
405 struct CloudDiskFuseData *data = new CloudDiskFuseData;
406 std::shared_ptr<CloudDiskFile> file = std::make_shared<CloudDiskFile>();
407 data->fileCache.insert(std::make_pair(1, file));
408 int64_t key = 1;
409
410 fuseoperationshelper_->FindCloudDiskFile(data, key);
411 delete data;
412 EXPECT_TRUE(true);
413 } catch (...) {
414 EXPECT_TRUE(false);
415 GTEST_LOG_(INFO) << "FindCloudDiskFileTest001 ERROR";
416 }
417 GTEST_LOG_(INFO) << "FindCloudDiskFileTest001 End";
418 }
419
420 /**
421 * @tc.name: FindCloudDiskFileTest002
422 * @tc.desc: Verify the FindCloudDiskFile function
423 * @tc.type: FUNC
424 * @tc.require: issuesI92WQP
425 */
426 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskFileTest002, TestSize.Level1)
427 {
428 GTEST_LOG_(INFO) << "FindCloudDiskFileTest002 Start";
429 try {
430 struct CloudDiskFuseData *data = new CloudDiskFuseData;
431 int64_t key = 0;
432
433 fuseoperationshelper_->FindCloudDiskFile(data, key);
434 delete data;
435 EXPECT_TRUE(true);
436 } catch (...) {
437 EXPECT_TRUE(false);
438 GTEST_LOG_(INFO) << "FindCloudDiskFileTest002 ERROR";
439 }
440 GTEST_LOG_(INFO) << "FindCloudDiskFileTest002 End";
441 }
442
443 /**
444 * @tc.name: FindLocalIdTest001
445 * @tc.desc: Verify the FindLocalId function
446 * @tc.type: FUNC
447 * @tc.require: issuesI92WQP
448 */
449 HWTEST_F(FuseOperationsHelperTest, FindLocalIdTest001, TestSize.Level1)
450 {
451 GTEST_LOG_(INFO) << "FindLocalIdTest001 Start";
452 try {
453 struct CloudDiskFuseData *data = new CloudDiskFuseData;
454 data->localIdCache.insert(std::make_pair("test", 1));
455 string key = "test";
456
457 int ret = fuseoperationshelper_->FindLocalId(data, key);
458 delete data;
459 EXPECT_EQ(ret, 1);
460 EXPECT_TRUE(true);
461 } catch (...) {
462 EXPECT_TRUE(false);
463 GTEST_LOG_(INFO) << "FindLocalIdTest001 ERROR";
464 }
465 GTEST_LOG_(INFO) << "FindLocalIdTest001 End";
466 }
467
468 /**
469 * @tc.name: FindLocalIdTest002
470 * @tc.desc: Verify the FindLocalId function
471 * @tc.type: FUNC
472 * @tc.require: issuesI92WQP
473 */
474 HWTEST_F(FuseOperationsHelperTest, FindLocalIdTest002, TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "FindLocalIdTest002 Start";
477 try {
478 struct CloudDiskFuseData *data = new CloudDiskFuseData;
479 string key = "";
480
481 int ret = fuseoperationshelper_->FindLocalId(data, key);
482 delete data;
483 EXPECT_EQ(ret, -1);
484 EXPECT_TRUE(true);
485 } catch (...) {
486 EXPECT_TRUE(false);
487 GTEST_LOG_(INFO) << "FindLocalIdTest002 ERROR";
488 }
489 GTEST_LOG_(INFO) << "FindLocalIdTest002 End";
490 }
491
492 /**
493 * @tc.name: FuseReplyLimitedTest001
494 * @tc.desc: Verify the FuseReplyLimited function
495 * @tc.type: FUNC
496 * @tc.require: issuesI92WQP
497 */
498 HWTEST_F(FuseOperationsHelperTest, FuseReplyLimitedTest001, TestSize.Level1)
499 {
500 GTEST_LOG_(INFO) << "FuseReplyLimitedTest001 Start";
501 try {
502 fuse_req_t req = nullptr;
503 const char *buf;
504 size_t bufSize = 1024;
505 off_t off = 0;
506 size_t maxSize = 1024 * 4 * 4;
507 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(0));
508
509 fuseoperationshelper_->FuseReplyLimited(req, buf, bufSize, off, maxSize);
510 EXPECT_TRUE(true);
511 } catch (...) {
512 EXPECT_TRUE(false);
513 GTEST_LOG_(INFO) << "FuseReplyLimitedTest001 ERROR";
514 }
515 GTEST_LOG_(INFO) << "FuseReplyLimitedTest001 End";
516 }
517
518 /**
519 * @tc.name: FuseReplyLimitedTest002
520 * @tc.desc: Verify the FuseReplyLimited function
521 * @tc.type: FUNC
522 * @tc.require: issuesI92WQP
523 */
524 HWTEST_F(FuseOperationsHelperTest, FuseReplyLimitedTest002, TestSize.Level1)
525 {
526 GTEST_LOG_(INFO) << "FuseReplyLimitedTest002 Start";
527 try {
528 fuse_req_t req = nullptr;
529 const char *buf;
530 size_t bufSize = 1024;
531 off_t off = 1024 * 4;
532 size_t maxSize = 1024 * 4 * 4;
533 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(0));
534
535 fuseoperationshelper_->FuseReplyLimited(req, buf, bufSize, off, maxSize);
536 EXPECT_TRUE(true);
537 } catch (...) {
538 EXPECT_TRUE(false);
539 GTEST_LOG_(INFO) << "FuseReplyLimitedTest002 ERROR";
540 }
541 GTEST_LOG_(INFO) << "FuseReplyLimitedTest002 End";
542 }
543
544 /**
545 * @tc.name: GenerateCloudDiskInodeTest001
546 * @tc.desc: Verify the FuseReplyLimited function
547 * @tc.type: FUNC
548 * @tc.require: issuesI92WQP
549 */
550 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest001, TestSize.Level1)
551 {
552 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest001 Start";
553 try {
554 struct CloudDiskFuseData *data = new CloudDiskFuseData;
555 fuse_ino_t parent = 0;
556 string fileName = "";
557 string path = "";
558
559 fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
560 delete data;
561 EXPECT_TRUE(true);
562 } catch (...) {
563 EXPECT_TRUE(false);
564 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest001 ERROR";
565 }
566 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest001 End";
567 }
568
569 /**
570 * @tc.name: GenerateCloudDiskInodeTest002
571 * @tc.desc: Verify the FuseReplyLimited function
572 * @tc.type: FUNC
573 * @tc.require: issuesI92WQP
574 */
575 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest002, TestSize.Level1)
576 {
577 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest002 Start";
578 try {
579 struct CloudDiskFuseData *data = new CloudDiskFuseData;
580 fuse_ino_t parent = 0;
581 string fileName = "";
582 string path = "/data";
583
584 fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
585 delete data;
586 EXPECT_TRUE(true);
587 } catch (...) {
588 EXPECT_TRUE(false);
589 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest002 ERROR";
590 }
591 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest002 End";
592 }
593
594 /**
595 * @tc.name: GenerateCloudDiskInodeTest003
596 * @tc.desc: Verify the FuseReplyLimited function
597 * @tc.type: FUNC
598 * @tc.require: issuesI92WQP
599 */
600 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest003, TestSize.Level1)
601 {
602 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest003 Start";
603 try {
604 struct CloudDiskFuseData *data = new CloudDiskFuseData;
605 std::shared_ptr<CloudDiskInode> inode = std::make_shared<CloudDiskInode>();
606 data->inodeCache.insert(std::make_pair(1, inode));
607 fuse_ino_t parent = 1;
608 string fileName = "";
609 string path = "/data";
610
611 fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
612 delete data;
613 EXPECT_TRUE(true);
614 } catch (...) {
615 EXPECT_TRUE(false);
616 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest003 ERROR";
617 }
618 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest003 End";
619 }
620
621 /**
622 * @tc.name: GenerateCloudDiskInodeTest004
623 * @tc.desc: Verify the FuseReplyLimited function
624 * @tc.type: FUNC
625 * @tc.require: issuesI92WQP
626 */
627 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest004, TestSize.Level1)
628 {
629 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest004 Start";
630 try {
631 struct CloudDiskFuseData *data = new CloudDiskFuseData;
632 std::shared_ptr<CloudDiskInode> inode = std::make_shared<CloudDiskInode>();
633 data->inodeCache.insert(std::make_pair(0, inode));
634 fuse_ino_t parent = 0;
635 string fileName = "";
636 string path = "/data";
637
638 fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
639 delete data;
640 EXPECT_TRUE(true);
641 } catch (...) {
642 EXPECT_TRUE(false);
643 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest004 ERROR";
644 }
645 GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest004 End";
646 }
647
648 /**
649 * @tc.name: PutCloudDiskInodeTest001
650 * @tc.desc: Verify the PutCloudDiskInode function
651 * @tc.type: FUNC
652 * @tc.require: issuesI92WQP
653 */
654 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest001, TestSize.Level1)
655 {
656 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest001 Start";
657 try {
658 struct CloudDiskFuseData *data = new CloudDiskFuseData;
659 std::shared_ptr<CloudDiskInode> inoPtr = nullptr;
660 uint64_t num = 1;
661 int64_t key = 0;
662
663 fuseoperationshelper_->PutCloudDiskInode(data, inoPtr, num, key);
664 delete data;
665 EXPECT_TRUE(true);
666 } catch (...) {
667 EXPECT_TRUE(false);
668 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest001 ERROR";
669 }
670 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest001 End";
671 }
672
673 /**
674 * @tc.name: PutCloudDiskInodeTest002
675 * @tc.desc: Verify the PutCloudDiskInode function
676 * @tc.type: FUNC
677 * @tc.require: issuesI92WQP
678 */
679 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest002, TestSize.Level1)
680 {
681 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest002 Start";
682 try {
683 struct CloudDiskFuseData *data = new CloudDiskFuseData;
684 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
685 inoPtr->refCount.store(1);
686 uint64_t num = 1;
687 int64_t key = 0;
688
689 fuseoperationshelper_->PutCloudDiskInode(data, inoPtr, num, key);
690 delete data;
691 EXPECT_TRUE(true);
692 } catch (...) {
693 EXPECT_TRUE(false);
694 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest002 ERROR";
695 }
696 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest002 End";
697 }
698
699 /**
700 * @tc.name: PutCloudDiskInodeTest003
701 * @tc.desc: Verify the PutCloudDiskInode function
702 * @tc.type: FUNC
703 * @tc.require: issuesI92WQP
704 */
705 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest003, TestSize.Level1)
706 {
707 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest003 Start";
708 try {
709 struct CloudDiskFuseData *data = new CloudDiskFuseData;
710 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
711 inoPtr->refCount.store(2);
712 uint64_t num = 1;
713 int64_t key = 0;
714
715 fuseoperationshelper_->PutCloudDiskInode(data, inoPtr, num, key);
716 delete data;
717 EXPECT_TRUE(true);
718 } catch (...) {
719 EXPECT_TRUE(false);
720 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest003 ERROR";
721 }
722 GTEST_LOG_(INFO) << "PutCloudDiskInodeTest003 End";
723 }
724
725 /**
726 * @tc.name: PutCloudDiskFileTest001
727 * @tc.desc: Verify the PutCloudDiskFile function
728 * @tc.type: FUNC
729 * @tc.require: issuesI92WQP
730 */
731 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest001, TestSize.Level1)
732 {
733 GTEST_LOG_(INFO) << "PutCloudDiskFileTest001 Start";
734 try {
735 struct CloudDiskFuseData *data = new CloudDiskFuseData;
736 std::shared_ptr<CloudDiskFile> file = nullptr;
737 int64_t key = 0;
738
739 fuseoperationshelper_->PutCloudDiskFile(data, file, key);
740 delete data;
741 EXPECT_TRUE(true);
742 } catch (...) {
743 EXPECT_TRUE(false);
744 GTEST_LOG_(INFO) << "PutCloudDiskFileTest001 ERROR";
745 }
746 GTEST_LOG_(INFO) << "PutCloudDiskFileTest001 End";
747 }
748
749 /**
750 * @tc.name: PutCloudDiskFileTest002
751 * @tc.desc: Verify the PutCloudDiskFile function
752 * @tc.type: FUNC
753 * @tc.require: issuesI92WQP
754 */
755 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest002, TestSize.Level1)
756 {
757 GTEST_LOG_(INFO) << "PutCloudDiskFileTest002 Start";
758 try {
759 struct CloudDiskFuseData *data = new CloudDiskFuseData;
760 std::shared_ptr<CloudDiskFile> file = make_shared<CloudDiskFile>();
761 file->refCount.store(0);
762 int64_t key = 0;
763
764 fuseoperationshelper_->PutCloudDiskFile(data, file, key);
765 delete data;
766 EXPECT_TRUE(true);
767 } catch (...) {
768 EXPECT_TRUE(false);
769 GTEST_LOG_(INFO) << "PutCloudDiskFileTest002 ERROR";
770 }
771 GTEST_LOG_(INFO) << "PutCloudDiskFileTest002 End";
772 }
773
774 /**
775 * @tc.name: PutCloudDiskFileTest003
776 * @tc.desc: Verify the PutCloudDiskFile function
777 * @tc.type: FUNC
778 * @tc.require: issuesI92WQP
779 */
780 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest003, TestSize.Level1)
781 {
782 GTEST_LOG_(INFO) << "PutCloudDiskFileTest003 Start";
783 try {
784 struct CloudDiskFuseData *data = new CloudDiskFuseData;
785 std::shared_ptr<CloudDiskFile> file = make_shared<CloudDiskFile>();
786 file->refCount.store(1);
787 int64_t key = 0;
788
789 fuseoperationshelper_->PutCloudDiskFile(data, file, key);
790 delete data;
791 EXPECT_TRUE(true);
792 } catch (...) {
793 EXPECT_TRUE(false);
794 GTEST_LOG_(INFO) << "PutCloudDiskFileTest003 ERROR";
795 }
796 GTEST_LOG_(INFO) << "PutCloudDiskFileTest003 End";
797 }
798
799 /**
800 * @tc.name: PutLocalIdTest001
801 * @tc.desc: Verify the PutLocalId function
802 * @tc.type: FUNC
803 * @tc.require: issuesI92WQP
804 */
805 HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest001, TestSize.Level1)
806 {
807 GTEST_LOG_(INFO) << "PutLocalIdTest001 Start";
808 try {
809 struct CloudDiskFuseData *data = new CloudDiskFuseData;
810 std::shared_ptr<CloudDiskInode> inoPtr = nullptr;
811 uint64_t num = 1;
812 string key = "";
813
814 fuseoperationshelper_->PutLocalId(data, inoPtr, num, key);
815 delete data;
816 EXPECT_TRUE(true);
817 } catch (...) {
818 EXPECT_TRUE(false);
819 GTEST_LOG_(INFO) << "PutLocalIdTest001 ERROR";
820 }
821 GTEST_LOG_(INFO) << "PutLocalIdTest001 End";
822 }
823
824 /**
825 * @tc.name: PutLocalIdTest002
826 * @tc.desc: Verify the PutLocalId function
827 * @tc.type: FUNC
828 * @tc.require: issuesI92WQP
829 */
830 HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest002, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO) << "PutLocalIdTest002 Start";
833 try {
834 struct CloudDiskFuseData *data = new CloudDiskFuseData;
835 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
836 inoPtr->refCount.store(1);
837 uint64_t num = 1;
838 string key = "";
839
840 fuseoperationshelper_->PutLocalId(data, inoPtr, num, key);
841 delete data;
842 EXPECT_TRUE(true);
843 } catch (...) {
844 EXPECT_TRUE(false);
845 GTEST_LOG_(INFO) << "PutLocalIdTest002 ERROR";
846 }
847 GTEST_LOG_(INFO) << "PutLocalIdTest002 End";
848 }
849
850 /**
851 * @tc.name: PutLocalIdTest003
852 * @tc.desc: Verify the PutLocalId function
853 * @tc.type: FUNC
854 * @tc.require: issuesI92WQP
855 */
856 HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest003, TestSize.Level1)
857 {
858 GTEST_LOG_(INFO) << "PutLocalIdTest003 Start";
859 try {
860 struct CloudDiskFuseData *data = new CloudDiskFuseData;
861 std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
862 inoPtr->refCount.store(2);
863 uint64_t num = 1;
864 string key = "";
865
866 fuseoperationshelper_->PutLocalId(data, inoPtr, num, key);
867 delete data;
868 EXPECT_TRUE(true);
869 } catch (...) {
870 EXPECT_TRUE(false);
871 GTEST_LOG_(INFO) << "PutLocalIdTest003 ERROR";
872 }
873 GTEST_LOG_(INFO) << "PutLocalIdTest003 End";
874 }
875 } // namespace OHOS::FileManagement::CloudDisk::Test