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_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
366 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
367 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
368 EXPECT_TRUE(true);
369 EXPECT_TRUE(true);
370 } catch (...) {
371 EXPECT_TRUE(false);
372 GTEST_LOG_(INFO) << "OpenTest002 ERROR";
373 }
374 GTEST_LOG_(INFO) << "OpenTest002 End";
375 }
376
377 /**
378 * @tc.name: OpenTest003
379 * @tc.desc: Verify the Open function
380 * @tc.type: FUNC
381 * @tc.require: issuesI91IOG
382 */
383 HWTEST_F(FileOperationsCloudTest, OpenTest003, TestSize.Level1)
384 {
385 GTEST_LOG_(INFO) << "OpenTest003 Start";
386 try {
387 CloudDiskFuseData data;
388 data.userId = 0;
389 fuse_req_t req = nullptr;
390 CloudDiskInode ino;
391 struct fuse_file_info fi;
392 fi.flags |= O_APPEND;
393
394 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
395 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
396 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
397 EXPECT_TRUE(true);
398 EXPECT_TRUE(true);
399 } catch (...) {
400 EXPECT_TRUE(false);
401 GTEST_LOG_(INFO) << "OpenTest003 ERROR";
402 }
403 GTEST_LOG_(INFO) << "OpenTest003 End";
404 }
405
406 /**
407 * @tc.name: OpenTest004
408 * @tc.desc: Verify the Open function
409 * @tc.type: FUNC
410 * @tc.require: issuesI91IOG
411 */
412 HWTEST_F(FileOperationsCloudTest, OpenTest004, TestSize.Level1)
413 {
414 GTEST_LOG_(INFO) << "OpenTest004 Start";
415 try {
416 CloudDiskFuseData data;
417 data.userId = 0;
418 fuse_req_t req = nullptr;
419 CloudDiskInode ino;
420 struct fuse_file_info fi;
421 fi.flags |= O_DIRECT;
422
423 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
424 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
425 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
426 EXPECT_TRUE(true);
427 EXPECT_TRUE(true);
428 } catch (...) {
429 EXPECT_TRUE(false);
430 GTEST_LOG_(INFO) << "OpenTest004 ERROR";
431 }
432 GTEST_LOG_(INFO) << "OpenTest004 End";
433 }
434
435 /**
436 * @tc.name: OpenTest005
437 * @tc.desc: Verify the Open function
438 * @tc.type: FUNC
439 * @tc.require: issuesI91IOG
440 */
441 HWTEST_F(FileOperationsCloudTest, OpenTest005, TestSize.Level1)
442 {
443 GTEST_LOG_(INFO) << "OpenTest005 Start";
444 try {
445 CloudDiskFuseData data;
446 data.userId = 0;
447 fuse_req_t req = nullptr;
448 CloudDiskInode ino;
449 struct fuse_file_info fi;
450
451 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
452 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
453 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
454 EXPECT_TRUE(true);
455 EXPECT_TRUE(true);
456 } catch (...) {
457 EXPECT_TRUE(false);
458 GTEST_LOG_(INFO) << "OpenTest005 ERROR";
459 }
460 GTEST_LOG_(INFO) << "OpenTest005 End";
461 }
462
463 /**
464 * @tc.name: OpenTest006
465 * @tc.desc: Verify the Open function
466 * @tc.type: FUNC
467 * @tc.require: issuesI91IOG
468 */
469 HWTEST_F(FileOperationsCloudTest, OpenTest006, TestSize.Level1)
470 {
471 GTEST_LOG_(INFO) << "OpenTest006 Start";
472 try {
473 CloudDiskFuseData data;
474 data.userId = 100;
475 fuse_req_t req = nullptr;
476 CloudDiskInode ino;
477 struct fuse_file_info fi;
478 fi.fh = -1;
479
480 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
481 .WillOnce(Return(reinterpret_cast<void*>(&data)));
482 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
483 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
484 EXPECT_TRUE(true);
485 EXPECT_TRUE(true);
486 } catch (...) {
487 EXPECT_TRUE(false);
488 GTEST_LOG_(INFO) << "OpenTest006 ERROR";
489 }
490 GTEST_LOG_(INFO) << "OpenTest006 End";
491 }
492
493 /**
494 * @tc.name: OpenTest007
495 * @tc.desc: Verify the Open function
496 * @tc.type: FUNC
497 * @tc.require: issuesI91IOG
498 */
499 HWTEST_F(FileOperationsCloudTest, OpenTest007, TestSize.Level1)
500 {
501 GTEST_LOG_(INFO) << "OpenTest007 Start";
502 try {
503 CloudDiskFuseData data;
504 data.userId = 100;
505 fuse_req_t req = nullptr;
506 CloudDiskInode ino;
507 struct fuse_file_info fi;
508
509 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
510 .WillOnce(Return(reinterpret_cast<void*>(&data)));
511 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
512 fileOperationsCloud_->Open(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
513 EXPECT_TRUE(true);
514 EXPECT_TRUE(true);
515 } catch (...) {
516 EXPECT_TRUE(false);
517 GTEST_LOG_(INFO) << "OpenTest007 ERROR";
518 }
519 GTEST_LOG_(INFO) << "OpenTest007 End";
520 }
521
522 /**
523 * @tc.name: MkNodTest001
524 * @tc.desc: Verify the MkNod function
525 * @tc.type: FUNC
526 * @tc.require: issuesI91IOG
527 */
528 HWTEST_F(FileOperationsCloudTest, MkNodTest001, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "MkNodTest001 Start";
531 try {
532 CloudDiskFuseData data;
533 fuse_req_t req = nullptr;
534 CloudDiskInode ino;
535 const char *name = "";
536 mode_t mode = 0;
537 dev_t rdev = 0;
538
539 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
540 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
541 fileOperationsCloud_->MkNod(req, reinterpret_cast<fuse_ino_t>(&ino), name, mode, rdev);
542 EXPECT_TRUE(true);
543 } catch (...) {
544 EXPECT_TRUE(false);
545 GTEST_LOG_(INFO) << "MkNodTest001 ERROR";
546 }
547 GTEST_LOG_(INFO) << "MkNodTest001 End";
548 }
549
550 /**
551 * @tc.name: CreateTest001
552 * @tc.desc: Verify the Create function
553 * @tc.type: FUNC
554 * @tc.require: issuesI91IOG
555 */
556 HWTEST_F(FileOperationsCloudTest, CreateTest001, TestSize.Level1)
557 {
558 GTEST_LOG_(INFO) << "CreateTest001 Start";
559 try {
560 CloudDiskFuseData data;
561 fuse_req_t req = nullptr;
562 fuse_ino_t parent = 0;
563 const char *name = "";
564 mode_t mode = 0;
565 struct fuse_file_info fi;
566
567 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
568 .WillOnce(Return(reinterpret_cast<void*>(&data)));
569 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
570 fileOperationsCloud_->Create(req, parent, name, mode, &fi);
571 EXPECT_TRUE(true);
572 } catch (...) {
573 EXPECT_TRUE(false);
574 GTEST_LOG_(INFO) << "CreateTest001 ERROR";
575 }
576 GTEST_LOG_(INFO) << "CreateTest001 End";
577 }
578
579 /**
580 * @tc.name: ReadDirTest001
581 * @tc.desc: Verify the ReadDir function
582 * @tc.type: FUNC
583 * @tc.require: issuesI91IOG
584 */
585 HWTEST_F(FileOperationsCloudTest, ReadDirTest001, TestSize.Level1)
586 {
587 GTEST_LOG_(INFO) << "ReadDirTest001 Start";
588 try {
589 CloudDiskFuseData data;
590 fuse_req_t req = nullptr;
591 fuse_ino_t ino = 4;
592 size_t size = 0;
593 off_t off = 0;
594 struct fuse_file_info fi;
595
596 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
597 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillRepeatedly(Return(E_OK));
598 fileOperationsCloud_->ReadDir(req, ino, size, off, &fi);
599 EXPECT_TRUE(true);
600 } catch (...) {
601 EXPECT_TRUE(false);
602 GTEST_LOG_(INFO) << "ReadDirTest001 ERROR";
603 }
604 GTEST_LOG_(INFO) << "ReadDirTest001 End";
605 }
606
607 /**
608 * @tc.name: ReadDirTest002
609 * @tc.desc: Verify the ReadDir function
610 * @tc.type: FUNC
611 * @tc.require: issuesI91IOG
612 */
613 HWTEST_F(FileOperationsCloudTest, ReadDirTest002, TestSize.Level1)
614 {
615 GTEST_LOG_(INFO) << "ReadDirTest002 Start";
616 try {
617 CloudDiskFuseData data;
618 fuse_req_t req = nullptr;
619 fuse_ino_t ino = -1;
620 size_t size = 0;
621 off_t off = 0;
622 struct fuse_file_info fi;
623
624 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
625 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
626 fileOperationsCloud_->ReadDir(req, ino, size, off, &fi);
627 EXPECT_TRUE(true);
628 } catch (...) {
629 EXPECT_TRUE(false);
630 GTEST_LOG_(INFO) << "ReadDirTest002 ERROR";
631 }
632 GTEST_LOG_(INFO) << "ReadDirTest002 End";
633 }
634
635
636 /**
637 * @tc.name: ReadDirTest003
638 * @tc.desc: Verify the ReadDir function
639 * @tc.type: FUNC
640 * @tc.require: issuesI91IOG
641 */
642 HWTEST_F(FileOperationsCloudTest, ReadDirTest003, TestSize.Level1)
643 {
644 GTEST_LOG_(INFO) << "ReadDirTest003 Start";
645 try {
646 CloudDiskFuseData data;
647 fuse_req_t req = nullptr;
648 fuse_ino_t ino = 0;
649 size_t size = 0;
650 off_t off = 0;
651 struct fuse_file_info fi;
652
653 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
654 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(E_OK));
655 fileOperationsCloud_->ReadDir(req, ino, size, off, &fi);
656 EXPECT_TRUE(true);
657 } catch (...) {
658 EXPECT_TRUE(false);
659 GTEST_LOG_(INFO) << "ReadDirTest003 ERROR";
660 }
661 GTEST_LOG_(INFO) << "ReadDirTest003 End";
662 }
663
664 /**
665 * @tc.name: SetXattrTest001
666 * @tc.desc: Verify the SetXattr function
667 * @tc.type: FUNC
668 * @tc.require: issuesI91IOG
669 */
670 HWTEST_F(FileOperationsCloudTest, SetXattrTest001, TestSize.Level1)
671 {
672 GTEST_LOG_(INFO) << "SetXattrTest001 Start";
673 try {
674 CloudDiskFuseData data;
675 fuse_req_t req = nullptr;
676 fuse_ino_t ino = 0;
677 string name = HMDFS_PERMISSION_XATTR;
678 const char *value = "";
679 size_t size = 0;
680 int flags = 0;
681
682 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
683 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
684 EXPECT_TRUE(true);
685 } catch (...) {
686 EXPECT_TRUE(false);
687 GTEST_LOG_(INFO) << "SetXattrTest001 ERROR";
688 }
689 GTEST_LOG_(INFO) << "SetXattrTest001 End";
690 }
691
692 /**
693 * @tc.name: SetXattrTest002
694 * @tc.desc: Verify the SetXattr function
695 * @tc.type: FUNC
696 * @tc.require: issuesI91IOG
697 */
698 HWTEST_F(FileOperationsCloudTest, SetXattrTest002, TestSize.Level1)
699 {
700 GTEST_LOG_(INFO) << "SetXattrTest002 Start";
701 try {
702 CloudDiskFuseData data;
703 fuse_req_t req = nullptr;
704 fuse_ino_t ino = -1;
705 string name = CLOUD_FILE_LOCATION;
706 const char *value = "";
707 size_t size = 0;
708 int flags = 0;
709
710 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
711 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
712 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
713 EXPECT_TRUE(true);
714 } catch (...) {
715 EXPECT_TRUE(false);
716 GTEST_LOG_(INFO) << "SetXattrTest002 ERROR";
717 }
718 GTEST_LOG_(INFO) << "SetXattrTest002 End";
719 }
720
721 /**
722 * @tc.name: SetXattrTest003
723 * @tc.desc: Verify the SetXattr function
724 * @tc.type: FUNC
725 * @tc.require: issuesI91IOG
726 */
727 HWTEST_F(FileOperationsCloudTest, SetXattrTest003, TestSize.Level1)
728 {
729 GTEST_LOG_(INFO) << "SetXattrTest003 Start";
730 try {
731 CloudDiskFuseData data;
732 fuse_req_t req = nullptr;
733 fuse_ino_t ino = 0;
734 string name = CLOUD_FILE_LOCATION;
735 const char *value = "";
736 size_t size = 0;
737 int flags = 0;
738
739 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
740 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
741 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
742 EXPECT_TRUE(true);
743 } catch (...) {
744 EXPECT_TRUE(false);
745 GTEST_LOG_(INFO) << "SetXattrTest003 ERROR";
746 }
747 GTEST_LOG_(INFO) << "SetXattrTest003 End";
748 }
749
750 /**
751 * @tc.name: SetXattrTest004
752 * @tc.desc: Verify the SetXattr function
753 * @tc.type: FUNC
754 * @tc.require: issuesI91IOG
755 */
756 HWTEST_F(FileOperationsCloudTest, SetXattrTest004, TestSize.Level1)
757 {
758 GTEST_LOG_(INFO) << "SetXattrTest004 Start";
759 try {
760 CloudDiskFuseData data;
761 fuse_req_t req = nullptr;
762 fuse_ino_t ino = 1;
763 string name = CLOUD_FILE_LOCATION;
764 const char *value = "";
765 size_t size = 0;
766 int flags = 0;
767
768 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
769 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
770 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
771 EXPECT_TRUE(true);
772 } catch (...) {
773 EXPECT_TRUE(false);
774 GTEST_LOG_(INFO) << "SetXattrTest004 ERROR";
775 }
776 GTEST_LOG_(INFO) << "SetXattrTest004 End";
777 }
778
779 /**
780 * @tc.name: SetXattrTest005
781 * @tc.desc: Verify the SetXattr function
782 * @tc.type: FUNC
783 * @tc.require: issuesI91IOG
784 */
785 HWTEST_F(FileOperationsCloudTest, SetXattrTest005, TestSize.Level1)
786 {
787 GTEST_LOG_(INFO) << "SetXattrTest005 Start";
788 try {
789 CloudDiskFuseData data;
790 fuse_req_t req = nullptr;
791 fuse_ino_t ino = 1;
792 string name = CLOUD_FILE_LOCATION;
793 const char *value = "test";
794 size_t size = 0;
795 int flags = 0;
796
797 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
798 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
799 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
800 EXPECT_TRUE(true);
801 } catch (...) {
802 EXPECT_TRUE(false);
803 GTEST_LOG_(INFO) << "SetXattrTest005 ERROR";
804 }
805 GTEST_LOG_(INFO) << "SetXattrTest005 End";
806 }
807
808 /**
809 * @tc.name: SetXattrTest006
810 * @tc.desc: Verify the SetXattr function
811 * @tc.type: FUNC
812 * @tc.require: issuesI91IOG
813 */
814 HWTEST_F(FileOperationsCloudTest, SetXattrTest006, TestSize.Level1)
815 {
816 GTEST_LOG_(INFO) << "SetXattrTest006 Start";
817 try {
818 CloudDiskFuseData data;
819 fuse_req_t req = nullptr;
820 fuse_ino_t ino = -1;
821 string name = CLOUD_CLOUD_RECYCLE_XATTR;
822 const char *value = "";
823 size_t size = 0;
824 int flags = 0;
825
826 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
827 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
828 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
829 EXPECT_TRUE(true);
830 } catch (...) {
831 EXPECT_TRUE(false);
832 GTEST_LOG_(INFO) << "SetXattrTest006 ERROR";
833 }
834 GTEST_LOG_(INFO) << "SetXattrTest006 End";
835 }
836
837 /**
838 * @tc.name: SetXattrTest007
839 * @tc.desc: Verify the SetXattr function
840 * @tc.type: FUNC
841 * @tc.require: issuesI91IOG
842 */
843 HWTEST_F(FileOperationsCloudTest, SetXattrTest007, TestSize.Level1)
844 {
845 GTEST_LOG_(INFO) << "SetXattrTest007 Start";
846 try {
847 CloudDiskFuseData data;
848 fuse_req_t req = nullptr;
849 fuse_ino_t ino = 0;
850 string name = CLOUD_CLOUD_RECYCLE_XATTR;
851 const char *value = "";
852 size_t size = 0;
853 int flags = 0;
854
855 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
856 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
857 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
858 EXPECT_TRUE(true);
859 } catch (...) {
860 EXPECT_TRUE(false);
861 GTEST_LOG_(INFO) << "SetXattrTest007 ERROR";
862 }
863 GTEST_LOG_(INFO) << "SetXattrTest007 End";
864 }
865
866 /**
867 * @tc.name: SetXattrTest008
868 * @tc.desc: Verify the SetXattr function
869 * @tc.type: FUNC
870 * @tc.require: issuesI91IOG
871 */
872 HWTEST_F(FileOperationsCloudTest, SetXattrTest008, TestSize.Level1)
873 {
874 GTEST_LOG_(INFO) << "SetXattrTest008 Start";
875 try {
876 CloudDiskFuseData data;
877 fuse_req_t req = nullptr;
878 fuse_ino_t ino = 1;
879 string name = CLOUD_CLOUD_RECYCLE_XATTR;
880 const char *value = "";
881 size_t size = 0;
882 int flags = 0;
883
884 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
885 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
886 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
887 EXPECT_TRUE(true);
888 } catch (...) {
889 EXPECT_TRUE(false);
890 GTEST_LOG_(INFO) << "SetXattrTest008 ERROR";
891 }
892 GTEST_LOG_(INFO) << "SetXattrTest008 End";
893 }
894
895 /**
896 * @tc.name: SetXattrTest009
897 * @tc.desc: Verify the SetXattr function
898 * @tc.type: FUNC
899 * @tc.require: issuesI91IOG
900 */
901 HWTEST_F(FileOperationsCloudTest, SetXattrTest009, TestSize.Level1)
902 {
903 GTEST_LOG_(INFO) << "SetXattrTest009 Start";
904 try {
905 CloudDiskFuseData data;
906 fuse_req_t req = nullptr;
907 fuse_ino_t ino = 2;
908 string name = CLOUD_CLOUD_RECYCLE_XATTR;
909 const char *value = "";
910 size_t size = 0;
911 int flags = 0;
912
913 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
914 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
915 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
916 EXPECT_TRUE(true);
917 } catch (...) {
918 EXPECT_TRUE(false);
919 GTEST_LOG_(INFO) << "SetXattrTest009 ERROR";
920 }
921 GTEST_LOG_(INFO) << "SetXattrTest009 End";
922 }
923
924 /**
925 * @tc.name: SetXattrTest010
926 * @tc.desc: Verify the SetXattr function
927 * @tc.type: FUNC
928 * @tc.require: issuesI91IOG
929 */
930 HWTEST_F(FileOperationsCloudTest, SetXattrTest010, TestSize.Level1)
931 {
932 GTEST_LOG_(INFO) << "SetXattrTest010 Start";
933 try {
934 CloudDiskFuseData data;
935 fuse_req_t req = nullptr;
936 fuse_ino_t ino = 2;
937 string name = CLOUD_CLOUD_RECYCLE_XATTR;
938 const char *value = "test";
939 size_t size = 0;
940 int flags = 0;
941
942 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
943 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
944 EXPECT_TRUE(true);
945 } catch (...) {
946 EXPECT_TRUE(false);
947 GTEST_LOG_(INFO) << "SetXattrTest010 ERROR";
948 }
949 GTEST_LOG_(INFO) << "SetXattrTest010 End";
950 }
951
952 /**
953 * @tc.name: SetXattrTest011
954 * @tc.desc: Verify the SetXattr function
955 * @tc.type: FUNC
956 * @tc.require: issuesI91IOG
957 */
958 HWTEST_F(FileOperationsCloudTest, SetXattrTest011, TestSize.Level1)
959 {
960 GTEST_LOG_(INFO) << "SetXattrTest011 Start";
961 try {
962 CloudDiskFuseData data;
963 fuse_req_t req = nullptr;
964 fuse_ino_t ino = -1;
965 string name = IS_FAVORITE_XATTR;
966 const char *value = "";
967 size_t size = 0;
968 int flags = 0;
969
970 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
971 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
972 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
973 EXPECT_TRUE(true);
974 } catch (...) {
975 EXPECT_TRUE(false);
976 GTEST_LOG_(INFO) << "SetXattrTest011 ERROR";
977 }
978 GTEST_LOG_(INFO) << "SetXattrTest011 End";
979 }
980
981 /**
982 * @tc.name: SetXattrTest012
983 * @tc.desc: Verify the SetXattr function
984 * @tc.type: FUNC
985 * @tc.require: issuesI91IOG
986 */
987 HWTEST_F(FileOperationsCloudTest, SetXattrTest012, TestSize.Level1)
988 {
989 GTEST_LOG_(INFO) << "SetXattrTest012 Start";
990 try {
991 CloudDiskFuseData data;
992 fuse_req_t req = nullptr;
993 fuse_ino_t ino = 0;
994 string name = IS_FAVORITE_XATTR;
995 const char *value = "";
996 size_t size = 0;
997 int flags = 0;
998
999 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1000 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1001 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1002 EXPECT_TRUE(true);
1003 } catch (...) {
1004 EXPECT_TRUE(false);
1005 GTEST_LOG_(INFO) << "SetXattrTest012 ERROR";
1006 }
1007 GTEST_LOG_(INFO) << "SetXattrTest012 End";
1008 }
1009
1010 /**
1011 * @tc.name: SetXattrTest013
1012 * @tc.desc: Verify the SetXattr function
1013 * @tc.type: FUNC
1014 * @tc.require: issuesI91IOG
1015 */
1016 HWTEST_F(FileOperationsCloudTest, SetXattrTest013, TestSize.Level1)
1017 {
1018 GTEST_LOG_(INFO) << "SetXattrTest013 Start";
1019 try {
1020 CloudDiskFuseData data;
1021 fuse_req_t req = nullptr;
1022 fuse_ino_t ino = 0;
1023 string name = IS_FAVORITE_XATTR;
1024 const char *value = "test";
1025 size_t size = 0;
1026 int flags = 0;
1027
1028 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1029 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1030 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1031 EXPECT_TRUE(true);
1032 } catch (...) {
1033 EXPECT_TRUE(false);
1034 GTEST_LOG_(INFO) << "SetXattrTest013 ERROR";
1035 }
1036 GTEST_LOG_(INFO) << "SetXattrTest013 End";
1037 }
1038
1039 /**
1040 * @tc.name: SetXattrTest014
1041 * @tc.desc: Verify the SetXattr function
1042 * @tc.type: FUNC
1043 * @tc.require: issuesI91IOG
1044 */
1045 HWTEST_F(FileOperationsCloudTest, SetXattrTest014, TestSize.Level1)
1046 {
1047 GTEST_LOG_(INFO) << "SetXattrTest014 Start";
1048 try {
1049 CloudDiskFuseData data;
1050 fuse_req_t req = nullptr;
1051 fuse_ino_t ino = -1;
1052 string name = IS_FILE_STATUS_XATTR;
1053 const char *value = "";
1054 size_t size = 0;
1055 int flags = 0;
1056
1057 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1058 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1059 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1060 EXPECT_TRUE(true);
1061 } catch (...) {
1062 EXPECT_TRUE(false);
1063 GTEST_LOG_(INFO) << "SetXattrTest014 ERROR";
1064 }
1065 GTEST_LOG_(INFO) << "SetXattrTest014 End";
1066 }
1067
1068 /**
1069 * @tc.name: SetXattrTest015
1070 * @tc.desc: Verify the SetXattr function
1071 * @tc.type: FUNC
1072 * @tc.require: issuesI91IOG
1073 */
1074 HWTEST_F(FileOperationsCloudTest, SetXattrTest015, TestSize.Level1)
1075 {
1076 GTEST_LOG_(INFO) << "SetXattrTest015 Start";
1077 try {
1078 CloudDiskFuseData data;
1079 fuse_req_t req = nullptr;
1080 fuse_ino_t ino = 0;
1081 string name = IS_FILE_STATUS_XATTR;
1082 const char *value = "";
1083 size_t size = 0;
1084 int flags = 0;
1085
1086 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1087 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1088 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1089 EXPECT_TRUE(true);
1090 } catch (...) {
1091 EXPECT_TRUE(false);
1092 GTEST_LOG_(INFO) << "SetXattrTest015 ERROR";
1093 }
1094 GTEST_LOG_(INFO) << "SetXattrTest015 End";
1095 }
1096
1097 /**
1098 * @tc.name: SetXattrTest016
1099 * @tc.desc: Verify the SetXattr function
1100 * @tc.type: FUNC
1101 * @tc.require: issuesI91IOG
1102 */
1103 HWTEST_F(FileOperationsCloudTest, SetXattrTest016, TestSize.Level1)
1104 {
1105 GTEST_LOG_(INFO) << "SetXattrTest016 Start";
1106 try {
1107 CloudDiskFuseData data;
1108 fuse_req_t req = nullptr;
1109 fuse_ino_t ino = 0;
1110 string name = IS_FILE_STATUS_XATTR;
1111 const char *value = "test";
1112 size_t size = 0;
1113 int flags = 0;
1114
1115 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1116 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1117 fileOperationsCloud_->SetXattr(req, ino, name.c_str(), value, size, flags);
1118 EXPECT_TRUE(true);
1119 } catch (...) {
1120 EXPECT_TRUE(false);
1121 GTEST_LOG_(INFO) << "SetXattrTest016 ERROR";
1122 }
1123 GTEST_LOG_(INFO) << "SetXattrTest016 End";
1124 }
1125
1126 /**
1127 * @tc.name: GetXattrTest001
1128 * @tc.desc: Verify the GetXattr function
1129 * @tc.type: FUNC
1130 * @tc.require: issuesI91IOG
1131 */
1132 HWTEST_F(FileOperationsCloudTest, GetXattrTest001, TestSize.Level1)
1133 {
1134 GTEST_LOG_(INFO) << "GetXattrTest001 Start";
1135 try {
1136 CloudDiskFuseData data;
1137 fuse_req_t req = nullptr;
1138 fuse_ino_t ino = -1;
1139 size_t size = 0;
1140 string name = HMDFS_PERMISSION_XATTR;
1141
1142 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1143 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1144 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1145 EXPECT_TRUE(true);
1146 } catch (...) {
1147 EXPECT_TRUE(false);
1148 GTEST_LOG_(INFO) << "GetXattrTest001 ERROR";
1149 }
1150 GTEST_LOG_(INFO) << "GetXattrTest001 End";
1151 }
1152
1153 /**
1154 * @tc.name: GetXattrTest002
1155 * @tc.desc: Verify the GetXattr function
1156 * @tc.type: FUNC
1157 * @tc.require: issuesI91IOG
1158 */
1159 HWTEST_F(FileOperationsCloudTest, GetXattrTest002, TestSize.Level1)
1160 {
1161 GTEST_LOG_(INFO) << "GetXattrTest002 Start";
1162 try {
1163 CloudDiskFuseData data;
1164 fuse_req_t req = nullptr;
1165 fuse_ino_t ino = 0;
1166 size_t size = 0;
1167 string name = HMDFS_PERMISSION_XATTR;
1168
1169 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1170 EXPECT_CALL(*insMock, fuse_reply_xattr(_, _)).WillOnce(Return(E_OK));
1171 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1172 EXPECT_TRUE(true);
1173 } catch (...) {
1174 EXPECT_TRUE(false);
1175 GTEST_LOG_(INFO) << "GetXattrTest002 ERROR";
1176 }
1177 GTEST_LOG_(INFO) << "GetXattrTest002 End";
1178 }
1179
1180 /**
1181 * @tc.name: GetXattrTest003
1182 * @tc.desc: Verify the GetXattr function
1183 * @tc.type: FUNC
1184 * @tc.require: issuesI91IOG
1185 */
1186 HWTEST_F(FileOperationsCloudTest, GetXattrTest003, TestSize.Level1)
1187 {
1188 GTEST_LOG_(INFO) << "GetXattrTest003 Start";
1189 try {
1190 CloudDiskFuseData data;
1191 fuse_req_t req = nullptr;
1192 fuse_ino_t ino = 0;
1193 size_t size = 0;
1194 string name = CLOUD_CLOUD_ID_XATTR;
1195
1196 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1197 EXPECT_CALL(*insMock, fuse_reply_xattr(_, _)).WillOnce(Return(E_OK));
1198 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1199 EXPECT_TRUE(true);
1200 } catch (...) {
1201 EXPECT_TRUE(false);
1202 GTEST_LOG_(INFO) << "GetXattrTest003 ERROR";
1203 }
1204 GTEST_LOG_(INFO) << "GetXattrTest003 End";
1205 }
1206
1207 /**
1208 * @tc.name: GetXattrTest004
1209 * @tc.desc: Verify the GetXattr function
1210 * @tc.type: FUNC
1211 * @tc.require: issuesI91IOG
1212 */
1213 HWTEST_F(FileOperationsCloudTest, GetXattrTest004, TestSize.Level1)
1214 {
1215 GTEST_LOG_(INFO) << "GetXattrTest004 Start";
1216 try {
1217 CloudDiskFuseData data;
1218 fuse_req_t req = nullptr;
1219 fuse_ino_t ino = 0;
1220 size_t size = 0;
1221 string name = IS_FAVORITE_XATTR;
1222
1223 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1224 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1225 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1226 EXPECT_TRUE(true);
1227 } catch (...) {
1228 EXPECT_TRUE(false);
1229 GTEST_LOG_(INFO) << "GetXattrTest004 ERROR";
1230 }
1231 GTEST_LOG_(INFO) << "GetXattrTest004 End";
1232 }
1233
1234 /**
1235 * @tc.name: GetXattrTest005
1236 * @tc.desc: Verify the GetXattr function
1237 * @tc.type: FUNC
1238 * @tc.require: issuesI91IOG
1239 */
1240 HWTEST_F(FileOperationsCloudTest, GetXattrTest005, TestSize.Level1)
1241 {
1242 GTEST_LOG_(INFO) << "GetXattrTest005 Start";
1243 try {
1244 CloudDiskFuseData data;
1245 fuse_req_t req = nullptr;
1246 fuse_ino_t ino = 2;
1247 size_t size = 0;
1248 string name = IS_FAVORITE_XATTR;
1249
1250 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1251 EXPECT_CALL(*insMock, fuse_reply_xattr(_, _)).WillOnce(Return(E_OK));
1252 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1253 EXPECT_TRUE(true);
1254 } catch (...) {
1255 EXPECT_TRUE(false);
1256 GTEST_LOG_(INFO) << "GetXattrTest005 ERROR";
1257 }
1258 GTEST_LOG_(INFO) << "GetXattrTest005 End";
1259 }
1260
1261 /**
1262 * @tc.name: GetXattrTest006
1263 * @tc.desc: Verify the GetXattr function
1264 * @tc.type: FUNC
1265 * @tc.require: issuesI91IOG
1266 */
1267 HWTEST_F(FileOperationsCloudTest, GetXattrTest006, TestSize.Level1)
1268 {
1269 GTEST_LOG_(INFO) << "GetXattrTest006 Start";
1270 try {
1271 CloudDiskFuseData data;
1272 fuse_req_t req = nullptr;
1273 fuse_ino_t ino = 0;
1274 size_t size = 0;
1275 string name = IS_FILE_STATUS_XATTR;
1276
1277 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1278 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1279 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1280 EXPECT_TRUE(true);
1281 } catch (...) {
1282 EXPECT_TRUE(false);
1283 GTEST_LOG_(INFO) << "GetXattrTest006 ERROR";
1284 }
1285 GTEST_LOG_(INFO) << "GetXattrTest006 End";
1286 }
1287
1288 /**
1289 * @tc.name: GetXattrTest007
1290 * @tc.desc: Verify the GetXattr function
1291 * @tc.type: FUNC
1292 * @tc.require: issuesI91IOG
1293 */
1294 HWTEST_F(FileOperationsCloudTest, GetXattrTest007, TestSize.Level1)
1295 {
1296 GTEST_LOG_(INFO) << "GetXattrTest007 Start";
1297 try {
1298 CloudDiskFuseData data;
1299 fuse_req_t req = nullptr;
1300 fuse_ino_t ino = 2;
1301 size_t size = 0;
1302 string name = IS_FILE_STATUS_XATTR;
1303
1304 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1305 EXPECT_CALL(*insMock, fuse_reply_xattr(_, _)).WillOnce(Return(E_OK)).WillOnce(Return(E_OK));
1306 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1307 EXPECT_TRUE(true);
1308 } catch (...) {
1309 EXPECT_TRUE(false);
1310 GTEST_LOG_(INFO) << "GetXattrTest007 ERROR";
1311 }
1312 GTEST_LOG_(INFO) << "GetXattrTest007 End";
1313 }
1314
1315 /**
1316 * @tc.name: GetXattrTest008
1317 * @tc.desc: Verify the GetXattr function
1318 * @tc.type: FUNC
1319 * @tc.require: issuesI91IOG
1320 */
1321 HWTEST_F(FileOperationsCloudTest, GetXattrTest008, TestSize.Level1)
1322 {
1323 GTEST_LOG_(INFO) << "GetXattrTest008 Start";
1324 try {
1325 CloudDiskFuseData data;
1326 fuse_req_t req = nullptr;
1327 fuse_ino_t ino = 0;
1328 size_t size = 0;
1329 string name = CLOUD_FILE_LOCATION;
1330
1331 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1332 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1333 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1334 EXPECT_TRUE(true);
1335 } catch (...) {
1336 EXPECT_TRUE(false);
1337 GTEST_LOG_(INFO) << "GetXattrTest008 ERROR";
1338 }
1339 GTEST_LOG_(INFO) << "GetXattrTest008 End";
1340 }
1341
1342 /**
1343 * @tc.name: GetXattrTest009
1344 * @tc.desc: Verify the GetXattr function
1345 * @tc.type: FUNC
1346 * @tc.require: issuesI91IOG
1347 */
1348 HWTEST_F(FileOperationsCloudTest, GetXattrTest009, TestSize.Level1)
1349 {
1350 GTEST_LOG_(INFO) << "GetXattrTest009 Start";
1351 try {
1352 CloudDiskFuseData data;
1353 fuse_req_t req = nullptr;
1354 fuse_ino_t ino = 1;
1355 size_t size = 0;
1356 string name = CLOUD_FILE_LOCATION;
1357
1358 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1359 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1360 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1361 EXPECT_TRUE(true);
1362 } catch (...) {
1363 EXPECT_TRUE(false);
1364 GTEST_LOG_(INFO) << "GetXattrTest009 ERROR";
1365 }
1366 GTEST_LOG_(INFO) << "GetXattrTest009 End";
1367 }
1368
1369 /**
1370 * @tc.name: GetXattrTest010
1371 * @tc.desc: Verify the GetXattr function
1372 * @tc.type: FUNC
1373 * @tc.require: issuesI91IOG
1374 */
1375 HWTEST_F(FileOperationsCloudTest, GetXattrTest010, TestSize.Level1)
1376 {
1377 GTEST_LOG_(INFO) << "GetXattrTest010 Start";
1378 try {
1379 CloudDiskFuseData data;
1380 fuse_req_t req = nullptr;
1381 fuse_ino_t ino = 2;
1382 size_t size = 0;
1383 string name = CLOUD_FILE_LOCATION;
1384
1385 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1386 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1387 EXPECT_TRUE(true);
1388 } catch (...) {
1389 EXPECT_TRUE(false);
1390 GTEST_LOG_(INFO) << "GetXattrTest010 ERROR";
1391 }
1392 GTEST_LOG_(INFO) << "GetXattrTest010 End";
1393 }
1394
1395 /**
1396 * @tc.name: GetXattrTest011
1397 * @tc.desc: Verify the GetXattr function
1398 * @tc.type: FUNC
1399 * @tc.require: issuesI91IOG
1400 */
1401 HWTEST_F(FileOperationsCloudTest, GetXattrTest011, TestSize.Level1)
1402 {
1403 GTEST_LOG_(INFO) << "GetXattrTest011 Start";
1404 try {
1405 CloudDiskFuseData data;
1406 fuse_req_t req = nullptr;
1407 fuse_ino_t ino = 0;
1408 size_t size = 0;
1409 string name = CLOUD_CLOUD_RECYCLE_XATTR;
1410
1411 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1412 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1413 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1414 EXPECT_TRUE(true);
1415 } catch (...) {
1416 EXPECT_TRUE(false);
1417 GTEST_LOG_(INFO) << "GetXattrTest011 ERROR";
1418 }
1419 GTEST_LOG_(INFO) << "GetXattrTest011 End";
1420 }
1421
1422 /**
1423 * @tc.name: GetXattrTest012
1424 * @tc.desc: Verify the GetXattr function
1425 * @tc.type: FUNC
1426 * @tc.require: issuesI91IOG
1427 */
1428 HWTEST_F(FileOperationsCloudTest, GetXattrTest012, TestSize.Level1)
1429 {
1430 GTEST_LOG_(INFO) << "GetXattrTest012 Start";
1431 try {
1432 CloudDiskFuseData data;
1433 fuse_req_t req = nullptr;
1434 fuse_ino_t ino = 2;
1435 size_t size = 0;
1436 string name = CLOUD_CLOUD_RECYCLE_XATTR;
1437
1438 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1439 EXPECT_CALL(*insMock, fuse_reply_xattr(_, _)).WillOnce(Return(E_OK));
1440 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1441 EXPECT_TRUE(true);
1442 } catch (...) {
1443 EXPECT_TRUE(false);
1444 GTEST_LOG_(INFO) << "GetXattrTest012 ERROR";
1445 }
1446 GTEST_LOG_(INFO) << "GetXattrTest012 End";
1447 }
1448
1449 /**
1450 * @tc.name: GetXattrTest013
1451 * @tc.desc: Verify the GetXattr function
1452 * @tc.type: FUNC
1453 * @tc.require: issuesI91IOG
1454 */
1455 HWTEST_F(FileOperationsCloudTest, GetXattrTest013, TestSize.Level1)
1456 {
1457 GTEST_LOG_(INFO) << "GetXattrTest013 Start";
1458 try {
1459 CloudDiskFuseData data;
1460 fuse_req_t req = nullptr;
1461 fuse_ino_t ino = 2;
1462 size_t size = 1;
1463 string name = CLOUD_CLOUD_RECYCLE_XATTR;
1464
1465 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1466 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
1467 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1468 EXPECT_TRUE(true);
1469 } catch (...) {
1470 EXPECT_TRUE(false);
1471 GTEST_LOG_(INFO) << "GetXattrTest013 ERROR";
1472 }
1473 GTEST_LOG_(INFO) << "GetXattrTest013 End";
1474 }
1475
1476 /**
1477 * @tc.name: GetXattrTest014
1478 * @tc.desc: Verify the GetXattr function
1479 * @tc.type: FUNC
1480 * @tc.require: issuesI91IOG
1481 */
1482 HWTEST_F(FileOperationsCloudTest, GetXattrTest014, TestSize.Level1)
1483 {
1484 GTEST_LOG_(INFO) << "GetXattrTest014 Start";
1485 try {
1486 CloudDiskFuseData data;
1487 fuse_req_t req = nullptr;
1488 fuse_ino_t ino = 2;
1489 size_t size = 1;
1490 string name = HMDFS_PERMISSION_XATTR;
1491
1492 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillRepeatedly(Return(reinterpret_cast<void*>(&data)));
1493 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(E_OK));
1494 fileOperationsCloud_->GetXattr(req, ino, name.c_str(), size);
1495 EXPECT_TRUE(true);
1496 } catch (...) {
1497 EXPECT_TRUE(false);
1498 GTEST_LOG_(INFO) << "GetXattrTest014 ERROR";
1499 }
1500 GTEST_LOG_(INFO) << "GetXattrTest014 End";
1501 }
1502
1503 /**
1504 * @tc.name: MkDirTest001
1505 * @tc.desc: Verify the MkDir function
1506 * @tc.type: FUNC
1507 * @tc.require: issuesI91IOG
1508 */
1509 HWTEST_F(FileOperationsCloudTest, MkDirTest001, TestSize.Level1)
1510 {
1511 GTEST_LOG_(INFO) << "MkDirTest001 Start";
1512 try {
1513 CloudDiskFuseData data;
1514 fuse_req_t req = nullptr;
1515 fuse_ino_t parent = -1;
1516 const char *name = nullptr;
1517 mode_t mode = 0;
1518
1519 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1520 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1521 fileOperationsCloud_->MkDir(req, parent, name, mode);
1522 EXPECT_TRUE(true);
1523 } catch (...) {
1524 EXPECT_TRUE(false);
1525 GTEST_LOG_(INFO) << "MkDirTest001 ERROR";
1526 }
1527 GTEST_LOG_(INFO) << "MkDirTest001 End";
1528 }
1529
1530 /**
1531 * @tc.name: MkDirTest002
1532 * @tc.desc: Verify the MkDir function
1533 * @tc.type: FUNC
1534 * @tc.require: issuesI91IOG
1535 */
1536 HWTEST_F(FileOperationsCloudTest, MkDirTest002, TestSize.Level1)
1537 {
1538 GTEST_LOG_(INFO) << "MkDirTest002 Start";
1539 try {
1540 CloudDiskFuseData data;
1541 fuse_req_t req = nullptr;
1542 fuse_ino_t parent = 0;
1543 const char *name = ".thumbs";
1544 mode_t mode = 0;
1545
1546 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1547 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1548 fileOperationsCloud_->MkDir(req, parent, name, mode);
1549 EXPECT_TRUE(true);
1550 } catch (...) {
1551 EXPECT_TRUE(false);
1552 GTEST_LOG_(INFO) << "MkDirTest002 ERROR";
1553 }
1554 GTEST_LOG_(INFO) << "MkDirTest002 End";
1555 }
1556
1557 /**
1558 * @tc.name: MkDirTest003
1559 * @tc.desc: Verify the MkDir function
1560 * @tc.type: FUNC
1561 * @tc.require: issuesI91IOG
1562 */
1563 HWTEST_F(FileOperationsCloudTest, MkDirTest003, TestSize.Level1)
1564 {
1565 GTEST_LOG_(INFO) << "MkDirTest003 Start";
1566 try {
1567 CloudDiskFuseData data;
1568 fuse_req_t req = nullptr;
1569 fuse_ino_t parent = 3;
1570 const char *name = "";
1571 mode_t mode = 0;
1572
1573 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1574 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1575 fileOperationsCloud_->MkDir(req, parent, name, mode);
1576 EXPECT_TRUE(true);
1577 } catch (...) {
1578 EXPECT_TRUE(false);
1579 GTEST_LOG_(INFO) << "MkDirTest003 ERROR";
1580 }
1581 GTEST_LOG_(INFO) << "MkDirTest003 End";
1582 }
1583
1584 /**
1585 * @tc.name: MkDirTest004
1586 * @tc.desc: Verify the MkDir function
1587 * @tc.type: FUNC
1588 * @tc.require: issuesI91IOG
1589 */
1590 HWTEST_F(FileOperationsCloudTest, MkDirTest004, TestSize.Level1)
1591 {
1592 GTEST_LOG_(INFO) << "MkDirTest004 Start";
1593 try {
1594 CloudDiskFuseData data;
1595 fuse_req_t req = nullptr;
1596 fuse_ino_t parent = 2;
1597 const char *name = "";
1598 mode_t mode = 0;
1599
1600 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1601 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1602 fileOperationsCloud_->MkDir(req, parent, name, mode);
1603 EXPECT_TRUE(true);
1604 } catch (...) {
1605 EXPECT_TRUE(false);
1606 GTEST_LOG_(INFO) << "MkDirTest004 ERROR";
1607 }
1608 GTEST_LOG_(INFO) << "MkDirTest004 End";
1609 }
1610
1611 /**
1612 * @tc.name: RmDirTest001
1613 * @tc.desc: Verify the RmDir function
1614 * @tc.type: FUNC
1615 * @tc.require: issuesI91IOG
1616 */
1617 HWTEST_F(FileOperationsCloudTest, RmDirTest001, TestSize.Level1)
1618 {
1619 GTEST_LOG_(INFO) << "RmDirTest001 Start";
1620 try {
1621 CloudDiskFuseData data;
1622 fuse_req_t req = nullptr;
1623 fuse_ino_t parent = -1;
1624 const char *name = nullptr;
1625
1626 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1627 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1628 fileOperationsCloud_->RmDir(req, parent, name);
1629 EXPECT_TRUE(true);
1630 } catch (...) {
1631 EXPECT_TRUE(false);
1632 GTEST_LOG_(INFO) << "RmDirTest001 ERROR";
1633 }
1634 GTEST_LOG_(INFO) << "RmDirTest001 End";
1635 }
1636
1637 /**
1638 * @tc.name: RmDirTest002
1639 * @tc.desc: Verify the RmDir function
1640 * @tc.type: FUNC
1641 * @tc.require: issuesI91IOG
1642 */
1643 HWTEST_F(FileOperationsCloudTest, RmDirTest002, TestSize.Level1)
1644 {
1645 GTEST_LOG_(INFO) << "RmDirTest002 Start";
1646 try {
1647 CloudDiskFuseData data;
1648 fuse_req_t req = nullptr;
1649 fuse_ino_t parent = 0;
1650 const char *name = "mock";
1651
1652 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
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_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
1679 .WillOnce(Return(reinterpret_cast<void*>(&data)));
1680 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1681 fileOperationsCloud_->RmDir(req, parent, name);
1682 EXPECT_TRUE(true);
1683 } catch (...) {
1684 EXPECT_TRUE(false);
1685 GTEST_LOG_(INFO) << "RmDirTest003 ERROR";
1686 }
1687 GTEST_LOG_(INFO) << "RmDirTest003 End";
1688 }
1689
1690 /**
1691 * @tc.name: UnlinkTest001
1692 * @tc.desc: Verify the Unlink function
1693 * @tc.type: FUNC
1694 * @tc.require: issuesI91IOG
1695 */
1696 HWTEST_F(FileOperationsCloudTest, UnlinkTest001, TestSize.Level1)
1697 {
1698 GTEST_LOG_(INFO) << "UnlinkTest001 Start";
1699 try {
1700 CloudDiskFuseData data;
1701 fuse_ino_t parent = -1;
1702 fuse_req_t req = nullptr;
1703 const char *name = "";
1704
1705 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
1706 .WillOnce(Return(reinterpret_cast<void*>(&data)));
1707 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1708 fileOperationsCloud_->Unlink(req, parent, name);
1709 EXPECT_TRUE(true);
1710 } catch (...) {
1711 EXPECT_TRUE(false);
1712 GTEST_LOG_(INFO) << "UnlinkTest001 ERROR";
1713 }
1714 GTEST_LOG_(INFO) << "UnlinkTest001 End";
1715 }
1716
1717 /**
1718 * @tc.name: UnlinkTest002
1719 * @tc.desc: Verify the Unlink function
1720 * @tc.type: FUNC
1721 * @tc.require: issuesI91IOG
1722 */
1723 HWTEST_F(FileOperationsCloudTest, UnlinkTest002, TestSize.Level1)
1724 {
1725 GTEST_LOG_(INFO) << "UnlinkTest002 Start";
1726 try {
1727 CloudDiskFuseData data;
1728 fuse_ino_t parent = -1;
1729 fuse_req_t req = nullptr;
1730 const char *name = "mock";
1731
1732 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
1733 .WillOnce(Return(reinterpret_cast<void*>(&data)));
1734 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1735 fileOperationsCloud_->Unlink(req, parent, name);
1736 EXPECT_TRUE(true);
1737 } catch (...) {
1738 EXPECT_TRUE(false);
1739 GTEST_LOG_(INFO) << "UnlinkTest002 ERROR";
1740 }
1741 GTEST_LOG_(INFO) << "UnlinkTest002 End";
1742 }
1743
1744 /**
1745 * @tc.name: UnlinkTest003
1746 * @tc.desc: Verify the Unlink function
1747 * @tc.type: FUNC
1748 * @tc.require: issuesI91IOG
1749 */
1750 HWTEST_F(FileOperationsCloudTest, UnlinkTest003, TestSize.Level1)
1751 {
1752 GTEST_LOG_(INFO) << "UnlinkTest003 Start";
1753 try {
1754 CloudDiskFuseData data;
1755 fuse_ino_t parent = 0;
1756 fuse_req_t req = nullptr;
1757 const char *name = "test";
1758
1759 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)))
1760 .WillOnce(Return(reinterpret_cast<void*>(&data)));
1761 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1762 EXPECT_CALL(*insMock, lseek(_, _, _)).WillRepeatedly(Return(E_OK));
1763 fileOperationsCloud_->Unlink(req, parent, name);
1764 EXPECT_TRUE(true);
1765 } catch (...) {
1766 EXPECT_TRUE(false);
1767 GTEST_LOG_(INFO) << "UnlinkTest003 ERROR";
1768 }
1769 GTEST_LOG_(INFO) << "UnlinkTest003 End";
1770 }
1771
1772 /**
1773 * @tc.name: RenameTest001
1774 * @tc.desc: Verify the Rename function
1775 * @tc.type: FUNC
1776 * @tc.require: issuesI91IOG
1777 */
1778 HWTEST_F(FileOperationsCloudTest, RenameTest001, TestSize.Level1)
1779 {
1780 GTEST_LOG_(INFO) << "RenameTest001 Start";
1781 try {
1782 CloudDiskFuseData data;
1783 fuse_ino_t parent = 0;
1784 fuse_ino_t newParent = 0;
1785 fuse_req_t req = nullptr;
1786 const char *name = "";
1787 const char *newName = "";
1788 unsigned int flags = 1;
1789
1790 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1791 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1792 EXPECT_TRUE(true);
1793 } catch (...) {
1794 EXPECT_TRUE(false);
1795 GTEST_LOG_(INFO) << "RenameTest001 ERROR";
1796 }
1797 GTEST_LOG_(INFO) << "RenameTest001 End";
1798 }
1799
1800 /**
1801 * @tc.name: RenameTest002
1802 * @tc.desc: Verify the Rename function
1803 * @tc.type: FUNC
1804 * @tc.require: issuesI91IOG
1805 */
1806 HWTEST_F(FileOperationsCloudTest, RenameTest002, TestSize.Level1)
1807 {
1808 GTEST_LOG_(INFO) << "RenameTest002 Start";
1809 try {
1810 CloudDiskFuseData data;
1811 fuse_ino_t parent = -1;
1812 fuse_ino_t newParent = -1;
1813 fuse_req_t req = nullptr;
1814 const char *name = "";
1815 const char *newName = "";
1816 unsigned int flags = 0;
1817
1818 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1819 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1820 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1821 EXPECT_TRUE(true);
1822 } catch (...) {
1823 EXPECT_TRUE(false);
1824 GTEST_LOG_(INFO) << "RenameTest002 ERROR";
1825 }
1826 GTEST_LOG_(INFO) << "RenameTest002 End";
1827 }
1828
1829 /**
1830 * @tc.name: RenameTest003
1831 * @tc.desc: Verify the Rename function
1832 * @tc.type: FUNC
1833 * @tc.require: issuesI91IOG
1834 */
1835 HWTEST_F(FileOperationsCloudTest, RenameTest003, TestSize.Level1)
1836 {
1837 GTEST_LOG_(INFO) << "RenameTest003 Start";
1838 try {
1839 CloudDiskFuseData data;
1840 fuse_ino_t parent = 2;
1841 fuse_ino_t newParent = 2;
1842 fuse_req_t req = nullptr;
1843 const char *name = "mock";
1844 const char *newName = "mock";
1845 unsigned int flags = 0;
1846
1847 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1848 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1849 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1850 EXPECT_TRUE(true);
1851 } catch (...) {
1852 EXPECT_TRUE(false);
1853 GTEST_LOG_(INFO) << "RenameTest003 ERROR";
1854 }
1855 GTEST_LOG_(INFO) << "RenameTest003 End";
1856 }
1857
1858 /**
1859 * @tc.name: RenameTest004
1860 * @tc.desc: Verify the Rename function
1861 * @tc.type: FUNC
1862 * @tc.require: issuesI91IOG
1863 */
1864 HWTEST_F(FileOperationsCloudTest, RenameTest004, TestSize.Level1)
1865 {
1866 GTEST_LOG_(INFO) << "RenameTest004 Start";
1867 try {
1868 CloudDiskFuseData data;
1869 fuse_ino_t parent = 2;
1870 fuse_ino_t newParent = 2;
1871 fuse_req_t req = nullptr;
1872 const char *name = "test";
1873 const char *newName = "test";
1874 unsigned int flags = 0;
1875
1876 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1877 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1878 fileOperationsCloud_->Rename(req, parent, name, newParent, newName, flags);
1879 EXPECT_TRUE(true);
1880 } catch (...) {
1881 EXPECT_TRUE(false);
1882 GTEST_LOG_(INFO) << "RenameTest004 ERROR";
1883 }
1884 GTEST_LOG_(INFO) << "RenameTest004 End";
1885 }
1886
1887 /**
1888 * @tc.name: ReadTest001
1889 * @tc.desc: Verify the ReadDir function
1890 * @tc.type: FUNC
1891 * @tc.require: issuesI91IOG
1892 */
1893 HWTEST_F(FileOperationsCloudTest, ReadTest001, TestSize.Level1)
1894 {
1895 GTEST_LOG_(INFO) << "ReadTest001 Start";
1896 try {
1897 CloudDiskFuseData data;
1898 fuse_req_t req = nullptr;
1899 CloudDiskInode ino;
1900 size_t size = 5 * 1024 *1024;
1901 off_t off = 0;
1902 struct fuse_file_info fi;
1903
1904 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1905 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1906 EXPECT_TRUE(true);
1907 } catch (...) {
1908 EXPECT_TRUE(false);
1909 GTEST_LOG_(INFO) << "ReadTest001 ERROR";
1910 }
1911 GTEST_LOG_(INFO) << "ReadTest001 End";
1912 }
1913
1914 /**
1915 * @tc.name: ReadTest002
1916 * @tc.desc: Verify the ReadDir function
1917 * @tc.type: FUNC
1918 * @tc.require: issuesI91IOG
1919 */
1920 HWTEST_F(FileOperationsCloudTest, ReadTest002, TestSize.Level1)
1921 {
1922 GTEST_LOG_(INFO) << "ReadTest002 Start";
1923 try {
1924 CloudDiskFuseData data;
1925 fuse_req_t req = nullptr;
1926 CloudDiskInode ino;
1927 size_t size = 1024;
1928 off_t off = 0;
1929 struct fuse_file_info fi;
1930 fi.fh = -1;
1931
1932 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1933 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
1934 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1935 EXPECT_TRUE(true);
1936 } catch (...) {
1937 EXPECT_TRUE(false);
1938 GTEST_LOG_(INFO) << "ReadTest002 ERROR";
1939 }
1940 GTEST_LOG_(INFO) << "ReadTest002 End";
1941 }
1942
1943 /**
1944 * @tc.name: ReadTest003
1945 * @tc.desc: Verify the ReadDir function
1946 * @tc.type: FUNC
1947 * @tc.require: issuesI91IOG
1948 */
1949 HWTEST_F(FileOperationsCloudTest, ReadTest003, TestSize.Level1)
1950 {
1951 GTEST_LOG_(INFO) << "ReadTest003 Start";
1952 try {
1953 CloudDiskFuseData data;
1954 fuse_req_t req = nullptr;
1955 CloudDiskInode ino;
1956 size_t size = 1024;
1957 off_t off = 0;
1958 struct fuse_file_info fi;
1959
1960 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1961 EXPECT_CALL(*insMock, fuse_reply_data(_, _, _)).WillOnce(Return(E_OK));
1962 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1963 EXPECT_TRUE(true);
1964 } catch (...) {
1965 EXPECT_TRUE(false);
1966 GTEST_LOG_(INFO) << "ReadTest003 ERROR";
1967 }
1968 GTEST_LOG_(INFO) << "ReadTest003 End";
1969 }
1970
1971 /**
1972 * @tc.name: ReadTest004
1973 * @tc.desc: Verify the ReadDir function
1974 * @tc.type: FUNC
1975 * @tc.require: issuesI91IOG
1976 */
1977 HWTEST_F(FileOperationsCloudTest, ReadTest004, TestSize.Level1)
1978 {
1979 GTEST_LOG_(INFO) << "ReadTest004 Start";
1980 try {
1981 CloudDiskFuseData data;
1982 fuse_req_t req = nullptr;
1983 CloudDiskInode ino;
1984 size_t size = 1024;
1985 off_t off = 0;
1986 struct fuse_file_info fi;
1987 fi.fh = 1;
1988
1989 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
1990 EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(E_OK));
1991 fileOperationsCloud_->Read(req, reinterpret_cast<fuse_ino_t>(&ino), size, off, &fi);
1992 EXPECT_TRUE(true);
1993 } catch (...) {
1994 EXPECT_TRUE(false);
1995 GTEST_LOG_(INFO) << "ReadTest004 ERROR";
1996 }
1997 GTEST_LOG_(INFO) << "ReadTest004 End";
1998 }
1999
2000 /**
2001 * @tc.name: WriteBufTest001
2002 * @tc.desc: Verify the WriteBuf function
2003 * @tc.type: FUNC
2004 * @tc.require: issuesI91IOG
2005 */
2006 HWTEST_F(FileOperationsCloudTest, WriteBufTest001, TestSize.Level1)
2007 {
2008 GTEST_LOG_(INFO) << "WriteBufTest001 Start";
2009 try {
2010 CloudDiskFuseData data;
2011 fuse_req_t req = nullptr;
2012 CloudDiskInode ino;
2013 struct fuse_bufvec *bufv = nullptr;
2014 off_t offset = 0;
2015 struct fuse_file_info fi;
2016 fi.fh = -1;
2017
2018 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2019 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2020 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2021 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2022 EXPECT_TRUE(true);
2023 } catch (...) {
2024 EXPECT_TRUE(false);
2025 GTEST_LOG_(INFO) << "WriteBufTest001 ERROR";
2026 }
2027 GTEST_LOG_(INFO) << "WriteBufTest001 End";
2028 }
2029
2030 /**
2031 * @tc.name: WriteBufTest002
2032 * @tc.desc: Verify the WriteBuf function
2033 * @tc.type: FUNC
2034 * @tc.require: issuesI91IOG
2035 */
2036 HWTEST_F(FileOperationsCloudTest, WriteBufTest002, TestSize.Level1)
2037 {
2038 GTEST_LOG_(INFO) << "WriteBufTest002 Start";
2039 try {
2040 CloudDiskFuseData data;
2041 fuse_req_t req = nullptr;
2042 CloudDiskInode ino;
2043 struct fuse_bufvec *bufv = nullptr;
2044 off_t offset = 0;
2045 struct fuse_file_info fi;
2046 fi.fh = 1;
2047
2048 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2049 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2050 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2051 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2052 EXPECT_TRUE(true);
2053 } catch (...) {
2054 EXPECT_TRUE(false);
2055 GTEST_LOG_(INFO) << "WriteBufTest002 ERROR";
2056 }
2057 GTEST_LOG_(INFO) << "WriteBufTest002 End";
2058 }
2059
2060 /**
2061 * @tc.name: WriteBufTest003
2062 * @tc.desc: Verify the WriteBuf function
2063 * @tc.type: FUNC
2064 * @tc.require: issuesI91IOG
2065 */
2066 HWTEST_F(FileOperationsCloudTest, WriteBufTest003, TestSize.Level1)
2067 {
2068 GTEST_LOG_(INFO) << "WriteBufTest003 Start";
2069 try {
2070 CloudDiskFuseData data;
2071 fuse_req_t req = nullptr;
2072 CloudDiskInode ino;
2073 struct fuse_bufvec *bufv = nullptr;
2074 off_t offset = 0;
2075 struct fuse_file_info fi;
2076 fi.fh = 2;
2077
2078 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2079 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2080 EXPECT_CALL(*insMock, fuse_buf_copy(_, _, _)).WillOnce(Return(-1));
2081 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2082 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2083 EXPECT_TRUE(true);
2084 } catch (...) {
2085 EXPECT_TRUE(false);
2086 GTEST_LOG_(INFO) << "WriteBufTest003 ERROR";
2087 }
2088 GTEST_LOG_(INFO) << "WriteBufTest003 End";
2089 }
2090
2091 /**
2092 * @tc.name: WriteBufTest004
2093 * @tc.desc: Verify the WriteBuf function
2094 * @tc.type: FUNC
2095 * @tc.require: issuesI91IOG
2096 */
2097 HWTEST_F(FileOperationsCloudTest, WriteBufTest004, TestSize.Level1)
2098 {
2099 GTEST_LOG_(INFO) << "WriteBufTest004 Start";
2100 try {
2101 CloudDiskFuseData data;
2102 fuse_req_t req = nullptr;
2103 CloudDiskInode ino;
2104 struct fuse_bufvec *bufv = nullptr;
2105 off_t offset = 0;
2106 struct fuse_file_info fi;
2107 fi.fh = 2;
2108
2109 EXPECT_CALL(*insMock, fuse_buf_size(_)).WillOnce(Return(E_OK));
2110 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2111 EXPECT_CALL(*insMock, fuse_buf_copy(_, _, _)).WillOnce(Return(1));
2112 EXPECT_CALL(*insMock, fuse_reply_write(_, _)).WillOnce(Return(E_OK));
2113 fileOperationsCloud_->WriteBuf(req, reinterpret_cast<fuse_ino_t>(&ino), bufv, offset, &fi);
2114 EXPECT_TRUE(true);
2115 } catch (...) {
2116 EXPECT_TRUE(false);
2117 GTEST_LOG_(INFO) << "WriteBufTest004 ERROR";
2118 }
2119 GTEST_LOG_(INFO) << "WriteBufTest004 End";
2120 }
2121
2122 /**
2123 * @tc.name: ReleaseTest001
2124 * @tc.desc: Verify the Release function
2125 * @tc.type: FUNC
2126 * @tc.require: issuesI91IOG
2127 */
2128 HWTEST_F(FileOperationsCloudTest, ReleaseTest001, TestSize.Level1)
2129 {
2130 GTEST_LOG_(INFO) << "ReleaseTest001 Start";
2131 try {
2132 CloudDiskFuseData data;
2133 fuse_req_t req = nullptr;
2134 fuse_ino_t ino = -1;
2135 struct fuse_file_info fi;
2136
2137 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2138 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
2139 fileOperationsCloud_->Release(req, ino, &fi);
2140 EXPECT_TRUE(true);
2141 } catch (...) {
2142 EXPECT_TRUE(false);
2143 GTEST_LOG_(INFO) << "ReleaseTest001 ERROR";
2144 }
2145 GTEST_LOG_(INFO) << "ReleaseTest001 End";
2146 }
2147
2148 /**
2149 * @tc.name: ReleaseTest002
2150 * @tc.desc: Verify the Release function
2151 * @tc.type: FUNC
2152 * @tc.require: issuesI91IOG
2153 */
2154 HWTEST_F(FileOperationsCloudTest, ReleaseTest002, TestSize.Level1)
2155 {
2156 GTEST_LOG_(INFO) << "ReleaseTest002 Start";
2157 try {
2158 CloudDiskFuseData data;
2159 fuse_req_t req = nullptr;
2160 fuse_ino_t ino = 0;
2161 struct fuse_file_info fi;
2162
2163 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2164 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
2165 fileOperationsCloud_->Release(req, ino, &fi);
2166 EXPECT_TRUE(true);
2167 } catch (...) {
2168 EXPECT_TRUE(false);
2169 GTEST_LOG_(INFO) << "ReleaseTest002 ERROR";
2170 }
2171 GTEST_LOG_(INFO) << "ReleaseTest002 End";
2172 }
2173
2174 /**
2175 * @tc.name: ReleaseTest003
2176 * @tc.desc: Verify the Release function
2177 * @tc.type: FUNC
2178 * @tc.require: issuesI91IOG
2179 */
2180 HWTEST_F(FileOperationsCloudTest, ReleaseTest003, TestSize.Level1)
2181 {
2182 GTEST_LOG_(INFO) << "ReleaseTest003 Start";
2183 try {
2184 CloudDiskFuseData data;
2185 fuse_req_t req = nullptr;
2186 fuse_ino_t ino = 1;
2187 struct fuse_file_info fi;
2188 fi.fh = -1;
2189
2190 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2191 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2192 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2193 EXPECT_TRUE(true);
2194 } catch (...) {
2195 EXPECT_TRUE(false);
2196 GTEST_LOG_(INFO) << "ReleaseTest003 ERROR";
2197 }
2198 GTEST_LOG_(INFO) << "ReleaseTest003 End";
2199 }
2200
2201 /**
2202 * @tc.name: ReleaseTest004
2203 * @tc.desc: Verify the Release function
2204 * @tc.type: FUNC
2205 * @tc.require: issuesI91IOG
2206 */
2207 HWTEST_F(FileOperationsCloudTest, ReleaseTest004, TestSize.Level1)
2208 {
2209 GTEST_LOG_(INFO) << "ReleaseTest004 Start";
2210 try {
2211 CloudDiskFuseData data;
2212 fuse_req_t req = nullptr;
2213 fuse_ino_t ino = 1;
2214 struct fuse_file_info fi;
2215 fi.fh = 2;
2216
2217 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2218 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2219 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2220 EXPECT_TRUE(true);
2221 } catch (...) {
2222 EXPECT_TRUE(false);
2223 GTEST_LOG_(INFO) << "ReleaseTest004 ERROR";
2224 }
2225 GTEST_LOG_(INFO) << "ReleaseTest003 End";
2226 }
2227
2228 /**
2229 * @tc.name: ReleaseTest005
2230 * @tc.desc: Verify the Release function
2231 * @tc.type: FUNC
2232 * @tc.require: issuesI91IOG
2233 */
2234 HWTEST_F(FileOperationsCloudTest, ReleaseTest005, TestSize.Level1)
2235 {
2236 GTEST_LOG_(INFO) << "ReleaseTest005 Start";
2237 try {
2238 CloudDiskFuseData data;
2239 fuse_req_t req = nullptr;
2240 fuse_ino_t ino = 1;
2241 struct fuse_file_info fi;
2242 fi.fh = 1;
2243
2244 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2245 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2246 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2247 EXPECT_TRUE(true);
2248 } catch (...) {
2249 EXPECT_TRUE(false);
2250 GTEST_LOG_(INFO) << "ReleaseTest005 ERROR";
2251 }
2252 GTEST_LOG_(INFO) << "ReleaseTest005 End";
2253 }
2254
2255 /**
2256 * @tc.name: ReleaseTest006
2257 * @tc.desc: Verify the Release function
2258 * @tc.type: FUNC
2259 * @tc.require: issuesI91IOG
2260 */
2261 HWTEST_F(FileOperationsCloudTest, ReleaseTest006, TestSize.Level1)
2262 {
2263 GTEST_LOG_(INFO) << "ReleaseTest006 Start";
2264 try {
2265 CloudDiskFuseData data;
2266 fuse_req_t req = nullptr;
2267 fuse_ino_t ino = 1;
2268 struct fuse_file_info fi;
2269 fi.fh = 0;
2270
2271 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2272 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2273 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2274 EXPECT_TRUE(true);
2275 } catch (...) {
2276 EXPECT_TRUE(false);
2277 GTEST_LOG_(INFO) << "ReleaseTest006 ERROR";
2278 }
2279 GTEST_LOG_(INFO) << "ReleaseTest006 End";
2280 }
2281
2282 /**
2283 * @tc.name: ReleaseTest007
2284 * @tc.desc: Verify the Release function
2285 * @tc.type: FUNC
2286 * @tc.require: issuesI91IOG
2287 */
2288 HWTEST_F(FileOperationsCloudTest, ReleaseTest007, TestSize.Level1)
2289 {
2290 GTEST_LOG_(INFO) << "ReleaseTest007 Start";
2291 try {
2292 CloudDiskFuseData data;
2293 fuse_req_t req = nullptr;
2294 fuse_ino_t ino = 1;
2295 struct fuse_file_info fi;
2296 fi.fh = 3;
2297
2298 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2299 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2300 fileOperationsCloud_->Release(req, reinterpret_cast<fuse_ino_t>(&ino), &fi);
2301 EXPECT_TRUE(true);
2302 } catch (...) {
2303 EXPECT_TRUE(false);
2304 GTEST_LOG_(INFO) << "ReleaseTest007 ERROR";
2305 }
2306 GTEST_LOG_(INFO) << "ReleaseTest007 End";
2307 }
2308
2309 /**
2310 * @tc.name: SetAttrTest001
2311 * @tc.desc: Verify the SetAttr function
2312 * @tc.type: FUNC
2313 * @tc.require: issuesI91IOG
2314 */
2315 HWTEST_F(FileOperationsCloudTest, SetAttrTest001, TestSize.Level1)
2316 {
2317 GTEST_LOG_(INFO) << "SetAttrTest001 Start";
2318 try {
2319 CloudDiskFuseData data;
2320 fuse_req_t req = nullptr;
2321 fuse_ino_t ino = -1;
2322 struct stat attr;
2323 int valid = 0;
2324 struct fuse_file_info fi;
2325
2326 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2327 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillRepeatedly(Return(E_OK));
2328 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2329 EXPECT_TRUE(true);
2330 } catch (...) {
2331 EXPECT_TRUE(false);
2332 GTEST_LOG_(INFO) << "SetAttrTest001 ERROR";
2333 }
2334 GTEST_LOG_(INFO) << "SetAttrTest001 End";
2335 }
2336
2337 /**
2338 * @tc.name: SetAttrTest002
2339 * @tc.desc: Verify the SetAttr function
2340 * @tc.type: FUNC
2341 * @tc.require: issuesI91IOG
2342 */
2343 HWTEST_F(FileOperationsCloudTest, SetAttrTest002, TestSize.Level1)
2344 {
2345 GTEST_LOG_(INFO) << "SetAttrTest002 Start";
2346 try {
2347 CloudDiskFuseData data;
2348 fuse_req_t req = nullptr;
2349 fuse_ino_t ino = 1;
2350 struct stat attr;
2351 int valid = 0;
2352 struct fuse_file_info fi;
2353
2354 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2355 EXPECT_CALL(*insMock, fuse_reply_attr(_, _, _)).WillOnce(Return(E_OK));
2356 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2357 EXPECT_TRUE(true);
2358 } catch (...) {
2359 EXPECT_TRUE(false);
2360 GTEST_LOG_(INFO) << "SetAttrTest002 ERROR";
2361 }
2362 GTEST_LOG_(INFO) << "SetAttrTest002 End";
2363 }
2364
2365 /**
2366 * @tc.name: SetAttrTest003
2367 * @tc.desc: Verify the SetAttr function
2368 * @tc.type: FUNC
2369 * @tc.require: issuesI91IOG
2370 */
2371 HWTEST_F(FileOperationsCloudTest, SetAttrTest003, TestSize.Level1)
2372 {
2373 GTEST_LOG_(INFO) << "SetAttrTest003 Start";
2374 try {
2375 CloudDiskFuseData data;
2376 data.userId = 100;
2377 fuse_req_t req = nullptr;
2378 fuse_ino_t ino = 4;
2379 struct stat attr;
2380 int valid = 13;
2381 struct fuse_file_info fi;
2382
2383 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2384 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2385 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2386 EXPECT_TRUE(true);
2387 } catch (...) {
2388 EXPECT_TRUE(false);
2389 GTEST_LOG_(INFO) << "SetAttrTest003 ERROR";
2390 }
2391 GTEST_LOG_(INFO) << "SetAttrTest003 End";
2392 }
2393
2394 /**
2395 * @tc.name: SetAttrTest004
2396 * @tc.desc: Verify the SetAttr function
2397 * @tc.type: FUNC
2398 * @tc.require: issuesI91IOG
2399 */
2400 HWTEST_F(FileOperationsCloudTest, SetAttrTest004, TestSize.Level1)
2401 {
2402 GTEST_LOG_(INFO) << "SetAttrTest004 Start";
2403 try {
2404 CloudDiskFuseData data;
2405 fuse_req_t req = nullptr;
2406 fuse_ino_t ino = 3;
2407 struct stat attr;
2408 int valid = 13;
2409 struct fuse_file_info fi;
2410
2411 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2412 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2413 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2414 EXPECT_TRUE(true);
2415 } catch (...) {
2416 EXPECT_TRUE(false);
2417 GTEST_LOG_(INFO) << "SetAttrTest004 ERROR";
2418 }
2419 GTEST_LOG_(INFO) << "SetAttrTest004 End";
2420 }
2421
2422 /**
2423 * @tc.name: SetAttrTest005
2424 * @tc.desc: Verify the SetAttr function
2425 * @tc.type: FUNC
2426 * @tc.require: issuesI91IOG
2427 */
2428 HWTEST_F(FileOperationsCloudTest, SetAttrTest005, TestSize.Level1)
2429 {
2430 GTEST_LOG_(INFO) << "SetAttrTest005 Start";
2431 try {
2432 CloudDiskFuseData data;
2433 fuse_req_t req = nullptr;
2434 fuse_ino_t ino = 2;
2435 struct stat attr;
2436 int valid = 13;
2437 struct fuse_file_info fi;
2438 fi.fh = -1;
2439
2440 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2441 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2442 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2443 EXPECT_TRUE(true);
2444 } catch (...) {
2445 EXPECT_TRUE(false);
2446 GTEST_LOG_(INFO) << "SetAttrTest005 ERROR";
2447 }
2448 GTEST_LOG_(INFO) << "SetAttrTest005 End";
2449 }
2450
2451 /**
2452 * @tc.name: SetAttrTest006
2453 * @tc.desc: Verify the SetAttr function
2454 * @tc.type: FUNC
2455 * @tc.require: issuesI91IOG
2456 */
2457 HWTEST_F(FileOperationsCloudTest, SetAttrTest006, TestSize.Level1)
2458 {
2459 GTEST_LOG_(INFO) << "SetAttrTest006 Start";
2460 try {
2461 CloudDiskFuseData data;
2462 fuse_req_t req = nullptr;
2463 fuse_ino_t ino = 2;
2464 struct stat attr;
2465 int valid = 13;
2466 struct fuse_file_info fi;
2467 fi.fh = 0;
2468
2469 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2470 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2471 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, &fi);
2472 EXPECT_TRUE(true);
2473 } catch (...) {
2474 EXPECT_TRUE(false);
2475 GTEST_LOG_(INFO) << "SetAttrTest006 ERROR";
2476 }
2477 GTEST_LOG_(INFO) << "SetAttrTest006 End";
2478 }
2479
2480 /**
2481 * @tc.name: SetAttrTest007
2482 * @tc.desc: Verify the SetAttr function
2483 * @tc.type: FUNC
2484 * @tc.require: issuesI91IOG
2485 */
2486 HWTEST_F(FileOperationsCloudTest, SetAttrTest007, TestSize.Level1)
2487 {
2488 GTEST_LOG_(INFO) << "SetAttrTest007 Start";
2489 try {
2490 CloudDiskFuseData data;
2491 fuse_req_t req = nullptr;
2492 fuse_ino_t ino = 2;
2493 struct stat attr;
2494 int valid = 13;
2495
2496 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2497 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2498 fileOperationsCloud_->SetAttr(req, ino, &attr, valid, nullptr);
2499 EXPECT_TRUE(true);
2500 } catch (...) {
2501 EXPECT_TRUE(false);
2502 GTEST_LOG_(INFO) << "SetAttrTest007 ERROR";
2503 }
2504 GTEST_LOG_(INFO) << "SetAttrTest007 End";
2505 }
2506
2507 /**
2508 * @tc.name: LseekTest001
2509 * @tc.desc: Verify the Lseek function
2510 * @tc.type: FUNC
2511 * @tc.require: issuesI91IOG
2512 */
2513 HWTEST_F(FileOperationsCloudTest, LseekTest001, TestSize.Level1)
2514 {
2515 GTEST_LOG_(INFO) << "LseekTest001 Start";
2516 try {
2517 CloudDiskFuseData data;
2518 fuse_req_t req = nullptr;
2519 fuse_ino_t ino = -1;
2520 off_t off = 0;
2521 int whence = 0;
2522 struct fuse_file_info fi;
2523
2524 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2525 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2526 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2527 EXPECT_TRUE(true);
2528 } catch (...) {
2529 EXPECT_TRUE(false);
2530 GTEST_LOG_(INFO) << "LseekTest001 ERROR";
2531 }
2532 GTEST_LOG_(INFO) << "LseekTest001 End";
2533 }
2534
2535 /**
2536 * @tc.name: LseekTest002
2537 * @tc.desc: Verify the Lseek function
2538 * @tc.type: FUNC
2539 * @tc.require: issuesI91IOG
2540 */
2541 HWTEST_F(FileOperationsCloudTest, LseekTest002, TestSize.Level1)
2542 {
2543 GTEST_LOG_(INFO) << "LseekTest002 Start";
2544 try {
2545 CloudDiskFuseData data;
2546 fuse_req_t req = nullptr;
2547 fuse_ino_t ino = 0;
2548 off_t off = 0;
2549 int whence = 0;
2550 struct fuse_file_info fi;
2551 fi.fh = -1;
2552
2553 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2554 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2555 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2556 EXPECT_TRUE(true);
2557 } catch (...) {
2558 EXPECT_TRUE(false);
2559 GTEST_LOG_(INFO) << "LseekTest002 ERROR";
2560 }
2561 GTEST_LOG_(INFO) << "LseekTest002 End";
2562 }
2563
2564 /**
2565 * @tc.name: LseekTest003
2566 * @tc.desc: Verify the Lseek function
2567 * @tc.type: FUNC
2568 * @tc.require: issuesI91IOG
2569 */
2570 HWTEST_F(FileOperationsCloudTest, LseekTest003, TestSize.Level1)
2571 {
2572 GTEST_LOG_(INFO) << "LseekTest003 Start";
2573 try {
2574 CloudDiskFuseData data;
2575 fuse_req_t req = nullptr;
2576 fuse_ino_t ino = 0;
2577 off_t off = 0;
2578 int whence = 0;
2579 struct fuse_file_info fi;
2580 fi.fh = 1;
2581
2582 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2583 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2584 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2585 EXPECT_TRUE(true);
2586 } catch (...) {
2587 EXPECT_TRUE(false);
2588 GTEST_LOG_(INFO) << "LseekTest003 ERROR";
2589 }
2590 GTEST_LOG_(INFO) << "LseekTest003 End";
2591 }
2592
2593 /**
2594 * @tc.name: LseekTest004
2595 * @tc.desc: Verify the Lseek function
2596 * @tc.type: FUNC
2597 * @tc.require: issuesI91IOG
2598 */
2599 HWTEST_F(FileOperationsCloudTest, LseekTest004, TestSize.Level1)
2600 {
2601 GTEST_LOG_(INFO) << "LseekTest004 Start";
2602 try {
2603 CloudDiskFuseData data;
2604 fuse_req_t req = nullptr;
2605 fuse_ino_t ino = 0;
2606 off_t off = 0;
2607 int whence = 0;
2608 struct fuse_file_info fi;
2609 fi.fh = 2;
2610
2611 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2612 EXPECT_CALL(*insMock, lseek(_, _, _)).WillOnce(Return(-1));
2613 EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
2614 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2615 EXPECT_TRUE(true);
2616 } catch (...) {
2617 EXPECT_TRUE(false);
2618 GTEST_LOG_(INFO) << "LseekTest004 ERROR";
2619 }
2620 GTEST_LOG_(INFO) << "LseekTest004 End";
2621 }
2622
2623 /**
2624 * @tc.name: LseekTest005
2625 * @tc.desc: Verify the Lseek function
2626 * @tc.type: FUNC
2627 * @tc.require: issuesI91IOG
2628 */
2629 HWTEST_F(FileOperationsCloudTest, LseekTest005, TestSize.Level1)
2630 {
2631 GTEST_LOG_(INFO) << "LseekTest005 Start";
2632 try {
2633 CloudDiskFuseData data;
2634 fuse_req_t req = nullptr;
2635 fuse_ino_t ino = 0;
2636 off_t off = 0;
2637 int whence = 0;
2638 struct fuse_file_info fi;
2639 fi.fh = 2;
2640
2641 EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
2642 EXPECT_CALL(*insMock, lseek(_, _, _)).WillOnce(Return(1));
2643 EXPECT_CALL(*insMock, fuse_reply_lseek(_, _)).WillOnce(Return(E_OK));
2644 fileOperationsCloud_->Lseek(req, ino, off, whence, &fi);
2645 EXPECT_TRUE(true);
2646 } catch (...) {
2647 EXPECT_TRUE(false);
2648 GTEST_LOG_(INFO) << "LseekTest005 ERROR";
2649 }
2650 GTEST_LOG_(INFO) << "LseekTest005 End";
2651 }
2652 }