diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn
index 3c4ddabd989b02f0a78d67f916b3c4cf72541662..97cbc5d2fde65bdce1a3bcc9231e2695f0d0c701 100644
--- a/interfaces/kits/js/BUILD.gn
+++ b/interfaces/kits/js/BUILD.gn
@@ -1077,7 +1077,6 @@ ohos_shared_library("ani_file_statvfs") {
   ]
   use_exceptions = true
   cflags = [
-    "-fvisibility=hidden",
     "-fdata-sections",
     "-ffunction-sections",
     "-Oz",
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/BUILD.gn b/interfaces/test/unittest/BUILD.gn
index 924b53b3970c793ddea4d5a45ec7e2dde6bb4bfb..9342adac2bd5eaecb3c9e984217555eb43c8b2ae 100644
--- a/interfaces/test/unittest/BUILD.gn
+++ b/interfaces/test/unittest/BUILD.gn
@@ -18,6 +18,7 @@ group("file_api_unittest") {
     "filemgmt_libn_test:filemgmt_libn_test",
     "js:ani_file_fs_mock_test",
     "js:ani_file_fs_test",
+    "js:ani_file_statvfs_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 d3fc839a00cd563fe82ed6f169f68f042e1eaca8..a7cf4c07e0012f11c085bd2de74faf8180d86fd4 100644
--- a/interfaces/test/unittest/js/BUILD.gn
+++ b/interfaces/test/unittest/js/BUILD.gn
@@ -32,13 +32,16 @@ ohos_unittest("ani_file_fs_test") {
   ]
 
   sources = [
+    "mod_fs/class_file/fs_file_test.cpp",
     "mod_fs/class_randomaccessfile/fs_randomaccessfile_test.cpp",
+    "mod_fs/class_stat/fs_stat_test.cpp",
     "mod_fs/class_stream/fs_stream_test.cpp",
     "mod_fs/properties/close_core_test.cpp",
     "mod_fs/properties/create_randomaccessfile_core_test.cpp",
     "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",
   ]
 
@@ -84,9 +87,13 @@ ohos_unittest("ani_file_fs_mock_test") {
   ]
 
   sources = [
+    "mod_fs/class_file/fs_file_mock_test.cpp",
     "mod_fs/class_randomaccessfile/fs_randomaccessfile_mock_test.cpp",
+    "mod_fs/class_stat/fs_stat_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 = [
@@ -112,4 +119,33 @@ ohos_unittest("ani_file_fs_mock_test") {
   defines = [
     "private=public",
   ]
+}
+
+ohos_unittest("ani_file_statvfs_test") {
+  module_out_path = "file_api/file_api"
+
+  resource_config_file = "../resource/ohos_test.xml"
+
+  sources = [
+    "mod_statvfs/statvfs_core_test.cpp",
+  ]
+
+  include_dirs = [
+    "mock/libuv",
+    "${file_api_path}/interfaces/kits/js/src/mod_statvfs",
+  ]
+
+  deps = [
+    "${file_api_path}/interfaces/kits/js:ani_file_statvfs",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+    "hilog:libhilog",
+    "libuv:uv",
+  ]
 }
\ No newline at end of file
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/class_stat/fs_stat_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/class_stat/fs_stat_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2de8331e085893f1b1c0b6c862446bbcaa369cda
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stat/fs_stat_mock_test.cpp
@@ -0,0 +1,118 @@
+/*
+ * 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 <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "fs_stat_entity.h"
+#include "fs_stat.h"
+#include "securec.h"
+#include "system_mock.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class FsStatMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static inline shared_ptr<SystemMock> sys = nullptr;
+};
+
+void FsStatMockTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    sys = make_shared<SystemMock>();
+    System::ins = sys;
+}
+
+void FsStatMockTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+    System::ins = nullptr;
+    sys = nullptr;
+}
+
+void FsStatMockTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FsStatMockTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsStatMockTest_GetLocation_001
+ * @tc.desc: Test function of GetLocation() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatMockTest, FsStatMockTest_GetLocation_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatMockTes-begin FsStatMockTest_GetLocation_001";
+
+    unique_ptr<StatEntity> statEntity;
+    unique_ptr<FsStat> fsStat;
+    statEntity = make_unique<StatEntity>();
+    statEntity->fileInfo_ = make_unique<FileInfo>();
+    statEntity->fileInfo_->isPath = true;
+    int length = 100;
+    string testPath = "/test/stat_path";
+    statEntity->fileInfo_->path = make_unique<char[]>(length);
+    strncpy_s(statEntity->fileInfo_->path.get(), length, testPath.c_str(), testPath.size());
+    statEntity->fileInfo_->path.get()[99] = '\0';
+    fsStat = make_unique<FsStat>(move(statEntity));
+
+    EXPECT_CALL(*sys, getxattr(_, _, _, _)).WillOnce(Return(1));
+    EXPECT_EQ(fsStat->GetLocation(), 1);
+
+    GTEST_LOG_(INFO) << "FsStatMockTes-end FsStatMockTest_GetLocation_001";
+}
+
+/**
+ * @tc.name: FsStatMockTest_GetLocation_002
+ * @tc.desc: Test function of GetLocation() interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatMockTest, FsStatMockTest_GetLocation_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatMockTes-begin FsStatMockTest_GetLocation_002";
+
+    unique_ptr<StatEntity> statEntity;
+    unique_ptr<FsStat> fsStat;
+    statEntity = make_unique<StatEntity>();
+    statEntity->fileInfo_ = make_unique<FileInfo>();
+    statEntity->fileInfo_->isPath = false;
+    const int fdValue = 3;  //模拟fd为3
+    const bool isClosed = false;
+    statEntity->fileInfo_->fdg = make_unique<DistributedFS::FDGuard>(fdValue, isClosed);
+    fsStat = make_unique<FsStat>(move(statEntity));
+
+    EXPECT_CALL(*sys, fgetxattr(_, _, _, _)).WillOnce(Return(1));
+    EXPECT_EQ(fsStat->GetLocation(), 1);
+
+    GTEST_LOG_(INFO) << "FsStatMockTes-end FsStatMockTest_GetLocation_002";
+}
+
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_stat/fs_stat_test.cpp b/interfaces/test/unittest/js/mod_fs/class_stat/fs_stat_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e74ed320796418ad541d4df7170e2524f839433
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_stat/fs_stat_test.cpp
@@ -0,0 +1,471 @@
+/*
+ * 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 "fs_stat.h"
+
+#include <gtest/gtest.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class FsStatTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void FsStatTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void FsStatTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void FsStatTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FsStatTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsStatTest_Constructor_001
+ * @tc.desc: Test FsStat::Constructor for success case
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_Constructor_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_Constructor_001";
+    
+    auto stat = FsStat::Constructor();
+    EXPECT_NE(stat, nullptr);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_Constructor_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsBlockDevice_001
+ * @tc.desc: Test FsStat::IsBlockDevice for directory
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsBlockDevice_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsBlockDevice_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFBLK;
+    EXPECT_TRUE(stat->IsBlockDevice());
+    EXPECT_FALSE(stat->IsFile());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsBlockDevice_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsCharacterDevice_001
+ * @tc.desc: Test FsStat::IsCharacterDevice for directory
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsCharacterDevice_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsCharacterDevice_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFCHR;
+    EXPECT_TRUE(stat->IsCharacterDevice());
+    EXPECT_FALSE(stat->IsFile());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsCharacterDevice_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsDirectory_001
+ * @tc.desc: Test FsStat::IsDirectory for directory
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsDirectory_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsDirectory_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFDIR | 0755;
+    EXPECT_TRUE(stat->IsDirectory());
+    EXPECT_FALSE(stat->IsFile());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsDirectory_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsFIFO_001
+ * @tc.desc: Test FsStat::IsFIFO for directory
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsFIFO_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsFIFO_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFIFO;
+    EXPECT_TRUE(stat->IsFIFO());
+    EXPECT_FALSE(stat->IsFile());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsFIFO_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsFile_001
+ * @tc.desc: Test FsStat::IsFile for regular file
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsFile_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsFile_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFREG | 0644;
+    EXPECT_TRUE(stat->IsFile());
+    EXPECT_FALSE(stat->IsDirectory());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsFile_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsSocket_001
+ * @tc.desc: Test FsStat::IsSocket for symbolic link
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsSocket_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsSocket_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFSOCK;
+    EXPECT_TRUE(stat->IsSocket());
+    EXPECT_FALSE(stat->IsDirectory());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsSocket_001";
+}
+
+/**
+ * @tc.name: FsStatTest_IsSymbolicLink_001
+ * @tc.desc: Test FsStat::IsSymbolicLink for symbolic link
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_IsSymbolicLink_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_IsSymbolicLink_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFLNK | 0777;
+    EXPECT_TRUE(stat->IsSymbolicLink());
+    EXPECT_FALSE(stat->IsDirectory());
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_IsSymbolicLink_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetIno_001
+ * @tc.desc: Test FsStat::GetIno for valid inode number
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetIno_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetIno_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_ino = 123456789;
+    EXPECT_EQ(stat->GetIno(), 123456789);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetIno_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetMode_001
+ * @tc.desc: Test FsStat::GetMode for permission bits
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetMode_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetMode_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mode = S_IFREG | 0755;
+    EXPECT_EQ(stat->GetMode(), 0755);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetMode_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetUid_001
+ * @tc.desc: Test FsStat::GetUid for user ID
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetUid_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetUid_001";
+
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_uid = 1000;
+    EXPECT_EQ(stat->GetUid(), 1000);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetUid_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetGid_001
+ * @tc.desc: Test FsStat::GetGid for group ID
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetGid_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetGid_001";
+
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_gid = 1000;
+    EXPECT_EQ(stat->GetGid(), 1000);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetGid_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetSize_001
+ * @tc.desc: Test FsStat::GetSize for file size
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetSize_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetSize_001";
+
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_size = 123456789;
+    EXPECT_EQ(stat->GetSize(), 123456789);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetSize_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetAtime_001
+ * @tc.desc: Test FsStat::GetAtime for access time in seconds
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetAtime_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetAtime_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_atim.tv_sec = 1630473600;
+    stat->entity->stat_.st_atim.tv_nsec = 500000000;
+    
+    EXPECT_EQ(stat->GetAtime(), 1630473600);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetAtime_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetMtime_001
+ * @tc.desc: Test FsStat::GetMtime for modification time in seconds
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetMtime_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetMtime_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mtim.tv_sec = 1630473601;
+    stat->entity->stat_.st_mtim.tv_nsec = 500000000;
+    
+    EXPECT_EQ(stat->GetMtime(), 1630473601);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetMtime_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetCtime_001
+ * @tc.desc: Test FsStat::GetCtime for change time in seconds
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetCtime_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetCtime_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_ctim.tv_sec = 1630473602;
+    stat->entity->stat_.st_ctim.tv_nsec = 500000000;
+
+    EXPECT_EQ(stat->GetCtime(), 1630473602);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetCtime_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetAtimeNs_001
+ * @tc.desc: Test FsStat::GetAtimeNs for access time in nanoseconds
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetAtimeNs_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetAtimeNs_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_atim.tv_sec = 1630473600;
+    stat->entity->stat_.st_atim.tv_nsec = 500000000;
+
+    int64_t expected = 1630473600LL * 1000000000 + 500000000;
+    EXPECT_EQ(stat->GetAtimeNs(), expected);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetAtimeNs_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetMtimeNs_001
+ * @tc.desc: Test FsStat::GetMtimeNs for modification time in nanoseconds
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetMtimeNs_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetMtimeNs_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_mtim.tv_sec = 1630473601;
+    stat->entity->stat_.st_mtim.tv_nsec = 500000000;
+
+    int64_t expected = 1630473601LL * 1000000000 + 500000000;
+    EXPECT_EQ(stat->GetMtimeNs(), expected);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetMtimeNs_001";
+}
+
+/**
+ * @tc.name: FsStatTest_GetCtimeNs_001
+ * @tc.desc: Test FsStat::GetCtimeNs for change time in nanoseconds
+ * @tc.size: SMALL
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsStatTest, FsStatTest_GetCtimeNs_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsStatTest-begin FsStatTest_GetCtimeNs_001";
+    
+    auto stat = FsStat::Constructor();
+    ASSERT_NE(stat, nullptr);
+
+    stat->entity->stat_.st_ctim.tv_sec = 1630473602;
+    stat->entity->stat_.st_ctim.tv_nsec = 500000000;
+
+    int64_t expected = 1630473602LL * 1000000000 + 500000000;
+    EXPECT_EQ(stat->GetCtimeNs(), expected);
+    delete stat;
+    
+    GTEST_LOG_(INFO) << "FsStatTest-end FsStatTest_GetCtimeNs_001";
+}
+
+}
\ 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/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
diff --git a/interfaces/test/unittest/js/mod_statvfs/statvfs_core_test.cpp b/interfaces/test/unittest/js/mod_statvfs/statvfs_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..82316d884a2a557cb956332ee3eba59575bc70d0
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_statvfs/statvfs_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 "statvfs_core.h"
+
+#include <fcntl.h>
+#include <gtest/gtest.h>
+#include <sys/statvfs.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class StatvFsCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void StatvFsCoreTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    int32_t fd = open("/data/test/statvfs.txt", O_CREAT | O_RDWR, 0644);
+    if (fd <= 0) {
+        close(fd);
+        ASSERT_TRUE(false);
+    }
+    close(fd);
+}
+
+void StatvFsCoreTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+    rmdir("/data/test/statvfs.txt");
+}
+
+void StatvFsCoreTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void StatvFsCoreTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: StatvFsCoreTest_DoGetFreeSize_001
+ * @tc.desc: Test function of DoGetFreeSize interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(StatvFsCoreTest, StatvFsCoreTest_DoGetFreeSize_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-begin StatvFsCoreTest_DoGetFreeSize_001";
+
+    struct statvfs diskInfo;
+    diskInfo.f_bsize = 2;
+    diskInfo.f_bfree = 1;
+
+    auto result = ModuleStatvfs::StatvfsCore::DoGetFreeSize("/data/test/statvfs.txt");
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-end StatvFsCoreTest_DoGetFreeSize_001";
+}
+
+/**
+ * @tc.name: StatvFsCoreTest_DoGetFreeSize_002
+ * @tc.desc: Test function of DoGetFreeSize interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(StatvFsCoreTest, StatvFsCoreTest_DoGetFreeSize_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-begin StatvFsCoreTest_DoGetFreeSize_002";
+
+    auto result = ModuleStatvfs::StatvfsCore::DoGetFreeSize("/test/path");
+    EXPECT_EQ(result.IsSuccess(), false);
+    auto err = result.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-end StatvFsCoreTest_DoGetFreeSize_002";
+}
+
+/**
+ * @tc.name: StatvFsCoreTest_DoGetTotalSize_003
+ * @tc.desc: Test function of DoGetTotalSize interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(StatvFsCoreTest, StatvFsCoreTest_DoGetTotalSize_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-begin StatvFsCoreTest_DoGetTotalSize_003";
+
+    struct statvfs diskInfo;
+    diskInfo.f_bsize = 2;
+    diskInfo.f_blocks = 1;
+
+    auto result = ModuleStatvfs::StatvfsCore::DoGetTotalSize("/data/test/statvfs.txt");
+    EXPECT_EQ(result.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-end StatvFsCoreTest_DoGetTotalSize_003";
+}
+
+/**
+ * @tc.name: StatvFsCoreTest_DoGetTotalSize_004
+ * @tc.desc: Test function of DoGetTotalSize interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(StatvFsCoreTest, StatvFsCoreTest_DoGetTotalSize_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-begin StatvFsCoreTest_DoGetTotalSize_004";
+
+    auto result = ModuleStatvfs::StatvfsCore::DoGetTotalSize("/test/path");
+    EXPECT_EQ(result.IsSuccess(), false);
+    auto err = result.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "StatvFsCoreTest-end StatvFsCoreTest_DoGetTotalSize_004";
+}
+
+}
\ No newline at end of file