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