diff --git a/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp b/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
index 1599dfa757d186113b4ea02d38de23a155c64bab..d484b3d586eef1b7728b5c52f292766b36dbefb2 100644
--- a/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
+++ b/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
@@ -163,7 +163,7 @@ const string FS::ReadStreamOptionsInner::ctorSig = Builder::BuildSignatureDescri
 const string FS::ReadStreamOptionsInner::ctorDesc = Builder::BuildConstructorName();
 // FS::WriteStreamOptionsInner
 const Type FS::WriteStreamOptionsInner::classType = Builder::BuildClass("@ohos.file.fs.WriteStreamOptionsInner");
-const string FS::WriteStreamOptionsInner::classDesc = FS::ReadStreamOptionsInner::classType.Descriptor();
+const string FS::WriteStreamOptionsInner::classDesc = FS::WriteStreamOptionsInner::classType.Descriptor();
 const string FS::WriteStreamOptionsInner::ctorSig = Builder::BuildSignatureDescriptor({});
 const string FS::WriteStreamOptionsInner::ctorDesc = Builder::BuildConstructorName();
 
diff --git a/interfaces/kits/js/src/mod_fs/class_randomaccessfile/ani/randomaccessfile_ani.cpp b/interfaces/kits/js/src/mod_fs/class_randomaccessfile/ani/randomaccessfile_ani.cpp
index a220f84baa93943aaae7d349f7ff02c95de5fbc9..953755eb25e79b383a94c5552e956520e719a761 100644
--- a/interfaces/kits/js/src/mod_fs/class_randomaccessfile/ani/randomaccessfile_ani.cpp
+++ b/interfaces/kits/js/src/mod_fs/class_randomaccessfile/ani/randomaccessfile_ani.cpp
@@ -285,15 +285,15 @@ static ani_string GetFilePath(ani_env *env, const int fd)
 
 static ani_object CreateReadStreamOptions(ani_env *env, int64_t start, int64_t end)
 {
-    static const char *className = FS::ReadStreamOptionsInner::classType;
+    static const char *className = FS::ReadStreamOptionsInner::classDesc.c_str();
     ani_class cls;
     if (ANI_OK != env->FindClass(className, &cls)) {
         HILOGE("Cannot find class %{public}s", className);
         return nullptr;
     }
     ani_method ctor;
-    if (ANI_OK != env->Class_FindMethod(cls, FS::ReadStreamOptionsInner::ctorDesc,
-        FS::ReadStreamOptionsInner::ctorSig, &ctor)) {
+    if (ANI_OK != env->Class_FindMethod(cls, FS::ReadStreamOptionsInner::ctorDesc.c_str(),
+        FS::ReadStreamOptionsInner::ctorSig.c_str(), &ctor)) {
         HILOGE("Cannot find constructor method for class %{public}s", className);
         return nullptr;
     }
@@ -329,15 +329,15 @@ static ani_object CreateReadStreamOptions(ani_env *env, int64_t start, int64_t e
 
 static ani_object CreateWriteStreamOptions(ani_env *env, int64_t start, int flags)
 {
-    static const char *className = FS::WriteStreamOptionsInner::classType;
+    static const char *className = FS::WriteStreamOptionsInner::classDesc.c_str();
     ani_class cls;
     if (ANI_OK != env->FindClass(className, &cls)) {
         HILOGE("Cannot find class %{public}s", className);
         return nullptr;
     }
     ani_method ctor;
-    if (ANI_OK != env->Class_FindMethod(cls, FS::WriteStreamOptionsInner::ctorDesc,
-        FS::WriteStreamOptionsInner::ctorSig, &ctor)) {
+    if (ANI_OK != env->Class_FindMethod(cls, FS::WriteStreamOptionsInner::ctorDesc.c_str(),
+        FS::WriteStreamOptionsInner::ctorSig.c_str(), &ctor)) {
         HILOGE("Cannot find constructor method for class %{public}s", className);
         return nullptr;
     }
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp
index cc30854185643a69979ee7c5622da78b32963e60..79be6423190c34796a9b015ac57405afc7f0bda5 100644
--- a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp
@@ -32,7 +32,7 @@ using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
 FsTaskSignal *TaskSignalWrapper::Unwrap(ani_env *env, ani_object object)
 {
     ani_long nativePtr;
-    auto status = env->Object_GetFieldByName_Long(object, FS::TaskSignal::nativeTaskSignal, &nativePtr);
+    auto status = env->Object_GetFieldByName_Long(object, "nativeTaskSignal", &nativePtr);
     if (status != ANI_OK) {
         HILOGE("Unwrap taskSignal obj failed! status: %{public}d", status);
         return nullptr;
@@ -56,7 +56,7 @@ bool TaskSignalWrapper::Wrap(ani_env *env, ani_object object, const FsTaskSignal
 
     ani_long ptr = static_cast<ani_long>(reinterpret_cast<std::uintptr_t>(signal));
 
-    auto status = env->Object_SetFieldByName_Long(object, FS::TaskSignal::nativeTaskSignal, ptr);
+    auto status = env->Object_SetFieldByName_Long(object, "nativeTaskSignal", ptr);
     if (status != ANI_OK) {
         HILOGE("Wrap taskSignal obj failed! status: %{public}d", status);
         return false;
diff --git a/interfaces/kits/js/src/mod_fs/class_watcher/ani/fs_watcher_wrapper.cpp b/interfaces/kits/js/src/mod_fs/class_watcher/ani/fs_watcher_wrapper.cpp
index 51ea2e2d345479dc9b36933b17303297f8a39dc6..f769d533aea73f33f5f29a32a5acc47025832229 100644
--- a/interfaces/kits/js/src/mod_fs/class_watcher/ani/fs_watcher_wrapper.cpp
+++ b/interfaces/kits/js/src/mod_fs/class_watcher/ani/fs_watcher_wrapper.cpp
@@ -29,7 +29,7 @@ using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
 FsWatcher *FsWatcherWrapper::Unwrap(ani_env *env, ani_object object)
 {
     ani_long nativePtr;
-    auto ret = env->Object_GetFieldByName_Long(object, FS::WatcherInner::nativePtr, &nativePtr);
+    auto ret = env->Object_GetFieldByName_Long(object, "nativePtr", &nativePtr);
     if (ret != ANI_OK) {
         HILOGE("Unwrap fsWatcher err: %{public}d", ret);
         return nullptr;
diff --git a/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c7cf2dd2207de4c5123f86a8c57da433caa579a
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_mock_test.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "c_mock.h"
+#include "create_stream_core.h"
+#include "fs_utils.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace Test {
+using namespace std;
+
+static const string g_streamFilePath = "/data/test/FsStreamCoreTest.txt";
+
+class FsStreamMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        CMock::EnableMock();
+        int32_t fd = open(g_streamFilePath.c_str(), CREATE | O_RDWR, 0644);
+        if (fd <= 0) {
+            ASSERT_TRUE(false);
+        }
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        CMock::DisableMock();
+        rmdir(g_streamFilePath.c_str());
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: FsStreamSeekTest_0001
+ * @tc.desc: Test function of Seek() interface for fail fseek.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamMockTest, FsStreamSeekTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamMockTest-begin FsStreamSeekTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(g_streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto mock_ = CMock::GetMock();
+    EXPECT_CALL(*mock_, fseek(testing::_, testing::_, testing::_)).WillOnce(testing::Return(-1));
+
+    auto retSk = result->Seek(1);
+    EXPECT_FALSE(retSk.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamMockTest-end FsStreamSeekTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamSeekTest_0002
+ * @tc.desc: Test function of Seek() interface for fail ftell.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamMockTest, FsStreamSeekTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamMockTest-begin FsStreamSeekTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(g_streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto mock_ = CMock::GetMock();
+    EXPECT_CALL(*mock_, fseek(testing::_, testing::_, testing::_)).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mock_, ftell(testing::_)).WillOnce(testing::Return(-1));
+
+    auto retSk = result->Seek(1);
+    EXPECT_FALSE(retSk.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamMockTest-end FsStreamSeekTest_0002";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0001
+ * @tc.desc: Test function of Write() interface for string fail fseek.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamMockTest, FsStreamWriteTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamMockTest-begin FsStreamWriteTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(g_streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto mock_ = CMock::GetMock();
+    EXPECT_CALL(*mock_, fseek(testing::_, testing::_, testing::_)).WillOnce(testing::Return(-1));
+
+    WriteOptions opt;
+    opt.offset = 5;
+    auto retWr = result->Write("FsStreamWriteTest_0001", opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamMockTest-end FsStreamWriteTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0002
+ * @tc.desc: Test function of Write() interface for ArrayBuffer fail fseek.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamMockTest, FsStreamWriteTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamMockTest-begin FsStreamWriteTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(g_streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto mock_ = CMock::GetMock();
+    EXPECT_CALL(*mock_, fseek(testing::_, testing::_, testing::_)).WillOnce(testing::Return(-1));
+
+    WriteOptions opt;
+    opt.offset = 5;
+    string buf = "FsStreamWriteTest_0002";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), buf.length()), opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamMockTest-end FsStreamWriteTest_0002";
+}
+
+/**
+ * @tc.name: FsStreamReadTest_0001
+ * @tc.desc: Test function of Read() interface for fail fseek.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamMockTest, FsStreamReadTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamMockTest-begin FsStreamReadTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(g_streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+
+    auto mock_ = CMock::GetMock();
+    EXPECT_CALL(*mock_, fseek(testing::_, testing::_, testing::_)).WillOnce(testing::Return(-1));
+
+    ReadOptions opt;
+    opt.offset = 5;
+    auto retRd = result->Read(arrayBuffer, opt);
+    EXPECT_FALSE(retRd.IsSuccess());
+
+    free(buffer);
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamMockTest-end FsStreamReadTest_0001";
+}
+
+} // namespace Test
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_test.cpp b/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3ba5155b3733f9efb0476f629bcf6a0e2483334b
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_test.cpp
@@ -0,0 +1,794 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "create_stream_core.h"
+#include "fs_utils.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+static const string streamFilePath = "/data/test/FsStreamCoreTest.txt";
+
+class FsStreamTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        int32_t fd = open(streamFilePath.c_str(), CREATE | O_RDWR, 0644);
+        if (fd <= 0) {
+            ASSERT_TRUE(false);
+        }
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        rmdir(streamFilePath.c_str());
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: FsStreamCloseTest_0001
+ * @tc.desc: Test function of Close() interface for close success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamCloseTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamCloseTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamCloseTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamCloseTest_0002
+ * @tc.desc: Test function of Close() interface for close fail.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamCloseTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamCloseTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    retCs = result->Close();
+    EXPECT_FALSE(retCs.IsSuccess());
+    auto err = retCs.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900005);
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamCloseTest_0002";
+}
+
+/**
+ * @tc.name: FsStreamFlushTest_0001
+ * @tc.desc: Test function of Flush() interface for null fp.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamFlushTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamFlushTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    auto retFl = result->Flush();
+    EXPECT_FALSE(retFl.IsSuccess());
+    auto err = retFl.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900005);
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamFlushTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamFlushTest_0002
+ * @tc.desc: Test function of Flush() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamFlushTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamFlushTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retFl = result->Flush();
+    ASSERT_TRUE(retFl.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamFlushTest_0002";
+}
+
+/**
+ * @tc.name: FsStreamSeekTest_0001
+ * @tc.desc: Test function of Seek() interface for null fp.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamSeekTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    auto retSk = result->Seek(0);
+    EXPECT_FALSE(retSk.IsSuccess());
+    auto err = retSk.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamSeekTest_0002
+ * @tc.desc: Test function of Seek() interface for error whence < SEEK_SET (0).
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamSeekTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    optional<int32_t> opt = -1;
+    auto retSk = result->Seek(0, opt);
+    EXPECT_FALSE(retSk.IsSuccess());
+    auto err = retSk.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0002";
+}
+
+/**
+ * @tc.name: FsStreamSeekTest_0003
+ * @tc.desc: Test function of Seek() interface for error whence > SEEK_END (2).
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamSeekTest_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0003";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    optional<int32_t> opt = 3;
+    auto retSk = result->Seek(0, opt);
+    EXPECT_FALSE(retSk.IsSuccess());
+    auto err = retSk.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0003";
+}
+
+/**
+ * @tc.name: FsStreamSeekTest_0004
+ * @tc.desc: Test function of Seek() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamSeekTest_0004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0004";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retSk = result->Seek(1);
+    ASSERT_TRUE(retSk.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0004";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0001
+ * @tc.desc: Test function of Write() interface for string single argument fail null fp.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    auto retWr = result->Write("FsStreamWriteTest_0001");
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0002
+ * @tc.desc: Test function of Write() interface for ArrayBuffer single argument fail null fp.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    string buf = "FsStreamWriteTest_0001";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22));
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0002";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0003
+ * @tc.desc: Test function of Write() interface for string error offset.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0003";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.offset = -1;
+
+    auto retWr = result->Write("FsStreamWriteTest_0003", opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0003";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0004
+ * @tc.desc: Test function of Write() interface for ArrayBuffer error offset.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0004";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.offset = -1;
+
+    string buf = "FsStreamWriteTest_0004";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0004";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0005
+ * @tc.desc: Test function of Write() interface for string error encoding.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0005";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.encoding = "utf-16";
+
+    auto retWr = result->Write("FsStreamWriteTest_0005", opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0005";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0006
+ * @tc.desc: Test function of Write() interface for ArrayBuffer error encoding.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0006, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0006";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.encoding = "utf-16";
+
+    string buf = "FsStreamWriteTest_0006";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0004";
+}
+
+#if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) || defined(__LP64__)
+/**
+ * @tc.name: FsStreamWriteTest_0007
+ * @tc.desc: Test function of Write() interface for string > UINT_MAX.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0007, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0007";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    size_t largeLength = static_cast<size_t>(UINT_MAX) + 1;
+    string largeString(largeLength, 'a');
+
+    auto retWr = result->Write(largeString);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0005";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0008
+ * @tc.desc: Test function of Write() interface for ArrayBuffer > UINT_MAX.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0008, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0008";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    size_t largeLength = static_cast<size_t>(UINT_MAX) + 1;
+    string largeString(largeLength, 'a');
+
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(largeString.data()), largeLength));
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0008";
+}
+#endif
+
+/**
+ * @tc.name: FsStreamWriteTest_0009
+ * @tc.desc: Test function of Write() interface for string length < 0.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0009, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0009";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.length = -1;
+
+    auto retWr = result->Write("FsStreamWriteTest_0009", opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0009";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0010
+ * @tc.desc: Test function of Write() interface for ArrayBuffer length < 0.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0010, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0010";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.length = -1;
+
+    string buf = "FsStreamWriteTest_0010";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0010";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0013
+ * @tc.desc: Test function of Write() interface for string no permission.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0013, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0013";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retWr = result->Write("FsStreamWriteTest_0013");
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0013";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0014
+ * @tc.desc: Test function of Write() interface for ArrayBuffer no permission.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0014, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0014";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    string buf = "FsStreamWriteTest_0014";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22));
+    EXPECT_FALSE(retWr.IsSuccess());
+    EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0014";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0015
+ * @tc.desc: Test function of Write() interface for string success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0015, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0015";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.offset = 0;
+    opt.encoding = "utf-8";
+    opt.length = 5;
+
+    auto retWr = result->Write("FsStreamWriteTest_0015", opt);
+    ASSERT_TRUE(retWr.IsSuccess());
+
+    size_t retLen = retWr.GetData().value();
+    EXPECT_EQ(retLen, 5);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0015";
+}
+
+/**
+ * @tc.name: FsStreamWriteTest_0016
+ * @tc.desc: Test function of Write() interface for ArrayBuffer success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamWriteTest_0016, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0016";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    WriteOptions opt;
+    opt.offset = 0;
+    opt.encoding = "utf-8";
+    opt.length = 5;
+
+    string buf = "FsStreamWriteTest_0016";
+    auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
+    ASSERT_TRUE(retWr.IsSuccess());
+
+    size_t retLen = retWr.GetData().value();
+    EXPECT_EQ(retLen, 5);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0016";
+}
+
+/**
+ * @tc.name: FsStreamReadTest_0001
+ * @tc.desc: Test function of Read() interface for single argument null fp.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamReadTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+    auto retRd = result->Read(arrayBuffer);
+    EXPECT_FALSE(retRd.IsSuccess());
+    EXPECT_EQ(retRd.GetError().GetErrNo(), 13900005);
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0001";
+}
+
+/**
+ * @tc.name: FsStreamReadTest_0002
+ * @tc.desc: Test function of Read() interface for error offset.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamReadTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    ReadOptions opt;
+    opt.offset = -1;
+
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+    auto retRd = result->Read(arrayBuffer, opt);
+    EXPECT_FALSE(retRd.IsSuccess());
+    EXPECT_EQ(retRd.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0002";
+}
+
+#if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) || defined(__LP64__)
+/**
+ * @tc.name: FsStreamReadTest_0003
+ * @tc.desc: Test function of Read() interface for bufLen > UINT_MAX.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamReadTest_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0003";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    size_t largeLength = static_cast<size_t>(UINT_MAX) + 1;
+
+    void *buffer = std::malloc(largeLength);
+    ArrayBuffer arrayBuffer(buffer, largeLength);
+    auto retRd = result->Read(arrayBuffer);
+    EXPECT_FALSE(retRd.IsSuccess());
+    EXPECT_EQ(retRd.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0003";
+}
+#endif
+
+/**
+ * @tc.name: FsStreamReadTest_0004
+ * @tc.desc: Test function of Read() interface for error length.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamReadTest_0004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0004";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    ReadOptions opt;
+    opt.length = -1;
+
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+    auto retRd = result->Read(arrayBuffer, opt);
+    EXPECT_FALSE(retRd.IsSuccess());
+    EXPECT_EQ(retRd.GetError().GetErrNo(), 13900020);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0004";
+}
+
+/**
+ * @tc.name: FsStreamReadTest_0005
+ * @tc.desc: Test function of Read() interface for no permission.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamReadTest_0005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0005";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+    auto retRd = result->Read(arrayBuffer);
+    EXPECT_FALSE(retRd.IsSuccess());
+    EXPECT_EQ(retRd.GetError().GetErrNo(), 13900005);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0005";
+}
+
+/**
+ * @tc.name: FsStreamReadTest_0006
+ * @tc.desc: Test function of Read() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStreamTest, FsStreamReadTest_0006, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0006";
+    auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    ReadOptions opt;
+    opt.offset = 0;
+    opt.length = 5;
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+
+    auto retRd = result->Read(arrayBuffer, opt);
+    ASSERT_TRUE(retRd.IsSuccess());
+
+    size_t retLen = retRd.GetData().value();
+    EXPECT_EQ(retLen, 0);
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0006";
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.cpp b/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa513e4fee61fc2fa2354385d08279b0e69def0e
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "c_mock.h"
+
+#include <dlfcn.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+
+thread_local std::shared_ptr<CMock> CMock::cMock = nullptr;
+thread_local bool CMock::mockable = false;
+
+std::shared_ptr<CMock> CMock::GetMock()
+{
+    if (cMock == nullptr) {
+        cMock = std::make_shared<CMock>();
+    }
+    return cMock;
+}
+
+void CMock::EnableMock()
+{
+    mockable = true;
+}
+
+void CMock::DisableMock()
+{
+    cMock = nullptr;
+    mockable = false;
+}
+
+bool CMock::IsMockable()
+{
+    return mockable;
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
+
+#ifdef __cplusplus
+extern "C" {
+using namespace OHOS::FileManagement::ModuleFileIO::Test;
+
+int fseek(FILE *stream, long len, int offset)
+{
+    if (CMock::IsMockable()) {
+        return CMock::GetMock()->fseek(stream, len, offset);
+    }
+
+    static int (*realFseek)(FILE *, long, int) = []() {
+        auto func = (int (*)(FILE *, long, int))dlsym(RTLD_NEXT, "fseek");
+        if (!func) {
+            GTEST_LOG_(ERROR) << "Failed to resolve real fseek: " << dlerror();
+        }
+        return func;
+    }();
+
+    if (!realFseek) {
+        return -1;
+    }
+
+    return realFseek(stream, len, offset);
+}
+
+long ftell(FILE *stream)
+{
+    if (CMock::IsMockable()) {
+        return CMock::GetMock()->ftell(stream);
+    }
+
+    static long (*realFtell)(FILE *) = []() {
+        auto func = (long (*)(FILE *))dlsym(RTLD_NEXT, "ftell");
+        if (!func) {
+            GTEST_LOG_(ERROR) << "Failed to resolve real ftell: " << dlerror();
+        }
+        return func;
+    }();
+
+    if (!realFtell) {
+        return -1;
+    }
+
+    return realFtell(stream);
+}
+} // extern "C"
+#endif
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.h b/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..9baf3240cc265ff73f474a16c5002778b333e4e8
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACES_TEST_UNITTEST_JS_MOD_FS_CLASS_STREAM_MOCK_C_MOCK_H
+#define INTERFACES_TEST_UNITTEST_JS_MOD_FS_CLASS_STREAM_MOCK_C_MOCK_H
+
+#include <cstdio>
+#include <gmock/gmock.h>
+#include <sys/stat.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+
+class ICMock {
+public:
+    virtual ~ICMock() = default;
+    virtual int fseek(FILE *, long, int) = 0;
+    virtual long ftell(FILE *) = 0;
+};
+
+class CMock : public ICMock {
+public:
+    MOCK_METHOD(int, fseek, (FILE *, long, int), (override));
+    MOCK_METHOD(long, ftell, (FILE *), (override));
+
+public:
+    static std::shared_ptr<CMock> GetMock();
+    static void EnableMock();
+    static void DisableMock();
+    static bool IsMockable();
+
+private:
+    static thread_local std::shared_ptr<CMock> cMock;
+    static thread_local bool mockable;
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
+#endif // INTERFACES_TEST_UNITTEST_JS_MOD_FS_CLASS_STREAM_MOCK_C_MOCK_H
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/trans_listener_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/trans_listener_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6b5ddcceea8f94624e2b80a34bb20ceba157b40d
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/trans_listener_mock_test.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "trans_listener_core.h"
+
+#include <fcntl.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "copy_core.h"
+#include "unistd_mock.h"
+
+using namespace OHOS;
+using namespace OHOS::Storage::DistributedFile;
+
+class MockDistributedFileDaemonManager final : public DistributedFileDaemonManager {
+public:
+    MOCK_METHOD(int32_t, PrepareSession,
+        (const std::string &srcUri, const std::string &dstUri, const std::string &srcDeviceId,
+            const sptr<IRemoteObject> &listener, HmdfsInfo &info),
+        (override));
+
+    int32_t OpenP2PConnection(const DistributedHardware::DmDeviceInfo &deviceInfo) override
+    {
+        return 0;
+    }
+    int32_t CloseP2PConnection(const DistributedHardware::DmDeviceInfo &deviceInfo) override
+    {
+        return 0;
+    }
+    int32_t OpenP2PConnectionEx(const std::string &networkId, sptr<IFileDfsListener> remoteReverseObj) override
+    {
+        return 0;
+    }
+    int32_t CloseP2PConnectionEx(const std::string &networkId) override
+    {
+        return 0;
+    }
+    int32_t CancelCopyTask(const std::string &sessionName) override
+    {
+        return 0;
+    }
+    int32_t PushAsset(
+        int32_t userId, const sptr<AssetObj> &assetObj, const sptr<IAssetSendCallback> &sendCallback) override
+    {
+        return 0;
+    }
+    int32_t RegisterAssetCallback(const sptr<IAssetRecvCallback> &recvCallback) override
+    {
+        return 0;
+    }
+    int32_t UnRegisterAssetCallback(const sptr<IAssetRecvCallback> &recvCallback) override
+    {
+        return 0;
+    }
+    int32_t GetSize(const std::string &uri, bool isSrcUri, uint64_t &size) override
+    {
+        return 0;
+    }
+    int32_t IsDirectory(const std::string &uri, bool isSrcUri, bool &isDirectory) override
+    {
+        return 0;
+    }
+    int32_t Copy(const std::string &srcUri, const std::string &destUri, ProcessCallback processCallback) override
+    {
+        return 0;
+    }
+    int32_t Cancel(const std::string &srcUri, const std::string &destUri) override
+    {
+        return 0;
+    }
+    int32_t Cancel() override
+    {
+        return 0;
+    }
+
+    MockDistributedFileDaemonManager() = default;
+    ~MockDistributedFileDaemonManager() = default;
+
+    static std::shared_ptr<MockDistributedFileDaemonManager> GetMock();
+    static void DisableMock();
+
+private:
+    static thread_local std::shared_ptr<MockDistributedFileDaemonManager> managerMock;
+};
+
+thread_local std::shared_ptr<MockDistributedFileDaemonManager> MockDistributedFileDaemonManager::managerMock = nullptr;
+
+std::shared_ptr<MockDistributedFileDaemonManager> MockDistributedFileDaemonManager::GetMock()
+{
+    if (managerMock == nullptr) {
+        managerMock = std::make_shared<MockDistributedFileDaemonManager>();
+    }
+    return managerMock;
+}
+
+void MockDistributedFileDaemonManager::DisableMock()
+{
+    managerMock = nullptr;
+}
+
+class MockTaskSignalListener : public OHOS::DistributedFS::ModuleTaskSignal::TaskSignalListener {
+public:
+    MOCK_METHOD(void, OnCancel, (), (override));
+};
+
+#ifdef ENABLE_DISTRIBUTED_FILE_MOCK
+DistributedFileDaemonManager &DistributedFileDaemonManager::GetInstance()
+{
+    return *MockDistributedFileDaemonManager::GetMock();
+}
+#endif
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+string g_path = "/data/test/TransListenerCoreMockTest.txt";
+const string FILE_MANAGER_AUTHORITY = "docs";
+const string MEDIA_AUTHORITY = "media";
+
+class IProgressListenerTest : public IProgressListener {
+public:
+    void InvokeListener(uint64_t progressSize, uint64_t totalSize) const override {}
+};
+
+class TransListenerCoreMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void TransListenerCoreMockTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    int32_t fd = open(g_path.c_str(), O_CREAT | O_RDWR, 0644);
+    if (fd < 0) {
+        EXPECT_TRUE(false);
+    }
+    close(fd);
+    UnistdMock::EnableMock();
+}
+
+void TransListenerCoreMockTest::TearDownTestCase(void)
+{
+    rmdir(g_path.c_str());
+    MockDistributedFileDaemonManager::DisableMock();
+    UnistdMock::DisableMock();
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void TransListenerCoreMockTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void TransListenerCoreMockTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: TransListenerCoreMockTest_PrepareCopySession_001
+ * @tc.desc: Test function of TransListenerCore::PrepareCopySession interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreMockTest, TransListenerCoreMockTest_PrepareCopySession_001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreMockTest-begin TransListenerCoreMockTest_PrepareCopySession_001";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = FILE_MANAGER_AUTHORITY;
+    info.authority = MEDIA_AUTHORITY;
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    string disSandboxPath = "disSandboxPath";
+    auto unistdMock = UnistdMock::GetMock();
+    auto managerMock = MockDistributedFileDaemonManager::GetMock();
+
+    EXPECT_CALL(*unistdMock, read(testing::_, testing::_, testing::_)).WillRepeatedly(testing::Return(1));
+    EXPECT_CALL(*managerMock, PrepareSession(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(ERRNO_NOERR));
+    auto result = TransListenerCore::PrepareCopySession(srcUri, "destUri", nullptr, info, disSandboxPath);
+    EXPECT_EQ(result, ERRNO_NOERR);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreMockTest-end TransListenerCoreMockTest_PrepareCopySession_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreMockTest_CopyFileFromSoftBus_001
+ * @tc.desc: Test function of TransListenerCore::CopyFileFromSoftBus interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreMockTest, TransListenerCoreMockTest_CopyFileFromSoftBus_001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreMockTest-begin TransListenerCoreMockTest_CopyFileFromSoftBus_001";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = FILE_MANAGER_AUTHORITY;
+
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+    std::shared_ptr<TransListenerCore> transListener = std::make_shared<TransListenerCore>();
+    std::shared_ptr<FsFileInfos> infos = std::make_shared<FsFileInfos>();
+    auto unistdMock = UnistdMock::GetMock();
+    auto managerMock = MockDistributedFileDaemonManager::GetMock();
+
+    EXPECT_CALL(*unistdMock, read(testing::_, testing::_, testing::_)).WillRepeatedly(testing::Return(1));
+    EXPECT_CALL(*managerMock, PrepareSession(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(ERRNO_NOERR));
+
+    auto res = transListener->CopyFileFromSoftBus(srcUri, "destUri", infos, nullptr);
+    EXPECT_EQ(res, EIO);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreMockTest-end TransListenerCoreMockTest_CopyFileFromSoftBus_001";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
diff --git a/interfaces/test/unittest/js/mod_fs/properties/trans_listener_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/trans_listener_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3bfc837d4d30485a158fc6d38b7705bde8b5bc08
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/trans_listener_test.cpp
@@ -0,0 +1,580 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "trans_listener_core.h"
+
+#include <fcntl.h>
+#include <gtest/gtest.h>
+
+#include "copy_core.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+string g_path = "/data/test/TransListenerCoreTest.txt";
+const string FILE_MANAGER_AUTHORITY = "docs";
+const string MEDIA_AUTHORITY = "media";
+
+class IProgressListenerTest : public IProgressListener {
+public:
+    void InvokeListener(uint64_t progressSize, uint64_t totalSize) const override {}
+};
+
+class TransListenerCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void TransListenerCoreTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    int32_t fd = open(g_path.c_str(), O_CREAT | O_RDWR, 0644);
+    if (fd < 0) {
+        EXPECT_TRUE(false);
+    }
+    close(fd);
+}
+
+void TransListenerCoreTest::TearDownTestCase(void)
+{
+    rmdir(g_path.c_str());
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void TransListenerCoreTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void TransListenerCoreTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CreateDfsCopyPath_001
+ * @tc.desc: Test function of TransListenerCore::CreateDfsCopyPath interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CreateDfsCopyPath_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CreateDfsCopyPath_001";
+
+    string result = TransListenerCore::CreateDfsCopyPath();
+    EXPECT_FALSE(result.empty());
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CreateDfsCopyPath_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_HandleCopyFailure_001
+ * @tc.desc: Test function of TransListenerCore::HandleCopyFailure interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_HandleCopyFailure_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_HandleCopyFailure_001";
+
+    string path = "/data/test/TransListenerCoreTest_HandleCopyFailure_001.txt";
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = "abc";
+    CopyEvent event;
+    event.errorCode = 0;
+    int result = TransListenerCore::HandleCopyFailure(event, info, path, "");
+    EXPECT_EQ(result, EIO);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_HandleCopyFailure_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_HandleCopyFailure_002
+ * @tc.desc: Test function of TransListenerCore::HandleCopyFailure interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_HandleCopyFailure_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_HandleCopyFailure_002";
+
+    string path = "/data/test/TransListenerCoreTest_HandleCopyFailure_002.txt";
+    int32_t fd = open(path.c_str(), O_CREAT | O_RDWR, 0644);
+    if (fd < 0) {
+        EXPECT_TRUE(false);
+    }
+    close(fd);
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = "abc";
+    CopyEvent event;
+    event.errorCode = SOFTBUS_TRANS_FILE_EXISTED;
+    int result = TransListenerCore::HandleCopyFailure(event, info, path, "");
+    EXPECT_EQ(result, EEXIST);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_HandleCopyFailure_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_HandleCopyFailure_003
+ * @tc.desc: Test function of TransListenerCore::HandleCopyFailure interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_HandleCopyFailure_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_HandleCopyFailure_003";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = MEDIA_AUTHORITY;
+    CopyEvent event;
+    event.errorCode = DFS_CANCEL_SUCCESS;
+    int result = TransListenerCore::HandleCopyFailure(event, info, "", "");
+    EXPECT_EQ(result, ECANCELED);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_HandleCopyFailure_003";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_WaitForCopyResult_001
+ * @tc.desc: Test function of TransListenerCore::WaitForCopyResult interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_WaitForCopyResult_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_WaitForCopyResult_001";
+
+    shared_ptr<TransListenerCore> transListener = make_shared<TransListenerCore>();
+    transListener->copyEvent_.copyResult = FAILED;
+    int result = TransListenerCore::WaitForCopyResult(transListener.get());
+    EXPECT_EQ(result, 2);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_WaitForCopyResult_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_WaitForCopyResult_002
+ * @tc.desc: Test function of TransListenerCore::WaitForCopyResult interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_WaitForCopyResult_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_WaitForCopyResult_002";
+
+    int result = TransListenerCore::WaitForCopyResult(nullptr);
+    EXPECT_TRUE(result);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_WaitForCopyResult_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_PrepareCopySession_001
+ * @tc.desc: Test function of TransListenerCore::PrepareCopySession interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_PrepareCopySession_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_PrepareCopySession_001";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = MEDIA_AUTHORITY;
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    string disSandboxPath = "disSandboxPath";
+
+    int result = TransListenerCore::PrepareCopySession(srcUri, "destUri", nullptr, info, disSandboxPath);
+    EXPECT_EQ(result, EIO);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_PrepareCopySession_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_PrepareCopySession_002
+ * @tc.desc: Test function of TransListenerCore::PrepareCopySession interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_PrepareCopySession_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_PrepareCopySession_002";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = "abc";
+
+    string disSandboxPath = "disSandboxPath";
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    int result = TransListenerCore::PrepareCopySession(srcUri, "destUri", nullptr, info, disSandboxPath);
+    EXPECT_EQ(result, ENOENT);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_PrepareCopySession_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_PrepareCopySession_003
+ * @tc.desc: Test function of TransListenerCore::PrepareCopySession interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_PrepareCopySession_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_PrepareCopySession_003";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = "abc";
+    info.sandboxPath = "abc";
+
+    string disSandboxPath = "disSandboxPath";
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    int result = TransListenerCore::PrepareCopySession(srcUri, "destUri", nullptr, info, disSandboxPath);
+    EXPECT_EQ(result, ENOENT);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_PrepareCopySession_003";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_PrepareCopySession_004
+ * @tc.desc: Test function of TransListenerCore::PrepareCopySession interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_PrepareCopySession_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_PrepareCopySession_004";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = "abc";
+    info.sandboxPath = "/data/test/PrepareCopySession_004.txt";
+
+    string disSandboxPath = "disSandboxPath";
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    int result = TransListenerCore::PrepareCopySession(srcUri, "destUri", nullptr, info, disSandboxPath);
+    EXPECT_EQ(result, ENOENT);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_PrepareCopySession_004";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_PrepareCopySession_005
+ * @tc.desc: Test function of TransListenerCore::PrepareCopySession interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_PrepareCopySession_005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_PrepareCopySession_005";
+
+    Storage::DistributedFile::HmdfsInfo info;
+    info.authority = "abc";
+    info.sandboxPath = "/data/test/PrepareCopySession_004.txt";
+    int32_t fd = open(info.sandboxPath.c_str(), O_CREAT | O_RDWR, 0644);
+    if (fd < 0) {
+        EXPECT_TRUE(false);
+    }
+    close(fd);
+
+    string disSandboxPath = "disSandboxPath";
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    int result = TransListenerCore::PrepareCopySession(srcUri, "destUri", nullptr, info, disSandboxPath);
+    EXPECT_EQ(result, ENOENT);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_PrepareCopySession_005";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CopyToSandBox_001
+ * @tc.desc: Test function of TransListenerCore::CopyToSandBox interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CopyToSandBox_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CopyToSandBox_001";
+
+    string disSandboxPath = "disSandboxPath";
+    string sandboxPath = "sandboxPath";
+    string currentId = "currentId";
+
+    int result = TransListenerCore::CopyToSandBox("srcUri", disSandboxPath, sandboxPath, currentId);
+    EXPECT_EQ(result, EIO);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CopyToSandBox_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CopyToSandBox_002
+ * @tc.desc: Test function of TransListenerCore::CopyToSandBox interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CopyToSandBox_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CopyToSandBox_002";
+
+    string disSandboxPath = g_path;
+    string sandboxPath = "/data/test";
+    string currentId = "currentId";
+
+    int result = TransListenerCore::CopyToSandBox("srcUri", disSandboxPath, sandboxPath, currentId);
+    EXPECT_EQ(result, EIO);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CopyToSandBox_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_GetFileName_001
+ * @tc.desc: Test function of TransListenerCore::GetFileName interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_GetFileName_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_GetFileName_001";
+
+    string path = "abc";
+
+    auto result = TransListenerCore::GetFileName(path);
+    EXPECT_EQ(result, "");
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_GetFileName_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_GetFileName_002
+ * @tc.desc: Test function of TransListenerCore::GetFileName interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_GetFileName_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_GetFileName_002";
+
+    auto result = TransListenerCore::GetFileName(g_path);
+    EXPECT_EQ(result, "/TransListenerCoreTest.txt");
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_GetFileName_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_GetNetworkIdFromUri_001
+ * @tc.desc: Test function of TransListenerCore::GetNetworkIdFromUri interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_GetNetworkIdFromUri_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_GetNetworkIdFromUri_001";
+
+    string uri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+
+    auto result = TransListenerCore::GetNetworkIdFromUri(uri);
+    EXPECT_EQ(result, "AD125AD1CF");
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_GetNetworkIdFromUri_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CallbackComplete_001
+ * @tc.desc: Test function of TransListenerCore::CallbackComplete interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CallbackComplete_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CallbackComplete_001";
+
+    TransListenerCore::CallbackComplete(nullptr);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CallbackComplete_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CallbackComplete_002
+ * @tc.desc: Test function of TransListenerCore::CallbackComplete interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CallbackComplete_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CallbackComplete_002";
+
+    auto entry = make_shared<FsUvEntry>(make_shared<FsCallbackObject>(make_shared<IProgressListenerTest>()));
+    entry->callback = nullptr;
+    TransListenerCore::CallbackComplete(entry);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CallbackComplete_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CallbackComplete_003
+ * @tc.desc: Test function of TransListenerCore::CallbackComplete interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CallbackComplete_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CallbackComplete_003";
+
+    auto entry = make_shared<FsUvEntry>(make_shared<FsCallbackObject>(make_shared<IProgressListenerTest>()));
+    entry->callback->listener = nullptr;
+    TransListenerCore::CallbackComplete(entry);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CallbackComplete_003";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CallbackComplete_004
+ * @tc.desc: Test function of TransListenerCore::CallbackComplete interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CallbackComplete_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CallbackComplete_004";
+
+    auto entry = make_shared<FsUvEntry>(make_shared<FsCallbackObject>(make_shared<IProgressListenerTest>()));
+    TransListenerCore::CallbackComplete(entry);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CallbackComplete_004";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_OnFileReceive_001
+ * @tc.desc: Test function of TransListenerCore::OnFileReceive interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_OnFileReceive_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_OnFileReceive_001";
+
+    shared_ptr<TransListenerCore> transListener = make_shared<TransListenerCore>();
+    transListener->callback_ = nullptr;
+    auto res = transListener->OnFileReceive(0, 0);
+    EXPECT_EQ(res, ENOMEM);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_OnFileReceive_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_OnFileReceive_002
+ * @tc.desc: Test function of TransListenerCore::OnFileReceive interface for SUCC.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_OnFileReceive_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_OnFileReceive_002";
+
+    shared_ptr<TransListenerCore> transListener = make_shared<TransListenerCore>();
+    transListener->callback_ = make_shared<FsCallbackObject>(make_shared<IProgressListenerTest>());
+    auto res = transListener->OnFileReceive(0, 0);
+    EXPECT_EQ(res, ERRNO_NOERR);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_OnFileReceive_002";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_OnFinished_001
+ * @tc.desc: Test function of TransListenerCore::OnFinished interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_OnFinished_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_OnFinished_001";
+
+    shared_ptr<TransListenerCore> transListener = make_shared<TransListenerCore>();
+    auto res = transListener->OnFinished("sessionName");
+    EXPECT_EQ(res, ERRNO_NOERR);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_OnFinished_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_OnFailed_001
+ * @tc.desc: Test function of TransListenerCore::OnFailed interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_OnFailed_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_OnFailed_001";
+
+    shared_ptr<TransListenerCore> transListener = make_shared<TransListenerCore>();
+    auto res = transListener->OnFailed("sessionName", 0);
+    EXPECT_EQ(res, ERRNO_NOERR);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_OnFailed_001";
+}
+
+/**
+ * @tc.name: TransListenerCoreTest_CopyFileFromSoftBus_001
+ * @tc.desc: Test function of TransListenerCore::CopyFileFromSoftBus interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(TransListenerCoreTest, TransListenerCoreTest_CopyFileFromSoftBus_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-begin TransListenerCoreTest_CopyFileFromSoftBus_001";
+
+    string srcUri = "http://translistener.preparecopysession?networkid=AD125AD1CF";
+    shared_ptr<TransListenerCore> transListener = make_shared<TransListenerCore>();
+    shared_ptr<FsFileInfos> infos = make_shared<FsFileInfos>();
+    transListener->copyEvent_.copyResult = FAILED;
+
+    auto res = transListener->CopyFileFromSoftBus(srcUri, "destUri", infos, nullptr);
+    EXPECT_EQ(res, EIO);
+
+    GTEST_LOG_(INFO) << "TransListenerCoreTest-end TransListenerCoreTest_CopyFileFromSoftBus_001";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/unlink_core_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/unlink_core_mock_test.cpp
index fcd294b5f4beadc8f37eeafb3e1e4120b5a8a737..160a4b63b2b8b42781f878ac7d0190d800b6c4c0 100644
--- a/interfaces/test/unittest/js/mod_fs/properties/unlink_core_mock_test.cpp
+++ b/interfaces/test/unittest/js/mod_fs/properties/unlink_core_mock_test.cpp
@@ -15,11 +15,12 @@
 
 #include <filesystem>
 #include <fstream>
-#include <gtest/gtest.h>
+
 #include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
-#include "mock/uv_fs_mock.h"
 #include "unlink_core.h"
+#include "uv_fs_mock.h"
 
 namespace OHOS::FileManagement::ModuleFileIO::Test {
 using namespace testing;