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