diff --git a/interfaces/test/unittest/BUILD.gn b/interfaces/test/unittest/BUILD.gn
index 3a6c6eb263f86b72ed9418d085f89ade25f70f08..1c1ca95da3386de462fb78cd5bcf6e9c765b9c73 100644
--- a/interfaces/test/unittest/BUILD.gn
+++ b/interfaces/test/unittest/BUILD.gn
@@ -17,7 +17,10 @@ group("file_api_unittest") {
     "class_file:class_file_test",
     "filemgmt_libn_test:filemgmt_libn_test",
     "js:ani_file_fs_test",
+    "js:ani_file_fs_mock_test",
     "remote_uri:remote_uri_test",
     "task_signal:task_signal_test",
+    "js:ani_file_hash_test",
+    "js:ani_file_securitylabel_test",
   ]
 }
diff --git a/interfaces/test/unittest/js/BUILD.gn b/interfaces/test/unittest/js/BUILD.gn
index a22cb0a2b7c27d01c14e9d238930fb1c01014702..2ca2e73dd0e261970fbeb5ef5b6d36bda240e7b6 100644
--- a/interfaces/test/unittest/js/BUILD.gn
+++ b/interfaces/test/unittest/js/BUILD.gn
@@ -64,4 +64,114 @@ ohos_unittest("ani_file_fs_test") {
   defines = [
     "private=public",
   ]
+
+  cflags_cc = [ "-DENABLE_NAPI_MOCK" ]
+}
+
+ohos_unittest("ani_file_fs_mock_test") {
+  branch_protector_ret = "pac_ret"
+  testonly = true
+
+  module_out_path = "file_api/file_api"
+
+  resource_config_file = "../resource/ohos_test.xml"
+
+  include_dirs = [
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/class_atomicfile",
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/class_file",
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/class_randomaccessfile",
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/class_readeriterator",
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/class_stat",
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/class_stream",
+    "${file_api_path}/interfaces/kits/js/src/mod_fs/properties",
+    "${file_api_path}/interfaces/test/unittest/js/mod_fs/class_stream/mock",
+    "${file_api_path}/interfaces/test/unittest/js/mod_fs/properties/mock",
+  ]
+
+  sources = [
+    "mod_fs/class_stream/fs_stream_mock_test.cpp",
+    "mod_fs/class_stream/mock/c_mock.cpp",
+  ]
+
+  deps = [
+    "${file_api_path}/interfaces/kits/native:remote_uri_native",
+    "${file_api_path}/interfaces/kits/native:task_signal_native",
+    "${file_api_path}/interfaces/kits/rust:rust_file",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+    "${file_api_path}/interfaces/kits/js:ani_file_fs",
+  ]
+
+  external_deps = [
+    "ability_runtime:ability_manager",
+    "app_file_service:fileuri_native",
+    "c_utils:utils",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+    "libuv:uv",
+  ]
+
+  defines = [
+    "private=public",
+  ]
+}
+
+ohos_unittest("ani_file_hash_test") {
+  module_out_path = "file_api/file_api"
+
+  resource_config_file = "../resource/ohos_test.xml"
+
+  sources = [ 
+    "mod_hash/hash_core_test.cpp",
+  ]
+
+  include_dirs = [
+    "mock/libuv",
+    "${file_api_path}/interfaces/kits/js/src/mod_hash",
+  ]
+
+  deps = [
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${file_api_path}/interfaces/kits/js:ani_file_hash",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "libuv:uv",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+  ]
+}
+
+ohos_unittest("ani_file_securitylabel_test") {
+  module_out_path = "file_api/file_api"
+
+  resource_config_file = "../resource/ohos_test.xml"
+
+  sources = [ 
+    "mod_securitylabel/securitylabel_core_test.cpp",
+  ]
+
+  include_dirs = [
+    "mock/libuv",
+    "${file_api_path}/interfaces/kits/js/src/mod_securitylabel",
+  ]
+
+  deps = [
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${file_api_path}/interfaces/kits/js:ani_file_securitylabel",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "libuv:uv",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+  ]
 }
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp b/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f506c732f2a9a1959c92d90f6ec371fc1c1da48b
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp
@@ -0,0 +1,366 @@
+/*
+ * 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 <filesystem>
+#include <fstream>
+
+#include <gtest/gtest.h>
+#include "fs_atomicfile.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace std;
+namespace fs = std::filesystem;
+
+string g_filePath = "/data/test/FsAtomicfileTest.txt";
+string g_deleteFile = "/data/test/FsAtomicfileDelTest.txt";
+
+class FsAtomicfileTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void FsAtomicfileTest::SetUpTestCase(void)
+{
+    ofstream tempfile(g_filePath);
+    tempfile << "hello world";
+    tempfile.close();
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void FsAtomicfileTest::TearDownTestCase(void)
+{
+    filesystem::remove(g_filePath);
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void FsAtomicfileTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FsAtomicfileTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetPath_001
+ * @tc.desc: Test function of FsAtomicFile::GetPath interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetPath_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetPath_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    string path = stream->GetPath();
+    EXPECT_EQ(path, g_filePath);
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetPath_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_001
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_TRUE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_002
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for path > PATH_MAX.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_002";
+
+    size_t largeLength = static_cast<size_t>(PATH_MAX) + 1;
+    string largeString(largeLength, 'a');
+
+    auto ret = FsAtomicFile::Constructor(largeString);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_002";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_003
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for failed realpath.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_003";
+
+    string path = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_003";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_004
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for failed open.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_004";
+
+    string path = "/data/test/aaaaaaaaaa.txt";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_004";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_StartWrite_001
+ * @tc.desc: Test function of FsAtomicFile::StartWrite interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    EXPECT_TRUE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_StartWrite_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_StartWrite_002
+ * @tc.desc: Test function of FsAtomicFile::StartWrite interface for no parent dir.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_002";
+
+    string path = "/data/local/tmp/test/test/test/test.txt";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_StartWrite_002";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_StartWrite_003
+ * @tc.desc: Test function of FsAtomicFile::StartWrite interface for no permission.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_003";
+
+    string path = "/sys/kernel/address_bits";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_StartWrite_003";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_FinishWrite_001
+ * @tc.desc: Test function of FsAtomicFile::FinishWrite interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_FinishWrite_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_FinishWrite_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    ASSERT_TRUE(retFl.IsSuccess());
+    string newPath = retFl.GetData().value();
+    ofstream tempfile(newPath);
+    tempfile << "hello world";
+    tempfile.close();
+
+    auto retFW = stream->FinishWrite();
+    EXPECT_TRUE(retFW.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_FinishWrite_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_FailWrite_001
+ * @tc.desc: Test function of FsAtomicFile::FailWrite interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_FailWrite_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_FailWrite_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    ASSERT_TRUE(retFl.IsSuccess());
+    string newPath = retFl.GetData().value();
+    ofstream tempfile(newPath);
+    tempfile << "hello world";
+    tempfile.close();
+
+    auto retFW = stream->FailWrite();
+    EXPECT_TRUE(retFW.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_FailWrite_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_Delete_001
+ * @tc.desc: Test function of FsAtomicFile::Delete interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_Delete_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_Delete_001";
+
+    auto ret = FsAtomicFile::Constructor(g_deleteFile);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    ASSERT_TRUE(retFl.IsSuccess());
+    string newPath = retFl.GetData().value();
+    ofstream tempfile(newPath);
+    tempfile << "hello world";
+    tempfile.close();
+
+    auto retFW = stream->Delete();
+    EXPECT_TRUE(retFW.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_Delete_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_ReadFully_001
+ * @tc.desc: Test function of FsAtomicFile::ReadFully interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_ReadFully_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_ReadFully_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto result = stream->ReadFully();
+    ASSERT_TRUE(result.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_ReadFully_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_ReadFully_002
+ * @tc.desc: Test function of FsAtomicFile::ReadFully interface for valied path.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_ReadFully_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_ReadFully_002";
+
+    auto ret = FsAtomicFile::Constructor("aaaaaaaaaaaaaaaa");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto result = stream->ReadFully();
+    ASSERT_FALSE(result.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_ReadFully_002";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file
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..f133390065b21eb4b2d5646b28e77198bea1a9fa
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/fs_stream_mock_test.cpp
@@ -0,0 +1,191 @@
+/*
+ * 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"
+
+#define STREAM_FILE_PATH "/data/test/FsStreamCoreTest.txt"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+class FsStreamMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        mock_ = std::make_shared<CMock>();
+        ICMock::ins = mock_;
+        int32_t fd = open(STREAM_FILE_PATH, CREATE | O_RDWR, 0644);
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        ICMock::ins = nullptr;
+        mock_ = nullptr;
+        rmdir(STREAM_FILE_PATH);
+    };
+    void SetUp() {};
+    void TearDown() {};
+
+    static inline std::shared_ptr<CMock> mock_ = nullptr;
+};
+
+/**
+ * @tc.name: FsStreamSeekTest_0001
+ * @tc.desc: Test function of Seek() interface for fail fseek.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(FsStreamMockTest, FsStreamSeekTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin FsStreamSeekTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(STREAM_FILE_PATH, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    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) << "FdopenStreamCoreTest-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
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(FsStreamMockTest, FsStreamSeekTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin FsStreamSeekTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(STREAM_FILE_PATH, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    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) << "FdopenStreamCoreTest-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
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(FsStreamMockTest, FsStreamWriteTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin FsStreamWriteTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(STREAM_FILE_PATH, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    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) << "FdopenStreamCoreTest-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
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(FsStreamMockTest, FsStreamWriteTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin FsStreamWriteTest_0002";
+    auto ret = CreateStreamCore::DoCreateStream(STREAM_FILE_PATH, "w+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    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()), 22), opt);
+    EXPECT_FALSE(retWr.IsSuccess());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-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
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(FsStreamMockTest, FsStreamReadTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin FsStreamReadTest_0001";
+    auto ret = CreateStreamCore::DoCreateStream(STREAM_FILE_PATH, "r+");
+    ASSERT_TRUE(ret.IsSuccess());
+    auto result = ret.GetData().value();
+
+    void *buffer = std::malloc(4096);
+    ArrayBuffer arrayBuffer(buffer, 4096);
+
+    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());
+
+    auto retCs = result->Close();
+    ASSERT_TRUE(retCs.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-end FsStreamReadTest_0001";
+}
+
+} // 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..f9567b0d5eba004b7c7856a3296f0fef100795c3
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.cpp
@@ -0,0 +1,31 @@
+/*
+* 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"
+
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+extern "C" {
+
+int fseek(FILE *stream, long len, int offset)
+{
+    return ICMock::ins->fseek(stream, len, offset);
+}
+
+long ftell(FILE *stream)
+{
+    return ICMock::ins->ftell(stream);
+}
+}
\ 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..8f2bbe88eb071174fa229693ab76b25b75ec45fa
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stream/mock/c_mock.h
@@ -0,0 +1,42 @@
+/*
+* 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 <sys/stat.h>
+#include <gmock/gmock.h>
+
+namespace OHOS::FileManagement::ModuleFileIO {
+
+class ICMock {
+public:
+    static inline std::shared_ptr<ICMock> ins = nullptr;
+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));
+};
+
+
+} // OHOS::FileManagement::ModuleFileIO
+#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_hash/hash_core_test.cpp b/interfaces/test/unittest/js/mod_hash/hash_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c13b0e6e18476ca9ff587d9a8791c4886adb492
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_hash/hash_core_test.cpp
@@ -0,0 +1,136 @@
+/*
+ * 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 <fcntl.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include "hash_core.h"
+
+#define FILE_PATH "/data/test/HashCoreTest.txt"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+class HashCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        int32_t fd = open(FILE_PATH, O_CREAT | O_RDWR, 0644);
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        rmdir(FILE_PATH);
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: DoHashTest_0001
+ * @tc.desc: Test function of DoHash() interface for invalid alg.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0001";
+    string alg = "sha128";
+    auto ret = HashCore::DoHash(FILE_PATH, alg);
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0001";
+}
+
+/**
+ * @tc.name: DoHashTest_0002
+ * @tc.desc: Test function of DoHash() interface for md5 success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0002";
+    auto ret = HashCore::DoHash(FILE_PATH, "md5");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0002";
+}
+
+/**
+ * @tc.name: DoHashTest_0003
+ * @tc.desc: Test function of DoHash() interface for sha1 success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0003";
+    auto ret = HashCore::DoHash(FILE_PATH, "sha1");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0003";
+}
+
+/**
+ * @tc.name: DoHashTest_0004
+ * @tc.desc: Test function of DoHash() interface for sha256 success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0004";
+    auto ret = HashCore::DoHash(FILE_PATH, "sha256");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0004";
+}
+
+/**
+ * @tc.name: DoHashTest_0005
+ * @tc.desc: Test function of DoHash() interface for no such file or directory.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0005";
+    auto ret = HashCore::DoHash("/data/local/tmp/azuxyicayhyskjeh", "sha256");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0005";
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_securitylabel/securitylabel_core_test.cpp b/interfaces/test/unittest/js/mod_securitylabel/securitylabel_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae28da15795163e5346fbf33225c2233988f90e3
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_securitylabel/securitylabel_core_test.cpp
@@ -0,0 +1,142 @@
+/*
+ * 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 <fcntl.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include "securitylabel_core.h"
+
+#define FILE_PATH "/data/test/SecurityLabelCoreTest.txt"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleSecurityLabel {
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+class SecurityLabelCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        int32_t fd = open(FILE_PATH, O_CREAT | O_RDWR, 0644);
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        rmdir(FILE_PATH);
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: DoSetSecurityLabel_0001
+ * @tc.desc: Test function of DoSetSecurityLabel() interface for invalid level.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoSetSecurityLabel_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoSetSecurityLabel_0001";
+    auto ret = DoSetSecurityLabel(FILE_PATH, "abc");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoSetSecurityLabel_0001";
+}
+
+/**
+ * @tc.name: DoSetSecurityLabel_0002
+ * @tc.desc: Test function of DoSetSecurityLabel() interface for invalid path.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoSetSecurityLabel_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoSetDoSetSecurityLabel_0002SecurityLabel_0001";
+    auto ret = DoSetSecurityLabel("FILE_PATH", "s1");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoSetSecurityLabel_0002";
+}
+
+/**
+ * @tc.name: DoSetSecurityLabel_0003
+ * @tc.desc: Test function of DoSetSecurityLabel() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoSetSecurityLabel_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoSetSecurityLabel_0003";
+    auto ret = DoSetSecurityLabel(FILE_PATH, "s2");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoSetSecurityLabel_0003";
+}
+
+/**
+ * @tc.name: DoGetSecurityLabel_0001
+ * @tc.desc: Test function of DoGetSecurityLabel() interface for invalid path.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoGetSecurityLabel_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoGetSecurityLabel_0001";
+    auto ret = DoGetSecurityLabel("FILE_PATH");
+    EXPECT_TRUE(ret.IsSuccess());
+
+    const string level = ret.GetData().value();
+    EXPECT_EQ(level, "s3");
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoGetSecurityLabel_0001";
+}
+
+/**
+ * @tc.name: DoGetSecurityLabel_0002
+ * @tc.desc: Test function of DoGetSecurityLabel() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoGetSecurityLabel_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoGetSecurityLabel_0002";
+    auto ret = DoGetSecurityLabel(FILE_PATH);
+    EXPECT_TRUE(ret.IsSuccess());
+
+    const string level = ret.GetData().value();
+    EXPECT_EQ(level, "s2");
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoGetSecurityLabel_0002";
+}
+
+} // namespace ModuleSecurityLabel
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file