diff --git a/test/unittests/cloud_disk/database_manager_test.cpp b/test/unittests/cloud_disk/database_manager_test.cpp
index 4461981576a6530c2fa4a94560bb2dc0997486fe..e4f193e4bff06e5b4d5da7bb0598772487f9af95 100644
--- a/test/unittests/cloud_disk/database_manager_test.cpp
+++ b/test/unittests/cloud_disk/database_manager_test.cpp
@@ -62,7 +62,7 @@ void DatabaseManagerTest::TearDown(void)
*/
HWTEST_F(DatabaseManagerTest, GetRdbStoreTest001, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "GetRdbStoreTest001 Start";
+ GTEST_LOG_(INFO) << "GetRdbStoreTest001 start";
try {
const std::string bundleName = "GetRdbStoreTest";
const int32_t userId = 123456789;
@@ -70,9 +70,32 @@ HWTEST_F(DatabaseManagerTest, GetRdbStoreTest001, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "GetRdbStoreTest001 ERROR";
+ GTEST_LOG_(INFO) << "GetRdbStoreTest001 failed";
}
- GTEST_LOG_(INFO) << "GetRdbStoreTest001 End";
+ GTEST_LOG_(INFO) << "GetRdbStoreTest001 end";
}
-} // namespace OHOS::FileManagement::CloudDisk::Test
\ No newline at end of file
+/**
+ * @tc.name: GetInstanceTest001
+ * @tc.desc: Verify the GetInstance function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(DatabaseManagerTest, GetInstanceTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "GetInstanceTest001 start";
+ try{
+ DatabaseManager& instance1 = databaseManager_->GetInstance();
+ DatabaseManager& instance2 = databaseManager_->GetInstance();
+ EXPECT_EQ(&instance1, &instance2);
+ static DatabaseManager instance_static;
+ EXPECT_NE(&instance_static, &instance1);
+ }
+ catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "GetInstanceTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "GetInstanceTest001 end";
+}
+
+} // namespace OHOS::FileManagement::CloudDisk::Test
diff --git a/test/unittests/cloud_disk/file_operations_base_test.cpp b/test/unittests/cloud_disk/file_operations_base_test.cpp
index 588c1eb5be4f93db6dc4f4603a9cc3553d95153c..397e8231c6d5f0de9356ecdef7d37adcca72a571 100644
--- a/test/unittests/cloud_disk/file_operations_base_test.cpp
+++ b/test/unittests/cloud_disk/file_operations_base_test.cpp
@@ -16,11 +16,11 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-#include "file_operations_base.h"
+#include "assistant.h"
#include "cloud_disk_inode.h"
-#include "file_operations_helper.h"
#include "dfs_error.h"
-#include "assistant.h"
+#include "file_operations_base.h"
+#include "file_operations_helper.h"
namespace OHOS::FileManagement::CloudDisk::Test {
using namespace testing;
@@ -40,26 +40,26 @@ public:
void FileOperationBaseTest::SetUpTestCase(void)
{
GTEST_LOG_(INFO) << "SetUpTestCase";
- insMock = make_shared<AssistantMock>();
- Assistant::ins = insMock;
}
void FileOperationBaseTest::TearDownTestCase(void)
{
- GTEST_LOG_(INFO) << "TearDownTestCase";
fileoperationBase_ = nullptr;
- Assistant::ins = nullptr;
- insMock = nullptr;
+ GTEST_LOG_(INFO) << "TearDownTestCase";
}
void FileOperationBaseTest::SetUp(void)
{
GTEST_LOG_(INFO) << "SetUp";
+ insMock = make_shared<AssistantMock>();
+ Assistant::ins = insMock;
}
void FileOperationBaseTest::TearDown(void)
{
GTEST_LOG_(INFO) << "TearDown";
+ Assistant::ins = nullptr;
+ insMock = nullptr;
}
/**
@@ -70,7 +70,7 @@ void FileOperationBaseTest::TearDown(void)
*/
HWTEST_F(FileOperationBaseTest, ForgetTest001, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "ForgetTest001 Start";
+ GTEST_LOG_(INFO) << "ForgetTest001 start";
try {
CloudDiskFuseData data;
EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
@@ -81,9 +81,9 @@ HWTEST_F(FileOperationBaseTest, ForgetTest001, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "ForgetTest001 ERROR";
+ GTEST_LOG_(INFO) << "ForgetTest001 failed";
}
- GTEST_LOG_(INFO) << "ForgetTest001 End";
+ GTEST_LOG_(INFO) << "ForgetTest001 end";
}
/**
@@ -94,7 +94,7 @@ HWTEST_F(FileOperationBaseTest, ForgetTest001, TestSize.Level1)
*/
HWTEST_F(FileOperationBaseTest, ForgetTest002, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "ForgetTest002 Start";
+ GTEST_LOG_(INFO) << "ForgetTest002 start";
try {
CloudDiskFuseData data;
EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
@@ -105,9 +105,9 @@ HWTEST_F(FileOperationBaseTest, ForgetTest002, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "ForgetTest002 ERROR";
+ GTEST_LOG_(INFO) << "ForgetTest002 failed";
}
- GTEST_LOG_(INFO) << "ForgetTest002 End";
+ GTEST_LOG_(INFO) << "ForgetTest002 end";
}
/**
@@ -118,7 +118,7 @@ HWTEST_F(FileOperationBaseTest, ForgetTest002, TestSize.Level1)
*/
HWTEST_F(FileOperationBaseTest, ForgetMultiTest001, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "ForgetMultiTest001 Start";
+ GTEST_LOG_(INFO) << "ForgetMultiTest001 start";
try {
CloudDiskFuseData data;
EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
@@ -129,9 +129,9 @@ HWTEST_F(FileOperationBaseTest, ForgetMultiTest001, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "ForgetMultiTest001 ERROR";
+ GTEST_LOG_(INFO) << "ForgetMultiTest001 failed";
}
- GTEST_LOG_(INFO) << "ForgetMultiTest001 End";
+ GTEST_LOG_(INFO) << "ForgetMultiTest001 end";
}
/**
@@ -142,7 +142,7 @@ HWTEST_F(FileOperationBaseTest, ForgetMultiTest001, TestSize.Level1)
*/
HWTEST_F(FileOperationBaseTest, ForgetMultiTest002, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "ForgetMultiTest002 Start";
+ GTEST_LOG_(INFO) << "ForgetMultiTest002 start";
try {
CloudDiskFuseData data;
EXPECT_CALL(*insMock, fuse_req_userdata(_)).WillOnce(Return(reinterpret_cast<void*>(&data)));
@@ -154,9 +154,9 @@ HWTEST_F(FileOperationBaseTest, ForgetMultiTest002, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "ForgetMultiTest002 ERROR";
+ GTEST_LOG_(INFO) << "ForgetMultiTest002 failed";
}
- GTEST_LOG_(INFO) << "ForgetMultiTest002 End";
+ GTEST_LOG_(INFO) << "ForgetMultiTest002 end";
}
/**
@@ -167,7 +167,7 @@ HWTEST_F(FileOperationBaseTest, ForgetMultiTest002, TestSize.Level1)
*/
HWTEST_F(FileOperationBaseTest, ForgetMultiTest003, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "ForgetMultiTest003 Start";
+ GTEST_LOG_(INFO) << "ForgetMultiTest003 start";
try {
CloudDiskFuseData data;
(data.inodeCache)[2] = make_shared<CloudDiskInode>();
@@ -180,9 +180,9 @@ HWTEST_F(FileOperationBaseTest, ForgetMultiTest003, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "ForgetMultiTest003 ERROR";
+ GTEST_LOG_(INFO) << "ForgetMultiTest003 failed";
}
- GTEST_LOG_(INFO) << "ForgetMultiTest003 End";
+ GTEST_LOG_(INFO) << "ForgetMultiTest003 end";
}
/**
@@ -193,7 +193,7 @@ HWTEST_F(FileOperationBaseTest, ForgetMultiTest003, TestSize.Level1)
*/
HWTEST_F(FileOperationBaseTest, ForgetTest003, TestSize.Level1)
{
- GTEST_LOG_(INFO) << "ForgetTest003 Start";
+ GTEST_LOG_(INFO) << "ForgetTest003 start";
try {
CloudDiskFuseData data;
(data.inodeCache)[1] = make_shared<CloudDiskInode>();
@@ -205,8 +205,427 @@ HWTEST_F(FileOperationBaseTest, ForgetTest003, TestSize.Level1)
EXPECT_TRUE(true);
} catch (...) {
EXPECT_TRUE(false);
- GTEST_LOG_(INFO) << "ForgetTest003 ERROR";
+ GTEST_LOG_(INFO) << "ForgetTest003 failed";
+ }
+ GTEST_LOG_(INFO) << "ForgetTest003 end";
+}
+
+/**
+ * @tc.name: LookupTest001
+ * @tc.desc: Verify the Lookup function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, LookupTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "LookupTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ const char * name = "testFile";
+ fileoperationBase_->Lookup(req, parent, name);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "LookupTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "LookupTest001 end";
+}
+
+/**
+ * @tc.name: AccessTest001
+ * @tc.desc: Verify the Access function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, AccessTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "AccessTest001 start";
+ try {
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ int mask = 0;
+ fileoperationBase_->Access(req, ino, mask);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "AccessTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "AccessTest001 end";
+}
+
+/**
+ * @tc.name: GetAttrTest001
+ * @tc.desc: Verify the GetAttr function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, GetAttrTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "GetAttrTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->GetAttr(req, ino, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "GetAttrTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "GetAttrTest001 end";
+}
+
+/**
+ * @tc.name: OpenTest001
+ * @tc.desc: Verify the Open function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, OpenTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "OpenTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->Open(req, ino, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "OpenTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "OpenTest001 end";
+}
+
+/**
+ * @tc.name: MkDirTest001
+ * @tc.desc: Verify the MkDir function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, MkDirTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "MkDirTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ const char* name = "testMkdir";
+ mode_t mode = 0;
+ fileoperationBase_->MkDir(req, parent, name, mode);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "MkDirTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "MkDirTest001 end";
+}
+
+/**
+ * @tc.name: RmDirTest001
+ * @tc.desc: Verify the RmDir function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, RmDirTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "RmDirTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ const char* name = "testRmDir";
+ fileoperationBase_->RmDir(req, parent, name);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "RmDirTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "RmDirTest001 end";
+}
+
+/**
+ * @tc.name: UnlinkTest001
+ * @tc.desc: Verify the Unlink function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, UnlinkTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "UnlinkTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ const char* name = "testUnlink";
+ fileoperationBase_->Unlink(req, parent, name);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "UnlinkTest001 failed";
}
- GTEST_LOG_(INFO) << "ForgetTest003 End";
+ GTEST_LOG_(INFO) << "UnlinkTest001 end";
}
+
+/**
+ * @tc.name: ReleaseTest001
+ * @tc.desc: Verify the Release function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, ReleaseTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "ReleaseTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->Release(req, parent, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "ReleaseTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "ReleaseTest001 end";
+}
+
+/**
+ * @tc.name: MkNodTest001
+ * @tc.desc: Verify the MkNod function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, MkNodTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "MkNodTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ const char *name = "testMkmod";
+ mode_t mode = 0;
+ dev_t rdev = 0;
+ fileoperationBase_->MkNod(req, parent, name, mode, rdev);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "MkNodTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "MkNodTest001 end";
+}
+
+/**
+ * @tc.name: CreateTest001
+ * @tc.desc: Verify the Create function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, CreateTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "CreateTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = FUSE_ROOT_ID;
+ const char *name = "testMkmod";
+ mode_t mode = 0;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->Create(req, parent, name, mode, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "MkNodTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "MkNodTest001 end";
+}
+
+/**
+ * @tc.name: ReadDirTest001
+ * @tc.desc: Verify the ReadDir function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, ReadDirTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "ReadDirTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ size_t size = 0;
+ off_t off = 0;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->ReadDir(req, ino, size, off, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "ReadDirTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "ReadDirTest001 end";
+}
+
+/**
+ * @tc.name: SetXattrTest001
+ * @tc.desc: Verify the SetXattr function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, SetXattrTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "SetXattrTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ const char *name = "testSetXattr";
+ const char *value = "";
+ size_t size = 0;
+ int flags = 0;
+ fileoperationBase_->SetXattr(req, ino, name, value, size, flags);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "SetXattrTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "SetXattrTest001 end";
+}
+
+/**
+ * @tc.name: GetXattrTest001
+ * @tc.desc: Verify the GetXattr function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, GetXattrTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "GetXattrTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ const char *name = "testGetXattr";
+ size_t size = 0;
+ fileoperationBase_->GetXattr(req, ino, name, size);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "GetXattrTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "GetXattrTest001 end";
+}
+
+/**
+ * @tc.name: RenameTest001
+ * @tc.desc: Verify the Rename function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, RenameTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "RenameTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t parent = 0;
+ const char *name = "testRename";
+ fuse_ino_t newParent = FUSE_ROOT_ID;
+ const char* newName = "renameTest";
+ unsigned int flags = 0;
+ fileoperationBase_->Rename(req, parent, name, newParent, newName, flags);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "RenameTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "RenameTest001 end";
+}
+
+/**
+ * @tc.name: ReadTest001
+ * @tc.desc: Verify the Read function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, ReadTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "ReadTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ size_t size = 0;
+ off_t offset = 0;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->Read(req, ino, size, offset, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "ReadTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "ReadTest001 end";
+}
+
+/**
+ * @tc.name: WriteBufTest001
+ * @tc.desc: Verify the WriteBuf function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, WriteBufTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "WriteBufTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ std::shared_ptr<fuse_bufvec> buf = std::make_shared<fuse_bufvec>();
+ off_t offset = 0;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->WriteBuf(req, ino, buf.get(), offset, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "WriteBufTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "WriteBufTest001 end";
+}
+
+/**
+ * @tc.name: SetAttrTest001
+ * @tc.desc: Verify the SetAttr function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, SetAttrTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "SetAttrTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ std::shared_ptr<struct stat> attr = std::make_shared<struct stat>();
+ int valid = 0;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->SetAttr(req, ino, attr.get(), valid, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "SetAttrTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "SetAttrTest001 end";
+}
+
+/**
+ * @tc.name: LseekTest001
+ * @tc.desc: Verify the Lseek function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FileOperationBaseTest, LseekTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "LseekTest001 start";
+ try {
+ EXPECT_CALL(*insMock, fuse_reply_err(_, _)).WillOnce(Return(E_OK));
+ fuse_req_t req = nullptr;
+ fuse_ino_t ino = FUSE_ROOT_ID;
+ off_t offset = 0;
+ int whence = 0;
+ std::shared_ptr<fuse_file_info> fi = std::make_shared<fuse_file_info>();
+ fileoperationBase_->Lseek(req, ino, offset, whence, fi.get());
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "LseekTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "LseekTest001 end";
+}
+
} // namespace OHOS::FileManagement::CloudDisk::Test
\ No newline at end of file
diff --git a/test/unittests/cloud_disk/file_operations_helper_test.cpp b/test/unittests/cloud_disk/file_operations_helper_test.cpp
index 1cfa21a37011ed7931bdd70ee924dbf45b8036f8..bf478f9027fc6d02b2a0ca512e1f934bc4425591 100644
--- a/test/unittests/cloud_disk/file_operations_helper_test.cpp
+++ b/test/unittests/cloud_disk/file_operations_helper_test.cpp
@@ -16,15 +16,15 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
-#include "fuse_operations.h"
+#include "assistant.h"
#include "cloud_disk_inode.h"
#include "cloud_file_utils.h"
-#include "file_operations_helper.h"
#include "file_operations_base.h"
#include "file_operations_cloud.h"
+#include "file_operations_helper.h"
+#include "fuse_operations.h"
#include "parameters.h"
#include "utils_log.h"
-#include "assistant.h"
namespace OHOS::FileManagement::CloudDisk::Test {
using namespace testing;
@@ -67,6 +67,31 @@ void FuseOperationsHelperTest::TearDown(void)
GTEST_LOG_(INFO) << "TearDown";
}
+/**
+ * @tc.name: AddDirEntryTest001
+ * @tc.desc: Verify the AddDirEntry function
+ * @tc.type: FUNC
+ * @tc.require: issuesIB4SSZ
+ */
+HWTEST_F(FuseOperationsHelperTest, AddDirEntryPathTest001, TestSize.Level1)
+{
+ GTEST_LOG_(INFO) << "AddDirEntryTest001 start";
+ try {
+ fuse_req_t req = nullptr;
+ std::string buffer = "";
+ size_t size = 0;
+ const char *name = "testAddDir";
+ std::shared_ptr<CloudDiskInode> ino = std::make_shared<CloudDiskInode>();
+ fuseoperationshelper_->AddDirEntry(req, buffer, size, name, ino);
+ EXPECT_GT(size, 0);
+ EXPECT_EQ(buffer.size(), size);
+ } catch (...) {
+ EXPECT_TRUE(false);
+ GTEST_LOG_(INFO) << "AddDirEntryTest001 failed";
+ }
+ GTEST_LOG_(INFO) << "AddDirEntryTest001 end";
+}
+
/**
* @tc.name: GetCloudDiskLocalPathTest001
* @tc.desc: Verify the GetCloudDiskLocalPath function