1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include "fuse_operations.h"
20 #include "cloud_disk_inode.h"
21 #include "cloud_file_utils.h"
22 #include "file_operations_helper.h"
23 #include "file_operations_base.h"
24 #include "file_operations_cloud.h"
25 #include "parameters.h"
26 #include "utils_log.h"
27 #include "assistant.h"
28 
29 namespace OHOS::FileManagement::CloudDisk::Test {
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace std;
33 
34 class FuseOperationsHelperTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40     static inline shared_ptr<FileOperationsHelper> fuseoperationshelper_ = nullptr;
41     static inline shared_ptr<AssistantMock> insMock = nullptr;
42 };
43 
SetUpTestCase(void)44 void FuseOperationsHelperTest::SetUpTestCase(void)
45 {
46     GTEST_LOG_(INFO) << "SetUpTestCase";
47     fuseoperationshelper_ = make_shared<FileOperationsHelper>();
48     insMock = make_shared<AssistantMock>();
49     Assistant::ins = insMock;
50 }
51 
TearDownTestCase(void)52 void FuseOperationsHelperTest::TearDownTestCase(void)
53 {
54     GTEST_LOG_(INFO) << "TearDownTestCase";
55     fuseoperationshelper_ = nullptr;
56     Assistant::ins = nullptr;
57     insMock = nullptr;
58 }
59 
SetUp(void)60 void FuseOperationsHelperTest::SetUp(void)
61 {
62     GTEST_LOG_(INFO) << "SetUp";
63 }
64 
TearDown(void)65 void FuseOperationsHelperTest::TearDown(void)
66 {
67     GTEST_LOG_(INFO) << "TearDown";
68 }
69 
70 /**
71  * @tc.name: GetCloudDiskLocalPathTest001
72  * @tc.desc: Verify the GetCloudDiskLocalPath function
73  * @tc.type: FUNC
74  * @tc.require: issuesI92WQP
75  */
HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest001, TestSize.Level1)76 HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest001, TestSize.Level1)
77 {
78     GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest001 Start";
79     try {
80         int32_t userId = 100;
81         string fileName = "data";
82 
83         string ret = fuseoperationshelper_->GetCloudDiskLocalPath(userId, fileName);
84         EXPECT_EQ(ret, "/data/service/el2/100/hmdfs/cloud/data/");
85         EXPECT_TRUE(true);
86     } catch (...) {
87         EXPECT_TRUE(false);
88         GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest001 ERROR";
89     }
90     GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest001 End";
91 }
92 
93 /**
94  * @tc.name: GetCloudDiskLocalPathTest002
95  * @tc.desc: Verify the GetCloudDiskLocalPath function
96  * @tc.type: FUNC
97  * @tc.require: issuesI92WQP
98  */
HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest002, TestSize.Level1)99 HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest002, TestSize.Level1)
100 {
101     GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest002 Start";
102     try {
103         int32_t userId = 100;
104         string fileName = "/";
105 
106         string ret = fuseoperationshelper_->GetCloudDiskLocalPath(userId, fileName);
107         EXPECT_EQ(ret, "/data/service/el2/100/hmdfs/cloud/");
108         EXPECT_TRUE(true);
109     } catch (...) {
110         EXPECT_TRUE(false);
111         GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest002 ERROR";
112     }
113     GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest002 End";
114 }
115 
116 /**
117  * @tc.name: GetCloudDiskLocalPathTest003
118  * @tc.desc: Verify the GetCloudDiskLocalPath function
119  * @tc.type: FUNC
120  * @tc.require: issuesI92WQP
121  */
HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest003, TestSize.Level1)122 HWTEST_F(FuseOperationsHelperTest, GetCloudDiskLocalPathTest003, TestSize.Level1)
123 {
124     GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest003 Start";
125     try {
126         int32_t userId = 100;
127         string fileName = "test";
128 
129         string ret = fuseoperationshelper_->GetCloudDiskLocalPath(userId, fileName);
130         EXPECT_EQ(ret, "/data/service/el2/100/hmdfs/cloud/data/test");
131         EXPECT_TRUE(true);
132     } catch (...) {
133         EXPECT_TRUE(false);
134         GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest003 ERROR";
135     }
136     GTEST_LOG_(INFO) << "GetCloudDiskLocalPathTest003 End";
137 }
138 
139 /**
140  * @tc.name: GetInodeAttrTest001
141  * @tc.desc: Verify the GetInodeAttr function
142  * @tc.type: FUNC
143  * @tc.require: issuesI92WQP
144  */
HWTEST_F(FuseOperationsHelperTest, GetInodeAttrTest001, TestSize.Level1)145 HWTEST_F(FuseOperationsHelperTest, GetInodeAttrTest001, TestSize.Level1)
146 {
147     GTEST_LOG_(INFO) << "GetInodeAttrTest001 Start";
148     try {
149         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
150         struct stat statBuf;
151         inoPtr->stat.st_mode |= S_IFREG;
152 
153         fuseoperationshelper_->GetInodeAttr(inoPtr, &statBuf);
154         EXPECT_TRUE(true);
155     } catch (...) {
156         EXPECT_TRUE(false);
157         GTEST_LOG_(INFO) << "GetInodeAttrTest001 ERROR";
158     }
159     GTEST_LOG_(INFO) << "GetInodeAttrTest001 End";
160 }
161 
162 /**
163  * @tc.name: GetInodeAttrTest002
164  * @tc.desc: Verify the GetInodeAttr function
165  * @tc.type: FUNC
166  * @tc.require: issuesI92WQP
167  */
HWTEST_F(FuseOperationsHelperTest, GetInodeAttrTest002, TestSize.Level1)168 HWTEST_F(FuseOperationsHelperTest, GetInodeAttrTest002, TestSize.Level1)
169 {
170     GTEST_LOG_(INFO) << "GetInodeAttrTest002 Start";
171     try {
172         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
173         struct stat statBuf;
174         inoPtr->stat.st_mode |= S_IFMT;
175 
176         fuseoperationshelper_->GetInodeAttr(inoPtr, &statBuf);
177         EXPECT_TRUE(true);
178     } catch (...) {
179         EXPECT_TRUE(false);
180         GTEST_LOG_(INFO) << "GetInodeAttrTest002 ERROR";
181     }
182     GTEST_LOG_(INFO) << "GetInodeAttrTest002 End";
183 }
184 
185 /**
186  * @tc.name: GetNextLayerTest001
187  * @tc.desc: Verify the GetNextLayer function
188  * @tc.type: FUNC
189  * @tc.require: issuesI92WQP
190  */
HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest001, TestSize.Level1)191 HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest001, TestSize.Level1)
192 {
193     GTEST_LOG_(INFO) << "GetNextLayerTest001 Start";
194     try {
195         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
196         fuse_ino_t ino = FUSE_ROOT_ID;
197 
198         int ret = fuseoperationshelper_->GetNextLayer(inoPtr, ino);
199         EXPECT_EQ(ret, CLOUD_DISK_INODE_ZERO_LAYER);
200         EXPECT_TRUE(true);
201     } catch (...) {
202         EXPECT_TRUE(false);
203         GTEST_LOG_(INFO) << "GetNextLayerTest001 ERROR";
204     }
205     GTEST_LOG_(INFO) << "GetNextLayerTest001 End";
206 }
207 
208 /**
209  * @tc.name: GetNextLayerTest002
210  * @tc.desc: Verify the GetNextLayer function
211  * @tc.type: FUNC
212  * @tc.require: issuesI92WQP
213  */
HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest002, TestSize.Level1)214 HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest002, TestSize.Level1)
215 {
216     GTEST_LOG_(INFO) << "GetNextLayerTest002 Start";
217     try {
218         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
219         inoPtr->layer = CLOUD_DISK_INODE_OTHER_LAYER;
220         fuse_ino_t ino = 0;
221 
222         int ret = fuseoperationshelper_->GetNextLayer(inoPtr, ino);
223         EXPECT_EQ(ret, CLOUD_DISK_INODE_OTHER_LAYER);
224         EXPECT_TRUE(true);
225     } catch (...) {
226         EXPECT_TRUE(false);
227         GTEST_LOG_(INFO) << "GetNextLayerTest002 ERROR";
228     }
229     GTEST_LOG_(INFO) << "GetNextLayerTest002 End";
230 }
231 
232 /**
233  * @tc.name: GetNextLayerTest003
234  * @tc.desc: Verify the GetNextLayer function
235  * @tc.type: FUNC
236  * @tc.require: issuesI92WQP
237  */
HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest003, TestSize.Level1)238 HWTEST_F(FuseOperationsHelperTest, GetNextLayerTest003, TestSize.Level1)
239 {
240     GTEST_LOG_(INFO) << "GetNextLayerTest003 Start";
241     try {
242         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
243         inoPtr->layer = CLOUD_DISK_INODE_FIRST_LAYER;
244         fuse_ino_t ino = 0;
245 
246         int ret = fuseoperationshelper_->GetNextLayer(inoPtr, ino);
247         EXPECT_EQ(ret, CLOUD_DISK_INODE_OTHER_LAYER);
248         EXPECT_TRUE(true);
249     } catch (...) {
250         EXPECT_TRUE(false);
251         GTEST_LOG_(INFO) << "GetNextLayerTest003 ERROR";
252     }
253     GTEST_LOG_(INFO) << "GetNextLayerTest003 End";
254 }
255 
256 /**
257  * @tc.name: GetFixedLayerRootIdTest001
258  * @tc.desc: Verify the GetFixedLayerRootId function
259  * @tc.type: FUNC
260  * @tc.require: issuesI92WQP
261  */
HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest001, TestSize.Level1)262 HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest001, TestSize.Level1)
263 {
264     GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest001 Start";
265     try {
266         int32_t layer = CLOUD_DISK_INODE_ZERO_LAYER;
267 
268         int ret = fuseoperationshelper_->GetFixedLayerRootId(layer);
269         EXPECT_EQ(ret, CLOUD_DISK_INODE_ZERO_LAYER_LOCALID);
270         EXPECT_TRUE(true);
271     } catch (...) {
272         EXPECT_TRUE(false);
273         GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest001 ERROR";
274     }
275     GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest001 End";
276 }
277 
278 /**
279  * @tc.name: GetFixedLayerRootIdTest002
280  * @tc.desc: Verify the GetFixedLayerRootId function
281  * @tc.type: FUNC
282  * @tc.require: issuesI92WQP
283  */
HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest002, TestSize.Level1)284 HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest002, TestSize.Level1)
285 {
286     GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest002 Start";
287     try {
288         int32_t layer = CLOUD_DISK_INODE_FIRST_LAYER;
289 
290         int ret = fuseoperationshelper_->GetFixedLayerRootId(layer);
291         EXPECT_EQ(ret, CLOUD_DISK_INODE_FIRST_LAYER_LOCALID);
292         EXPECT_TRUE(true);
293     } catch (...) {
294         EXPECT_TRUE(false);
295         GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest002 ERROR";
296     }
297     GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest002 End";
298 }
299 
300 /**
301  * @tc.name: GetFixedLayerRootIdTest003
302  * @tc.desc: Verify the GetFixedLayerRootId function
303  * @tc.type: FUNC
304  * @tc.require: issuesI92WQP
305  */
HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest003, TestSize.Level1)306 HWTEST_F(FuseOperationsHelperTest, GetFixedLayerRootIdTest003, TestSize.Level1)
307 {
308     GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest003 Start";
309     try {
310         int32_t layer = CLOUD_DISK_INODE_OTHER_LAYER;
311 
312         int ret = fuseoperationshelper_->GetFixedLayerRootId(layer);
313         EXPECT_EQ(ret, CLOUD_DISK_INODE_LAYER_LOCALID_UNKNOWN);
314         EXPECT_TRUE(true);
315     } catch (...) {
316         EXPECT_TRUE(false);
317         GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest003 ERROR";
318     }
319     GTEST_LOG_(INFO) << "GetFixedLayerRootIdTest003 End";
320 }
321 
322 /**
323  * @tc.name: FindCloudDiskInodeTest001
324  * @tc.desc: Verify the FindCloudDiskInode function
325  * @tc.type: FUNC
326  * @tc.require: issuesI92WQP
327  */
HWTEST_F(FuseOperationsHelperTest, FindCloudDiskInodeTest001, TestSize.Level1)328 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskInodeTest001, TestSize.Level1)
329 {
330     GTEST_LOG_(INFO) << "FindCloudDiskInodeTest001 Start";
331     try {
332         struct CloudDiskFuseData *data = new CloudDiskFuseData;
333         std::shared_ptr<CloudDiskInode> inode = std::make_shared<CloudDiskInode>();
334         data->inodeCache.insert(std::make_pair(1, inode));
335         int64_t key = 1;
336 
337         fuseoperationshelper_->FindCloudDiskInode(data, key);
338         delete data;
339         EXPECT_TRUE(true);
340     } catch (...) {
341         EXPECT_TRUE(false);
342         GTEST_LOG_(INFO) << "FindCloudDiskInodeTest001 ERROR";
343     }
344     GTEST_LOG_(INFO) << "FindCloudDiskInodeTest001 End";
345 }
346 
347 /**
348  * @tc.name: FindCloudDiskInodeTest002
349  * @tc.desc: Verify the FindCloudDiskInode function
350  * @tc.type: FUNC
351  * @tc.require: issuesI92WQP
352  */
HWTEST_F(FuseOperationsHelperTest, FindCloudDiskInodeTest002, TestSize.Level1)353 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskInodeTest002, TestSize.Level1)
354 {
355     GTEST_LOG_(INFO) << "FindCloudDiskInodeTest002 Start";
356     try {
357         struct CloudDiskFuseData *data = new CloudDiskFuseData;
358         int64_t key = 0;
359 
360         fuseoperationshelper_->FindCloudDiskInode(data, key);
361         delete data;
362         EXPECT_TRUE(true);
363     } catch (...) {
364         EXPECT_TRUE(false);
365         GTEST_LOG_(INFO) << "FindCloudDiskInodeTest002 ERROR";
366     }
367     GTEST_LOG_(INFO) << "FindCloudDiskInodeTest002 End";
368 }
369 
370 /**
371  * @tc.name: FindCloudDiskFileTest001
372  * @tc.desc: Verify the FindCloudDiskFile function
373  * @tc.type: FUNC
374  * @tc.require: issuesI92WQP
375  */
HWTEST_F(FuseOperationsHelperTest, FindCloudDiskFileTest001, TestSize.Level1)376 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskFileTest001, TestSize.Level1)
377 {
378     GTEST_LOG_(INFO) << "FindCloudDiskFileTest001 Start";
379     try {
380         struct CloudDiskFuseData *data = new CloudDiskFuseData;
381         std::shared_ptr<CloudDiskFile> file = std::make_shared<CloudDiskFile>();
382         data->fileCache.insert(std::make_pair(1, file));
383         int64_t key = 1;
384 
385         fuseoperationshelper_->FindCloudDiskFile(data, key);
386         delete data;
387         EXPECT_TRUE(true);
388     } catch (...) {
389         EXPECT_TRUE(false);
390         GTEST_LOG_(INFO) << "FindCloudDiskFileTest001 ERROR";
391     }
392     GTEST_LOG_(INFO) << "FindCloudDiskFileTest001 End";
393 }
394 
395 /**
396  * @tc.name: FindCloudDiskFileTest002
397  * @tc.desc: Verify the FindCloudDiskFile function
398  * @tc.type: FUNC
399  * @tc.require: issuesI92WQP
400  */
HWTEST_F(FuseOperationsHelperTest, FindCloudDiskFileTest002, TestSize.Level1)401 HWTEST_F(FuseOperationsHelperTest, FindCloudDiskFileTest002, TestSize.Level1)
402 {
403     GTEST_LOG_(INFO) << "FindCloudDiskFileTest002 Start";
404     try {
405         struct CloudDiskFuseData *data = new CloudDiskFuseData;
406         int64_t key = 0;
407 
408         fuseoperationshelper_->FindCloudDiskFile(data, key);
409         delete data;
410         EXPECT_TRUE(true);
411     } catch (...) {
412         EXPECT_TRUE(false);
413         GTEST_LOG_(INFO) << "FindCloudDiskFileTest002 ERROR";
414     }
415     GTEST_LOG_(INFO) << "FindCloudDiskFileTest002 End";
416 }
417 
418 /**
419  * @tc.name: FindLocalIdTest001
420  * @tc.desc: Verify the FindLocalId function
421  * @tc.type: FUNC
422  * @tc.require: issuesI92WQP
423  */
HWTEST_F(FuseOperationsHelperTest, FindLocalIdTest001, TestSize.Level1)424 HWTEST_F(FuseOperationsHelperTest, FindLocalIdTest001, TestSize.Level1)
425 {
426     GTEST_LOG_(INFO) << "FindLocalIdTest001 Start";
427     try {
428         struct CloudDiskFuseData *data = new CloudDiskFuseData;
429         data->localIdCache.insert(std::make_pair("test", 1));
430         string key = "test";
431 
432         int ret = fuseoperationshelper_->FindLocalId(data, key);
433         delete data;
434         EXPECT_EQ(ret, 1);
435         EXPECT_TRUE(true);
436     } catch (...) {
437         EXPECT_TRUE(false);
438         GTEST_LOG_(INFO) << "FindLocalIdTest001 ERROR";
439     }
440     GTEST_LOG_(INFO) << "FindLocalIdTest001 End";
441 }
442 
443 /**
444  * @tc.name: FindLocalIdTest002
445  * @tc.desc: Verify the FindLocalId function
446  * @tc.type: FUNC
447  * @tc.require: issuesI92WQP
448  */
HWTEST_F(FuseOperationsHelperTest, FindLocalIdTest002, TestSize.Level1)449 HWTEST_F(FuseOperationsHelperTest, FindLocalIdTest002, TestSize.Level1)
450 {
451     GTEST_LOG_(INFO) << "FindLocalIdTest002 Start";
452     try {
453         struct CloudDiskFuseData *data = new CloudDiskFuseData;
454         string key = "";
455 
456         int ret = fuseoperationshelper_->FindLocalId(data, key);
457         delete data;
458         EXPECT_EQ(ret, -1);
459         EXPECT_TRUE(true);
460     } catch (...) {
461         EXPECT_TRUE(false);
462         GTEST_LOG_(INFO) << "FindLocalIdTest002 ERROR";
463     }
464     GTEST_LOG_(INFO) << "FindLocalIdTest002 End";
465 }
466 
467 /**
468  * @tc.name: FuseReplyLimitedTest001
469  * @tc.desc: Verify the FuseReplyLimited function
470  * @tc.type: FUNC
471  * @tc.require: issuesI92WQP
472  */
HWTEST_F(FuseOperationsHelperTest, FuseReplyLimitedTest001, TestSize.Level1)473 HWTEST_F(FuseOperationsHelperTest, FuseReplyLimitedTest001, TestSize.Level1)
474 {
475     GTEST_LOG_(INFO) << "FuseReplyLimitedTest001 Start";
476     try {
477         fuse_req_t req = nullptr;
478         const char *buf;
479         size_t bufSize = 1024;
480         off_t off = 0;
481         size_t maxSize = 1024 * 4 * 4;
482         EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(0));
483 
484         fuseoperationshelper_->FuseReplyLimited(req, buf, bufSize, off, maxSize);
485         EXPECT_TRUE(true);
486     } catch (...) {
487         EXPECT_TRUE(false);
488         GTEST_LOG_(INFO) << "FuseReplyLimitedTest001 ERROR";
489     }
490     GTEST_LOG_(INFO) << "FuseReplyLimitedTest001 End";
491 }
492 
493 /**
494  * @tc.name: FuseReplyLimitedTest002
495  * @tc.desc: Verify the FuseReplyLimited function
496  * @tc.type: FUNC
497  * @tc.require: issuesI92WQP
498  */
HWTEST_F(FuseOperationsHelperTest, FuseReplyLimitedTest002, TestSize.Level1)499 HWTEST_F(FuseOperationsHelperTest, FuseReplyLimitedTest002, TestSize.Level1)
500 {
501     GTEST_LOG_(INFO) << "FuseReplyLimitedTest002 Start";
502     try {
503         fuse_req_t req = nullptr;
504         const char *buf;
505         size_t bufSize = 1024;
506         off_t off = 1024 * 4;
507         size_t maxSize = 1024 * 4 * 4;
508         EXPECT_CALL(*insMock, fuse_reply_buf(_, _, _)).WillOnce(Return(0));
509 
510         fuseoperationshelper_->FuseReplyLimited(req, buf, bufSize, off, maxSize);
511         EXPECT_TRUE(true);
512     } catch (...) {
513         EXPECT_TRUE(false);
514         GTEST_LOG_(INFO) << "FuseReplyLimitedTest002 ERROR";
515     }
516     GTEST_LOG_(INFO) << "FuseReplyLimitedTest002 End";
517 }
518 
519 /**
520  * @tc.name: GenerateCloudDiskInodeTest001
521  * @tc.desc: Verify the FuseReplyLimited function
522  * @tc.type: FUNC
523  * @tc.require: issuesI92WQP
524  */
HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest001, TestSize.Level1)525 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest001, TestSize.Level1)
526 {
527     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest001 Start";
528     try {
529         struct CloudDiskFuseData *data = new CloudDiskFuseData;
530         fuse_ino_t parent = 0;
531         string fileName = "";
532         string path = "";
533 
534         fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
535         delete data;
536         EXPECT_TRUE(true);
537     } catch (...) {
538         EXPECT_TRUE(false);
539         GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest001 ERROR";
540     }
541     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest001 End";
542 }
543 
544 /**
545  * @tc.name: GenerateCloudDiskInodeTest002
546  * @tc.desc: Verify the FuseReplyLimited function
547  * @tc.type: FUNC
548  * @tc.require: issuesI92WQP
549  */
HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest002, TestSize.Level1)550 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest002, TestSize.Level1)
551 {
552     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest002 Start";
553     try {
554         struct CloudDiskFuseData *data = new CloudDiskFuseData;
555         fuse_ino_t parent = 0;
556         string fileName = "";
557         string path = "/data";
558 
559         fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
560         delete data;
561         EXPECT_TRUE(true);
562     } catch (...) {
563         EXPECT_TRUE(false);
564         GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest002 ERROR";
565     }
566     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest002 End";
567 }
568 
569 /**
570  * @tc.name: GenerateCloudDiskInodeTest003
571  * @tc.desc: Verify the FuseReplyLimited function
572  * @tc.type: FUNC
573  * @tc.require: issuesI92WQP
574  */
HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest003, TestSize.Level1)575 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest003, TestSize.Level1)
576 {
577     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest003 Start";
578     try {
579         struct CloudDiskFuseData *data = new CloudDiskFuseData;
580         std::shared_ptr<CloudDiskInode> inode = std::make_shared<CloudDiskInode>();
581         data->inodeCache.insert(std::make_pair(1, inode));
582         fuse_ino_t parent = 1;
583         string fileName = "";
584         string path = "/data";
585 
586         fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
587         delete data;
588         EXPECT_TRUE(true);
589     } catch (...) {
590         EXPECT_TRUE(false);
591         GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest003 ERROR";
592     }
593     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest003 End";
594 }
595 
596 /**
597  * @tc.name: GenerateCloudDiskInodeTest004
598  * @tc.desc: Verify the FuseReplyLimited function
599  * @tc.type: FUNC
600  * @tc.require: issuesI92WQP
601  */
HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest004, TestSize.Level1)602 HWTEST_F(FuseOperationsHelperTest, GenerateCloudDiskInodeTest004, TestSize.Level1)
603 {
604     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest004 Start";
605     try {
606         struct CloudDiskFuseData *data = new CloudDiskFuseData;
607         std::shared_ptr<CloudDiskInode> inode = std::make_shared<CloudDiskInode>();
608         data->inodeCache.insert(std::make_pair(0, inode));
609         fuse_ino_t parent = 0;
610         string fileName = "";
611         string path = "/data";
612 
613         fuseoperationshelper_->GenerateCloudDiskInode(data, parent, fileName, path);
614         delete data;
615         EXPECT_TRUE(true);
616     } catch (...) {
617         EXPECT_TRUE(false);
618         GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest004 ERROR";
619     }
620     GTEST_LOG_(INFO) << "GenerateCloudDiskInodeTest004 End";
621 }
622 
623 /**
624  * @tc.name: PutCloudDiskInodeTest001
625  * @tc.desc: Verify the PutCloudDiskInode function
626  * @tc.type: FUNC
627  * @tc.require: issuesI92WQP
628  */
HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest001, TestSize.Level1)629 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest001, TestSize.Level1)
630 {
631     GTEST_LOG_(INFO) << "PutCloudDiskInodeTest001 Start";
632     try {
633         struct CloudDiskFuseData *data = new CloudDiskFuseData;
634         std::shared_ptr<CloudDiskInode> inoPtr = nullptr;
635         uint64_t num = 1;
636         int64_t key = 0;
637 
638         fuseoperationshelper_->PutCloudDiskInode(data, inoPtr, num, key);
639         delete data;
640         EXPECT_TRUE(true);
641     } catch (...) {
642         EXPECT_TRUE(false);
643         GTEST_LOG_(INFO) << "PutCloudDiskInodeTest001 ERROR";
644     }
645     GTEST_LOG_(INFO) << "PutCloudDiskInodeTest001 End";
646 }
647 
648 /**
649  * @tc.name: PutCloudDiskInodeTest002
650  * @tc.desc: Verify the PutCloudDiskInode function
651  * @tc.type: FUNC
652  * @tc.require: issuesI92WQP
653  */
HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest002, TestSize.Level1)654 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest002, TestSize.Level1)
655 {
656     GTEST_LOG_(INFO) << "PutCloudDiskInodeTest002 Start";
657     try {
658         struct CloudDiskFuseData *data = new CloudDiskFuseData;
659         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
660         inoPtr->refCount.store(1);
661         uint64_t num = 1;
662         int64_t key = 0;
663 
664         fuseoperationshelper_->PutCloudDiskInode(data, inoPtr, num, key);
665         delete data;
666         EXPECT_TRUE(true);
667     } catch (...) {
668         EXPECT_TRUE(false);
669         GTEST_LOG_(INFO) << "PutCloudDiskInodeTest002 ERROR";
670     }
671     GTEST_LOG_(INFO) << "PutCloudDiskInodeTest002 End";
672 }
673 
674 /**
675  * @tc.name: PutCloudDiskInodeTest003
676  * @tc.desc: Verify the PutCloudDiskInode function
677  * @tc.type: FUNC
678  * @tc.require: issuesI92WQP
679  */
HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest003, TestSize.Level1)680 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskInodeTest003, TestSize.Level1)
681 {
682     GTEST_LOG_(INFO) << "PutCloudDiskInodeTest003 Start";
683     try {
684         struct CloudDiskFuseData *data = new CloudDiskFuseData;
685         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
686         inoPtr->refCount.store(2);
687         uint64_t num = 1;
688         int64_t key = 0;
689 
690         fuseoperationshelper_->PutCloudDiskInode(data, inoPtr, num, key);
691         delete data;
692         EXPECT_TRUE(true);
693     } catch (...) {
694         EXPECT_TRUE(false);
695         GTEST_LOG_(INFO) << "PutCloudDiskInodeTest003 ERROR";
696     }
697     GTEST_LOG_(INFO) << "PutCloudDiskInodeTest003 End";
698 }
699 
700 /**
701  * @tc.name: PutCloudDiskFileTest001
702  * @tc.desc: Verify the PutCloudDiskFile function
703  * @tc.type: FUNC
704  * @tc.require: issuesI92WQP
705  */
HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest001, TestSize.Level1)706 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest001, TestSize.Level1)
707 {
708     GTEST_LOG_(INFO) << "PutCloudDiskFileTest001 Start";
709     try {
710         struct CloudDiskFuseData *data = new CloudDiskFuseData;
711         std::shared_ptr<CloudDiskFile> file = nullptr;
712         int64_t key = 0;
713 
714         fuseoperationshelper_->PutCloudDiskFile(data, file, key);
715         delete data;
716         EXPECT_TRUE(true);
717     } catch (...) {
718         EXPECT_TRUE(false);
719         GTEST_LOG_(INFO) << "PutCloudDiskFileTest001 ERROR";
720     }
721     GTEST_LOG_(INFO) << "PutCloudDiskFileTest001 End";
722 }
723 
724 /**
725  * @tc.name: PutCloudDiskFileTest002
726  * @tc.desc: Verify the PutCloudDiskFile function
727  * @tc.type: FUNC
728  * @tc.require: issuesI92WQP
729  */
HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest002, TestSize.Level1)730 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest002, TestSize.Level1)
731 {
732     GTEST_LOG_(INFO) << "PutCloudDiskFileTest002 Start";
733     try {
734         struct CloudDiskFuseData *data = new CloudDiskFuseData;
735         std::shared_ptr<CloudDiskFile> file = make_shared<CloudDiskFile>();
736         file->refCount.store(0);
737         int64_t key = 0;
738 
739         fuseoperationshelper_->PutCloudDiskFile(data, file, key);
740         delete data;
741         EXPECT_TRUE(true);
742     } catch (...) {
743         EXPECT_TRUE(false);
744         GTEST_LOG_(INFO) << "PutCloudDiskFileTest002 ERROR";
745     }
746     GTEST_LOG_(INFO) << "PutCloudDiskFileTest002 End";
747 }
748 
749 /**
750  * @tc.name: PutCloudDiskFileTest003
751  * @tc.desc: Verify the PutCloudDiskFile function
752  * @tc.type: FUNC
753  * @tc.require: issuesI92WQP
754  */
HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest003, TestSize.Level1)755 HWTEST_F(FuseOperationsHelperTest, PutCloudDiskFileTest003, TestSize.Level1)
756 {
757     GTEST_LOG_(INFO) << "PutCloudDiskFileTest003 Start";
758     try {
759         struct CloudDiskFuseData *data = new CloudDiskFuseData;
760         std::shared_ptr<CloudDiskFile> file = make_shared<CloudDiskFile>();
761         file->refCount.store(1);
762         int64_t key = 0;
763 
764         fuseoperationshelper_->PutCloudDiskFile(data, file, key);
765         delete data;
766         EXPECT_TRUE(true);
767     } catch (...) {
768         EXPECT_TRUE(false);
769         GTEST_LOG_(INFO) << "PutCloudDiskFileTest003 ERROR";
770     }
771     GTEST_LOG_(INFO) << "PutCloudDiskFileTest003 End";
772 }
773 
774 /**
775  * @tc.name: PutLocalIdTest001
776  * @tc.desc: Verify the PutLocalId function
777  * @tc.type: FUNC
778  * @tc.require: issuesI92WQP
779  */
HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest001, TestSize.Level1)780 HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest001, TestSize.Level1)
781 {
782     GTEST_LOG_(INFO) << "PutLocalIdTest001 Start";
783     try {
784         struct CloudDiskFuseData *data = new CloudDiskFuseData;
785         std::shared_ptr<CloudDiskInode> inoPtr = nullptr;
786         uint64_t num = 1;
787         string key = "";
788 
789         fuseoperationshelper_->PutLocalId(data, inoPtr, num, key);
790         delete data;
791         EXPECT_TRUE(true);
792     } catch (...) {
793         EXPECT_TRUE(false);
794         GTEST_LOG_(INFO) << "PutLocalIdTest001 ERROR";
795     }
796     GTEST_LOG_(INFO) << "PutLocalIdTest001 End";
797 }
798 
799 /**
800  * @tc.name: PutLocalIdTest002
801  * @tc.desc: Verify the PutLocalId function
802  * @tc.type: FUNC
803  * @tc.require: issuesI92WQP
804  */
HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest002, TestSize.Level1)805 HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest002, TestSize.Level1)
806 {
807     GTEST_LOG_(INFO) << "PutLocalIdTest002 Start";
808     try {
809         struct CloudDiskFuseData *data = new CloudDiskFuseData;
810         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
811         inoPtr->refCount.store(1);
812         uint64_t num = 1;
813         string key = "";
814 
815         fuseoperationshelper_->PutLocalId(data, inoPtr, num, key);
816         delete data;
817         EXPECT_TRUE(true);
818     } catch (...) {
819         EXPECT_TRUE(false);
820         GTEST_LOG_(INFO) << "PutLocalIdTest002 ERROR";
821     }
822     GTEST_LOG_(INFO) << "PutLocalIdTest002 End";
823 }
824 
825 /**
826  * @tc.name: PutLocalIdTest003
827  * @tc.desc: Verify the PutLocalId function
828  * @tc.type: FUNC
829  * @tc.require: issuesI92WQP
830  */
HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest003, TestSize.Level1)831 HWTEST_F(FuseOperationsHelperTest, PutLocalIdTest003, TestSize.Level1)
832 {
833     GTEST_LOG_(INFO) << "PutLocalIdTest003 Start";
834     try {
835         struct CloudDiskFuseData *data = new CloudDiskFuseData;
836         std::shared_ptr<CloudDiskInode> inoPtr = make_shared<CloudDiskInode>();
837         inoPtr->refCount.store(2);
838         uint64_t num = 1;
839         string key = "";
840 
841         fuseoperationshelper_->PutLocalId(data, inoPtr, num, key);
842         delete data;
843         EXPECT_TRUE(true);
844     } catch (...) {
845         EXPECT_TRUE(false);
846         GTEST_LOG_(INFO) << "PutLocalIdTest003 ERROR";
847     }
848     GTEST_LOG_(INFO) << "PutLocalIdTest003 End";
849 }
850 } // namespace OHOS::FileManagement::CloudDisk::Test