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