diff --git a/interfaces/test/unittest/BUILD.gn b/interfaces/test/unittest/BUILD.gn
index 3a6c6eb263f86b72ed9418d085f89ade25f70f08..e7ec1360f7e326649d2234f30b6e268a8ffd0769 100644
--- a/interfaces/test/unittest/BUILD.gn
+++ b/interfaces/test/unittest/BUILD.gn
@@ -17,6 +17,7 @@ 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",
   ]
diff --git a/interfaces/test/unittest/js/BUILD.gn b/interfaces/test/unittest/js/BUILD.gn
index a22cb0a2b7c27d01c14e9d238930fb1c01014702..779f4a8692afa2eddbda15ab46a55a28228eeee6 100644
--- a/interfaces/test/unittest/js/BUILD.gn
+++ b/interfaces/test/unittest/js/BUILD.gn
@@ -34,6 +34,7 @@ ohos_unittest("ani_file_fs_test") {
   ]
 
   sources = [
+    "mod_fs/class_file/fs_file_test.cpp",
     "mod_fs/properties/close_core_test.cpp",
     "mod_fs/properties/create_stream_core_test.cpp",
     "mod_fs/properties/fdopen_stream_core_test.cpp",
@@ -61,6 +62,57 @@ ohos_unittest("ani_file_fs_test") {
     "libuv:uv",
   ]
 
+  defines = [
+    "private=public",
+  ]
+}
+
+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/properties/mock",
+  ]
+
+  sources = [
+    "mod_fs/class_file/fs_file_mock_test.cpp",
+    "mod_fs/properties/mock/system_mock.cpp",
+    "mod_fs/properties/mock/uv_fs_mock.cpp",
+    "mod_fs/properties/open_core_mock_test.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",
   ]
diff --git a/interfaces/test/unittest/js/mod_fs/class_file/fs_file_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/class_file/fs_file_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90cc1f29fd106e2b2727a9d0ab28e7bc0534308e
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_file/fs_file_mock_test.cpp
@@ -0,0 +1,386 @@
+/*
+ * 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 "file_entity.h"
+#include "fs_file.h"
+#include "system_mock.h"
+#include "uv_fs_mock.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class FsFileMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static inline shared_ptr<UvfsMock> uvMock = nullptr;
+    static inline shared_ptr<SystemMock> sys = nullptr;
+    std::unique_ptr<FileEntity> fileEntity;
+    std::unique_ptr<FsFile> fsFile;
+};
+
+void FsFileMockTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    uvMock = std::make_shared<UvfsMock>();
+    Uvfs::ins = uvMock;
+    sys = std::make_shared<SystemMock>();
+    System::ins = sys;
+}
+
+void FsFileMockTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+    Uvfs::ins = nullptr;
+    uvMock = nullptr;
+    System::ins = nullptr;
+    sys = nullptr;
+}
+
+void FsFileMockTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+    
+    fileEntity = std::make_unique<FileEntity>();
+    const int fdValue = 3;
+    const bool isClosed = false;
+    fileEntity->fd_ = std::make_unique<DistributedFS::FDGuard>(fdValue, isClosed);
+    fileEntity->path_ = "/data/test/file_test.txt";
+    fileEntity->uri_ = "";
+    fsFile = std::make_unique<FsFile>(std::move(fileEntity));
+}
+
+void FsFileMockTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetPath_001
+ * @tc.desc: Test function of GetPath() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetPath_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetPath_001";
+
+    uv_fs_t mock_req;
+    mock_req.ptr = const_cast<char*>("/data/test/file_test.txt");
+
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _))
+        .WillOnce(Invoke([&](uv_loop_t*, uv_fs_t* req, const char*, uv_fs_cb) {
+            *req = mock_req;
+            return 0;
+        }));
+    auto result = fsFile->GetPath();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetPath_001";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetPath_002
+ * @tc.desc: Test function of GetPath() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetPath_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetPath_002";
+
+    fsFile->fileEntity->path_ = "/invalid/path";
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _)).WillOnce(Return(-1));
+    auto result = fsFile->GetPath();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetPath_002";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetName_003
+ * @tc.desc: Test function of GetName() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetName_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetName_003";
+
+    fsFile->fileEntity->path_ = "/invalid/path";
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _)).WillOnce(Return(-1));
+    auto result = fsFile->GetName();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetName_003";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetName_004
+ * @tc.desc: Test function of GetName() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetName_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetName_004";
+
+    fsFile->fileEntity->path_ = "file_test.txt";
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _)).WillOnce(Return(-1));
+    auto result = fsFile->GetName();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetName_004";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetParent_005
+ * @tc.desc: Test function of GetParent() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetParent_005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetParent_005";
+
+    fsFile->fileEntity->path_ = "/invalid/path";
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _)).WillOnce(Return(-1));
+    auto result = fsFile->GetParent();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetParent_005";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetName_006
+ * @tc.desc: Test function of GetName() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetName_006, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetName_006";
+
+    uv_fs_t mock_req;
+    mock_req.ptr = const_cast<char*>("/file_test.txt");
+
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _))
+        .WillOnce(Invoke([&](uv_loop_t*, uv_fs_t* req, const char*, uv_fs_cb) {
+            *req = mock_req;
+            return 0;
+        }));
+    auto result = fsFile->GetName();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetName_006";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetParent_007
+ * @tc.desc: Test function of GetParent() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetParent_007, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetParent_007";
+
+    uv_fs_t mock_req;
+    mock_req.ptr = const_cast<char*>("/test/dir_test");
+
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _))
+        .WillOnce(Invoke([&](uv_loop_t*, uv_fs_t* req, const char*, uv_fs_cb) {
+            *req = mock_req;
+            return 0;
+        }));
+    auto result = fsFile->GetParent();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetParent_007";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetName_008
+ * @tc.desc: Test function of GetName() interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetName_008, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetName_008";
+
+    uv_fs_t mock_req;
+    mock_req.ptr = const_cast<char*>("file_test.txt");
+
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _))
+        .WillOnce(Invoke([&](uv_loop_t*, uv_fs_t* req, const char*, uv_fs_cb) {
+            *req = mock_req;
+            return 0;
+        }));
+    auto result = fsFile->GetName();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetName_008";
+}
+
+/**
+ * @tc.name: FsFileMockTest_GetParent_009
+ * @tc.desc: Test function of GetParent() interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_GetParent_009, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_GetParent_009";
+
+    uv_fs_t mock_req;
+    mock_req.ptr = const_cast<char*>("dir_test");
+
+    EXPECT_CALL(*uvMock, uv_fs_realpath(_, _, _, _))
+        .WillOnce(Invoke([&](uv_loop_t*, uv_fs_t* req, const char*, uv_fs_cb) {
+            *req = mock_req;
+            return 0;
+        }));
+    auto result = fsFile->GetParent();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_GetParent_009";
+}
+
+/**
+ * @tc.name: FsFileMockTest_Lock_010
+ * @tc.desc: Test function of Lock() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_Lock_010, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_Lock_010";
+
+    EXPECT_CALL(*sys, flock(_, _)).WillOnce(Return(1));
+    auto result = fsFile->Lock(true);
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_Lock_010";
+}
+
+/**
+ * @tc.name: FsFileMockTest_Lock_011
+ * @tc.desc: Test function of Lock() interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_Lock_011, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_Lock_011";
+
+    EXPECT_CALL(*sys, flock(_, _)).WillOnce(Return(-1));
+    auto result = fsFile->Lock(false);
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_Lock_011";
+}
+
+/**
+ * @tc.name: FsFileMockTest_TryLock_012
+ * @tc.desc: Test function of TryLock() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_TryLock_012, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_TryLock_012";
+
+    EXPECT_CALL(*sys, flock(_, _)).WillOnce(Return(1));
+    auto result = fsFile->TryLock(true);
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_TryLock_012";
+}
+
+/**
+ * @tc.name: FsFileMockTest_TryLock_013
+ * @tc.desc: Test function of TryLock() interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_TryLock_013, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_TryLock_013";
+
+    EXPECT_CALL(*sys, flock(_, _)).WillOnce(Return(-1));
+    auto result = fsFile->TryLock(false);
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_TryLock_013";
+}
+
+/**
+ * @tc.name: FsFileMockTest_UnLock_014
+ * @tc.desc: Test function of UnLock() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_UnLock_014, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_UnLock_014";
+
+    EXPECT_CALL(*sys, flock(_, _)).WillOnce(Return(1));
+    auto result = fsFile->UnLock();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_UnLock_014";
+}
+
+/**
+ * @tc.name: FsFileMockTest_UnLock_015
+ * @tc.desc: Test function of UnLock() interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileMockTest, FsFileMockTest_UnLock_015, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileMockTest-begin FsFileMockTest_UnLock_015";
+
+    EXPECT_CALL(*sys, flock(_, _)).WillOnce(Return(-1));
+    auto result = fsFile->UnLock();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileMockTest-end FsFileMockTest_UnLock_015";
+}
+
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_file/fs_file_test.cpp b/interfaces/test/unittest/js/mod_fs/class_file/fs_file_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a72cf86f58800a1bdcacb731ab90cbe890d81b7
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_file/fs_file_test.cpp
@@ -0,0 +1,278 @@
+/*
+ * 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 "file_entity.h"
+#include "fs_file.h"
+
+#include <gtest/gtest.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class FsFileTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    std::unique_ptr<FileEntity> fileEntity;
+    std::unique_ptr<FsFile> fsFile;
+};
+
+void FsFileTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void FsFileTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void FsFileTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+    
+    fileEntity = std::make_unique<FileEntity>();
+    const int fdValue = 3;
+    const bool isClosed = false;
+    fileEntity->fd_ = std::make_unique<DistributedFS::FDGuard>(fdValue, isClosed);
+    fileEntity->path_ = "/data/test/file_test.txt";
+    fileEntity->uri_ = "";
+    fsFile = std::make_unique<FsFile>(std::move(fileEntity));
+}
+
+void FsFileTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsFileTest_Constructor_001
+ * @tc.desc: Test function of FsFile::Constructor() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_Constructor_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_Constructor_001";
+
+    auto result = FsFile::Constructor();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_Constructor_001";
+}
+
+/**
+ * @tc.name: FsFileTest_GetFD_002
+ * @tc.desc: Test function of GetFD() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetFD_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetFD_002";
+
+    auto result = fsFile->GetFD();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetFD_002";
+}
+
+/**
+ * @tc.name: FsFileTest_GetFD_003
+ * @tc.desc: Test function of GetFD() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetFD_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetFD_003";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->GetFD();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetFD_003";
+}
+
+/**
+ * @tc.name: FsFileTest_GetPath_004
+ * @tc.desc: Test function of GetPath() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetPath_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetPath_004";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->GetPath();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetPath_004";
+}
+
+/**
+ * @tc.name: FsFileTest_GetName_005
+ * @tc.desc: Test function of GetName() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetName_005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetName_005";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->GetName();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetName_005";
+}
+
+/**
+ * @tc.name: FsFileTest_GetParent_006
+ * @tc.desc: Test function of GetParent() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetParent_006, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetParent_006";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->GetParent();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetParent_006";
+}
+
+/**
+ * @tc.name: FsFileTest_Lock_007
+ * @tc.desc: Test function of Lock() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_Lock_007, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_Lock_007";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->Lock(true);
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_Lock_007";
+}
+
+/**
+ * @tc.name: FsFileTest_TryLock_008
+ * @tc.desc: Test function of TryLock() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_TryLock_008, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_TryLock_008";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->TryLock(true);
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_TryLock_008";
+}
+
+/**
+ * @tc.name: FsFileTest_UnLock_009
+ * @tc.desc: Test function of UnLock() interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_UnLock_009, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_UnLock_009";
+
+    fsFile = std::make_unique<FsFile>(nullptr);
+    auto result = fsFile->UnLock();
+    EXPECT_EQ(result.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_UnLock_009";
+}
+
+/**
+ * @tc.name: FsFileTest_GetName_010
+ * @tc.desc: Test function of GetName() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetName_010, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetName_010";
+
+    fsFile->fileEntity->uri_ = "file://storage/file_test.txt";
+    auto result = fsFile->GetName();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetName_010";
+}
+
+/**
+ * @tc.name: FsFileTest_GetParent_011
+ * @tc.desc: Test function of GetParent() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetParent_011, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetParent_011";
+
+    fsFile->fileEntity->uri_ = "file://storage/file_test.txt";
+    auto result = fsFile->GetParent();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetParent_011";
+}
+
+/**
+ * @tc.name: FsFileTest_GetPath_012
+ * @tc.desc: Test function of GetPath() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsFileTest, FsFileTest_GetPath_012, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsFileTest-begin FsFileTest_GetPath_012";
+
+    fsFile->fileEntity->uri_ = "file://storage/file_test.txt";
+    auto result = fsFile->GetPath();
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsFileTest-end FsFileTest_GetPath_012";
+}
+
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/mock/system_mock.cpp b/interfaces/test/unittest/js/mod_fs/properties/mock/system_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5878a93046576b034577b1d1431decb895cdb2dc
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/mock/system_mock.cpp
@@ -0,0 +1,40 @@
+/*
+ * 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 "system_mock.h"
+
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+extern "C" {
+int setxattr(const char *path, const char *name, const void *value, size_t size, int flags)
+{
+    return System::ins->setxattr(path, name, value, size, flags);
+}
+
+int getxattr(const char *path, const char *name, void *value, size_t size)
+{
+    return System::ins->getxattr(path, name, value, size);
+}
+
+int fgetxattr(int filedes, const char *name, void *value, size_t size)
+{
+    return System::ins->fgetxattr(filedes, name, value, size);
+}
+
+int flock(int fd, int operation)
+{
+    return System::ins->flock(fd, operation);
+}
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/mock/system_mock.h b/interfaces/test/unittest/js/mod_fs/properties/mock/system_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ff74be78027d70a93550e1fbb0a4d59a0331885
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/mock/system_mock.h
@@ -0,0 +1,46 @@
+/*
+ * 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_PROPERTIES_MOCK_SYSTEM_MOCK_H
+#define INTERFACES_TEST_UNITTEST_JS_MOD_FS_PROPERTIES_MOCK_SYSTEM_MOCK_H
+
+#include <sys/file.h>
+#include <vector>
+#include <gmock/gmock.h>
+
+namespace OHOS::FileManagement::ModuleFileIO {
+
+class System {
+public:
+    static inline std::shared_ptr<System> ins = nullptr;
+
+public:
+    virtual ~System() = default;
+    virtual int setxattr(const char *path, const char *name, const void *value, size_t size, int flags) = 0;
+    virtual int getxattr(const char *path, const char *name, void *value, size_t size) = 0;
+    virtual int fgetxattr(int filedes, const char *name, void *value, size_t size) = 0;
+    virtual int flock(int fd, int operation) = 0;
+};
+
+class SystemMock : public System {
+public:
+    MOCK_METHOD5(setxattr, int(const char *path, const char *name, const void *value, size_t size, int flags));
+    MOCK_METHOD4(getxattr, int(const char *path, const char *name, void *value, size_t size));
+    MOCK_METHOD4(fgetxattr, int(int filedes, const char *name, void *value, size_t size));
+    MOCK_METHOD2(flock, int(int fd, int operation));
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO
+#endif // INTERFACES_TEST_UNITTEST_JS_MOD_FS_PROPERTIES_MOCK_SYSTEM_MOCK_H
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.cpp b/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.cpp
index 13ceb7b5405e3cca678d7b6a7e93f5a8b23c6cb1..09f91974cf9aed4f3ffe8ae25b2761a6d4db7b90 100644
--- a/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.cpp
+++ b/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.cpp
@@ -17,8 +17,8 @@
 
 using namespace OHOS::FileManagement::ModuleFileIO;
 
-int uv_fs_read(
-    uv_loop_t *loop, uv_fs_t *req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t off, uv_fs_cb cb)
+int uv_fs_read(uv_loop_t *loop, uv_fs_t *req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t off,
+    uv_fs_cb cb)
 {
     return Uvfs::ins->uv_fs_read(loop, req, file, bufs, nbufs, off, cb);
 }
@@ -68,12 +68,22 @@ int uv_fs_ftruncate(uv_loop_t *loop, uv_fs_t *req, uv_file fd, int64_t offset, u
     return Uvfs::ins->uv_fs_ftruncate(loop, req, fd, offset, cb);
 }
 
-int uv_fs_write(
-    uv_loop_t *loop, uv_fs_t *req, uv_file fd, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb)
+int uv_fs_write(uv_loop_t *loop, uv_fs_t *req, uv_file fd, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset,
+    uv_fs_cb cb)
 {
     return Uvfs::ins->uv_fs_write(loop, req, fd, bufs, nbufs, offset, cb);
 }
 
+int uv_fs_realpath(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
+{
+    return Uvfs::ins->uv_fs_realpath(loop, req, path, cb);
+}
+
+int uv_fs_close(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
+{
+    return Uvfs::ins->uv_fs_close(loop, req, file, cb);
+}
+
 int uv_fs_fdatasync(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
 {
     return Uvfs::ins->uv_fs_fdatasync(loop, req, file, cb);
@@ -99,4 +109,22 @@ int uv_fs_unlink(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
     return Uvfs::ins->uv_fs_unlink(loop, req, path, cb);
 }
 
-void uv_fs_req_cleanup(uv_fs_t *req) {}
+void uv_fs_req_cleanup(uv_fs_t *req)
+{
+    return;
+}
+
+int uv_fs_rename(uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, uv_fs_cb cb)
+{
+    return Uvfs::ins->uv_fs_rename(loop, req, path, newPath, cb);
+}
+
+int uv_fs_fsync(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
+{
+    return Uvfs::ins->uv_fs_fsync(loop, req, file, cb);
+}
+
+int uv_fs_sendfile(uv_loop_t *loop, uv_fs_t *req, uv_file outFd, uv_file inFd, int64_t off, size_t len, uv_fs_cb cb)
+{
+    return Uvfs::ins->uv_fs_sendfile(loop, req, outFd, inFd, off, len, cb);
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.h b/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.h
index 6b0f3c5fdebacac71bd14803b4b7cc9691584e1a..736eebb6e1703e5501eac1a9c26c8feb792b5dd9 100644
--- a/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.h
+++ b/interfaces/test/unittest/js/mod_fs/properties/mock/uv_fs_mock.h
@@ -16,7 +16,7 @@
 #ifndef INTERFACES_TEST_UNITTEST_JS_MOD_FS_PROPERTIES_MOCK_UV_FS_MOCK_H
 #define INTERFACES_TEST_UNITTEST_JS_MOD_FS_PROPERTIES_MOCK_UV_FS_MOCK_H
 
-#include "read_core.h"
+#include "uv.h"
 
 #include <gmock/gmock.h>
 
@@ -32,46 +32,58 @@ public:
         int64_t off, uv_fs_cb cb) = 0;
     virtual int uv_fs_readlink(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb) = 0;
     virtual int uv_fs_stat(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb) = 0;
-    virtual int uv_fs_utime(
-        uv_loop_t *loop, uv_fs_t *req, const char *path, double atime, double mtime, uv_fs_cb cb) = 0;
+    virtual int uv_fs_utime(uv_loop_t *loop, uv_fs_t *req, const char *path, double atime,
+        double mtime, uv_fs_cb cb) = 0;
     virtual int uv_fs_scandir(uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, uv_fs_cb cb) = 0;
     virtual int uv_fs_scandir_next(uv_fs_t *req, uv_dirent_t *ent) = 0;
-    virtual int uv_fs_rmdir(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb) = 0;
-    virtual int uv_fs_symlink(
-        uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, int flags, uv_fs_cb cb) = 0;
+    virtual int uv_fs_rmdir(uv_loop_t *loop, uv_fs_t *req, const char* path, uv_fs_cb cb) = 0;
+    virtual int uv_fs_symlink(uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, int flags,
+        uv_fs_cb cb) = 0;
     virtual int uv_fs_open(uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, int mode, uv_fs_cb cb) = 0;
     virtual int uv_fs_ftruncate(uv_loop_t *loop, uv_fs_t *req, uv_file fd, int64_t offset, uv_fs_cb cb) = 0;
     virtual int uv_fs_write(uv_loop_t *loop, uv_fs_t *req, uv_file fd, const uv_buf_t bufs[], unsigned int nbufs,
         int64_t offset, uv_fs_cb cb) = 0;
+    virtual int uv_fs_realpath(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb) = 0;
+    virtual int uv_fs_close(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb) = 0;
     virtual int uv_fs_fdatasync(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb) = 0;
     virtual int uv_fs_mkdir(uv_loop_t *loop, uv_fs_t *req, const char *path, int mode, uv_fs_cb cb) = 0;
     virtual int uv_fs_access(uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, uv_fs_cb cb) = 0;
     virtual int uv_fs_mkdtemp(uv_loop_t *loop, uv_fs_t *req, const char *tpl, uv_fs_cb cb) = 0;
     virtual int uv_fs_unlink(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb) = 0;
+    virtual int uv_fs_rename(uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, uv_fs_cb cb) = 0;
+    virtual int uv_fs_fsync(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb) = 0;
+    virtual int uv_fs_sendfile(uv_loop_t *loop, uv_fs_t *req, uv_file outFd, uv_file inFd, int64_t off, size_t len,
+        uv_fs_cb cb) = 0;
 };
 
 class UvfsMock : public Uvfs {
 public:
     MOCK_METHOD7(uv_fs_read, int(uv_loop_t *loop, uv_fs_t *req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs,
-                                 int64_t off, uv_fs_cb cb));
+        int64_t off, uv_fs_cb cb));
     MOCK_METHOD4(uv_fs_readlink, int(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb));
     MOCK_METHOD4(uv_fs_stat, int(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb));
-    MOCK_METHOD6(
-        uv_fs_utime, int(uv_loop_t *loop, uv_fs_t *req, const char *path, double atime, double mtime, uv_fs_cb cb));
+    MOCK_METHOD6(uv_fs_utime, int(uv_loop_t *loop, uv_fs_t *req, const char *path, double atime, double mtime,
+        uv_fs_cb cb));
     MOCK_METHOD5(uv_fs_scandir, int(uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, uv_fs_cb cb));
     MOCK_METHOD2(uv_fs_scandir_next, int(uv_fs_t *req, uv_dirent_t *ent));
     MOCK_METHOD4(uv_fs_rmdir, int(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb));
-    MOCK_METHOD6(uv_fs_symlink,
-        int(uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, int flags, uv_fs_cb cb));
+    MOCK_METHOD6(uv_fs_symlink, int(uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, int flags,
+        uv_fs_cb cb));
     MOCK_METHOD6(uv_fs_open, int(uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, int mode, uv_fs_cb cb));
     MOCK_METHOD5(uv_fs_ftruncate, int(uv_loop_t *loop, uv_fs_t *req, uv_file fd, int64_t offset, uv_fs_cb cb));
     MOCK_METHOD7(uv_fs_write, int(uv_loop_t *loop, uv_fs_t *req, uv_file fd, const uv_buf_t bufs[], unsigned int nbufs,
-                                  int64_t offset, uv_fs_cb cb));
+        int64_t offset, uv_fs_cb cb));
+    MOCK_METHOD4(uv_fs_realpath, int(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb));
+    MOCK_METHOD4(uv_fs_close, int(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb));
     MOCK_METHOD4(uv_fs_fdatasync, int(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb));
     MOCK_METHOD5(uv_fs_mkdir, int(uv_loop_t *loop, uv_fs_t *req, const char *path, int mode, uv_fs_cb cb));
     MOCK_METHOD5(uv_fs_access, int(uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, uv_fs_cb cb));
     MOCK_METHOD4(uv_fs_mkdtemp, int(uv_loop_t *loop, uv_fs_t *req, const char *tpl, uv_fs_cb cb));
     MOCK_METHOD4(uv_fs_unlink, int(uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb));
+    MOCK_METHOD5(uv_fs_rename, int(uv_loop_t *loop, uv_fs_t *req, const char *path, const char *newPath, uv_fs_cb cb));
+    MOCK_METHOD4(uv_fs_fsync, int(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb));
+    MOCK_METHOD7(uv_fs_sendfile, int(uv_loop_t *loop, uv_fs_t *req, uv_file outFd, uv_file inFd, int64_t off,
+        size_t len, uv_fs_cb cb));
 };
 
 } // namespace OHOS::FileManagement::ModuleFileIO
diff --git a/interfaces/test/unittest/js/mod_fs/properties/open_core_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/open_core_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d3b3752b2ee17ff28cf6378a10f076f5192f41d2
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/open_core_mock_test.cpp
@@ -0,0 +1,146 @@
+/*
+ * 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 "open_core.h"
+#include "mock/uv_fs_mock.h"
+
+#include <filesystem>
+#include <fstream>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class OpenCoreMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static inline shared_ptr<UvfsMock> uvMock = nullptr;
+};
+
+void OpenCoreMockTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    uvMock = std::make_shared<UvfsMock>();
+    Uvfs::ins = uvMock;
+}
+
+void OpenCoreMockTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+    Uvfs::ins = nullptr;
+    uvMock = nullptr;
+}
+
+void OpenCoreMockTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void OpenCoreMockTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: OpenCoreMockTest_DoOpen_001
+ * @tc.desc: Test function of OpenCore::DoOpen interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreMockTest, OpenCoreMockTest_DoOpen_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-begin OpenCoreMockTest_DoOpen_001";
+
+    string path = "/test/open_test.txt";
+    int32_t mode = 0;
+    
+    EXPECT_CALL(*uvMock, uv_fs_open(_, _, _, _, _, _)).WillOnce(Return(0));
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-end OpenCoreMockTest_DoOpen_001";
+}
+
+/**
+ * @tc.name: OpenCoreMockTest_DoOpen_002
+ * @tc.desc: Test function of OpenCore::DoOpen interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreMockTest, OpenCoreMockTest_DoOpen_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-begin OpenCoreMockTest_DoOpen_002";
+
+    string path = "file://test/open_test.txt";
+    int32_t mode = 0;
+
+    EXPECT_CALL(*uvMock, uv_fs_open(_, _, _, _, _, _)).WillOnce(Return(0));
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-end OpenCoreMockTest_DoOpen_002";
+}
+
+/**
+ * @tc.name: OpenCoreMockTest_DoOpen_003
+ * @tc.desc: Test function of OpenCore::DoOpen interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreMockTest, OpenCoreMockTest_DoOpen_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-begin OpenCoreMockTest_DoOpen_003";
+
+    string path = "file://test/open_test.txt";
+    int32_t mode = 0;
+
+    EXPECT_CALL(*uvMock, uv_fs_open(_, _, _, _, _, _)).WillOnce(Return(-1));
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-end OpenCoreMockTest_DoOpen_003";
+}
+
+/**
+ * @tc.name: OpenCoreMockTest_DoOpen_004
+ * @tc.desc: Test function of OpenCore::DoOpen interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreMockTest, OpenCoreMockTest_DoOpen_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-begin OpenCoreMockTest_DoOpen_004";
+
+    string path = "/test/open_test.txt";
+    int32_t mode = 0;
+
+    EXPECT_CALL(*uvMock, uv_fs_open(_, _, _, _, _, _)).WillOnce(Return(-1));
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreMockTest-end OpenCoreMockTest_DoOpen_004";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/open_core_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/open_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9b40e7ef611058032b4d227cfea37e14eb650c6c
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/open_core_test.cpp
@@ -0,0 +1,193 @@
+/*
+ * 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 "open_core.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class OpenCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void OpenCoreTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void OpenCoreTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void OpenCoreTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void OpenCoreTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_001
+ * @tc.desc: Test function of OpenCore::DoOpen interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_001";
+
+    string path = "/test/open_test.txt";
+    int32_t mode = -1;
+    
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_001";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_002
+ * @tc.desc: Test function of OpenCore::DoOpen interface for ERROR.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_002";
+
+    string path = "/test/open_test.txt";
+    int32_t mode = 3;
+    
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_002";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_003
+ * @tc.desc: Test function of OpenCore::DoOpen interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_003";
+
+    string path = "file://media/open_test.jpg";
+    int32_t mode = 0;
+    
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_003";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_004
+ * @tc.desc: Test function of OpenCore::DoOpen interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_004";
+
+    string path = "file://docs/open_test.pdf";
+    int32_t mode = 0;
+
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_004";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_005
+ * @tc.desc: Test function of OpenCore::DoOpen interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_005";
+
+    string path = "content://com.example.provider/open_test.txt";
+    int32_t mode = 0;
+
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_005";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_006
+ * @tc.desc: Test function of OpenCore::DoOpen interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_006, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_006";
+
+    string path = "datashare://media/open_test.jpg";
+    int32_t mode = 0;
+
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_006";
+}
+
+/**
+ * @tc.name: OpenCoreTest_DoOpen_007
+ * @tc.desc: Test function of OpenCore::DoOpen interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(OpenCoreTest, OpenCoreTest_DoOpen_007, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "OpenCoreTest-begin OpenCoreTest_DoOpen_007";
+
+    string path = "invalid://path/dir_test";
+    int32_t mode = 0;
+
+    auto res = OpenCore::DoOpen(path, mode);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "OpenCoreTest-end OpenCoreTest_DoOpen_007";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file