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 "file_operations_cloud.h"
20
21 #include "assistant.h"
22 #include "cloud_disk_inode.h"
23 #include "clouddisk_rdb_utils.h"
24 #include "dfs_error.h"
25
26 namespace OHOS::FileManagement::CloudDisk {
FuseDentryAlignSize(const char * name)27 size_t CloudDiskRdbUtils::FuseDentryAlignSize(const char *name)
28 {
29 return 0;
30 }
31 }
32
33 namespace OHOS::FileManagement::CloudDisk::Test {
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace std;
37
38 class FileOperationsCloudTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 static inline shared_ptr<FileOperationsCloud> fileOperationsCloud_ = nullptr;
45 static inline shared_ptr<AssistantMock> insMock = nullptr;
46 };
47
SetUpTestCase(void)48 void FileOperationsCloudTest::SetUpTestCase(void)
49 {
50 fileOperationsCloud_ = make_shared<FileOperationsCloud>();
51 insMock = make_shared<AssistantMock>();
52 Assistant::ins = insMock;
53 GTEST_LOG_(INFO) << "SetUpTestCase";
54 }
55
TearDownTestCase(void)56 void FileOperationsCloudTest::TearDownTestCase(void)
57 {
58 Assistant::ins = nullptr;
59 insMock = nullptr;
60 fileOperationsCloud_ = nullptr;
61 GTEST_LOG_(INFO) << "TearDownTestCase";
62 }
63
SetUp(void)64 void FileOperationsCloudTest::SetUp(void)
65 {
66 GTEST_LOG_(INFO) << "SetUp";
67 }
68
TearDown(void)69 void FileOperationsCloudTest::TearDown(void)
70 {
71 GTEST_LOG_(INFO) << "TearDown";
72 }
73
74 /**
75 * @tc.name: LookupTest001
76 * @tc.desc: Verify the Lookup function
77 * @tc.type: FUNC
78 * @tc.require: issuesI91IOG
79 */
80 HWTEST_F(FileOperationsCloudTest, LookupTest001, TestSize.Level1)
81 {
82 GTEST_LOG_(INFO) << "LookupTest001 Start";
83 try {
84 CloudDiskFuseData data;
85 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
86 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
87
88 fuse_ino_t parent = FUSE_ROOT_ID;
89 const char *name = "";
90 fileOperationsCloud_->Lookup(nullptr, parent, name);
91 EXPECT_TRUE(true);
92 } catch (...) {
93 EXPECT_TRUE(false);
94 GTEST_LOG_(INFO) << "LookupTest001 ERROR";
95 }
96 GTEST_LOG_(INFO) << "LookupTest001 End";
97 }
98
99 /**
100 * @tc.name: LookupTest002
101 * @tc.desc: Verify the Lookup function
102 * @tc.type: FUNC
103 * @tc.require: issuesI91IOG
104 */
105 HWTEST_F(FileOperationsCloudTest, LookupTest002, TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "LookupTest002 Start";
108 try {
109 CloudDiskFuseData data;
110 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
111 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
112
113 fuse_ino_t parent = -1;
114 const char *name = "";
115 fileOperationsCloud_->Lookup(nullptr, parent, name);
116 EXPECT_TRUE(true);
117 } catch (...) {
118 EXPECT_TRUE(false);
119 GTEST_LOG_(INFO) << "LookupTest002 ERROR";
120 }
121 GTEST_LOG_(INFO) << "LookupTest002 End";
122 }
123
124 /**
125 * @tc.name: LookupTest003
126 * @tc.desc: Verify the Lookup function
127 * @tc.type: FUNC
128 * @tc.require: issuesI91IOG
129 */
130 HWTEST_F(FileOperationsCloudTest, LookupTest003, TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "LookupTest003 Start";
133 try {
134 CloudDiskFuseData data;
135 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
136 EXPECT_CALL(*insMock, fuse_reply_entry(_, _)).WillOnce(Return(E_OK));
137
138 fuse_ino_t parent = 4;
139 const char *name = ".trash";
140 fileOperationsCloud_->Lookup(nullptr, parent, name);
141 EXPECT_TRUE(true);
142 } catch (...) {
143 EXPECT_TRUE(false);
144 GTEST_LOG_(INFO) << "LookupTest003 ERROR";
145 }
146 GTEST_LOG_(INFO) << "LookupTest003 End";
147 }
148
149 /**
150 * @tc.name: LookupTest004
151 * @tc.desc: Verify the Lookup function
152 * @tc.type: FUNC
153 * @tc.require: issuesI91IOG
154 */
155 HWTEST_F(FileOperationsCloudTest, LookupTest004, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "LookupTest004 Start";
158 try {
159 CloudDiskFuseData data;
160 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
161 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
162
163 fuse_ino_t parent = 4;
164 const char *name = "mock";
165 fileOperationsCloud_->Lookup(nullptr, parent, name);
166 EXPECT_TRUE(true);
167 } catch (...) {
168 EXPECT_TRUE(false);
169 GTEST_LOG_(INFO) << "LookupTest004 ERROR";
170 }
171 GTEST_LOG_(INFO) << "LookupTest004 End";
172 }
173
174 /**
175 * @tc.name: LookupTest005
176 * @tc.desc: Verify the Lookup function
177 * @tc.type: FUNC
178 * @tc.require: issuesI91IOG
179 */
180 HWTEST_F(FileOperationsCloudTest, LookupTest005, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO) << "LookupTest005 Start";
183 try {
184 CloudDiskFuseData data;
185 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
186 EXPECT_CALL(*insMock, fuse_reply_entry(_, _)).WillOnce(Return(E_OK));
187
188 fuse_ino_t parent = 4;
189 const char *name = "";
190 fileOperationsCloud_->Lookup(nullptr, parent, name);
191 EXPECT_TRUE(true);
192 } catch (...) {
193 EXPECT_TRUE(false);
194 GTEST_LOG_(INFO) << "LookupTest005 ERROR";
195 }
196 GTEST_LOG_(INFO) << "LookupTest005 End";
197 }
198
199 /**
200 * @tc.name: LookupTest006
201 * @tc.desc: Verify the Lookup function
202 * @tc.type: FUNC
203 * @tc.require: issuesI91IOG
204 */
205 HWTEST_F(FileOperationsCloudTest, LookupTest006, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "LookupTest006 Start";
208 try {
209 CloudDiskFuseData data;
210 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
211 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
212
213 fuse_ino_t parent = 2;
214 const char *name = "mock";
215 fileOperationsCloud_->Lookup(nullptr, parent, name);
216 EXPECT_TRUE(true);
217 } catch (...) {
218 EXPECT_TRUE(false);
219 GTEST_LOG_(INFO) << "LookupTest006 ERROR";
220 }
221 GTEST_LOG_(INFO) << "LookupTest006 End";
222 }
223
224 /**
225 * @tc.name: LookupTest007
226 * @tc.desc: Verify the Lookup function
227 * @tc.type: FUNC
228 * @tc.require: issuesI91IOG
229 */
230 HWTEST_F(FileOperationsCloudTest, LookupTest007, TestSize.Level1)
231 {
232 GTEST_LOG_(INFO) << "LookupTest007 Start";
233 try {
234 CloudDiskFuseData data;
235 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
236 EXPECT_CALL(*insMock, fuse_reply_entry(_, _)).WillOnce(Return(E_OK));
237
238 fuse_ino_t parent = 2;
239 const char *name = "";
240 fileOperationsCloud_->Lookup(nullptr, parent, name);
241 EXPECT_TRUE(true);
242 } catch (...) {
243 EXPECT_TRUE(false);
244 GTEST_LOG_(INFO) << "LookupTest007 ERROR";
245 }
246 GTEST_LOG_(INFO) << "LookupTest007 End";
247 }
248
249 /**
250 * @tc.name: AccessTest001
251 * @tc.desc: Verify the Access function
252 * @tc.type: FUNC
253 * @tc.require: issuesI91IOG
254 */
255 HWTEST_F(FileOperationsCloudTest, AccessTest001, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "AccessTest001 Start";
258 try {
259 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
260
261 fuse_ino_t ino = FUSE_ROOT_ID;
262 int mask = 0;
263 fileOperationsCloud_->Access(nullptr, ino, mask);
264 EXPECT_TRUE(true);
265 } catch (...) {
266 EXPECT_TRUE(false);
267 GTEST_LOG_(INFO) << "AccessTest001 ERROR";
268 }
269 GTEST_LOG_(INFO) << "AccessTest001 End";
270 }
271
272 /**
273 * @tc.name: GetAttrTest001
274 * @tc.desc: Verify the GetAttr function
275 * @tc.type: FUNC
276 * @tc.require: issuesI91IOG
277 */
278 HWTEST_F(FileOperationsCloudTest, GetAttrTest001, TestSize.Level1)
279 {
280 GTEST_LOG_(INFO) << "GetAttrTest001 Start";
281 try {
282 CloudDiskFuseData data;
283 fuse_ino_t ino = FUSE_ROOT_ID;
284 struct fuse_file_info *fi = nullptr;
285
286 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
287 EXPECT_CALL(*insMock, fuse_reply_attr(_, _, _)).WillRepeatedly(Return(E_OK));
288 fileOperationsCloud_->GetAttr(nullptr, ino, fi);
289 EXPECT_TRUE(true);
290 } catch (...) {
291 EXPECT_TRUE(false);
292 GTEST_LOG_(INFO) << "GetAttrTest001 ERROR";
293 }
294 GTEST_LOG_(INFO) << "GetAttrTest001 End";
295 }
296
297 /**
298 * @tc.name: GetAttrTest002
299 * @tc.desc: Verify the GetAttr function
300 * @tc.type: FUNC
301 * @tc.require: issuesI91IOG
302 */
303 HWTEST_F(FileOperationsCloudTest, GetAttrTest002, TestSize.Level1)
304 {
305 GTEST_LOG_(INFO) << "GetAttrTest002 Start";
306 try {
307 CloudDiskFuseData data;
308 fuse_ino_t ino = -1;
309 struct fuse_file_info *fi = nullptr;
310
311 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
312 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
313 fileOperationsCloud_->GetAttr(nullptr, ino, fi);
314 EXPECT_TRUE(true);
315 } catch (...) {
316 EXPECT_TRUE(false);
317 GTEST_LOG_(INFO) << "GetAttrTest002 ERROR";
318 }
319 GTEST_LOG_(INFO) << "GetAttrTest002 End";
320 }
321
322 /**
323 * @tc.name: OpenTest001
324 * @tc.desc: Verify the Open function
325 * @tc.type: FUNC
326 * @tc.require: issuesI91IOG
327 */
328 HWTEST_F(FileOperationsCloudTest, OpenTest001, TestSize.Level1)
329 {
330 GTEST_LOG_(INFO) << "OpenTest001 Start";
331 try {
332 CloudDiskFuseData data;
333 fuse_req_t req = nullptr;
334 fuse_ino_t ino = -1;
335 struct fuse_file_info fi;
336
337 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
338 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
339 fileOperationsCloud_->Open(req, ino, &fi);
340 EXPECT_TRUE(true);
341 } catch (...) {
342 EXPECT_TRUE(false);
343 GTEST_LOG_(INFO) << "OpenTest001 ERROR";
344 }
345 GTEST_LOG_(INFO) << "OpenTest001 End";
346 }
347
348 /**
349 * @tc.name: OpenTest002
350 * @tc.desc: Verify the Open function
351 * @tc.type: FUNC
352 * @tc.require: issuesI91IOG
353 */
354 HWTEST_F(FileOperationsCloudTest, OpenTest002, TestSize.Level1)
355 {
356 GTEST_LOG_(INFO) << "OpenTest002 Start";
357 try {
358 CloudDiskFuseData data;
359 data.userId = 0;
360 fuse_req_t req = nullptr;
361 CloudDiskInode ino;
362 struct fuse_file_info fi;
363 fi.flags |= (O_ACCMODE | O_WRONLY);
364
365 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
366 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
367 EXPECT_TRUE(true);
368 EXPECT_TRUE(true);
369 } catch (...) {
370 EXPECT_TRUE(false);
371 GTEST_LOG_(INFO) << "OpenTest002 ERROR";
372 }
373 GTEST_LOG_(INFO) << "OpenTest002 End";
374 }
375
376 /**
377 * @tc.name: OpenTest003
378 * @tc.desc: Verify the Open function
379 * @tc.type: FUNC
380 * @tc.require: issuesI91IOG
381 */
382 HWTEST_F(FileOperationsCloudTest, OpenTest003, TestSize.Level1)
383 {
384 GTEST_LOG_(INFO) << "OpenTest003 Start";
385 try {
386 CloudDiskFuseData data;
387 data.userId = 0;
388 fuse_req_t req = nullptr;
389 CloudDiskInode ino;
390 struct fuse_file_info fi;
391 fi.flags |= O_APPEND;
392
393 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
394 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
395 EXPECT_TRUE(true);
396 EXPECT_TRUE(true);
397 } catch (...) {
398 EXPECT_TRUE(false);
399 GTEST_LOG_(INFO) << "OpenTest003 ERROR";
400 }
401 GTEST_LOG_(INFO) << "OpenTest003 End";
402 }
403
404 /**
405 * @tc.name: OpenTest004
406 * @tc.desc: Verify the Open function
407 * @tc.type: FUNC
408 * @tc.require: issuesI91IOG
409 */
410 HWTEST_F(FileOperationsCloudTest, OpenTest004, TestSize.Level1)
411 {
412 GTEST_LOG_(INFO) << "OpenTest004 Start";
413 try {
414 CloudDiskFuseData data;
415 data.userId = 0;
416 fuse_req_t req = nullptr;
417 CloudDiskInode ino;
418 struct fuse_file_info fi;
419 fi.flags |= O_DIRECT;
420
421 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
422 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
423 EXPECT_TRUE(true);
424 EXPECT_TRUE(true);
425 } catch (...) {
426 EXPECT_TRUE(false);
427 GTEST_LOG_(INFO) << "OpenTest004 ERROR";
428 }
429 GTEST_LOG_(INFO) << "OpenTest004 End";
430 }
431
432 /**
433 * @tc.name: OpenTest005
434 * @tc.desc: Verify the Open function
435 * @tc.type: FUNC
436 * @tc.require: issuesI91IOG
437 */
438 HWTEST_F(FileOperationsCloudTest, OpenTest005, TestSize.Level1)
439 {
440 GTEST_LOG_(INFO) << "OpenTest005 Start";
441 try {
442 CloudDiskFuseData data;
443 data.userId = 0;
444 fuse_req_t req = nullptr;
445 CloudDiskInode ino;
446 struct fuse_file_info fi;
447
448 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
449 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
450 EXPECT_TRUE(true);
451 EXPECT_TRUE(true);
452 } catch (...) {
453 EXPECT_TRUE(false);
454 GTEST_LOG_(INFO) << "OpenTest005 ERROR";
455 }
456 GTEST_LOG_(INFO) << "OpenTest005 End";
457 }
458
459 /**
460 * @tc.name: OpenTest006
461 * @tc.desc: Verify the Open function
462 * @tc.type: FUNC
463 * @tc.require: issuesI91IOG
464 */
465 HWTEST_F(FileOperationsCloudTest, OpenTest006, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO) << "OpenTest006 Start";
468 try {
469 CloudDiskFuseData data;
470 data.userId = 100;
471 fuse_req_t req = nullptr;
472 CloudDiskInode ino;
473 struct fuse_file_info fi;
474 fi.fh = -1;
475
476 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
477 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
478 EXPECT_TRUE(true);
479 EXPECT_TRUE(true);
480 } catch (...) {
481 EXPECT_TRUE(false);
482 GTEST_LOG_(INFO) << "OpenTest006 ERROR";
483 }
484 GTEST_LOG_(INFO) << "OpenTest006 End";
485 }
486
487 /**
488 * @tc.name: OpenTest007
489 * @tc.desc: Verify the Open function
490 * @tc.type: FUNC
491 * @tc.require: issuesI91IOG
492 */
493 HWTEST_F(FileOperationsCloudTest, OpenTest007, TestSize.Level1)
494 {
495 GTEST_LOG_(INFO) << "OpenTest007 Start";
496 try {
497 CloudDiskFuseData data;
498 data.userId = 100;
499 fuse_req_t req = nullptr;
500 CloudDiskInode ino;
501 struct fuse_file_info fi;
502
503 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
504 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
505 EXPECT_TRUE(true);
506 EXPECT_TRUE(true);
507 } catch (...) {
508 EXPECT_TRUE(false);
509 GTEST_LOG_(INFO) << "OpenTest007 ERROR";
510 }
511 GTEST_LOG_(INFO) << "OpenTest007 End";
512 }
513
514 /**
515 * @tc.name: MkNodTest001
516 * @tc.desc: Verify the MkNod function
517 * @tc.type: FUNC
518 * @tc.require: issuesI91IOG
519 */
520 HWTEST_F(FileOperationsCloudTest, MkNodTest001, TestSize.Level1)
521 {
522 GTEST_LOG_(INFO) << "MkNodTest001 Start";
523 try {
524 CloudDiskFuseData data;
525 fuse_req_t req = nullptr;
526 CloudDiskInode ino;
527 const char *name = "";
528 mode_t mode = 0;
529 dev_t rdev = 0;
530
531 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
532 fileOperationsCloud_->MkNod(req, reinterpret_cast<fuse_ino_t>(&ino), name, mode, rdev);
533 EXPECT_TRUE(true);
534 } catch (...) {
535 EXPECT_TRUE(false);
536 GTEST_LOG_(INFO) << "MkNodTest001 ERROR";
537 }
538 GTEST_LOG_(INFO) << "MkNodTest001 End";
539 }
540
541 /**
542 * @tc.name: MkNodTest002
543 * @tc.desc: Verify the MkNod function
544 * @tc.type: FUNC
545 * @tc.require: issuesI91IOG
546 */
547 HWTEST_F(FileOperationsCloudTest, MkNodTest002, TestSize.Level1)
548 {
549 GTEST_LOG_(INFO) << "MkNodTest002 Start";
550 try {
551 CloudDiskFuseData data;
552 fuse_req_t req = nullptr;
553 uint64_t parent = -1;
554 const char *name = "";
555 mode_t mode = 0;
556 dev_t rdev = 0;
557
558 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
559 fileOperationsCloud_->MkNod(req, parent, name, mode, rdev);
560 EXPECT_TRUE(true);
561 } catch (...) {
562 EXPECT_TRUE(false);
563 GTEST_LOG_(INFO) << "MkNodTest002 ERROR";
564 }
565 GTEST_LOG_(INFO) << "MkNodTest002 End";
566 }
567
568 /**
569 * @tc.name: CreateTest001
570 * @tc.desc: Verify the Create function
571 * @tc.type: FUNC
572 * @tc.require: issuesI91IOG
573 */
574 HWTEST_F(FileOperationsCloudTest, CreateTest001, TestSize.Level1)
575 {
576 GTEST_LOG_(INFO) << "CreateTest001 Start";
577 try {
578 CloudDiskFuseData data;
579 fuse_req_t req = nullptr;
580 fuse_ino_t parent = 0;
581 const char *name = "";
582 mode_t mode = 0;
583 struct fuse_file_info fi;
584
585 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
586 fileOperationsCloud_->Create(req, parent, name, mode, &fi);
587 EXPECT_TRUE(true);
588 } catch (...) {
589 EXPECT_TRUE(false);
590 GTEST_LOG_(INFO) << "CreateTest001 ERROR";
591 }
592 GTEST_LOG_(INFO) << "CreateTest001 End";
593 }
594
595 /**
596 * @tc.name: CreateTest002
597 * @tc.desc: Verify the Create function
598 * @tc.type: FUNC
599 * @tc.require: issuesI91IOG
600 */
601 HWTEST_F(FileOperationsCloudTest, CreateTest002, TestSize.Level1)
602 {
603 GTEST_LOG_(INFO) << "CreateTest002 Start";
604 try {
605 CloudDiskFuseData data;
606 fuse_req_t req = nullptr;
607 fuse_ino_t parent = 5;
608 const char *name = "";
609 mode_t mode = 0;
610 struct fuse_file_info fi;
611 fi.fh = 4;
612
613 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
614 fileOperationsCloud_->Create(req, parent, name, mode, &fi);
615 EXPECT_TRUE(true);
616 } catch (...) {
617 EXPECT_TRUE(false);
618 GTEST_LOG_(INFO) << "CreateTest002 ERROR";
619 }
620 GTEST_LOG_(INFO) << "CreateTest002 End";
621 }
622
623 /**
624 * @tc.name: ReadDirTest001
625 * @tc.desc: Verify the ReadDir function
626 * @tc.type: FUNC
627 * @tc.require: issuesI91IOG
628 */
629 HWTEST_F(FileOperationsCloudTest, ReadDirTest001, TestSize.Level1)
630 {
631 GTEST_LOG_(INFO) << "ReadDirTest001 Start";
632 try {
633 CloudDiskFuseData data;
634 fuse_req_t req = nullptr;
635 fuse_ino_t ino = 4;
636 size_t size = 0;
637 off_t off = 0;
638 struct fuse_file_info fi;
639
640 fileOperationsCloud_->ReadDir(req, ino, size, off, &fi);
641 EXPECT_TRUE(true);
642 } catch (...) {
643 EXPECT_TRUE(false);
644 GTEST_LOG_(INFO) << "ReadDirTest001 ERROR";
645 }
646 GTEST_LOG_(INFO) << "ReadDirTest001 End";
647 }
648
649 /**
650 * @tc.name: ReadDirTest002
651 * @tc.desc: Verify the ReadDir function
652 * @tc.type: FUNC
653 * @tc.require: issuesI91IOG
654 */
655 HWTEST_F(FileOperationsCloudTest, ReadDirTest002, TestSize.Level1)
656 {
657 GTEST_LOG_(INFO) << "ReadDirTest002 Start";
658 try {
659 CloudDiskFuseData data;
660 fuse_req_t req = nullptr;
661 fuse_ino_t ino = -1;
662 size_t size = 0;
663 off_t off = 0;
664 struct fuse_file_info fi;
665
666 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
667 fileOperationsCloud_->ReadDir(req, ino, size, off, &fi);
668 EXPECT_TRUE(true);
669 } catch (...) {
670 EXPECT_TRUE(false);
671 GTEST_LOG_(INFO) << "ReadDirTest002 ERROR";
672 }
673 GTEST_LOG_(INFO) << "ReadDirTest002 End";
674 }
675
676
677 /**
678 * @tc.name: ReadDirTest003
679 * @tc.desc: Verify the ReadDir function
680 * @tc.type: FUNC
681 * @tc.require: issuesI91IOG
682 */
683 HWTEST_F(FileOperationsCloudTest, ReadDirTest003, TestSize.Level1)
684 {
685 GTEST_LOG_(INFO) << "ReadDirTest003 Start";
686 try {
687 CloudDiskFuseData data;
688 fuse_req_t req = nullptr;
689 fuse_ino_t ino = 0;
690 size_t size = 0;
691 off_t off = 0;
692 struct fuse_file_info fi;
693
694 fileOperationsCloud_->ReadDir(req, ino, size, off, &fi);
695 EXPECT_TRUE(true);
696 } catch (...) {
697 EXPECT_TRUE(false);
698 GTEST_LOG_(INFO) << "ReadDirTest003 ERROR";
699 }
700 GTEST_LOG_(INFO) << "ReadDirTest003 End";
701 }
702
703 /**
704 * @tc.name: SetXattrTest001
705 * @tc.desc: Verify the SetXattr function
706 * @tc.type: FUNC
707 * @tc.require: issuesI91IOG
708 */
709 HWTEST_F(FileOperationsCloudTest, SetXattrTest001, TestSize.Level1)
710 {
711 GTEST_LOG_(INFO) << "SetXattrTest001 Start";
712 try {
713 CloudDiskFuseData data;
714 fuse_req_t req = nullptr;
715 fuse_ino_t ino = 0;
716 string name = HMDFS_PERMISSION_XATTR;
717 const char *value = "";
718 size_t size = 0;
719 int flags = 0;
720
721 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
722 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
723 EXPECT_TRUE(true);
724 } catch (...) {
725 EXPECT_TRUE(false);
726 GTEST_LOG_(INFO) << "SetXattrTest001 ERROR";
727 }
728 GTEST_LOG_(INFO) << "SetXattrTest001 End";
729 }
730
731 /**
732 * @tc.name: SetXattrTest002
733 * @tc.desc: Verify the SetXattr function
734 * @tc.type: FUNC
735 * @tc.require: issuesI91IOG
736 */
737 HWTEST_F(FileOperationsCloudTest, SetXattrTest002, TestSize.Level1)
738 {
739 GTEST_LOG_(INFO) << "SetXattrTest002 Start";
740 try {
741 CloudDiskFuseData data;
742 fuse_req_t req = nullptr;
743 fuse_ino_t ino = -1;
744 string name = CLOUD_FILE_LOCATION;
745 const char *value = "";
746 size_t size = 0;
747 int flags = 0;
748
749 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
750 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
751 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
752 EXPECT_TRUE(true);
753 } catch (...) {
754 EXPECT_TRUE(false);
755 GTEST_LOG_(INFO) << "SetXattrTest002 ERROR";
756 }
757 GTEST_LOG_(INFO) << "SetXattrTest002 End";
758 }
759
760 /**
761 * @tc.name: SetXattrTest003
762 * @tc.desc: Verify the SetXattr function
763 * @tc.type: FUNC
764 * @tc.require: issuesI91IOG
765 */
766 HWTEST_F(FileOperationsCloudTest, SetXattrTest003, TestSize.Level1)
767 {
768 GTEST_LOG_(INFO) << "SetXattrTest003 Start";
769 try {
770 CloudDiskFuseData data;
771 fuse_req_t req = nullptr;
772 fuse_ino_t ino = 0;
773 string name = CLOUD_FILE_LOCATION;
774 const char *value = "";
775 size_t size = 0;
776 int flags = 0;
777
778 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
779 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
780 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
781 EXPECT_TRUE(true);
782 } catch (...) {
783 EXPECT_TRUE(false);
784 GTEST_LOG_(INFO) << "SetXattrTest003 ERROR";
785 }
786 GTEST_LOG_(INFO) << "SetXattrTest003 End";
787 }
788
789 /**
790 * @tc.name: SetXattrTest004
791 * @tc.desc: Verify the SetXattr function
792 * @tc.type: FUNC
793 * @tc.require: issuesI91IOG
794 */
795 HWTEST_F(FileOperationsCloudTest, SetXattrTest004, TestSize.Level1)
796 {
797 GTEST_LOG_(INFO) << "SetXattrTest004 Start";
798 try {
799 CloudDiskFuseData data;
800 fuse_req_t req = nullptr;
801 fuse_ino_t ino = 1;
802 string name = CLOUD_FILE_LOCATION;
803 const char *value = "";
804 size_t size = 0;
805 int flags = 0;
806
807 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
808 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
809 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
810 EXPECT_TRUE(true);
811 } catch (...) {
812 EXPECT_TRUE(false);
813 GTEST_LOG_(INFO) << "SetXattrTest004 ERROR";
814 }
815 GTEST_LOG_(INFO) << "SetXattrTest004 End";
816 }
817
818 /**
819 * @tc.name: SetXattrTest005
820 * @tc.desc: Verify the SetXattr function
821 * @tc.type: FUNC
822 * @tc.require: issuesI91IOG
823 */
824 HWTEST_F(FileOperationsCloudTest, SetXattrTest005, TestSize.Level1)
825 {
826 GTEST_LOG_(INFO) << "SetXattrTest005 Start";
827 try {
828 CloudDiskFuseData data;
829 fuse_req_t req = nullptr;
830 fuse_ino_t ino = 1;
831 string name = CLOUD_FILE_LOCATION;
832 const char *value = "test";
833 size_t size = 0;
834 int flags = 0;
835
836 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
837 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
838 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
839 EXPECT_TRUE(true);
840 } catch (...) {
841 EXPECT_TRUE(false);
842 GTEST_LOG_(INFO) << "SetXattrTest005 ERROR";
843 }
844 GTEST_LOG_(INFO) << "SetXattrTest005 End";
845 }
846
847 /**
848 * @tc.name: SetXattrTest006
849 * @tc.desc: Verify the SetXattr function
850 * @tc.type: FUNC
851 * @tc.require: issuesI91IOG
852 */
853 HWTEST_F(FileOperationsCloudTest, SetXattrTest006, TestSize.Level1)
854 {
855 GTEST_LOG_(INFO) << "SetXattrTest006 Start";
856 try {
857 CloudDiskFuseData data;
858 fuse_req_t req = nullptr;
859 fuse_ino_t ino = -1;
860 string name = CLOUD_CLOUD_RECYCLE_XATTR;
861 const char *value = "";
862 size_t size = 0;
863 int flags = 0;
864
865 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
866 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
867 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
868 EXPECT_TRUE(true);
869 } catch (...) {
870 EXPECT_TRUE(false);
871 GTEST_LOG_(INFO) << "SetXattrTest006 ERROR";
872 }
873 GTEST_LOG_(INFO) << "SetXattrTest006 End";
874 }
875
876 /**
877 * @tc.name: SetXattrTest007
878 * @tc.desc: Verify the SetXattr function
879 * @tc.type: FUNC
880 * @tc.require: issuesI91IOG
881 */
882 HWTEST_F(FileOperationsCloudTest, SetXattrTest007, TestSize.Level1)
883 {
884 GTEST_LOG_(INFO) << "SetXattrTest007 Start";
885 try {
886 CloudDiskFuseData data;
887 fuse_req_t req = nullptr;
888 fuse_ino_t ino = -1;
889 string name = CLOUD_CLOUD_RECYCLE_XATTR;
890 const char *value = "";
891 size_t size = 0;
892 int flags = 0;
893
894 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
895 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
896 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
897 EXPECT_TRUE(true);
898 } catch (...) {
899 EXPECT_TRUE(false);
900 GTEST_LOG_(INFO) << "SetXattrTest007 ERROR";
901 }
902 GTEST_LOG_(INFO) << "SetXattrTest007 End";
903 }
904
905 /**
906 * @tc.name: SetXattrTest008
907 * @tc.desc: Verify the SetXattr function
908 * @tc.type: FUNC
909 * @tc.require: issuesI91IOG
910 */
911 HWTEST_F(FileOperationsCloudTest, SetXattrTest008, TestSize.Level1)
912 {
913 GTEST_LOG_(INFO) << "SetXattrTest008 Start";
914 try {
915 CloudDiskFuseData data;
916 fuse_req_t req = nullptr;
917 fuse_ino_t ino = 1;
918 string name = CLOUD_CLOUD_RECYCLE_XATTR;
919 const char *value = "";
920 size_t size = 0;
921 int flags = 0;
922
923 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
924 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
925 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
926 EXPECT_TRUE(true);
927 } catch (...) {
928 EXPECT_TRUE(false);
929 GTEST_LOG_(INFO) << "SetXattrTest008 ERROR";
930 }
931 GTEST_LOG_(INFO) << "SetXattrTest008 End";
932 }
933
934 /**
935 * @tc.name: SetXattrTest009
936 * @tc.desc: Verify the SetXattr function
937 * @tc.type: FUNC
938 * @tc.require: issuesI91IOG
939 */
940 HWTEST_F(FileOperationsCloudTest, SetXattrTest009, TestSize.Level1)
941 {
942 GTEST_LOG_(INFO) << "SetXattrTest009 Start";
943 try {
944 CloudDiskFuseData data;
945 fuse_req_t req = nullptr;
946 fuse_ino_t ino = 2;
947 string name = CLOUD_CLOUD_RECYCLE_XATTR;
948 const char *value = "";
949 size_t size = 0;
950 int flags = 0;
951
952 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
953 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
954 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
955 EXPECT_TRUE(true);
956 } catch (...) {
957 EXPECT_TRUE(false);
958 GTEST_LOG_(INFO) << "SetXattrTest009 ERROR";
959 }
960 GTEST_LOG_(INFO) << "SetXattrTest009 End";
961 }
962
963 /**
964 * @tc.name: SetXattrTest010
965 * @tc.desc: Verify the SetXattr function
966 * @tc.type: FUNC
967 * @tc.require: issuesI91IOG
968 */
969 HWTEST_F(FileOperationsCloudTest, SetXattrTest010, TestSize.Level1)
970 {
971 GTEST_LOG_(INFO) << "SetXattrTest010 Start";
972 try {
973 CloudDiskFuseData data;
974 fuse_req_t req = nullptr;
975 fuse_ino_t ino = -1;
976 string name = IS_FAVORITE_XATTR;
977 const char *value = "";
978 size_t size = 0;
979 int flags = 0;
980
981 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
982 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
983 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
984 EXPECT_TRUE(true);
985 } catch (...) {
986 EXPECT_TRUE(false);
987 GTEST_LOG_(INFO) << "SetXattrTest010 ERROR";
988 }
989 GTEST_LOG_(INFO) << "SetXattrTest010 End";
990 }
991
992 /**
993 * @tc.name: SetXattrTest011
994 * @tc.desc: Verify the SetXattr function
995 * @tc.type: FUNC
996 * @tc.require: issuesI91IOG
997 */
998 HWTEST_F(FileOperationsCloudTest, SetXattrTest011, TestSize.Level1)
999 {
1000 GTEST_LOG_(INFO) << "SetXattrTest011 Start";
1001 try {
1002 CloudDiskFuseData data;
1003 fuse_req_t req = nullptr;
1004 fuse_ino_t ino = 0;
1005 string name = IS_FAVORITE_XATTR;
1006 const char *value = "";
1007 size_t size = 0;
1008 int flags = 0;
1009
1010 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1011 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1012 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1013 EXPECT_TRUE(true);
1014 } catch (...) {
1015 EXPECT_TRUE(false);
1016 GTEST_LOG_(INFO) << "SetXattrTest011 ERROR";
1017 }
1018 GTEST_LOG_(INFO) << "SetXattrTest011 End";
1019 }
1020
1021 /**
1022 * @tc.name: SetXattrTest012
1023 * @tc.desc: Verify the SetXattr function
1024 * @tc.type: FUNC
1025 * @tc.require: issuesI91IOG
1026 */
1027 HWTEST_F(FileOperationsCloudTest, SetXattrTest012, TestSize.Level1)
1028 {
1029 GTEST_LOG_(INFO) << "SetXattrTest012 Start";
1030 try {
1031 CloudDiskFuseData data;
1032 fuse_req_t req = nullptr;
1033 fuse_ino_t ino = 0;
1034 string name = IS_FAVORITE_XATTR;
1035 const char *value = "test";
1036 size_t size = 0;
1037 int flags = 0;
1038
1039 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1040 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1041 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1042 EXPECT_TRUE(true);
1043 } catch (...) {
1044 EXPECT_TRUE(false);
1045 GTEST_LOG_(INFO) << "SetXattrTest012 ERROR";
1046 }
1047 GTEST_LOG_(INFO) << "SetXattrTest012 End";
1048 }
1049
1050 /**
1051 * @tc.name: SetXattrTest013
1052 * @tc.desc: Verify the SetXattr function
1053 * @tc.type: FUNC
1054 * @tc.require: issuesI91IOG
1055 */
1056 HWTEST_F(FileOperationsCloudTest, SetXattrTest013, TestSize.Level1)
1057 {
1058 GTEST_LOG_(INFO) << "SetXattrTest013 Start";
1059 try {
1060 CloudDiskFuseData data;
1061 fuse_req_t req = nullptr;
1062 fuse_ino_t ino = -1;
1063 string name = IS_FILE_STATUS_XATTR;
1064 const char *value = "";
1065 size_t size = 0;
1066 int flags = 0;
1067
1068 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1069 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1070 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1071 EXPECT_TRUE(true);
1072 } catch (...) {
1073 EXPECT_TRUE(false);
1074 GTEST_LOG_(INFO) << "SetXattrTest013 ERROR";
1075 }
1076 GTEST_LOG_(INFO) << "SetXattrTest013 End";
1077 }
1078
1079 /**
1080 * @tc.name: SetXattrTest014
1081 * @tc.desc: Verify the SetXattr function
1082 * @tc.type: FUNC
1083 * @tc.require: issuesI91IOG
1084 */
1085 HWTEST_F(FileOperationsCloudTest, SetXattrTest014, TestSize.Level1)
1086 {
1087 GTEST_LOG_(INFO) << "SetXattrTest014 Start";
1088 try {
1089 CloudDiskFuseData data;
1090 fuse_req_t req = nullptr;
1091 fuse_ino_t ino = 0;
1092 string name = IS_FILE_STATUS_XATTR;
1093 const char *value = "";
1094 size_t size = 0;
1095 int flags = 0;
1096
1097 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1098 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1099 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1100 EXPECT_TRUE(true);
1101 } catch (...) {
1102 EXPECT_TRUE(false);
1103 GTEST_LOG_(INFO) << "SetXattrTest014 ERROR";
1104 }
1105 GTEST_LOG_(INFO) << "SetXattrTest014 End";
1106 }
1107
1108 /**
1109 * @tc.name: SetXattrTest015
1110 * @tc.desc: Verify the SetXattr function
1111 * @tc.type: FUNC
1112 * @tc.require: issuesI91IOG
1113 */
1114 HWTEST_F(FileOperationsCloudTest, SetXattrTest015, TestSize.Level1)
1115 {
1116 GTEST_LOG_(INFO) << "SetXattrTest015 Start";
1117 try {
1118 CloudDiskFuseData data;
1119 fuse_req_t req = nullptr;
1120 fuse_ino_t ino = 0;
1121 string name = IS_FILE_STATUS_XATTR;
1122 const char *value = "test";
1123 size_t size = 0;
1124 int flags = 0;
1125
1126 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1127 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1128 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1129 EXPECT_TRUE(true);
1130 } catch (...) {
1131 EXPECT_TRUE(false);
1132 GTEST_LOG_(INFO) << "SetXattrTest015 ERROR";
1133 }
1134 GTEST_LOG_(INFO) << "SetXattrTest015 End";
1135 }
1136
1137 /**
1138 * @tc.name: GetXattrTest001
1139 * @tc.desc: Verify the GetXattr function
1140 * @tc.type: FUNC
1141 * @tc.require: issuesI91IOG
1142 */
1143 HWTEST_F(FileOperationsCloudTest, GetXattrTest001, TestSize.Level1)
1144 {
1145 GTEST_LOG_(INFO) << "GetXattrTest001 Start";
1146 try {
1147 CloudDiskFuseData data;
1148 fuse_req_t req = nullptr;
1149 fuse_ino_t ino = -1;
1150 size_t size = 0;
1151 string name = HMDFS_PERMISSION_XATTR;
1152
1153 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1154 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1155 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1156 EXPECT_TRUE(true);
1157 } catch (...) {
1158 EXPECT_TRUE(false);
1159 GTEST_LOG_(INFO) << "GetXattrTest001 ERROR";
1160 }
1161 GTEST_LOG_(INFO) << "GetXattrTest001 End";
1162 }
1163
1164 /**
1165 * @tc.name: GetXattrTest002
1166 * @tc.desc: Verify the GetXattr function
1167 * @tc.type: FUNC
1168 * @tc.require: issuesI91IOG
1169 */
1170 HWTEST_F(FileOperationsCloudTest, GetXattrTest002, TestSize.Level1)
1171 {
1172 GTEST_LOG_(INFO) << "GetXattrTest002 Start";
1173 try {
1174 CloudDiskFuseData data;
1175 fuse_req_t req = nullptr;
1176 fuse_ino_t ino = 0;
1177 size_t size = 0;
1178 string name = HMDFS_PERMISSION_XATTR;
1179
1180 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1181 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1182 EXPECT_TRUE(true);
1183 } catch (...) {
1184 EXPECT_TRUE(false);
1185 GTEST_LOG_(INFO) << "GetXattrTest002 ERROR";
1186 }
1187 GTEST_LOG_(INFO) << "GetXattrTest002 End";
1188 }
1189
1190 /**
1191 * @tc.name: GetXattrTest003
1192 * @tc.desc: Verify the GetXattr function
1193 * @tc.type: FUNC
1194 * @tc.require: issuesI91IOG
1195 */
1196 HWTEST_F(FileOperationsCloudTest, GetXattrTest003, TestSize.Level1)
1197 {
1198 GTEST_LOG_(INFO) << "GetXattrTest003 Start";
1199 try {
1200 CloudDiskFuseData data;
1201 fuse_req_t req = nullptr;
1202 fuse_ino_t ino = 0;
1203 size_t size = 0;
1204 string name = CLOUD_CLOUD_ID_XATTR;
1205
1206 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1207 EXPECT_CALL(*insMock, fuse_reply_xattr(_, _)).WillOnce(Return(E_OK));
1208 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1209 EXPECT_TRUE(true);
1210 } catch (...) {
1211 EXPECT_TRUE(false);
1212 GTEST_LOG_(INFO) << "GetXattrTest003 ERROR";
1213 }
1214 GTEST_LOG_(INFO) << "GetXattrTest003 End";
1215 }
1216
1217 /**
1218 * @tc.name: GetXattrTest004
1219 * @tc.desc: Verify the GetXattr function
1220 * @tc.type: FUNC
1221 * @tc.require: issuesI91IOG
1222 */
1223 HWTEST_F(FileOperationsCloudTest, GetXattrTest004, TestSize.Level1)
1224 {
1225 GTEST_LOG_(INFO) << "GetXattrTest004 Start";
1226 try {
1227 CloudDiskFuseData data;
1228 fuse_req_t req = nullptr;
1229 fuse_ino_t ino = 0;
1230 size_t size = 0;
1231 string name = IS_FAVORITE_XATTR;
1232
1233 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1234 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1235 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1236 EXPECT_TRUE(true);
1237 } catch (...) {
1238 EXPECT_TRUE(false);
1239 GTEST_LOG_(INFO) << "GetXattrTest004 ERROR";
1240 }
1241 GTEST_LOG_(INFO) << "GetXattrTest004 End";
1242 }
1243
1244 /**
1245 * @tc.name: GetXattrTest005
1246 * @tc.desc: Verify the GetXattr function
1247 * @tc.type: FUNC
1248 * @tc.require: issuesI91IOG
1249 */
1250 HWTEST_F(FileOperationsCloudTest, GetXattrTest005, TestSize.Level1)
1251 {
1252 GTEST_LOG_(INFO) << "GetXattrTest005 Start";
1253 try {
1254 CloudDiskFuseData data;
1255 fuse_req_t req = nullptr;
1256 fuse_ino_t ino = 2;
1257 size_t size = 0;
1258 string name = IS_FAVORITE_XATTR;
1259
1260 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1261 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1262 EXPECT_TRUE(true);
1263 } catch (...) {
1264 EXPECT_TRUE(false);
1265 GTEST_LOG_(INFO) << "GetXattrTest005 ERROR";
1266 }
1267 GTEST_LOG_(INFO) << "GetXattrTest005 End";
1268 }
1269
1270 /**
1271 * @tc.name: GetXattrTest006
1272 * @tc.desc: Verify the GetXattr function
1273 * @tc.type: FUNC
1274 * @tc.require: issuesI91IOG
1275 */
1276 HWTEST_F(FileOperationsCloudTest, GetXattrTest006, TestSize.Level1)
1277 {
1278 GTEST_LOG_(INFO) << "GetXattrTest006 Start";
1279 try {
1280 CloudDiskFuseData data;
1281 fuse_req_t req = nullptr;
1282 fuse_ino_t ino = 0;
1283 size_t size = 0;
1284 string name = IS_FILE_STATUS_XATTR;
1285
1286 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1287 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1288 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1289 EXPECT_TRUE(true);
1290 } catch (...) {
1291 EXPECT_TRUE(false);
1292 GTEST_LOG_(INFO) << "GetXattrTest006 ERROR";
1293 }
1294 GTEST_LOG_(INFO) << "GetXattrTest006 End";
1295 }
1296
1297 /**
1298 * @tc.name: GetXattrTest007
1299 * @tc.desc: Verify the GetXattr function
1300 * @tc.type: FUNC
1301 * @tc.require: issuesI91IOG
1302 */
1303 HWTEST_F(FileOperationsCloudTest, GetXattrTest007, TestSize.Level1)
1304 {
1305 GTEST_LOG_(INFO) << "GetXattrTest007 Start";
1306 try {
1307 CloudDiskFuseData data;
1308 fuse_req_t req = nullptr;
1309 fuse_ino_t ino = 2;
1310 size_t size = 0;
1311 string name = IS_FILE_STATUS_XATTR;
1312
1313 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1314 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1315 EXPECT_TRUE(true);
1316 } catch (...) {
1317 EXPECT_TRUE(false);
1318 GTEST_LOG_(INFO) << "GetXattrTest007 ERROR";
1319 }
1320 GTEST_LOG_(INFO) << "GetXattrTest007 End";
1321 }
1322
1323 /**
1324 * @tc.name: GetXattrTest008
1325 * @tc.desc: Verify the GetXattr function
1326 * @tc.type: FUNC
1327 * @tc.require: issuesI91IOG
1328 */
1329 HWTEST_F(FileOperationsCloudTest, GetXattrTest008, TestSize.Level1)
1330 {
1331 GTEST_LOG_(INFO) << "GetXattrTest008 Start";
1332 try {
1333 CloudDiskFuseData data;
1334 fuse_req_t req = nullptr;
1335 fuse_ino_t ino = 0;
1336 size_t size = 0;
1337 string name = CLOUD_FILE_LOCATION;
1338
1339 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1340 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1341 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1342 EXPECT_TRUE(true);
1343 } catch (...) {
1344 EXPECT_TRUE(false);
1345 GTEST_LOG_(INFO) << "GetXattrTest008 ERROR";
1346 }
1347 GTEST_LOG_(INFO) << "GetXattrTest008 End";
1348 }
1349
1350 /**
1351 * @tc.name: GetXattrTest009
1352 * @tc.desc: Verify the GetXattr function
1353 * @tc.type: FUNC
1354 * @tc.require: issuesI91IOG
1355 */
1356 HWTEST_F(FileOperationsCloudTest, GetXattrTest009, TestSize.Level1)
1357 {
1358 GTEST_LOG_(INFO) << "GetXattrTest009 Start";
1359 try {
1360 CloudDiskFuseData data;
1361 fuse_req_t req = nullptr;
1362 fuse_ino_t ino = 1;
1363 size_t size = 0;
1364 string name = CLOUD_FILE_LOCATION;
1365
1366 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1367 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1368 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1369 EXPECT_TRUE(true);
1370 } catch (...) {
1371 EXPECT_TRUE(false);
1372 GTEST_LOG_(INFO) << "GetXattrTest009 ERROR";
1373 }
1374 GTEST_LOG_(INFO) << "GetXattrTest009 End";
1375 }
1376
1377 /**
1378 * @tc.name: GetXattrTest010
1379 * @tc.desc: Verify the GetXattr function
1380 * @tc.type: FUNC
1381 * @tc.require: issuesI91IOG
1382 */
1383 HWTEST_F(FileOperationsCloudTest, GetXattrTest010, TestSize.Level1)
1384 {
1385 GTEST_LOG_(INFO) << "GetXattrTest010 Start";
1386 try {
1387 CloudDiskFuseData data;
1388 fuse_req_t req = nullptr;
1389 fuse_ino_t ino = 2;
1390 size_t size = 0;
1391 string name = CLOUD_FILE_LOCATION;
1392
1393 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1394 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1395 EXPECT_TRUE(true);
1396 } catch (...) {
1397 EXPECT_TRUE(false);
1398 GTEST_LOG_(INFO) << "GetXattrTest010 ERROR";
1399 }
1400 GTEST_LOG_(INFO) << "GetXattrTest010 End";
1401 }
1402
1403 /**
1404 * @tc.name: GetXattrTest011
1405 * @tc.desc: Verify the GetXattr function
1406 * @tc.type: FUNC
1407 * @tc.require: issuesI91IOG
1408 */
1409 HWTEST_F(FileOperationsCloudTest, GetXattrTest011, TestSize.Level1)
1410 {
1411 GTEST_LOG_(INFO) << "GetXattrTest011 Start";
1412 try {
1413 CloudDiskFuseData data;
1414 fuse_req_t req = nullptr;
1415 fuse_ino_t ino = 0;
1416 size_t size = 0;
1417 string name = CLOUD_CLOUD_RECYCLE_XATTR;
1418
1419 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1420 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1421 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1422 EXPECT_TRUE(true);
1423 } catch (...) {
1424 EXPECT_TRUE(false);
1425 GTEST_LOG_(INFO) << "GetXattrTest011 ERROR";
1426 }
1427 GTEST_LOG_(INFO) << "GetXattrTest011 End";
1428 }
1429
1430 /**
1431 * @tc.name: GetXattrTest012
1432 * @tc.desc: Verify the GetXattr function
1433 * @tc.type: FUNC
1434 * @tc.require: issuesI91IOG
1435 */
1436 HWTEST_F(FileOperationsCloudTest, GetXattrTest012, TestSize.Level1)
1437 {
1438 GTEST_LOG_(INFO) << "GetXattrTest012 Start";
1439 try {
1440 CloudDiskFuseData data;
1441 fuse_req_t req = nullptr;
1442 fuse_ino_t ino = 2;
1443 size_t size = 0;
1444 string name = CLOUD_CLOUD_RECYCLE_XATTR;
1445
1446 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1447 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1448 EXPECT_TRUE(true);
1449 } catch (...) {
1450 EXPECT_TRUE(false);
1451 GTEST_LOG_(INFO) << "GetXattrTest012 ERROR";
1452 }
1453 GTEST_LOG_(INFO) << "GetXattrTest012 End";
1454 }
1455
1456 /**
1457 * @tc.name: GetXattrTest013
1458 * @tc.desc: Verify the GetXattr function
1459 * @tc.type: FUNC
1460 * @tc.require: issuesI91IOG
1461 */
1462 HWTEST_F(FileOperationsCloudTest, GetXattrTest013, TestSize.Level1)
1463 {
1464 GTEST_LOG_(INFO) << "GetXattrTest013 Start";
1465 try {
1466 CloudDiskFuseData data;
1467 fuse_req_t req = nullptr;
1468 fuse_ino_t ino = 2;
1469 size_t size = 1;
1470 string name = CLOUD_CLOUD_RECYCLE_XATTR;
1471
1472 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1473 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1474 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1475 EXPECT_TRUE(true);
1476 } catch (...) {
1477 EXPECT_TRUE(false);
1478 GTEST_LOG_(INFO) << "GetXattrTest013 ERROR";
1479 }
1480 GTEST_LOG_(INFO) << "GetXattrTest013 End";
1481 }
1482
1483 /**
1484 * @tc.name: GetXattrTest014
1485 * @tc.desc: Verify the GetXattr function
1486 * @tc.type: FUNC
1487 * @tc.require: issuesI91IOG
1488 */
1489 HWTEST_F(FileOperationsCloudTest, GetXattrTest014, TestSize.Level1)
1490 {
1491 GTEST_LOG_(INFO) << "GetXattrTest014 Start";
1492 try {
1493 CloudDiskFuseData data;
1494 fuse_req_t req = nullptr;
1495 fuse_ino_t ino = 2;
1496 size_t size = 1;
1497 string name = HMDFS_PERMISSION_XATTR;
1498
1499 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1500 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1501 EXPECT_TRUE(true);
1502 } catch (...) {
1503 EXPECT_TRUE(false);
1504 GTEST_LOG_(INFO) << "GetXattrTest014 ERROR";
1505 }
1506 GTEST_LOG_(INFO) << "GetXattrTest014 End";
1507 }
1508
1509 /**
1510 * @tc.name: MkDirTest001
1511 * @tc.desc: Verify the MkDir function
1512 * @tc.type: FUNC
1513 * @tc.require: issuesI91IOG
1514 */
1515 HWTEST_F(FileOperationsCloudTest, MkDirTest001, TestSize.Level1)
1516 {
1517 GTEST_LOG_(INFO) << "MkDirTest001 Start";
1518 try {
1519 CloudDiskFuseData data;
1520 fuse_req_t req = nullptr;
1521 fuse_ino_t parent = -1;
1522 const char *name = nullptr;
1523 mode_t mode = 0;
1524
1525 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1526 fileOperationsCloud_->MkDir(req, parent, name, mode);
1527 EXPECT_TRUE(true);
1528 } catch (...) {
1529 EXPECT_TRUE(false);
1530 GTEST_LOG_(INFO) << "MkDirTest001 ERROR";
1531 }
1532 GTEST_LOG_(INFO) << "MkDirTest001 End";
1533 }
1534
1535 /**
1536 * @tc.name: MkDirTest002
1537 * @tc.desc: Verify the MkDir function
1538 * @tc.type: FUNC
1539 * @tc.require: issuesI91IOG
1540 */
1541 HWTEST_F(FileOperationsCloudTest, MkDirTest002, TestSize.Level1)
1542 {
1543 GTEST_LOG_(INFO) << "MkDirTest002 Start";
1544 try {
1545 CloudDiskFuseData data;
1546 fuse_req_t req = nullptr;
1547 fuse_ino_t parent = 0;
1548 const char *name = ".cloudthumbnails";
1549 mode_t mode = 0;
1550
1551 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1552 fileOperationsCloud_->MkDir(req, parent, name, mode);
1553 EXPECT_TRUE(true);
1554 } catch (...) {
1555 EXPECT_TRUE(false);
1556 GTEST_LOG_(INFO) << "MkDirTest002 ERROR";
1557 }
1558 GTEST_LOG_(INFO) << "MkDirTest002 End";
1559 }
1560
1561 /**
1562 * @tc.name: MkDirTest003
1563 * @tc.desc: Verify the MkDir function
1564 * @tc.type: FUNC
1565 * @tc.require: issuesI91IOG
1566 */
1567 HWTEST_F(FileOperationsCloudTest, MkDirTest003, TestSize.Level1)
1568 {
1569 GTEST_LOG_(INFO) << "MkDirTest003 Start";
1570 try {
1571 CloudDiskFuseData data;
1572 fuse_req_t req = nullptr;
1573 fuse_ino_t parent = 3;
1574 const char *name = "";
1575 mode_t mode = 0;
1576
1577 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1578 fileOperationsCloud_->MkDir(req, parent, name, mode);
1579 EXPECT_TRUE(true);
1580 } catch (...) {
1581 EXPECT_TRUE(false);
1582 GTEST_LOG_(INFO) << "MkDirTest003 ERROR";
1583 }
1584 GTEST_LOG_(INFO) << "MkDirTest003 End";
1585 }
1586
1587 /**
1588 * @tc.name: MkDirTest004
1589 * @tc.desc: Verify the MkDir function
1590 * @tc.type: FUNC
1591 * @tc.require: issuesI91IOG
1592 */
1593 HWTEST_F(FileOperationsCloudTest, MkDirTest004, TestSize.Level1)
1594 {
1595 GTEST_LOG_(INFO) << "MkDirTest004 Start";
1596 try {
1597 CloudDiskFuseData data;
1598 fuse_req_t req = nullptr;
1599 fuse_ino_t parent = 2;
1600 const char *name = "";
1601 mode_t mode = 0;
1602
1603 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1604 fileOperationsCloud_->MkDir(req, parent, name, mode);
1605 EXPECT_TRUE(true);
1606 } catch (...) {
1607 EXPECT_TRUE(false);
1608 GTEST_LOG_(INFO) << "MkDirTest004 ERROR";
1609 }
1610 GTEST_LOG_(INFO) << "MkDirTest004 End";
1611 }
1612
1613 /**
1614 * @tc.name: RmDirTest001
1615 * @tc.desc: Verify the RmDir function
1616 * @tc.type: FUNC
1617 * @tc.require: issuesI91IOG
1618 */
1619 HWTEST_F(FileOperationsCloudTest, RmDirTest001, TestSize.Level1)
1620 {
1621 GTEST_LOG_(INFO) << "RmDirTest001 Start";
1622 try {
1623 CloudDiskFuseData data;
1624 fuse_req_t req = nullptr;
1625 fuse_ino_t parent = -1;
1626 const char *name = nullptr;
1627
1628 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1629 fileOperationsCloud_->RmDir(req, parent, name);
1630 EXPECT_TRUE(true);
1631 } catch (...) {
1632 EXPECT_TRUE(false);
1633 GTEST_LOG_(INFO) << "RmDirTest001 ERROR";
1634 }
1635 GTEST_LOG_(INFO) << "RmDirTest001 End";
1636 }
1637
1638 /**
1639 * @tc.name: RmDirTest002
1640 * @tc.desc: Verify the RmDir function
1641 * @tc.type: FUNC
1642 * @tc.require: issuesI91IOG
1643 */
1644 HWTEST_F(FileOperationsCloudTest, RmDirTest002, TestSize.Level1)
1645 {
1646 GTEST_LOG_(INFO) << "RmDirTest002 Start";
1647 try {
1648 CloudDiskFuseData data;
1649 fuse_req_t req = nullptr;
1650 fuse_ino_t parent = 0;
1651 const char *name = "mock";
1652
1653 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1654 fileOperationsCloud_->RmDir(req, parent, name);
1655 EXPECT_TRUE(true);
1656 } catch (...) {
1657 EXPECT_TRUE(false);
1658 GTEST_LOG_(INFO) << "RmDirTest002 ERROR";
1659 }
1660 GTEST_LOG_(INFO) << "RmDirTest002 End";
1661 }
1662
1663 /**
1664 * @tc.name: RmDirTest003
1665 * @tc.desc: Verify the RmDir function
1666 * @tc.type: FUNC
1667 * @tc.require: issuesI91IOG
1668 */
1669 HWTEST_F(FileOperationsCloudTest, RmDirTest003, TestSize.Level1)
1670 {
1671 GTEST_LOG_(INFO) << "RmDirTest003 Start";
1672 try {
1673 CloudDiskFuseData data;
1674 fuse_req_t req = nullptr;
1675 fuse_ino_t parent = 0;
1676 const char *name = "test";
1677
1678 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1679 fileOperationsCloud_->RmDir(req, parent, name);
1680 EXPECT_TRUE(true);
1681 } catch (...) {
1682 EXPECT_TRUE(false);
1683 GTEST_LOG_(INFO) << "RmDirTest003 ERROR";
1684 }
1685 GTEST_LOG_(INFO) << "RmDirTest003 End";
1686 }
1687
1688 /**
1689 * @tc.name: UnlinkTest001
1690 * @tc.desc: Verify the Unlink function
1691 * @tc.type: FUNC
1692 * @tc.require: issuesI91IOG
1693 */
1694 HWTEST_F(FileOperationsCloudTest, UnlinkTest001, TestSize.Level1)
1695 {
1696 GTEST_LOG_(INFO) << "UnlinkTest001 Start";
1697 try {
1698 CloudDiskFuseData data;
1699 fuse_ino_t parent = -1;
1700 fuse_req_t req = nullptr;
1701 const char *name = "";
1702
1703 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1704 fileOperationsCloud_->Unlink(req, parent, name);
1705 EXPECT_TRUE(true);
1706 } catch (...) {
1707 EXPECT_TRUE(false);
1708 GTEST_LOG_(INFO) << "UnlinkTest001 ERROR";
1709 }
1710 GTEST_LOG_(INFO) << "UnlinkTest001 End";
1711 }
1712
1713 /**
1714 * @tc.name: UnlinkTest002
1715 * @tc.desc: Verify the Unlink function
1716 * @tc.type: FUNC
1717 * @tc.require: issuesI91IOG
1718 */
1719 HWTEST_F(FileOperationsCloudTest, UnlinkTest002, TestSize.Level1)
1720 {
1721 GTEST_LOG_(INFO) << "UnlinkTest002 Start";
1722 try {
1723 CloudDiskFuseData data;
1724 fuse_ino_t parent = -1;
1725 fuse_req_t req = nullptr;
1726 const char *name = "mock";
1727
1728 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1729 fileOperationsCloud_->Unlink(req, parent, name);
1730 EXPECT_TRUE(true);
1731 } catch (...) {
1732 EXPECT_TRUE(false);
1733 GTEST_LOG_(INFO) << "UnlinkTest002 ERROR";
1734 }
1735 GTEST_LOG_(INFO) << "UnlinkTest002 End";
1736 }
1737
1738 /**
1739 * @tc.name: UnlinkTest003
1740 * @tc.desc: Verify the Unlink function
1741 * @tc.type: FUNC
1742 * @tc.require: issuesI91IOG
1743 */
1744 HWTEST_F(FileOperationsCloudTest, UnlinkTest003, TestSize.Level1)
1745 {
1746 GTEST_LOG_(INFO) << "UnlinkTest003 Start";
1747 try {
1748 CloudDiskFuseData data;
1749 fuse_ino_t parent = 0;
1750 fuse_req_t req = nullptr;
1751 const char *name = "test";
1752
1753 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1754 EXPECT_CALL(*insMock, lseek(_, _, _)).WillRepeatedly(Return(E_OK));
1755 fileOperationsCloud_->Unlink(req, parent, name);
1756 EXPECT_TRUE(true);
1757 } catch (...) {
1758 EXPECT_TRUE(false);
1759 GTEST_LOG_(INFO) << "UnlinkTest003 ERROR";
1760 }
1761 GTEST_LOG_(INFO) << "UnlinkTest003 End";
1762 }
1763
1764 /**
1765 * @tc.name: RenameTest001
1766 * @tc.desc: Verify the Rename function
1767 * @tc.type: FUNC
1768 * @tc.require: issuesI91IOG
1769 */
1770 HWTEST_F(FileOperationsCloudTest, RenameTest001, TestSize.Level1)
1771 {
1772 GTEST_LOG_(INFO) << "RenameTest001 Start";
1773 try {
1774 CloudDiskFuseData data;
1775 fuse_ino_t parent = 0;
1776 fuse_ino_t newParent = 0;
1777 fuse_req_t req = nullptr;
1778 const char *name = "";
1779 const char *newName = "";
1780 unsigned int flags = 1;
1781
1782 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1783 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1784 EXPECT_TRUE(true);
1785 } catch (...) {
1786 EXPECT_TRUE(false);
1787 GTEST_LOG_(INFO) << "RenameTest001 ERROR";
1788 }
1789 GTEST_LOG_(INFO) << "RenameTest001 End";
1790 }
1791
1792 /**
1793 * @tc.name: RenameTest002
1794 * @tc.desc: Verify the Rename function
1795 * @tc.type: FUNC
1796 * @tc.require: issuesI91IOG
1797 */
1798 HWTEST_F(FileOperationsCloudTest, RenameTest002, TestSize.Level1)
1799 {
1800 GTEST_LOG_(INFO) << "RenameTest002 Start";
1801 try {
1802 CloudDiskFuseData data;
1803 fuse_ino_t parent = -1;
1804 fuse_ino_t newParent = -1;
1805 fuse_req_t req = nullptr;
1806 const char *name = "";
1807 const char *newName = "";
1808 unsigned int flags = 0;
1809
1810 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1811 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1812 EXPECT_TRUE(true);
1813 } catch (...) {
1814 EXPECT_TRUE(false);
1815 GTEST_LOG_(INFO) << "RenameTest002 ERROR";
1816 }
1817 GTEST_LOG_(INFO) << "RenameTest002 End";
1818 }
1819
1820 /**
1821 * @tc.name: RenameTest003
1822 * @tc.desc: Verify the Rename function
1823 * @tc.type: FUNC
1824 * @tc.require: issuesI91IOG
1825 */
1826 HWTEST_F(FileOperationsCloudTest, RenameTest003, TestSize.Level1)
1827 {
1828 GTEST_LOG_(INFO) << "RenameTest003 Start";
1829 try {
1830 CloudDiskFuseData data;
1831 fuse_ino_t parent = 2;
1832 fuse_ino_t newParent = 2;
1833 fuse_req_t req = nullptr;
1834 const char *name = "mock";
1835 const char *newName = "mock";
1836 unsigned int flags = 0;
1837
1838 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1839 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1840 EXPECT_TRUE(true);
1841 } catch (...) {
1842 EXPECT_TRUE(false);
1843 GTEST_LOG_(INFO) << "RenameTest003 ERROR";
1844 }
1845 GTEST_LOG_(INFO) << "RenameTest003 End";
1846 }
1847
1848 /**
1849 * @tc.name: RenameTest004
1850 * @tc.desc: Verify the Rename function
1851 * @tc.type: FUNC
1852 * @tc.require: issuesI91IOG
1853 */
1854 HWTEST_F(FileOperationsCloudTest, RenameTest004, TestSize.Level1)
1855 {
1856 GTEST_LOG_(INFO) << "RenameTest004 Start";
1857 try {
1858 CloudDiskFuseData data;
1859 fuse_ino_t parent = 2;
1860 fuse_ino_t newParent = 2;
1861 fuse_req_t req = nullptr;
1862 const char *name = "test";
1863 const char *newName = "test";
1864 unsigned int flags = 0;
1865
1866 // EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1867 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1868 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1869 EXPECT_TRUE(true);
1870 } catch (...) {
1871 EXPECT_TRUE(false);
1872 GTEST_LOG_(INFO) << "RenameTest004 ERROR";
1873 }
1874 GTEST_LOG_(INFO) << "RenameTest004 End";
1875 }
1876
1877 /**
1878 * @tc.name: ReadTest001
1879 * @tc.desc: Verify the ReadDir function
1880 * @tc.type: FUNC
1881 * @tc.require: issuesI91IOG
1882 */
1883 HWTEST_F(FileOperationsCloudTest, ReadTest001, TestSize.Level1)
1884 {
1885 GTEST_LOG_(INFO) << "ReadTest001 Start";
1886 try {
1887 CloudDiskFuseData data;
1888 fuse_req_t req = nullptr;
1889 CloudDiskInode ino;
1890 size_t size = 5 * 1024 *1024;
1891 off_t off = 0;
1892 struct fuse_file_info fi;
1893
1894 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1895 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1896 EXPECT_TRUE(true);
1897 } catch (...) {
1898 EXPECT_TRUE(false);
1899 GTEST_LOG_(INFO) << "ReadTest001 ERROR";
1900 }
1901 GTEST_LOG_(INFO) << "ReadTest001 End";
1902 }
1903
1904 /**
1905 * @tc.name: ReadTest002
1906 * @tc.desc: Verify the ReadDir function
1907 * @tc.type: FUNC
1908 * @tc.require: issuesI91IOG
1909 */
1910 HWTEST_F(FileOperationsCloudTest, ReadTest002, TestSize.Level1)
1911 {
1912 GTEST_LOG_(INFO) << "ReadTest002 Start";
1913 try {
1914 CloudDiskFuseData data;
1915 fuse_req_t req = nullptr;
1916 CloudDiskInode ino;
1917 size_t size = 1024;
1918 off_t off = 0;
1919 struct fuse_file_info fi;
1920 fi.fh = -1;
1921
1922 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1923 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1924 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1925 EXPECT_TRUE(true);
1926 } catch (...) {
1927 EXPECT_TRUE(false);
1928 GTEST_LOG_(INFO) << "ReadTest002 ERROR";
1929 }
1930 GTEST_LOG_(INFO) << "ReadTest002 End";
1931 }
1932
1933 /**
1934 * @tc.name: ReadTest003
1935 * @tc.desc: Verify the ReadDir function
1936 * @tc.type: FUNC
1937 * @tc.require: issuesI91IOG
1938 */
1939 HWTEST_F(FileOperationsCloudTest, ReadTest003, TestSize.Level1)
1940 {
1941 GTEST_LOG_(INFO) << "ReadTest003 Start";
1942 try {
1943 CloudDiskFuseData data;
1944 fuse_req_t req = nullptr;
1945 CloudDiskInode ino;
1946 size_t size = 1024;
1947 off_t off = 0;
1948 struct fuse_file_info fi;
1949
1950 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1951 EXPECT_CALL(*insMock, fuse_reply_data(_, _, _)).WillOnce(Return(E_OK));
1952 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1953 EXPECT_TRUE(true);
1954 } catch (...) {
1955 EXPECT_TRUE(false);
1956 GTEST_LOG_(INFO) << "ReadTest003 ERROR";
1957 }
1958 GTEST_LOG_(INFO) << "ReadTest003 End";
1959 }
1960
1961 /**
1962 * @tc.name: ReadTest004
1963 * @tc.desc: Verify the ReadDir function
1964 * @tc.type: FUNC
1965 * @tc.require: issuesI91IOG
1966 */
1967 HWTEST_F(FileOperationsCloudTest, ReadTest004, TestSize.Level1)
1968 {
1969 GTEST_LOG_(INFO) << "ReadTest004 Start";
1970 try {
1971 CloudDiskFuseData data;
1972 fuse_req_t req = nullptr;
1973 CloudDiskInode ino;
1974 size_t size = 1024;
1975 off_t off = 0;
1976 struct fuse_file_info fi;
1977 fi.fh = 1;
1978
1979 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1980 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(E_OK));
1981 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1982 EXPECT_TRUE(true);
1983 } catch (...) {
1984 EXPECT_TRUE(false);
1985 GTEST_LOG_(INFO) << "ReadTest004 ERROR";
1986 }
1987 GTEST_LOG_(INFO) << "ReadTest004 End";
1988 }
1989
1990 /**
1991 * @tc.name: WriteBufTest001
1992 * @tc.desc: Verify the WriteBuf function
1993 * @tc.type: FUNC
1994 * @tc.require: issuesI91IOG
1995 */
1996 HWTEST_F(FileOperationsCloudTest, WriteBufTest001, TestSize.Level1)
1997 {
1998 GTEST_LOG_(INFO) << "WriteBufTest001 Start";
1999 try {
2000 CloudDiskFuseData data;
2001 fuse_req_t req = nullptr;
2002 CloudDiskInode ino;
2003 struct fuse_bufvec *bufv = nullptr;
2004 off_t offset = 0;
2005 struct fuse_file_info fi;
2006 fi.fh = -1;
2007
2008 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2009 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2010 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2011 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2012 EXPECT_TRUE(true);
2013 } catch (...) {
2014 EXPECT_TRUE(false);
2015 GTEST_LOG_(INFO) << "WriteBufTest001 ERROR";
2016 }
2017 GTEST_LOG_(INFO) << "WriteBufTest001 End";
2018 }
2019
2020 /**
2021 * @tc.name: WriteBufTest002
2022 * @tc.desc: Verify the WriteBuf function
2023 * @tc.type: FUNC
2024 * @tc.require: issuesI91IOG
2025 */
2026 HWTEST_F(FileOperationsCloudTest, WriteBufTest002, TestSize.Level1)
2027 {
2028 GTEST_LOG_(INFO) << "WriteBufTest002 Start";
2029 try {
2030 CloudDiskFuseData data;
2031 fuse_req_t req = nullptr;
2032 CloudDiskInode ino;
2033 struct fuse_bufvec *bufv = nullptr;
2034 off_t offset = 0;
2035 struct fuse_file_info fi;
2036 fi.fh = 1;
2037
2038 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2039 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2040 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2041 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2042 EXPECT_TRUE(true);
2043 } catch (...) {
2044 EXPECT_TRUE(false);
2045 GTEST_LOG_(INFO) << "WriteBufTest002 ERROR";
2046 }
2047 GTEST_LOG_(INFO) << "WriteBufTest002 End";
2048 }
2049
2050 /**
2051 * @tc.name: WriteBufTest003
2052 * @tc.desc: Verify the WriteBuf function
2053 * @tc.type: FUNC
2054 * @tc.require: issuesI91IOG
2055 */
2056 HWTEST_F(FileOperationsCloudTest, WriteBufTest003, TestSize.Level1)
2057 {
2058 GTEST_LOG_(INFO) << "WriteBufTest003 Start";
2059 try {
2060 CloudDiskFuseData data;
2061 fuse_req_t req = nullptr;
2062 CloudDiskInode ino;
2063 struct fuse_bufvec *bufv = nullptr;
2064 off_t offset = 0;
2065 struct fuse_file_info fi;
2066 fi.fh = 2;
2067
2068 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2069 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2070 EXPECT_CALL(*insMock, fuse_buf_copy(_, _, _)).WillOnce(Return(-1));
2071 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2072 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2073 EXPECT_TRUE(true);
2074 } catch (...) {
2075 EXPECT_TRUE(false);
2076 GTEST_LOG_(INFO) << "WriteBufTest003 ERROR";
2077 }
2078 GTEST_LOG_(INFO) << "WriteBufTest003 End";
2079 }
2080
2081 /**
2082 * @tc.name: WriteBufTest004
2083 * @tc.desc: Verify the WriteBuf function
2084 * @tc.type: FUNC
2085 * @tc.require: issuesI91IOG
2086 */
2087 HWTEST_F(FileOperationsCloudTest, WriteBufTest004, TestSize.Level1)
2088 {
2089 GTEST_LOG_(INFO) << "WriteBufTest004 Start";
2090 try {
2091 CloudDiskFuseData data;
2092 fuse_req_t req = nullptr;
2093 CloudDiskInode ino;
2094 struct fuse_bufvec *bufv = nullptr;
2095 off_t offset = 0;
2096 struct fuse_file_info fi;
2097 fi.fh = 2;
2098
2099 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2100 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2101 EXPECT_CALL(*insMock, fuse_buf_copy(_, _, _)).WillOnce(Return(1));
2102 EXPECT_CALL(*insMock, fuse_reply_write(_, _)).WillOnce(Return(E_OK));
2103 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2104 EXPECT_TRUE(true);
2105 } catch (...) {
2106 EXPECT_TRUE(false);
2107 GTEST_LOG_(INFO) << "WriteBufTest004 ERROR";
2108 }
2109 GTEST_LOG_(INFO) << "WriteBufTest004 End";
2110 }
2111
2112 /**
2113 * @tc.name: ReleaseTest001
2114 * @tc.desc: Verify the Release function
2115 * @tc.type: FUNC
2116 * @tc.require: issuesI91IOG
2117 */
2118 HWTEST_F(FileOperationsCloudTest, ReleaseTest001, TestSize.Level1)
2119 {
2120 GTEST_LOG_(INFO) << "ReleaseTest001 Start";
2121 try {
2122 CloudDiskFuseData data;
2123 fuse_req_t req = nullptr;
2124 fuse_ino_t ino = -1;
2125 struct fuse_file_info fi;
2126
2127 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2128 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
2129 fileOperationsCloud_->Release(req, ino, &fi);
2130 EXPECT_TRUE(true);
2131 } catch (...) {
2132 EXPECT_TRUE(false);
2133 GTEST_LOG_(INFO) << "ReleaseTest001 ERROR";
2134 }
2135 GTEST_LOG_(INFO) << "ReleaseTest001 End";
2136 }
2137
2138 /**
2139 * @tc.name: ReleaseTest002
2140 * @tc.desc: Verify the Release function
2141 * @tc.type: FUNC
2142 * @tc.require: issuesI91IOG
2143 */
2144 HWTEST_F(FileOperationsCloudTest, ReleaseTest002, TestSize.Level1)
2145 {
2146 GTEST_LOG_(INFO) << "ReleaseTest002 Start";
2147 try {
2148 CloudDiskFuseData data;
2149 fuse_req_t req = nullptr;
2150 fuse_ino_t ino = 0;
2151 struct fuse_file_info fi;
2152
2153 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2154 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
2155 fileOperationsCloud_->Release(req, ino, &fi);
2156 EXPECT_TRUE(true);
2157 } catch (...) {
2158 EXPECT_TRUE(false);
2159 GTEST_LOG_(INFO) << "ReleaseTest002 ERROR";
2160 }
2161 GTEST_LOG_(INFO) << "ReleaseTest002 End";
2162 }
2163
2164 /**
2165 * @tc.name: ReleaseTest003
2166 * @tc.desc: Verify the Release function
2167 * @tc.type: FUNC
2168 * @tc.require: issuesI91IOG
2169 */
2170 HWTEST_F(FileOperationsCloudTest, ReleaseTest003, TestSize.Level1)
2171 {
2172 GTEST_LOG_(INFO) << "ReleaseTest003 Start";
2173 try {
2174 CloudDiskFuseData data;
2175 fuse_req_t req = nullptr;
2176 fuse_ino_t ino = 1;
2177 struct fuse_file_info fi;
2178 fi.fh = -1;
2179
2180 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2181 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2182 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2183 EXPECT_TRUE(true);
2184 } catch (...) {
2185 EXPECT_TRUE(false);
2186 GTEST_LOG_(INFO) << "ReleaseTest003 ERROR";
2187 }
2188 GTEST_LOG_(INFO) << "ReleaseTest003 End";
2189 }
2190
2191 /**
2192 * @tc.name: ReleaseTest004
2193 * @tc.desc: Verify the Release function
2194 * @tc.type: FUNC
2195 * @tc.require: issuesI91IOG
2196 */
2197 HWTEST_F(FileOperationsCloudTest, ReleaseTest004, TestSize.Level1)
2198 {
2199 GTEST_LOG_(INFO) << "ReleaseTest004 Start";
2200 try {
2201 CloudDiskFuseData data;
2202 fuse_req_t req = nullptr;
2203 fuse_ino_t ino = 1;
2204 struct fuse_file_info fi;
2205 fi.fh = 2;
2206
2207 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2208 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2209 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2210 EXPECT_TRUE(true);
2211 } catch (...) {
2212 EXPECT_TRUE(false);
2213 GTEST_LOG_(INFO) << "ReleaseTest004 ERROR";
2214 }
2215 GTEST_LOG_(INFO) << "ReleaseTest003 End";
2216 }
2217
2218 /**
2219 * @tc.name: ReleaseTest005
2220 * @tc.desc: Verify the Release function
2221 * @tc.type: FUNC
2222 * @tc.require: issuesI91IOG
2223 */
2224 HWTEST_F(FileOperationsCloudTest, ReleaseTest005, TestSize.Level1)
2225 {
2226 GTEST_LOG_(INFO) << "ReleaseTest005 Start";
2227 try {
2228 CloudDiskFuseData data;
2229 fuse_req_t req = nullptr;
2230 fuse_ino_t ino = 1;
2231 struct fuse_file_info fi;
2232 fi.fh = 1;
2233
2234 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2235 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2236 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2237 EXPECT_TRUE(true);
2238 } catch (...) {
2239 EXPECT_TRUE(false);
2240 GTEST_LOG_(INFO) << "ReleaseTest005 ERROR";
2241 }
2242 GTEST_LOG_(INFO) << "ReleaseTest005 End";
2243 }
2244
2245 /**
2246 * @tc.name: ReleaseTest006
2247 * @tc.desc: Verify the Release function
2248 * @tc.type: FUNC
2249 * @tc.require: issuesI91IOG
2250 */
2251 HWTEST_F(FileOperationsCloudTest, ReleaseTest006, TestSize.Level1)
2252 {
2253 GTEST_LOG_(INFO) << "ReleaseTest006 Start";
2254 try {
2255 CloudDiskFuseData data;
2256 fuse_req_t req = nullptr;
2257 fuse_ino_t ino = 1;
2258 struct fuse_file_info fi;
2259 fi.fh = 0;
2260
2261 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2262 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2263 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2264 EXPECT_TRUE(true);
2265 } catch (...) {
2266 EXPECT_TRUE(false);
2267 GTEST_LOG_(INFO) << "ReleaseTest006 ERROR";
2268 }
2269 GTEST_LOG_(INFO) << "ReleaseTest006 End";
2270 }
2271
2272 /**
2273 * @tc.name: ReleaseTest007
2274 * @tc.desc: Verify the Release function
2275 * @tc.type: FUNC
2276 * @tc.require: issuesI91IOG
2277 */
2278 HWTEST_F(FileOperationsCloudTest, ReleaseTest007, TestSize.Level1)
2279 {
2280 GTEST_LOG_(INFO) << "ReleaseTest007 Start";
2281 try {
2282 CloudDiskFuseData data;
2283 fuse_req_t req = nullptr;
2284 fuse_ino_t ino = 1;
2285 struct fuse_file_info fi;
2286 fi.fh = 3;
2287
2288 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2289 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2290 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2291 EXPECT_TRUE(true);
2292 } catch (...) {
2293 EXPECT_TRUE(false);
2294 GTEST_LOG_(INFO) << "ReleaseTest007 ERROR";
2295 }
2296 GTEST_LOG_(INFO) << "ReleaseTest007 End";
2297 }
2298
2299 /**
2300 * @tc.name: SetAttrTest001
2301 * @tc.desc: Verify the SetAttr function
2302 * @tc.type: FUNC
2303 * @tc.require: issuesI91IOG
2304 */
2305 HWTEST_F(FileOperationsCloudTest, SetAttrTest001, TestSize.Level1)
2306 {
2307 GTEST_LOG_(INFO) << "SetAttrTest001 Start";
2308 try {
2309 CloudDiskFuseData data;
2310 fuse_req_t req = nullptr;
2311 fuse_ino_t ino = -1;
2312 struct stat attr;
2313 int valid = 0;
2314 struct fuse_file_info fi;
2315
2316 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
2317 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2318 EXPECT_TRUE(true);
2319 } catch (...) {
2320 EXPECT_TRUE(false);
2321 GTEST_LOG_(INFO) << "SetAttrTest001 ERROR";
2322 }
2323 GTEST_LOG_(INFO) << "SetAttrTest001 End";
2324 }
2325
2326 /**
2327 * @tc.name: SetAttrTest002
2328 * @tc.desc: Verify the SetAttr function
2329 * @tc.type: FUNC
2330 * @tc.require: issuesI91IOG
2331 */
2332 HWTEST_F(FileOperationsCloudTest, SetAttrTest002, TestSize.Level1)
2333 {
2334 GTEST_LOG_(INFO) << "SetAttrTest002 Start";
2335 try {
2336 CloudDiskFuseData data;
2337 fuse_req_t req = nullptr;
2338 fuse_ino_t ino = 1;
2339 struct stat attr;
2340 int valid = 0;
2341 struct fuse_file_info fi;
2342
2343 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2344 EXPECT_TRUE(true);
2345 } catch (...) {
2346 EXPECT_TRUE(false);
2347 GTEST_LOG_(INFO) << "SetAttrTest002 ERROR";
2348 }
2349 GTEST_LOG_(INFO) << "SetAttrTest002 End";
2350 }
2351
2352 /**
2353 * @tc.name: SetAttrTest003
2354 * @tc.desc: Verify the SetAttr function
2355 * @tc.type: FUNC
2356 * @tc.require: issuesI91IOG
2357 */
2358 HWTEST_F(FileOperationsCloudTest, SetAttrTest003, TestSize.Level1)
2359 {
2360 GTEST_LOG_(INFO) << "SetAttrTest003 Start";
2361 try {
2362 CloudDiskFuseData data;
2363 data.userId = 100;
2364 fuse_req_t req = nullptr;
2365 fuse_ino_t ino = 4;
2366 struct stat attr;
2367 int valid = 13;
2368 struct fuse_file_info fi;
2369
2370 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2371 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2372 EXPECT_TRUE(true);
2373 } catch (...) {
2374 EXPECT_TRUE(false);
2375 GTEST_LOG_(INFO) << "SetAttrTest003 ERROR";
2376 }
2377 GTEST_LOG_(INFO) << "SetAttrTest003 End";
2378 }
2379
2380 /**
2381 * @tc.name: SetAttrTest004
2382 * @tc.desc: Verify the SetAttr function
2383 * @tc.type: FUNC
2384 * @tc.require: issuesI91IOG
2385 */
2386 HWTEST_F(FileOperationsCloudTest, SetAttrTest004, TestSize.Level1)
2387 {
2388 GTEST_LOG_(INFO) << "SetAttrTest004 Start";
2389 try {
2390 CloudDiskFuseData data;
2391 fuse_req_t req = nullptr;
2392 fuse_ino_t ino = 3;
2393 struct stat attr;
2394 int valid = 13;
2395 struct fuse_file_info fi;
2396
2397 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2398 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2399 EXPECT_TRUE(true);
2400 } catch (...) {
2401 EXPECT_TRUE(false);
2402 GTEST_LOG_(INFO) << "SetAttrTest004 ERROR";
2403 }
2404 GTEST_LOG_(INFO) << "SetAttrTest004 End";
2405 }
2406
2407 /**
2408 * @tc.name: SetAttrTest005
2409 * @tc.desc: Verify the SetAttr function
2410 * @tc.type: FUNC
2411 * @tc.require: issuesI91IOG
2412 */
2413 HWTEST_F(FileOperationsCloudTest, SetAttrTest005, TestSize.Level1)
2414 {
2415 GTEST_LOG_(INFO) << "SetAttrTest005 Start";
2416 try {
2417 CloudDiskFuseData data;
2418 fuse_req_t req = nullptr;
2419 fuse_ino_t ino = 2;
2420 struct stat attr;
2421 int valid = 13;
2422 struct fuse_file_info fi;
2423 fi.fh = -1;
2424
2425 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2426 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2427 EXPECT_TRUE(true);
2428 } catch (...) {
2429 EXPECT_TRUE(false);
2430 GTEST_LOG_(INFO) << "SetAttrTest005 ERROR";
2431 }
2432 GTEST_LOG_(INFO) << "SetAttrTest005 End";
2433 }
2434
2435 /**
2436 * @tc.name: SetAttrTest006
2437 * @tc.desc: Verify the SetAttr function
2438 * @tc.type: FUNC
2439 * @tc.require: issuesI91IOG
2440 */
2441 HWTEST_F(FileOperationsCloudTest, SetAttrTest006, TestSize.Level1)
2442 {
2443 GTEST_LOG_(INFO) << "SetAttrTest006 Start";
2444 try {
2445 CloudDiskFuseData data;
2446 fuse_req_t req = nullptr;
2447 fuse_ino_t ino = 2;
2448 struct stat attr;
2449 int valid = 13;
2450 struct fuse_file_info fi;
2451 fi.fh = 0;
2452
2453 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2454 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2455 EXPECT_TRUE(true);
2456 } catch (...) {
2457 EXPECT_TRUE(false);
2458 GTEST_LOG_(INFO) << "SetAttrTest006 ERROR";
2459 }
2460 GTEST_LOG_(INFO) << "SetAttrTest006 End";
2461 }
2462
2463 /**
2464 * @tc.name: SetAttrTest007
2465 * @tc.desc: Verify the SetAttr function
2466 * @tc.type: FUNC
2467 * @tc.require: issuesI91IOG
2468 */
2469 HWTEST_F(FileOperationsCloudTest, SetAttrTest007, TestSize.Level1)
2470 {
2471 GTEST_LOG_(INFO) << "SetAttrTest007 Start";
2472 try {
2473 CloudDiskFuseData data;
2474 fuse_req_t req = nullptr;
2475 fuse_ino_t ino = 2;
2476 struct stat attr;
2477 int valid = 13;
2478
2479 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2480 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, nullptr);
2481 EXPECT_TRUE(true);
2482 } catch (...) {
2483 EXPECT_TRUE(false);
2484 GTEST_LOG_(INFO) << "SetAttrTest007 ERROR";
2485 }
2486 GTEST_LOG_(INFO) << "SetAttrTest007 End";
2487 }
2488
2489 /**
2490 * @tc.name: SetAttrTest008
2491 * @tc.desc: Verify the SetAttr function
2492 * @tc.type: FUNC
2493 * @tc.require: issuesI91IOG
2494 */
2495 HWTEST_F(FileOperationsCloudTest, SetAttrTest008, TestSize.Level1)
2496 {
2497 GTEST_LOG_(INFO) << "SetAttrTest008 Start";
2498 try {
2499 CloudDiskFuseData data;
2500 fuse_req_t req = nullptr;
2501 fuse_ino_t ino = 0;
2502 struct stat attr;
2503 int valid = 1;
2504
2505 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2506 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, nullptr);
2507 EXPECT_TRUE(true);
2508 } catch (...) {
2509 EXPECT_TRUE(false);
2510 GTEST_LOG_(INFO) << "SetAttrTest008 ERROR";
2511 }
2512 GTEST_LOG_(INFO) << "SetAttrTest008 End";
2513 }
2514
2515 /**
2516 * @tc.name: SetAttrTest009
2517 * @tc.desc: Verify the SetAttr function
2518 * @tc.type: FUNC
2519 * @tc.require: issuesI91IOG
2520 */
2521 HWTEST_F(FileOperationsCloudTest, SetAttrTest009, TestSize.Level1)
2522 {
2523 GTEST_LOG_(INFO) << "SetAttrTest009 Start";
2524 try {
2525 CloudDiskFuseData data;
2526 fuse_req_t req = nullptr;
2527 fuse_ino_t ino = 6;
2528 struct stat attr;
2529 int valid = 13;
2530
2531 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2532 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, nullptr);
2533 EXPECT_TRUE(true);
2534 } catch (...) {
2535 EXPECT_TRUE(false);
2536 GTEST_LOG_(INFO) << "SetAttrTest009 ERROR";
2537 }
2538 GTEST_LOG_(INFO) << "SetAttrTest009 End";
2539 }
2540
2541 /**
2542 * @tc.name: SetAttrTest010
2543 * @tc.desc: Verify the SetAttr function
2544 * @tc.type: FUNC
2545 * @tc.require: issuesI91IOG
2546 */
2547 HWTEST_F(FileOperationsCloudTest, SetAttrTest010, TestSize.Level1)
2548 {
2549 GTEST_LOG_(INFO) << "SetAttrTest010 Start";
2550 try {
2551 CloudDiskFuseData data;
2552 fuse_req_t req = nullptr;
2553 fuse_ino_t ino = 7;
2554 struct stat attr;
2555 int valid = 13;
2556
2557 // EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void *>(&data)));
2558 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2559 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, nullptr);
2560 EXPECT_TRUE(true);
2561 } catch (...) {
2562 EXPECT_TRUE(false);
2563 GTEST_LOG_(INFO) << "SetAttrTest010 ERROR";
2564 }
2565 GTEST_LOG_(INFO) << "SetAttrTest010 End";
2566 }
2567
2568 /**
2569 * @tc.name: LseekTest001
2570 * @tc.desc: Verify the Lseek function
2571 * @tc.type: FUNC
2572 * @tc.require: issuesI91IOG
2573 */
2574 HWTEST_F(FileOperationsCloudTest, LseekTest001, TestSize.Level1)
2575 {
2576 GTEST_LOG_(INFO) << "LseekTest001 Start";
2577 try {
2578 CloudDiskFuseData data;
2579 fuse_req_t req = nullptr;
2580 fuse_ino_t ino = -1;
2581 off_t off = 0;
2582 int whence = 0;
2583 struct fuse_file_info fi;
2584
2585 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2586 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2587 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2588 EXPECT_TRUE(true);
2589 } catch (...) {
2590 EXPECT_TRUE(false);
2591 GTEST_LOG_(INFO) << "LseekTest001 ERROR";
2592 }
2593 GTEST_LOG_(INFO) << "LseekTest001 End";
2594 }
2595
2596 /**
2597 * @tc.name: LseekTest002
2598 * @tc.desc: Verify the Lseek function
2599 * @tc.type: FUNC
2600 * @tc.require: issuesI91IOG
2601 */
2602 HWTEST_F(FileOperationsCloudTest, LseekTest002, TestSize.Level1)
2603 {
2604 GTEST_LOG_(INFO) << "LseekTest002 Start";
2605 try {
2606 CloudDiskFuseData data;
2607 fuse_req_t req = nullptr;
2608 fuse_ino_t ino = 0;
2609 off_t off = 0;
2610 int whence = 0;
2611 struct fuse_file_info fi;
2612 fi.fh = -1;
2613
2614 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2615 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2616 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2617 EXPECT_TRUE(true);
2618 } catch (...) {
2619 EXPECT_TRUE(false);
2620 GTEST_LOG_(INFO) << "LseekTest002 ERROR";
2621 }
2622 GTEST_LOG_(INFO) << "LseekTest002 End";
2623 }
2624
2625 /**
2626 * @tc.name: LseekTest003
2627 * @tc.desc: Verify the Lseek function
2628 * @tc.type: FUNC
2629 * @tc.require: issuesI91IOG
2630 */
2631 HWTEST_F(FileOperationsCloudTest, LseekTest003, TestSize.Level1)
2632 {
2633 GTEST_LOG_(INFO) << "LseekTest003 Start";
2634 try {
2635 CloudDiskFuseData data;
2636 fuse_req_t req = nullptr;
2637 fuse_ino_t ino = 0;
2638 off_t off = 0;
2639 int whence = 0;
2640 struct fuse_file_info fi;
2641 fi.fh = 1;
2642
2643 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2644 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2645 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2646 EXPECT_TRUE(true);
2647 } catch (...) {
2648 EXPECT_TRUE(false);
2649 GTEST_LOG_(INFO) << "LseekTest003 ERROR";
2650 }
2651 GTEST_LOG_(INFO) << "LseekTest003 End";
2652 }
2653
2654 /**
2655 * @tc.name: LseekTest004
2656 * @tc.desc: Verify the Lseek function
2657 * @tc.type: FUNC
2658 * @tc.require: issuesI91IOG
2659 */
2660 HWTEST_F(FileOperationsCloudTest, LseekTest004, TestSize.Level1)
2661 {
2662 GTEST_LOG_(INFO) << "LseekTest004 Start";
2663 try {
2664 CloudDiskFuseData data;
2665 fuse_req_t req = nullptr;
2666 fuse_ino_t ino = 0;
2667 off_t off = 0;
2668 int whence = 0;
2669 struct fuse_file_info fi;
2670 fi.fh = 2;
2671
2672 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2673 EXPECT_CALL(*insMock, lseek(_, _, _)).WillOnce(Return(-1));
2674 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK)).WillRepeatedly(Return(E_OK));
2675 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2676 EXPECT_TRUE(true);
2677 } catch (...) {
2678 EXPECT_TRUE(false);
2679 GTEST_LOG_(INFO) << "LseekTest004 ERROR";
2680 }
2681 GTEST_LOG_(INFO) << "LseekTest004 End";
2682 }
2683
2684 /**
2685 * @tc.name: LseekTest005
2686 * @tc.desc: Verify the Lseek function
2687 * @tc.type: FUNC
2688 * @tc.require: issuesI91IOG
2689 */
2690 HWTEST_F(FileOperationsCloudTest, LseekTest005, TestSize.Level1)
2691 {
2692 GTEST_LOG_(INFO) << "LseekTest005 Start";
2693 try {
2694 CloudDiskFuseData data;
2695 fuse_req_t req = nullptr;
2696 fuse_ino_t ino = 0;
2697 off_t off = 0;
2698 int whence = 0;
2699 struct fuse_file_info fi;
2700 fi.fh = 2;
2701
2702 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2703 EXPECT_CALL(*insMock, lseek(_, _, _)).WillOnce(Return(1));
2704 EXPECT_CALL(*insMock, fuse_reply_lseek(_, _)).WillOnce(Return(E_OK));
2705 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2706 EXPECT_TRUE(true);
2707 } catch (...) {
2708 EXPECT_TRUE(false);
2709 GTEST_LOG_(INFO) << "LseekTest005 ERROR";
2710 }
2711 GTEST_LOG_(INFO) << "LseekTest005 End";
2712 }
2713
2714 /**
2715 * @tc.name: IoctlTest001
2716 * @tc.desc: Verify the Ioctl function
2717 * @tc.type: FUNC
2718 * @tc.require: issuesI91IOG
2719 */
2720 HWTEST_F(FileOperationsCloudTest, IoctlTest1, TestSize.Level1)
2721 {
2722 GTEST_LOG_(INFO) << "IoctlTest001 Start";
2723 try {
2724 fuse_req_t req = nullptr;
2725 fuse_ino_t ino = 0;
2726 int cmd = 0x1234;
2727 void *arg = nullptr;
2728 struct fuse_file_info *fi = nullptr;
2729 unsigned flags = 0;
2730 const void *inBuf = nullptr;
2731 size_t inBufsz = 0;
2732 size_t outBufsz = 0;
2733
2734 fileOperationsCloud_->Ioctl(req, ino, cmd, arg, fi, flags, inBuf, inBufsz, outBufsz);
2735
2736 EXPECT_TRUE(true);
2737 } catch (...) {
2738 EXPECT_TRUE(false);
2739 GTEST_LOG_(INFO) << "IoctlTest001 ERROR";
2740 }
2741 GTEST_LOG_(INFO) << "IoctlTest001 End";
2742 }
2743
2744 /**
2745 * @tc.name: IoctlTest002
2746 * @tc.desc: Verify the Ioctl function
2747 * @tc.type: FUNC
2748 * @tc.require: issuesI91IOG
2749 */
2750 HWTEST_F(FileOperationsCloudTest, IoctlTest2, TestSize.Level1)
2751 {
2752 GTEST_LOG_(INFO) << "IoctlTest002 Start";
2753 try {
2754 fuse_req_t req = nullptr;
2755 fuse_ino_t ino = 0;
2756 int cmd = 0;
2757 void *arg = nullptr;
2758 struct fuse_file_info *fi = nullptr;
2759 unsigned flags = 0;
2760 const void *inBuf = nullptr;
2761 size_t inBufsz = 0;
2762 size_t outBufsz = 0;
2763
2764 fileOperationsCloud_->Ioctl(req, ino, cmd, arg, fi, flags, inBuf, inBufsz, outBufsz);
2765
2766 EXPECT_TRUE(true);
2767 } catch (...) {
2768 EXPECT_TRUE(false);
2769 GTEST_LOG_(INFO) << "IoctlTest002 ERROR";
2770 }
2771 GTEST_LOG_(INFO) << "IoctlTest002 End";
2772 }
2773
2774 /**
2775 * @tc.name: SetXattrTest016
2776 * @tc.desc: Verify the SetXattr function
2777 * @tc.type: FUNC
2778 * @tc.require: issuesI91IOG
2779 */
2780 HWTEST_F(FileOperationsCloudTest, SetXattrTest016, TestSize.Level1)
2781 {
2782 GTEST_LOG_(INFO) << "SetXattrTest016 Start";
2783 try {
2784 CloudDiskFuseData data;
2785 fuse_req_t req = nullptr;
2786 fuse_ino_t ino = -1;
2787 string name = CLOUD_HAS_THM;
2788 const char *value = "";
2789 size_t size = 0;
2790 int flags = 0;
2791
2792 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
2793 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2794 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
2795 EXPECT_TRUE(true);
2796 } catch (...) {
2797 EXPECT_TRUE(false);
2798 GTEST_LOG_(INFO) << "SetXattrTest016 ERROR";
2799 }
2800 GTEST_LOG_(INFO) << "SetXattrTest010 End";
2801 }
2802
2803 /**
2804 * @tc.name: SetXattrTest011
2805 * @tc.desc: Verify the SetXattr function
2806 * @tc.type: FUNC
2807 * @tc.require: issuesI91IOG
2808 */
2809 HWTEST_F(FileOperationsCloudTest, SetXattrTest017, TestSize.Level1)
2810 {
2811 GTEST_LOG_(INFO) << "SetXattrTest017 Start";
2812 try {
2813 CloudDiskFuseData data;
2814 fuse_req_t req = nullptr;
2815 fuse_ino_t ino = 0;
2816 string name = CLOUD_HAS_THM;
2817 const char *value = "";
2818 size_t size = 0;
2819 int flags = 0;
2820
2821 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
2822 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2823 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
2824 EXPECT_TRUE(true);
2825 } catch (...) {
2826 EXPECT_TRUE(false);
2827 GTEST_LOG_(INFO) << "SetXattrTest017 ERROR";
2828 }
2829 GTEST_LOG_(INFO) << "SetXattrTest017 End";
2830 }
2831
2832 /**
2833 * @tc.name: SetXattrTest012
2834 * @tc.desc: Verify the SetXattr function
2835 * @tc.type: FUNC
2836 * @tc.require: issuesI91IOG
2837 */
2838 HWTEST_F(FileOperationsCloudTest, SetXattrTest018, TestSize.Level1)
2839 {
2840 GTEST_LOG_(INFO) << "SetXattrTest018 Start";
2841 try {
2842 CloudDiskFuseData data;
2843 fuse_req_t req = nullptr;
2844 fuse_ino_t ino = 0;
2845 string name = CLOUD_HAS_THM;
2846 const char *value = "test";
2847 size_t size = 0;
2848 int flags = 0;
2849
2850 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
2851 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2852 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
2853 EXPECT_TRUE(true);
2854 } catch (...) {
2855 EXPECT_TRUE(false);
2856 GTEST_LOG_(INFO) << "SetXattrTest018 ERROR";
2857 }
2858 GTEST_LOG_(INFO) << "SetXattrTest018 End";
2859 }
2860
2861 }