diff --git a/interfaces/kits/js/src/mod_fs/class_file/fs_file.cpp b/interfaces/kits/js/src/mod_fs/class_file/fs_file.cpp
index 9218629ae14331a023ceadada777aadedbd1eafa..5dbc3b4ace78e2defa5c8eb7bf438acec1fb96a7 100644
--- a/interfaces/kits/js/src/mod_fs/class_file/fs_file.cpp
+++ b/interfaces/kits/js/src/mod_fs/class_file/fs_file.cpp
@@ -153,7 +153,7 @@ FsResult<void> FsFile::TryLock(bool exclusive) const
     }
 
     int ret = 0;
-    auto mode = exclusive ? LOCK_EX : LOCK_SH;
+    auto mode = static_cast<uint32_t>(exclusive ? LOCK_EX : LOCK_SH);
     ret = flock(fileEntity->fd_.get()->GetFD(), mode | LOCK_NB);
     if (ret < 0) {
         HILOGE("Failed to try to lock file");
diff --git a/interfaces/kits/js/src/mod_fs/properties/open_core.cpp b/interfaces/kits/js/src/mod_fs/properties/open_core.cpp
index f688e8b5e208a25f3f2b4d1ec3074b8c6417325a..8ead99468d9e2761f1932c1410595fe6900b82aa 100644
--- a/interfaces/kits/js/src/mod_fs/properties/open_core.cpp
+++ b/interfaces/kits/js/src/mod_fs/properties/open_core.cpp
@@ -75,7 +75,7 @@ static tuple<bool, uint32_t> ValidAndConvertFlags(const optional<int32_t> &mode)
         }
         flags = static_cast<uint32_t>(modeValue);
         uint32_t invalidMode = (O_WRONLY | O_RDWR);
-        if ((modeValue & invalidMode) == invalidMode) {
+        if ((flags & invalidMode) == invalidMode) {
             HILOGE("Invalid mode");
             return { false, flags };
         }
diff --git a/interfaces/test/unittest/js/BUILD.gn b/interfaces/test/unittest/js/BUILD.gn
index 33550e0d78902cbfa4ec63c3d6088c583bfc6934..e6d3243a40456d2155e0ca10c99063effbe7c3e2 100644
--- a/interfaces/test/unittest/js/BUILD.gn
+++ b/interfaces/test/unittest/js/BUILD.gn
@@ -32,6 +32,7 @@ ohos_unittest("ani_file_fs_test") {
   ]
 
   sources = [
+    "mod_fs/class_file/fs_file_test.cpp",
     "mod_fs/class_atomicfile/fs_atomicfile_test.cpp",
     "mod_fs/class_randomaccessfile/fs_randomaccessfile_test.cpp",
     "mod_fs/class_stream/fs_stream_test.cpp",
@@ -40,6 +41,7 @@ ohos_unittest("ani_file_fs_test") {
     "mod_fs/properties/create_stream_core_test.cpp",
     "mod_fs/properties/fdopen_stream_core_test.cpp",
     "mod_fs/properties/listfile_core_test.cpp",
+    "mod_fs/properties/open_core_test.cpp",
     "mod_fs/properties/read_text_core_test.cpp",
   ]
 
@@ -86,11 +88,14 @@ ohos_unittest("ani_file_fs_mock_test") {
   ]
 
   sources = [
+    "mod_fs/class_file/fs_file_mock_test.cpp",
     "mod_fs/class_stream/fs_stream_mock_test.cpp",
     "mod_fs/class_stream/mock/c_mock.cpp",
     "mod_fs/class_randomaccessfile/fs_randomaccessfile_mock_test.cpp",
     "mod_fs/properties/create_randomaccessfile_core_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 = [
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..e432f66f6109e8f96b668a2911b0842e34435beb
--- /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();
+    unique_ptr<FileEntity> fileEntity;
+    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 = make_unique<FileEntity>();
+    const int fdValue = 3;
+    const bool isClosed = false;
+    fileEntity->fd_ = make_unique<DistributedFS::FDGuard>(fdValue, isClosed);
+    fileEntity->path_ = "/data/test/file_test.txt";
+    fileEntity->uri_ = "";
+    fsFile = make_unique<FsFile>(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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 aa3534347a12bcbe1ad09d128762e5bad897af4f..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
@@ -127,4 +127,4 @@ int uv_fs_fsync(uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb 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/open_core_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/open_core_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33f25f3cdd2782d35a5bd416a935aa96cc11aea2
--- /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 "mock/uv_fs_mock.h"
+#include "open_core.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..a6cad138a535dfdc7f4779fc5991572ea60e2f8f
--- /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 "open_core.h"
+
+#include <gtest/gtest.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