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_cloud.h"
23 #include "file_operations_helper.h"
24 #include "file_operations_base.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 FuseOperationsTest : 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<FuseOperations> fuseoperations_ = nullptr;
41 static inline shared_ptr<AssistantMock> insMock = nullptr;
42 };
43
SetUpTestCase(void)44 void FuseOperationsTest::SetUpTestCase(void)
45 {
46 GTEST_LOG_(INFO) << "SetUpTestCase";
47 fuseoperations_ = make_shared<FuseOperations>();
48 insMock = make_shared<AssistantMock>();
49 Assistant::ins = insMock;
50 }
51
TearDownTestCase(void)52 void FuseOperationsTest::TearDownTestCase(void)
53 {
54 GTEST_LOG_(INFO) << "TearDownTestCase";
55 fuseoperations_ = nullptr;
56 Assistant::ins = nullptr;
57 insMock = nullptr;
58 }
59
SetUp(void)60 void FuseOperationsTest::SetUp(void)
61 {
62 GTEST_LOG_(INFO) << "SetUp";
63 }
64
TearDown(void)65 void FuseOperationsTest::TearDown(void)
66 {
67 GTEST_LOG_(INFO) << "TearDown";
68 }
69
70 /**
71 * @tc.name: LookupTest001
72 * @tc.desc: Verify the Lookup function
73 * @tc.type: FUNC
74 * @tc.require: issuesI92WQP
75 */
76 HWTEST_F(FuseOperationsTest, LookupTest001, TestSize.Level1)
77 {
78 GTEST_LOG_(INFO) << "LookupTest001 Start";
79 try {
80 fuse_req_t req = nullptr;
81 const char *name = "";
82
83 fuseoperations_->Lookup(req, FUSE_ROOT_ID, name);
84 EXPECT_TRUE(true);
85 } catch (...) {
86 EXPECT_TRUE(false);
87 GTEST_LOG_(INFO) << "LookupTest001 ERROR";
88 }
89 GTEST_LOG_(INFO) << "LookupTest001 End";
90 }
91
92 /**
93 * @tc.name: LookupTest002
94 * @tc.desc: Verify the Lookup function
95 * @tc.type: FUNC
96 * @tc.require: issuesI92WQP
97 */
98 HWTEST_F(FuseOperationsTest, LookupTest002, TestSize.Level1)
99 {
100 GTEST_LOG_(INFO) << "LookupTest002 Start";
101 try {
102 CloudDiskFuseData data;
103 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
104 fuse_req_t req = nullptr;
105 const char *name = "";
106
107 fuseoperations_->Lookup(req, 0, name);
108 EXPECT_TRUE(true);
109 } catch (...) {
110 EXPECT_TRUE(false);
111 GTEST_LOG_(INFO) << "LookupTest002 ERROR";
112 }
113 GTEST_LOG_(INFO) << "LookupTest002 End";
114 }
115
116 /**
117 * @tc.name: LookupTest
118 * @tc.desc: Verify the Lookup function
119 * @tc.type: FUNC
120 * @tc.require: issuesI92WQP
121 */
122 HWTEST_F(FuseOperationsTest, LookupTest, TestSize.Level1)
123 {
124 GTEST_LOG_(INFO) << "LookupTest Start";
125 try {
126 CloudDiskFuseData data;
127 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
128 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
129 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
130 .WillOnce(Return(reinterpret_cast<void*>(&data)));
131 fuse_req_t req = nullptr;
132 const char *name = "";
133 fuse_ino_t parent = 0;
134
135 fuseoperations_->Lookup(req, parent, name);
136 EXPECT_NE(parent, FUSE_ROOT_ID);
137 EXPECT_NE((data.inodeCache)[0], nullptr);
138 } catch (...) {
139 EXPECT_TRUE(false);
140 GTEST_LOG_(INFO) << "LookupTest ERROR";
141 }
142 GTEST_LOG_(INFO) << "LookupTest End";
143 }
144
145 /**
146 * @tc.name:AccessTest001
147 * @tc.desc: Verify the Access function
148 * @tc.type: FUNC
149 * @tc.require: issuesI92WQP
150 */
151 HWTEST_F(FuseOperationsTest, AccessTest001, TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "AccessTest001 Start";
154 try {
155 fuse_req_t req = nullptr;
156 int mask = 0;
157
158 fuseoperations_->Access(req, FUSE_ROOT_ID, mask);
159 EXPECT_TRUE(true);
160 } catch (...) {
161 EXPECT_TRUE(false);
162 GTEST_LOG_(INFO) << "AccessTest001 ERROR";
163 }
164 GTEST_LOG_(INFO) << "AccessTest001 End";
165 }
166
167 /**
168 * @tc.name:AccessTest002
169 * @tc.desc: Verify the Access function
170 * @tc.type: FUNC
171 * @tc.require: issuesI92WQP
172 */
173 HWTEST_F(FuseOperationsTest, AccessTest002, TestSize.Level1)
174 {
175 GTEST_LOG_(INFO) << "AccessTest002 Start";
176 try {
177 CloudDiskFuseData data;
178 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
179 fuse_req_t req = nullptr;
180 int mask = 0;
181
182 fuseoperations_->Access(req, 0, mask);
183 EXPECT_TRUE(true);
184 } catch (...) {
185 EXPECT_TRUE(false);
186 GTEST_LOG_(INFO) << "AccessTest002 ERROR";
187 }
188 GTEST_LOG_(INFO) << "AccessTest002 End";
189 }
190
191 /**
192 * @tc.name:AccessTest
193 * @tc.desc: Verify the Access function
194 * @tc.type: FUNC
195 * @tc.require: issuesI92WQP
196 */
197 HWTEST_F(FuseOperationsTest, AccessTest, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "AccessTest Start";
200 try {
201 CloudDiskFuseData data;
202 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
203 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
204 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
205 fuse_req_t req = nullptr;
206 fuse_ino_t ino = 0;
207 int mask = 0;
208
209 fuseoperations_->Access(req, ino, mask);
210 EXPECT_NE(ino, FUSE_ROOT_ID);
211 EXPECT_NE((data.inodeCache)[0], nullptr);
212 } catch (...) {
213 EXPECT_TRUE(false);
214 GTEST_LOG_(INFO) << "AccessTest ERROR";
215 }
216 GTEST_LOG_(INFO) << "AccessTest End";
217 }
218
219 /**
220 * @tc.name:GetAttrTest001
221 * @tc.desc: Verify the GetAttr function
222 * @tc.type: FUNC
223 * @tc.require: issuesI92WQP
224 */
225 HWTEST_F(FuseOperationsTest, GetAttrTest001, TestSize.Level1)
226 {
227 GTEST_LOG_(INFO) << "GetAttrTest001 Start";
228 try {
229 CloudDiskFuseData data;
230 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
231 fuse_req_t req = nullptr;
232 struct fuse_file_info *fi = nullptr;
233
234 fuseoperations_->GetAttr(req, FUSE_ROOT_ID, fi);
235 EXPECT_TRUE(true);
236 } catch (...) {
237 EXPECT_TRUE(false);
238 GTEST_LOG_(INFO) << "GetAttrTest001 ERROR";
239 }
240 GTEST_LOG_(INFO) << "GetAttrTest001 End";
241 }
242
243 /**
244 * @tc.name:GetAttrTest002
245 * @tc.desc: Verify the GetAttr function
246 * @tc.type: FUNC
247 * @tc.require: issuesI92WQP
248 */
249 HWTEST_F(FuseOperationsTest, GetAttrTest002, TestSize.Level1)
250 {
251 GTEST_LOG_(INFO) << "GetAttrTest002 Start";
252 try {
253 CloudDiskFuseData data;
254 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
255 fuse_req_t req = nullptr;
256 struct fuse_file_info *fi = nullptr;
257
258 fuseoperations_->GetAttr(req, 0, fi);
259 EXPECT_TRUE(true);
260 } catch (...) {
261 EXPECT_TRUE(false);
262 GTEST_LOG_(INFO) << "GetAttrTest002 ERROR";
263 }
264 GTEST_LOG_(INFO) << "GetAttrTest002 End";
265 }
266
267 /**
268 * @tc.name:GetAttrTest
269 * @tc.desc: Verify the GetAttr function
270 * @tc.type: FUNC
271 * @tc.require: issuesI92WQP
272 */
273 HWTEST_F(FuseOperationsTest, GetAttrTest, TestSize.Level1)
274 {
275 GTEST_LOG_(INFO) << "GetAttrTest Start";
276 try {
277 CloudDiskFuseData data;
278 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
279 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
280 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
281 .WillOnce(Return(reinterpret_cast<void *>(&data)));
282 fuse_req_t req = nullptr;
283 fuse_ino_t ino = 0;
284 struct fuse_file_info *fi = nullptr;
285
286 fuseoperations_->GetAttr(req, ino, fi);
287 EXPECT_NE(ino, FUSE_ROOT_ID);
288 EXPECT_NE((data.inodeCache)[0], nullptr);
289 } catch (...) {
290 EXPECT_TRUE(false);
291 GTEST_LOG_(INFO) << "GetAttrTest ERROR";
292 }
293 GTEST_LOG_(INFO) << "GetAttrTest End";
294 }
295
296 /**
297 * @tc.name:OpenTest001
298 * @tc.desc: Verify the Open function
299 * @tc.type: FUNC
300 * @tc.require: issuesI92WQP
301 */
302 HWTEST_F(FuseOperationsTest, OpenTest001, TestSize.Level1)
303 {
304 GTEST_LOG_(INFO) << "OpenTest001 Start";
305 try {
306 fuse_req_t req = nullptr;
307 struct fuse_file_info *fi = nullptr;
308
309 fuseoperations_->Open(req, FUSE_ROOT_ID, fi);
310 EXPECT_TRUE(true);
311 } catch (...) {
312 EXPECT_TRUE(false);
313 GTEST_LOG_(INFO) << "OpenTest001 ERROR";
314 }
315 GTEST_LOG_(INFO) << "OpenTest001 End";
316 }
317
318 /**
319 * @tc.name:OpenTest002
320 * @tc.desc: Verify the Open function
321 * @tc.type: FUNC
322 * @tc.require: issuesI92WQP
323 */
324 HWTEST_F(FuseOperationsTest, OpenTest002, TestSize.Level1)
325 {
326 GTEST_LOG_(INFO) << "OpenTest002 Start";
327 try {
328 CloudDiskFuseData data;
329 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
330 fuse_req_t req = nullptr;
331 struct fuse_file_info *fi = nullptr;
332
333 fuseoperations_->Open(req, 0, fi);
334 EXPECT_TRUE(true);
335 } catch (...) {
336 EXPECT_TRUE(false);
337 GTEST_LOG_(INFO) << "OpenTest002 ERROR";
338 }
339 GTEST_LOG_(INFO) << "OpenTest002 End";
340 }
341
342 /**
343 * @tc.name:OpenTest
344 * @tc.desc: Verify the Open function
345 * @tc.type: FUNC
346 * @tc.require: issuesI92WQP
347 */
348 HWTEST_F(FuseOperationsTest, OpenTest, TestSize.Level1)
349 {
350 GTEST_LOG_(INFO) << "OpenTest Start";
351 try {
352 CloudDiskFuseData data;
353 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
354 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
355 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void *>(&data)));
356 fuse_req_t req = nullptr;
357 fuse_ino_t ino = 0;
358 struct fuse_file_info fi;
359 fi.fh = 1;
360
361 fuseoperations_->Open(req, ino, &fi);
362 EXPECT_NE(ino, FUSE_ROOT_ID);
363 EXPECT_NE((data.inodeCache)[0], nullptr);
364 } catch (...) {
365 EXPECT_TRUE(false);
366 GTEST_LOG_(INFO) << "OpenTest ERROR";
367 }
368 GTEST_LOG_(INFO) << "OpenTest End";
369 }
370
371 /**
372 * @tc.name:ForgetTest001
373 * @tc.desc: Verify the Forget function
374 * @tc.type: FUNC
375 * @tc.require: issuesI92WQP
376 */
377 HWTEST_F(FuseOperationsTest, ForgetTest001, TestSize.Level1)
378 {
379 GTEST_LOG_(INFO) << "ForgetTest001 Start";
380 try {
381 CloudDiskFuseData data;
382 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
383 fuse_req_t req = nullptr;
384 uint64_t nLookup = 0;
385
386 fuseoperations_->Forget(req, FUSE_ROOT_ID, nLookup);
387 EXPECT_TRUE(true);
388 } catch (...) {
389 EXPECT_TRUE(false);
390 GTEST_LOG_(INFO) << "ForgetTest001 ERROR";
391 }
392 GTEST_LOG_(INFO) << "ForgetTest001 End";
393 }
394
395 /**
396 * @tc.name:ForgetTest002
397 * @tc.desc: Verify the Forget function
398 * @tc.type: FUNC
399 * @tc.require: issuesI92WQP
400 */
401 HWTEST_F(FuseOperationsTest, ForgetTest002, TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "ForgetTest002 Start";
404 try {
405 CloudDiskFuseData data;
406 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
407 fuse_req_t req = nullptr;
408 uint64_t nLookup = 0;
409
410 fuseoperations_->Forget(req, 0, nLookup);
411 EXPECT_TRUE(true);
412 } catch (...) {
413 EXPECT_TRUE(false);
414 GTEST_LOG_(INFO) << "ForgetTest002 ERROR";
415 }
416 GTEST_LOG_(INFO) << "ForgetTest002 End";
417 }
418
419 /**
420 * @tc.name:ForgetTest
421 * @tc.desc: Verify the Forget function
422 * @tc.type: FUNC
423 * @tc.require: issuesI92WQP
424 */
425 HWTEST_F(FuseOperationsTest, ForgetTest, TestSize.Level1)
426 {
427 GTEST_LOG_(INFO) << "ForgetTest Start";
428 try {
429 CloudDiskFuseData data;
430 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
431 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
432 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void *>(&data)));
433 fuse_req_t req = nullptr;
434 fuse_ino_t ino = 0;
435 uint64_t nLookup = 0;
436
437 fuseoperations_->Forget(req, ino, nLookup);
438 EXPECT_NE(ino, FUSE_ROOT_ID);
439 } catch (...) {
440 EXPECT_TRUE(false);
441 GTEST_LOG_(INFO) << "ForgetTest ERROR";
442 }
443 GTEST_LOG_(INFO) << "ForgetTest End";
444 }
445
446 /**
447 * @tc.name:ForgetMultiTest001
448 * @tc.desc: Verify the ForgetMulti function
449 * @tc.type: FUNC
450 * @tc.require: issuesI92WQP
451 */
452 HWTEST_F(FuseOperationsTest, ForgetMultiTest001, TestSize.Level1)
453 {
454 GTEST_LOG_(INFO) << "ForgetMultiTest001 Start";
455 try {
456 fuse_req_t req = nullptr;
457 struct fuse_forget_data forgets = {
458 FUSE_ROOT_ID,
459 1,
460 };
461
462 fuseoperations_->ForgetMulti(req, 1, &forgets);
463 EXPECT_TRUE(true);
464 } catch (...) {
465 EXPECT_TRUE(false);
466 GTEST_LOG_(INFO) << "ForgetMultiTest001 ERROR";
467 }
468 GTEST_LOG_(INFO) << "ForgetMultiTest001 End";
469 }
470
471 /**
472 * @tc.name:ForgetMultiTest002
473 * @tc.desc: Verify the ForgetMulti function
474 * @tc.type: FUNC
475 * @tc.require: issuesI92WQP
476 */
477 HWTEST_F(FuseOperationsTest, ForgetMultiTest002, TestSize.Level1)
478 {
479 GTEST_LOG_(INFO) << "ForgetMultiTest002 Start";
480 try {
481 fuse_req_t req = nullptr;
482 struct fuse_forget_data forgets = {
483 0,
484 1,
485 };
486
487 fuseoperations_->ForgetMulti(req, 0, &forgets);
488 EXPECT_TRUE(true);
489 } catch (...) {
490 EXPECT_TRUE(false);
491 GTEST_LOG_(INFO) << "ForgetMultiTest002 ERROR";
492 }
493 GTEST_LOG_(INFO) << "ForgetMultiTest002 End";
494 }
495
496 /**
497 * @tc.name:ForgetMultiTest01
498 * @tc.desc: Verify the ForgetMulti function
499 * @tc.type: FUNC
500 * @tc.require: issuesI92WQP
501 */
502 HWTEST_F(FuseOperationsTest, ForgetMultiTest01, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "ForgetMultiTest01 Start";
505 try {
506 CloudDiskFuseData data1;
507 CloudDiskFuseData data2;
508 (data1.inodeCache)[0] = make_shared<CloudDiskInode>();
509 (data1.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
510 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data1)))
511 .WillOnce(Return(reinterpret_cast<void *>(&data2)));
512 fuse_req_t req = nullptr;
513 struct fuse_forget_data forgets;
514 forgets.ino = 0;
515 size_t count = 1;
516
517 fuseoperations_->ForgetMulti(req, count, &forgets);
518 EXPECT_NE(count, 0);
519 EXPECT_NE((data1.inodeCache)[0], nullptr);
520 } catch (...) {
521 EXPECT_TRUE(false);
522 GTEST_LOG_(INFO) << "ForgetMultiTest01 ERROR";
523 }
524 GTEST_LOG_(INFO) << "ForgetMultiTest01 End";
525 }
526
527 /**
528 * @tc.name:ForgetMultiTest02
529 * @tc.desc: Verify the ForgetMulti function
530 * @tc.type: FUNC
531 * @tc.require: issuesI92WQP
532 */
533 HWTEST_F(FuseOperationsTest, ForgetMultiTest02, TestSize.Level1)
534 {
535 GTEST_LOG_(INFO) << "ForgetMultiTest02 Start";
536 try {
537 CloudDiskFuseData data;
538 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)));
539 fuse_req_t req = nullptr;
540 struct fuse_forget_data forgets;
541 forgets.ino = 0;
542 size_t count = 1;
543
544 fuseoperations_->ForgetMulti(req, count, &forgets);
545 EXPECT_NE(count, 0);
546 } catch (...) {
547 EXPECT_TRUE(false);
548 GTEST_LOG_(INFO) << "ForgetMultiTest02 ERROR";
549 }
550 GTEST_LOG_(INFO) << "ForgetMultiTest02 End";
551 }
552
553 /**
554 * @tc.name:MkNodTest001
555 * @tc.desc: Verify the MkNod function
556 * @tc.type: FUNC
557 * @tc.require: issuesI92WQP
558 */
559 HWTEST_F(FuseOperationsTest, MkNodTest001, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "MkNodTest001 Start";
562 try {
563 fuse_req_t req = nullptr;
564 const char *name = "";
565 mode_t mode = 0;
566 dev_t rdev = 0;
567
568 fuseoperations_->MkNod(req, FUSE_ROOT_ID, name, mode, rdev);
569 EXPECT_TRUE(true);
570 } catch (...) {
571 EXPECT_TRUE(false);
572 GTEST_LOG_(INFO) << "MkNodTest001 ERROR";
573 }
574 GTEST_LOG_(INFO) << "MkNodTest001 End";
575 }
576
577 /**
578 * @tc.name:MkNodTest002
579 * @tc.desc: Verify the MkNod function
580 * @tc.type: FUNC
581 * @tc.require: issuesI92WQP
582 */
583 HWTEST_F(FuseOperationsTest, MkNodTest002, TestSize.Level1)
584 {
585 GTEST_LOG_(INFO) << "MkNodTest002 Start";
586 try {
587 CloudDiskFuseData data;
588 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
589 fuse_req_t req = nullptr;
590 const char *name = "";
591 mode_t mode = 0;
592 dev_t rdev = 0;
593
594 fuseoperations_->MkNod(req, 0, name, mode, rdev);
595 EXPECT_TRUE(true);
596 } catch (...) {
597 EXPECT_TRUE(false);
598 GTEST_LOG_(INFO) << "MkNodTest002 ERROR";
599 }
600 GTEST_LOG_(INFO) << "MkNodTest002 End";
601 }
602
603 /**
604 * @tc.name:MkNodTest
605 * @tc.desc: Verify the MkNod function
606 * @tc.type: FUNC
607 * @tc.require: issuesI92WQP
608 */
609 HWTEST_F(FuseOperationsTest, MkNodTest, TestSize.Level1)
610 {
611 GTEST_LOG_(INFO) << "MkNodTest Start";
612 try {
613 CloudDiskFuseData data;
614 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
615 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
616 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
617 .WillOnce(Return(reinterpret_cast<void *>(&data)));
618 fuse_req_t req = nullptr;
619 fuse_ino_t parent = 0;
620 const char *name = "";
621 mode_t mode = 0;
622 dev_t rdev = 0;
623
624 fuseoperations_->MkNod(req, parent, name, mode, rdev);
625 EXPECT_NE(parent, FUSE_ROOT_ID);
626 EXPECT_NE((data.inodeCache)[0], nullptr);
627 } catch (...) {
628 EXPECT_TRUE(false);
629 GTEST_LOG_(INFO) << "MkNodTest ERROR";
630 }
631 GTEST_LOG_(INFO) << "MkNodTest End";
632 }
633
634 /**
635 * @tc.name:CreateTest001
636 * @tc.desc: Verify the Create function
637 * @tc.type: FUNC
638 * @tc.require: issuesI92WQP
639 */
640 HWTEST_F(FuseOperationsTest, CreateTest001, TestSize.Level1)
641 {
642 GTEST_LOG_(INFO) << "CreateTest001 Start";
643 try {
644 fuse_req_t req = nullptr;
645 const char *name = "";
646 mode_t mode = 0;
647 struct fuse_file_info fi;
648
649 fuseoperations_->Create(req, FUSE_ROOT_ID, name, mode, &fi);
650 EXPECT_TRUE(true);
651 } catch (...) {
652 EXPECT_TRUE(false);
653 GTEST_LOG_(INFO) << "CreateTest001 ERROR";
654 }
655 GTEST_LOG_(INFO) << "CreateTest001 End";
656 }
657
658 /**
659 * @tc.name:CreateTest002
660 * @tc.desc: Verify the Create function
661 * @tc.type: FUNC
662 * @tc.require: issuesI92WQP
663 */
664 HWTEST_F(FuseOperationsTest, CreateTest002, TestSize.Level1)
665 {
666 GTEST_LOG_(INFO) << "CreateTest002 Start";
667 try {
668 CloudDiskFuseData data;
669 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
670 fuse_req_t req = nullptr;
671 const char *name = "";
672 mode_t mode = 0;
673 struct fuse_file_info fi;
674
675 fuseoperations_->Create(req, 0, name, mode, &fi);
676 EXPECT_TRUE(true);
677 } catch (...) {
678 EXPECT_TRUE(false);
679 GTEST_LOG_(INFO) << "CreateTest002 ERROR";
680 }
681 GTEST_LOG_(INFO) << "CreateTest002 End";
682 }
683
684 /**
685 * @tc.name:CreateTest
686 * @tc.desc: Verify the Create function
687 * @tc.type: FUNC
688 * @tc.require: issuesI92WQP
689 */
690 HWTEST_F(FuseOperationsTest, CreateTest, TestSize.Level1)
691 {
692 GTEST_LOG_(INFO) << "CreateTesT Start";
693 try {
694 CloudDiskFuseData data;
695 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
696 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
697 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void *>(&data)));
698 fuse_req_t req = nullptr;
699 fuse_ino_t parent = 0;
700 const char *name = "";
701 mode_t mode = 0;
702 struct fuse_file_info fi;
703
704 fuseoperations_->Create(req, parent, name, mode, &fi);
705 EXPECT_NE(parent, FUSE_ROOT_ID);
706 EXPECT_NE((data.inodeCache)[0], nullptr);
707 } catch (...) {
708 EXPECT_TRUE(false);
709 GTEST_LOG_(INFO) << "CreateTest ERROR";
710 }
711 GTEST_LOG_(INFO) << "CreateTest End";
712 }
713
714 /**
715 * @tc.name:ReadDirTest001
716 * @tc.desc: Verify the ReadDir function
717 * @tc.type: FUNC
718 * @tc.require: issuesI92WQP
719 */
720 HWTEST_F(FuseOperationsTest, ReadDirTest001, TestSize.Level1)
721 {
722 GTEST_LOG_(INFO) << "ReadDirTest001 Start";
723 try {
724 CloudDiskFuseData data;
725 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
726 fuse_req_t req = nullptr;
727 size_t size = 0;
728 off_t off = 0;
729 struct fuse_file_info fi;
730
731 fuseoperations_->ReadDir(req, FUSE_ROOT_ID, size, off, &fi);
732 EXPECT_TRUE(true);
733 } catch (...) {
734 EXPECT_TRUE(false);
735 GTEST_LOG_(INFO) << "ReadDirTest001 ERROR";
736 }
737 GTEST_LOG_(INFO) << "ReadDirTest001 End";
738 }
739
740 /**
741 * @tc.name:ReadDirTest002
742 * @tc.desc: Verify the ReadDir function
743 * @tc.type: FUNC
744 * @tc.require: issuesI92WQP
745 */
746 HWTEST_F(FuseOperationsTest, ReadDirTest002, TestSize.Level1)
747 {
748 GTEST_LOG_(INFO) << "ReadDirTest002 Start";
749 try {
750 CloudDiskFuseData data;
751 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
752 fuse_req_t req = nullptr;
753 size_t size = 0;
754 off_t off = 0;
755 struct fuse_file_info fi;
756
757 fuseoperations_->ReadDir(req, 0, size, off, &fi);
758 EXPECT_TRUE(true);
759 } catch (...) {
760 EXPECT_TRUE(false);
761 GTEST_LOG_(INFO) << "ReadDirTest002 ERROR";
762 }
763 GTEST_LOG_(INFO) << "ReadDirTest002 End";
764 }
765
766 /**
767 * @tc.name:ReadDirTest
768 * @tc.desc: Verify the ReadDir function
769 * @tc.type: FUNC
770 * @tc.require: issuesI92WQP
771 */
772 HWTEST_F(FuseOperationsTest, ReadDirTest, TestSize.Level1)
773 {
774 GTEST_LOG_(INFO) << "ReadDirTest Start";
775 try {
776 CloudDiskFuseData data;
777 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
778 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
779 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
780 .WillOnce(Return(reinterpret_cast<void *>(&data)));
781 fuse_req_t req = nullptr;
782 fuse_ino_t ino = 0;
783 size_t size = 0;
784 off_t off = 0;
785 struct fuse_file_info fi;
786
787 fuseoperations_->ReadDir(req, ino, size, off, &fi);
788 EXPECT_NE(ino, FUSE_ROOT_ID);
789 EXPECT_NE((data.inodeCache)[0], nullptr);
790 } catch (...) {
791 EXPECT_TRUE(false);
792 GTEST_LOG_(INFO) << "ReadDirTest ERROR";
793 }
794 GTEST_LOG_(INFO) << "ReadDirTest End";
795 }
796
797 /**
798 * @tc.name:SetXattrTest001
799 * @tc.desc: Verify the SetXattr function
800 * @tc.type: FUNC
801 * @tc.require: issuesI92WQP
802 */
803 HWTEST_F(FuseOperationsTest, SetXattrTest001, TestSize.Level1)
804 {
805 GTEST_LOG_(INFO) << "SetXattrTest001 Start";
806 try {
807 fuse_req_t req = nullptr;
808 string name = HMDFS_PERMISSION_XATTR;
809 const char *value = "";
810 size_t size = 0;
811 int flags = 0;
812
813 fuseoperations_->SetXattr(req, FUSE_ROOT_ID, name.c_str(), value, size, flags);
814 EXPECT_TRUE(true);
815 } catch (...) {
816 EXPECT_TRUE(false);
817 GTEST_LOG_(INFO) << "SetXattrTest001 ERROR";
818 }
819 GTEST_LOG_(INFO) << "SetXattrTest001 End";
820 }
821
822 /**
823 * @tc.name:SetXattrTest002
824 * @tc.desc: Verify the SetXattr function
825 * @tc.type: FUNC
826 * @tc.require: issuesI92WQP
827 */
828 HWTEST_F(FuseOperationsTest, SetXattrTest002, TestSize.Level1)
829 {
830 GTEST_LOG_(INFO) << "SetXattrTest002 Start";
831 try {
832 CloudDiskFuseData data;
833 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
834 fuse_req_t req = nullptr;
835 string name = HMDFS_PERMISSION_XATTR;
836 const char *value = "";
837 size_t size = 0;
838 int flags = 0;
839
840 fuseoperations_->SetXattr(req, 0, name.c_str(), value, size, flags);
841 EXPECT_TRUE(true);
842 } catch (...) {
843 EXPECT_TRUE(false);
844 GTEST_LOG_(INFO) << "SetXattrTest002 ERROR";
845 }
846 GTEST_LOG_(INFO) << "SetXattrTest002 End";
847 }
848
849 /**
850 * @tc.name:SetXattrTest
851 * @tc.desc: Verify the SetXattr function
852 * @tc.type: FUNC
853 * @tc.require: issuesI92WQP
854 */
855 HWTEST_F(FuseOperationsTest, SetXattrTest, TestSize.Level1)
856 {
857 GTEST_LOG_(INFO) << "SetXattrTest Start";
858 try {
859 CloudDiskFuseData data;
860 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
861 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
862 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)));
863 fuse_req_t req = nullptr;
864 fuse_ino_t ino = 0;
865 string name = HMDFS_PERMISSION_XATTR;
866 const char *value = "";
867 size_t size = 0;
868 int flags = 0;
869
870 fuseoperations_->SetXattr(req, ino, name.c_str(), value, size, flags);
871 EXPECT_NE(ino, FUSE_ROOT_ID);
872 EXPECT_NE((data.inodeCache)[0], nullptr);
873 } catch (...) {
874 EXPECT_TRUE(false);
875 GTEST_LOG_(INFO) << "SetXattrTest ERROR";
876 }
877 GTEST_LOG_(INFO) << "SetXattrTest End";
878 }
879
880 /**
881 * @tc.name:GetXattrTest001
882 * @tc.desc: Verify the GetXattr function
883 * @tc.type: FUNC
884 * @tc.require: issuesI92WQP
885 */
886 HWTEST_F(FuseOperationsTest, GetXattrTest001, TestSize.Level1)
887 {
888 GTEST_LOG_(INFO) << "GetXattrTest001 Start";
889 try {
890 fuse_req_t req = nullptr;
891 size_t size = 0;
892 string name = HMDFS_PERMISSION_XATTR;
893
894 fuseoperations_->GetXattr(req, FUSE_ROOT_ID, name.c_str(), size);
895 EXPECT_TRUE(true);
896 } catch (...) {
897 EXPECT_TRUE(false);
898 GTEST_LOG_(INFO) << "GetXattrTest001 ERROR";
899 }
900 GTEST_LOG_(INFO) << "GetXattrTest001 End";
901 }
902
903 /**
904 * @tc.name:GetXattrTest002
905 * @tc.desc: Verify the GetXattr function
906 * @tc.type: FUNC
907 * @tc.require: issuesI92WQP
908 */
909 HWTEST_F(FuseOperationsTest, GetXattrTest002, TestSize.Level1)
910 {
911 GTEST_LOG_(INFO) << "GetXattrTest002 Start";
912 try {
913 CloudDiskFuseData data;
914 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
915 fuse_req_t req = nullptr;
916 size_t size = 0;
917 string name = HMDFS_PERMISSION_XATTR;
918
919 fuseoperations_->GetXattr(req, 0, name.c_str(), size);
920 EXPECT_TRUE(true);
921 } catch (...) {
922 EXPECT_TRUE(false);
923 GTEST_LOG_(INFO) << "GetXattrTest002 ERROR";
924 }
925 GTEST_LOG_(INFO) << "GetXattrTest002 End";
926 }
927
928 /**
929 * @tc.name:GetXattrTest
930 * @tc.desc: Verify the GetXattr function
931 * @tc.type: FUNC
932 * @tc.require: issuesI92WQP
933 */
934 HWTEST_F(FuseOperationsTest, GetXattrTest, TestSize.Level1)
935 {
936 GTEST_LOG_(INFO) << "GetXattrTest Start";
937 try {
938 CloudDiskFuseData data;
939 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
940 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
941 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
942 .WillOnce(Return(reinterpret_cast<void *>(&data)));
943 fuse_req_t req = nullptr;
944 fuse_ino_t ino = 0;
945 size_t size = 0;
946 string name = HMDFS_PERMISSION_XATTR;
947
948 fuseoperations_->GetXattr(req, ino, name.c_str(), size);
949 EXPECT_NE(ino, FUSE_ROOT_ID);
950 EXPECT_NE((data.inodeCache)[0], nullptr);
951 } catch (...) {
952 EXPECT_TRUE(false);
953 GTEST_LOG_(INFO) << "GetXattrTest ERROR";
954 }
955 GTEST_LOG_(INFO) << "GetXattrTest End";
956 }
957
958 /**
959 * @tc.name:MkDirTest001
960 * @tc.desc: Verify the MkDir function
961 * @tc.type: FUNC
962 * @tc.require: issuesI92WQP
963 */
964 HWTEST_F(FuseOperationsTest, MkDirTest001, TestSize.Level1)
965 {
966 GTEST_LOG_(INFO) << "MkDirTest001 Start";
967 try {
968 fuse_req_t req = nullptr;
969 const char *name = nullptr;
970 mode_t mode = 0;
971
972
973 fuseoperations_->MkDir(req, FUSE_ROOT_ID, name, mode);
974 EXPECT_TRUE(true);
975 } catch (...) {
976 EXPECT_TRUE(false);
977 GTEST_LOG_(INFO) << "MkDirTest001 ERROR";
978 }
979 GTEST_LOG_(INFO) << "MkDirTest001 End";
980 }
981
982 /**
983 * @tc.name:MkDirTest002
984 * @tc.desc: Verify the MkDir function
985 * @tc.type: FUNC
986 * @tc.require: issuesI92WQP
987 */
988 HWTEST_F(FuseOperationsTest, MkDirTest002, TestSize.Level1)
989 {
990 GTEST_LOG_(INFO) << "MkDirTest002 Start";
991 try {
992 CloudDiskFuseData data;
993 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
994 fuse_req_t req = nullptr;
995 const char *name = nullptr;
996 mode_t mode = 0;
997
998
999 fuseoperations_->MkDir(req, 0, name, mode);
1000 EXPECT_TRUE(true);
1001 } catch (...) {
1002 EXPECT_TRUE(false);
1003 GTEST_LOG_(INFO) << "MkDirTest002 ERROR";
1004 }
1005 GTEST_LOG_(INFO) << "MkDirTest002 End";
1006 }
1007
1008 /**
1009 * @tc.name:MkDirTest
1010 * @tc.desc: Verify the MkDir function
1011 * @tc.type: FUNC
1012 * @tc.require: issuesI92WQP
1013 */
1014 HWTEST_F(FuseOperationsTest, MkDirTest, TestSize.Level1)
1015 {
1016 GTEST_LOG_(INFO) << "MkDirTest Start";
1017 try {
1018 CloudDiskFuseData data1;
1019 CloudDiskFuseData data2;
1020 (data1.inodeCache)[0] = make_shared<CloudDiskInode>();
1021 (data1.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1022 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data1)))
1023 .WillOnce(Return(reinterpret_cast<void *>(&data2)));
1024 fuse_req_t req = nullptr;
1025 fuse_ino_t parent = 0;
1026 const char *name = nullptr;
1027 mode_t mode = 0;
1028
1029
1030 fuseoperations_->MkDir(req, parent, name, mode);
1031 EXPECT_NE(parent, FUSE_ROOT_ID);
1032 EXPECT_NE((data1.inodeCache)[0], nullptr);
1033 } catch (...) {
1034 EXPECT_TRUE(false);
1035 GTEST_LOG_(INFO) << "MkDirTest ERROR";
1036 }
1037 GTEST_LOG_(INFO) << "MkDirTest End";
1038 }
1039
1040 /**
1041 * @tc.name:RmDirTest001
1042 * @tc.desc: Verify the RmDir function
1043 * @tc.type: FUNC
1044 * @tc.require: issuesI92WQP
1045 */
1046 HWTEST_F(FuseOperationsTest, RmDirTest001, TestSize.Level1)
1047 {
1048 GTEST_LOG_(INFO) << "RmDirTest001 Start";
1049 try {
1050 fuse_req_t req = nullptr;
1051 const char *name = nullptr;
1052
1053 fuseoperations_->RmDir(req, FUSE_ROOT_ID, name);
1054 EXPECT_TRUE(true);
1055 } catch (...) {
1056 EXPECT_TRUE(false);
1057 GTEST_LOG_(INFO) << "RmDirTest001 ERROR";
1058 }
1059 GTEST_LOG_(INFO) << "RmDirTest001 End";
1060 }
1061
1062 /**
1063 * @tc.name:RmDirTest002
1064 * @tc.desc: Verify the RmDir function
1065 * @tc.type: FUNC
1066 * @tc.require: issuesI92WQP
1067 */
1068 HWTEST_F(FuseOperationsTest, RmDirTest002, TestSize.Level1)
1069 {
1070 GTEST_LOG_(INFO) << "RmDirTest002 Start";
1071 try {
1072 CloudDiskFuseData data;
1073 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1074 fuse_req_t req = nullptr;
1075 const char *name = nullptr;
1076
1077 fuseoperations_->RmDir(req, 0, name);
1078 EXPECT_TRUE(true);
1079 } catch (...) {
1080 EXPECT_TRUE(false);
1081 GTEST_LOG_(INFO) << "RmDirTest002 ERROR";
1082 }
1083 GTEST_LOG_(INFO) << "RmDirTest002 End";
1084 }
1085
1086 /**
1087 * @tc.name:RmDirTest
1088 * @tc.desc: Verify the RmDir function
1089 * @tc.type: FUNC
1090 * @tc.require: issuesI92WQP
1091 */
1092 HWTEST_F(FuseOperationsTest, RmDirTest, TestSize.Level1)
1093 {
1094 GTEST_LOG_(INFO) << "RmDirTest Start";
1095 try {
1096 CloudDiskFuseData data1;
1097 CloudDiskFuseData data2;
1098 (data1.inodeCache)[0] = make_shared<CloudDiskInode>();
1099 (data1.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1100 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data1)))
1101 .WillOnce(Return(reinterpret_cast<void *>(&data2)));
1102 fuse_req_t req = nullptr;
1103 fuse_ino_t parent = 0;
1104 const char *name = nullptr;
1105
1106 fuseoperations_->RmDir(req, parent, name);
1107 EXPECT_NE(parent, FUSE_ROOT_ID);
1108 EXPECT_NE((data1.inodeCache)[0], nullptr);
1109 } catch (...) {
1110 EXPECT_TRUE(false);
1111 GTEST_LOG_(INFO) << "RmDirTest ERROR";
1112 }
1113 GTEST_LOG_(INFO) << "RmDirTest End";
1114 }
1115
1116 /**
1117 * @tc.name:UnlinkTest001
1118 * @tc.desc: Verify the Unlink function
1119 * @tc.type: FUNC
1120 * @tc.require: issuesI92WQP
1121 */
1122 HWTEST_F(FuseOperationsTest, UnlinkTest001, TestSize.Level1)
1123 {
1124 GTEST_LOG_(INFO) << "UnlinkTest001 Start";
1125 try {
1126 fuse_req_t req = nullptr;
1127 const char *name = nullptr;
1128
1129 fuseoperations_->Unlink(req, FUSE_ROOT_ID, name);
1130 EXPECT_TRUE(true);
1131 } catch (...) {
1132 EXPECT_TRUE(false);
1133 GTEST_LOG_(INFO) << "UnlinkTest001 ERROR";
1134 }
1135 GTEST_LOG_(INFO) << "UnlinkTest001 End";
1136 }
1137
1138 /**
1139 * @tc.name:UnlinkTest002
1140 * @tc.desc: Verify the Unlink function
1141 * @tc.type: FUNC
1142 * @tc.require: issuesI92WQP
1143 */
1144 HWTEST_F(FuseOperationsTest, UnlinkTest002, TestSize.Level1)
1145 {
1146 GTEST_LOG_(INFO) << "UnlinkTest002 Start";
1147 try {
1148 CloudDiskFuseData data;
1149 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1150 fuse_req_t req = nullptr;
1151 const char *name = nullptr;
1152
1153 fuseoperations_->Unlink(req, 0, name);
1154 EXPECT_TRUE(true);
1155 } catch (...) {
1156 EXPECT_TRUE(false);
1157 GTEST_LOG_(INFO) << "UnlinkTest002 ERROR";
1158 }
1159 GTEST_LOG_(INFO) << "UnlinkTest002 End";
1160 }
1161
1162 /**
1163 * @tc.name:UnlinkTest
1164 * @tc.desc: Verify the Unlink function
1165 * @tc.type: FUNC
1166 * @tc.require: issuesI92WQP
1167 */
1168 HWTEST_F(FuseOperationsTest, UnlinkTest, TestSize.Level1)
1169 {
1170 GTEST_LOG_(INFO) << "UnlinkTest Start";
1171 try {
1172 CloudDiskFuseData data1;
1173 CloudDiskFuseData data2;
1174 (data1.inodeCache)[0] = make_shared<CloudDiskInode>();
1175 (data1.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1176 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data1)))
1177 .WillOnce(Return(reinterpret_cast<void*>(&data2)))
1178 .WillOnce(Return(reinterpret_cast<void*>(&data2)));
1179 fuse_req_t req = nullptr;
1180 fuse_ino_t parent = 0;
1181 const char *name = nullptr;
1182
1183 fuseoperations_->Unlink(req, parent, name);
1184 EXPECT_NE(parent, FUSE_ROOT_ID);
1185 EXPECT_NE((data1.inodeCache)[0], nullptr);
1186 } catch (...) {
1187 EXPECT_TRUE(false);
1188 GTEST_LOG_(INFO) << "UnlinkTest ERROR";
1189 }
1190 GTEST_LOG_(INFO) << "UnlinkTest End";
1191 }
1192
1193 /**
1194 * @tc.name:RenameTest001
1195 * @tc.desc: Verify the Rename function
1196 * @tc.type: FUNC
1197 * @tc.require: issuesI92WQP
1198 */
1199 HWTEST_F(FuseOperationsTest, RenameTest001, TestSize.Level1)
1200 {
1201 GTEST_LOG_(INFO) << "RenameTest001 Start";
1202 try {
1203 fuse_req_t req = nullptr;
1204 const char *name = "";
1205 const char *newName = "";
1206 unsigned int flags = 1;
1207
1208 fuseoperations_->Rename(req, FUSE_ROOT_ID, name, FUSE_ROOT_ID, newName, flags);
1209 EXPECT_TRUE(true);
1210 } catch (...) {
1211 EXPECT_TRUE(false);
1212 GTEST_LOG_(INFO) << "RenameTest001 ERROR";
1213 }
1214 GTEST_LOG_(INFO) << "RenameTest001 End";
1215 }
1216
1217 /**
1218 * @tc.name:RenameTest002
1219 * @tc.desc: Verify the Rename function
1220 * @tc.type: FUNC
1221 * @tc.require: issuesI92WQP
1222 */
1223 HWTEST_F(FuseOperationsTest, RenameTest002, TestSize.Level1)
1224 {
1225 GTEST_LOG_(INFO) << "RenameTest002 Start";
1226 try {
1227 CloudDiskFuseData data;
1228 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1229 fuse_req_t req = nullptr;
1230 const char *name = "";
1231 const char *newName = "";
1232 unsigned int flags = 1;
1233
1234 fuseoperations_->Rename(req, 0, name, FUSE_ROOT_ID, newName, flags);
1235 EXPECT_TRUE(true);
1236 } catch (...) {
1237 EXPECT_TRUE(false);
1238 GTEST_LOG_(INFO) << "RenameTest002 ERROR";
1239 }
1240 GTEST_LOG_(INFO) << "RenameTest002 End";
1241 }
1242
1243 /**
1244 * @tc.name:RenameTest
1245 * @tc.desc: Verify the Rename function
1246 * @tc.type: FUNC
1247 * @tc.require: issuesI92WQP
1248 */
1249 HWTEST_F(FuseOperationsTest, RenameTest, TestSize.Level1)
1250 {
1251 GTEST_LOG_(INFO) << "RenameTest Start";
1252 try {
1253 CloudDiskFuseData data;
1254 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
1255 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1256 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
1257 .WillOnce(Return(reinterpret_cast<void *>(&data)));
1258 fuse_req_t req = nullptr;
1259 fuse_ino_t parent = 0;
1260 const char *name = "";
1261 const char *newName = "";
1262 unsigned int flags = 1;
1263
1264 fuseoperations_->Rename(req, parent, name, FUSE_ROOT_ID, newName, flags);
1265 EXPECT_NE(parent, FUSE_ROOT_ID);
1266 EXPECT_NE((data.inodeCache)[0], nullptr);
1267 } catch (...) {
1268 EXPECT_TRUE(false);
1269 GTEST_LOG_(INFO) << "RenameTest ERROR";
1270 }
1271 GTEST_LOG_(INFO) << "RenameTest End";
1272 }
1273
1274 /**
1275 * @tc.name:ReadTest001
1276 * @tc.desc: Verify the Read function
1277 * @tc.type: FUNC
1278 * @tc.require: issuesI92WQP
1279 */
1280 HWTEST_F(FuseOperationsTest, ReadTest001, TestSize.Level1)
1281 {
1282 GTEST_LOG_(INFO) << "ReadTest001 Start";
1283 try {
1284 fuse_req_t req = nullptr;
1285 size_t size = 0;
1286 off_t off = 0;
1287 struct fuse_file_info fi;
1288
1289 fuseoperations_->Read(req, FUSE_ROOT_ID, size, off, &fi);
1290 EXPECT_TRUE(true);
1291 } catch (...) {
1292 EXPECT_TRUE(false);
1293 GTEST_LOG_(INFO) << "ReadTest001 ERROR";
1294 }
1295 GTEST_LOG_(INFO) << "ReadTest001 End";
1296 }
1297
1298 /**
1299 * @tc.name:ReadTest002
1300 * @tc.desc: Verify the Read function
1301 * @tc.type: FUNC
1302 * @tc.require: issuesI92WQP
1303 */
1304 HWTEST_F(FuseOperationsTest, ReadTest002, TestSize.Level1)
1305 {
1306 GTEST_LOG_(INFO) << "ReadTest002 Start";
1307 try {
1308 CloudDiskFuseData data;
1309 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1310 fuse_req_t req = nullptr;
1311 size_t size = 0;
1312 off_t off = 0;
1313 struct fuse_file_info fi;
1314
1315 fuseoperations_->Read(req, 0, size, off, &fi);
1316 EXPECT_TRUE(true);
1317 } catch (...) {
1318 EXPECT_TRUE(false);
1319 GTEST_LOG_(INFO) << "ReadTest002 ERROR";
1320 }
1321 GTEST_LOG_(INFO) << "ReadTest002 End";
1322 }
1323
1324 /**
1325 * @tc.name:ReadTest
1326 * @tc.desc: Verify the Read function
1327 * @tc.type: FUNC
1328 * @tc.require: issuesI92WQP
1329 */
1330 HWTEST_F(FuseOperationsTest, ReadTest, TestSize.Level1)
1331 {
1332 GTEST_LOG_(INFO) << "ReadTest Start";
1333 try {
1334 CloudDiskFuseData data;
1335 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
1336 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1337 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
1338 .WillOnce(Return(reinterpret_cast<void *>(&data)));
1339 fuse_req_t req = nullptr;
1340 fuse_ino_t ino = 0;
1341 size_t size = 0;
1342 off_t off = 0;
1343 struct fuse_file_info fi;
1344
1345 fuseoperations_->Read(req, ino, size, off, &fi);
1346 EXPECT_NE(ino, FUSE_ROOT_ID);
1347 EXPECT_NE((data.inodeCache)[0], nullptr);
1348 } catch (...) {
1349 EXPECT_TRUE(false);
1350 GTEST_LOG_(INFO) << "ReadTest ERROR";
1351 }
1352 GTEST_LOG_(INFO) << "ReadTest End";
1353 }
1354
1355 /**
1356 * @tc.name:WriteBufTest001
1357 * @tc.desc: Verify the WriteBuf function
1358 * @tc.type: FUNC
1359 * @tc.require: issuesI92WQP
1360 */
1361 HWTEST_F(FuseOperationsTest, WriteBufTest001, TestSize.Level1)
1362 {
1363 GTEST_LOG_(INFO) << "WriteBufTest001 Start";
1364 try {
1365 fuse_req_t req = nullptr;
1366 struct fuse_bufvec *bufv = nullptr;
1367 off_t offset = 0;
1368 struct fuse_file_info fi;
1369
1370 fuseoperations_->WriteBuf(req, FUSE_ROOT_ID, bufv, offset, &fi);
1371 EXPECT_TRUE(true);
1372 } catch (...) {
1373 EXPECT_TRUE(false);
1374 GTEST_LOG_(INFO) << "WriteBufTest001 ERROR";
1375 }
1376 GTEST_LOG_(INFO) << "WriteBufTest001 End";
1377 }
1378
1379 /**
1380 * @tc.name:WriteBufTest002
1381 * @tc.desc: Verify the WriteBuf function
1382 * @tc.type: FUNC
1383 * @tc.require: issuesI92WQP
1384 */
1385 HWTEST_F(FuseOperationsTest, WriteBufTest002, TestSize.Level1)
1386 {
1387 GTEST_LOG_(INFO) << "WriteBufTest002 Start";
1388 try {
1389 CloudDiskFuseData data;
1390 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1391 fuse_req_t req = nullptr;
1392 struct fuse_bufvec *bufv = nullptr;
1393 off_t offset = 0;
1394 struct fuse_file_info fi;
1395
1396 fuseoperations_->WriteBuf(req, 0, bufv, offset, &fi);
1397 EXPECT_TRUE(true);
1398 } catch (...) {
1399 EXPECT_TRUE(false);
1400 GTEST_LOG_(INFO) << "WriteBufTest002 ERROR";
1401 }
1402 GTEST_LOG_(INFO) << "WriteBufTest002 End";
1403 }
1404
1405 /**
1406 * @tc.name:WriteBufTest
1407 * @tc.desc: Verify the WriteBuf function
1408 * @tc.type: FUNC
1409 * @tc.require: issuesI92WQP
1410 */
1411 HWTEST_F(FuseOperationsTest, WriteBufTest, TestSize.Level1)
1412 {
1413 GTEST_LOG_(INFO) << "WriteBufTest Start";
1414 try {
1415 CloudDiskFuseData data;
1416 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
1417 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1418 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
1419 .WillOnce(Return(reinterpret_cast<void *>(&data)));
1420 fuse_req_t req = nullptr;
1421 fuse_ino_t ino = 0;
1422 struct fuse_bufvec *bufv = nullptr;
1423 off_t offset = 0;
1424 struct fuse_file_info fi;
1425
1426 fuseoperations_->WriteBuf(req, ino, bufv, offset, &fi);
1427 EXPECT_NE(ino, FUSE_ROOT_ID);
1428 EXPECT_NE((data.inodeCache)[0], nullptr);
1429 } catch (...) {
1430 EXPECT_TRUE(false);
1431 GTEST_LOG_(INFO) << "WriteBufTest ERROR";
1432 }
1433 GTEST_LOG_(INFO) << "WriteBufTest End";
1434 }
1435
1436 /**
1437 * @tc.name:ReleaseTest001
1438 * @tc.desc: Verify the Release function
1439 * @tc.type: FUNC
1440 * @tc.require: issuesI92WQP
1441 */
1442 HWTEST_F(FuseOperationsTest, ReleaseTest001, TestSize.Level1)
1443 {
1444 GTEST_LOG_(INFO) << "ReleaseTest001 Start";
1445 try {
1446 fuse_req_t req = nullptr;
1447 struct fuse_file_info fi;
1448
1449 fuseoperations_->Release(req, FUSE_ROOT_ID, &fi);
1450 EXPECT_TRUE(true);
1451 } catch (...) {
1452 EXPECT_TRUE(false);
1453 GTEST_LOG_(INFO) << "ReleaseTest001 ERROR";
1454 }
1455 GTEST_LOG_(INFO) << "ReleaseTest001 End";
1456 }
1457
1458 /**
1459 * @tc.name:ReleaseTest002
1460 * @tc.desc: Verify the Release function
1461 * @tc.type: FUNC
1462 * @tc.require: issuesI92WQP
1463 */
1464 HWTEST_F(FuseOperationsTest, ReleaseTest002, TestSize.Level1)
1465 {
1466 GTEST_LOG_(INFO) << "ReleaseTest002 Start";
1467 try {
1468 CloudDiskFuseData data;
1469 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1470 fuse_req_t req = nullptr;
1471 struct fuse_file_info fi;
1472
1473 fuseoperations_->Release(req, 0, &fi);
1474 EXPECT_TRUE(true);
1475 } catch (...) {
1476 EXPECT_TRUE(false);
1477 GTEST_LOG_(INFO) << "ReleaseTest002 ERROR";
1478 }
1479 GTEST_LOG_(INFO) << "ReleaseTest002 End";
1480 }
1481
1482 /**
1483 * @tc.name:ReleaseTest
1484 * @tc.desc: Verify the Release function
1485 * @tc.type: FUNC
1486 * @tc.require: issuesI92WQP
1487 */
1488 HWTEST_F(FuseOperationsTest, ReleaseTest, TestSize.Level1)
1489 {
1490 GTEST_LOG_(INFO) << "ReleaseTest Start";
1491 try {
1492 CloudDiskFuseData data;
1493 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
1494 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1495 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
1496 .WillOnce(Return(reinterpret_cast<void *>(&data)));
1497 fuse_req_t req = nullptr;
1498 fuse_ino_t ino = 0;
1499 struct fuse_file_info fi;
1500
1501 fuseoperations_->Release(req, ino, &fi);
1502 EXPECT_NE(ino, FUSE_ROOT_ID);
1503 EXPECT_NE((data.inodeCache)[0], nullptr);
1504 } catch (...) {
1505 EXPECT_TRUE(false);
1506 GTEST_LOG_(INFO) << "ReleaseTest ERROR";
1507 }
1508 GTEST_LOG_(INFO) << "ReleaseTest End";
1509 }
1510
1511 /**
1512 * @tc.name:SetAttrTest001
1513 * @tc.desc: Verify the SetAttr function
1514 * @tc.type: FUNC
1515 * @tc.require: issuesI92WQP
1516 */
1517 HWTEST_F(FuseOperationsTest, SetAttrTest001, TestSize.Level1)
1518 {
1519 GTEST_LOG_(INFO) << "SetAttrTest001 Start";
1520 try {
1521 fuse_req_t req = nullptr;
1522 struct fuse_file_info fi;
1523 struct stat attr;
1524 int valid = 0;
1525
1526 fuseoperations_->SetAttr(req, FUSE_ROOT_ID, &attr, valid, &fi);
1527 EXPECT_TRUE(true);
1528 } catch (...) {
1529 EXPECT_TRUE(false);
1530 GTEST_LOG_(INFO) << "SetAttrTest001 ERROR";
1531 }
1532 GTEST_LOG_(INFO) << "SetAttrTest001 End";
1533 }
1534
1535 /**
1536 * @tc.name:SetAttrTest002
1537 * @tc.desc: Verify the SetAttr function
1538 * @tc.type: FUNC
1539 * @tc.require: issuesI92WQP
1540 */
1541 HWTEST_F(FuseOperationsTest, SetAttrTest002, TestSize.Level1)
1542 {
1543 GTEST_LOG_(INFO) << "SetAttrTest002 Start";
1544 try {
1545 CloudDiskFuseData data;
1546 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1547 fuse_req_t req = nullptr;
1548 struct fuse_file_info fi;
1549 struct stat attr;
1550 int valid = 0;
1551
1552 fuseoperations_->SetAttr(req, 0, &attr, valid, &fi);
1553 EXPECT_TRUE(true);
1554 } catch (...) {
1555 EXPECT_TRUE(false);
1556 GTEST_LOG_(INFO) << "SetAttrTest002 ERROR";
1557 }
1558 GTEST_LOG_(INFO) << "SetAttrTest002 End";
1559 }
1560
1561 /**
1562 * @tc.name:SetAttrTest
1563 * @tc.desc: Verify the SetAttr function
1564 * @tc.type: FUNC
1565 * @tc.require: issuesI92WQP
1566 */
1567 HWTEST_F(FuseOperationsTest, SetAttrTest, TestSize.Level1)
1568 {
1569 GTEST_LOG_(INFO) << "SetAttrTest Start";
1570 try {
1571 CloudDiskFuseData data;
1572 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
1573 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1574 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
1575 .WillOnce(Return(reinterpret_cast<void *>(&data)));
1576 fuse_req_t req = nullptr;
1577 fuse_ino_t ino = 0;
1578 struct fuse_file_info fi;
1579 struct stat attr;
1580 int valid = 0;
1581
1582 fuseoperations_->SetAttr(req, ino, &attr, valid, &fi);
1583 EXPECT_NE(ino, FUSE_ROOT_ID);
1584 EXPECT_NE((data.inodeCache)[0], nullptr);
1585 } catch (...) {
1586 EXPECT_TRUE(false);
1587 GTEST_LOG_(INFO) << "SetAttrTest ERROR";
1588 }
1589 GTEST_LOG_(INFO) << "SetAttrTest End";
1590 }
1591
1592 /**
1593 * @tc.name:LseekTest001
1594 * @tc.desc: Verify the Lseek function
1595 * @tc.type: FUNC
1596 * @tc.require: issuesI92WQP
1597 */
1598 HWTEST_F(FuseOperationsTest, LseekTest001, TestSize.Level1)
1599 {
1600 GTEST_LOG_(INFO) << "LseekTest001 Start";
1601 try {
1602 fuse_req_t req = nullptr;
1603 off_t off = 0;
1604 int whence = 0;
1605 struct fuse_file_info fi;
1606
1607 fuseoperations_->Lseek(req, FUSE_ROOT_ID, off, whence, &fi);
1608 EXPECT_TRUE(true);
1609 } catch (...) {
1610 EXPECT_TRUE(false);
1611 GTEST_LOG_(INFO) << "LseekTest001 ERROR";
1612 }
1613 GTEST_LOG_(INFO) << "LseekTest001 End";
1614 }
1615
1616 /**
1617 * @tc.name:LseekTest002
1618 * @tc.desc: Verify the Lseek function
1619 * @tc.type: FUNC
1620 * @tc.require: issuesI92WQP
1621 */
1622 HWTEST_F(FuseOperationsTest, LseekTest002, TestSize.Level1)
1623 {
1624 GTEST_LOG_(INFO) << "LseekTest002 Start";
1625 try {
1626 CloudDiskFuseData data;
1627 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1628 fuse_req_t req = nullptr;
1629 off_t off = 0;
1630 int whence = 0;
1631 struct fuse_file_info fi;
1632
1633 fuseoperations_->Lseek(req, 0, off, whence, &fi);
1634 EXPECT_TRUE(true);
1635 } catch (...) {
1636 EXPECT_TRUE(false);
1637 GTEST_LOG_(INFO) << "LseekTest002 ERROR";
1638 }
1639 GTEST_LOG_(INFO) << "LseekTest002 End";
1640 }
1641
1642 /**
1643 * @tc.name:LseekTest
1644 * @tc.desc: Verify the Lseek function
1645 * @tc.type: FUNC
1646 * @tc.require: issuesI92WQP
1647 */
1648 HWTEST_F(FuseOperationsTest, LseekTest, TestSize.Level1)
1649 {
1650 GTEST_LOG_(INFO) << "LseekTest Start";
1651 try {
1652 CloudDiskFuseData data;
1653 (data.inodeCache)[0] = make_shared<CloudDiskInode>();
1654 (data.inodeCache)[0]->ops = make_shared<FileOperationsCloud>();
1655 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)))
1656 .WillOnce(Return(reinterpret_cast<void *>(&data)));
1657 fuse_req_t req = nullptr;
1658 fuse_ino_t ino = 0;
1659 off_t off = 0;
1660 int whence = 0;
1661 struct fuse_file_info fi;
1662
1663 fuseoperations_->Lseek(req, ino, off, whence, &fi);
1664 EXPECT_NE(ino, FUSE_ROOT_ID);
1665 EXPECT_NE((data.inodeCache)[0], nullptr);
1666 } catch (...) {
1667 EXPECT_TRUE(false);
1668 GTEST_LOG_(INFO) << "LseekTest ERROR";
1669 }
1670 GTEST_LOG_(INFO) << "LseekTest End";
1671 }
1672 } // namespace OHOS::FileManagement::CloudDisk::Test