diff --git a/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp b/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
index f46a4fdd45e9e34bfe79a44feca6b6b06e2952d1..e4c6fd512b00ba410f25759e917b5ed4a70d129b 100644
--- a/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
+++ b/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
@@ -30,6 +30,7 @@ const Type BasicTypes::doubleType = Builder::BuildDouble();
 // BasicTypesConverter::toLong
 const string BasicTypesConverter::toLong = "toLong";
 const string BasicTypesConverter::toInt = "toInt";
+const string BasicTypesConverter::toDouble = "toDouble";
 
 // BoxedTypes::Boolean
 const Type BoxedTypes::Boolean::classType = Builder::BuildClass("std.core.Boolean");
diff --git a/interfaces/kits/js/src/common/ani_helper/ani_signature.h b/interfaces/kits/js/src/common/ani_helper/ani_signature.h
index de58ba8cb391dd54eab87184554e70893709e36a..ac755165cd3f8542a831529efd2ed2238a8e0edb 100644
--- a/interfaces/kits/js/src/common/ani_helper/ani_signature.h
+++ b/interfaces/kits/js/src/common/ani_helper/ani_signature.h
@@ -41,6 +41,7 @@ struct BasicTypes {
 struct BasicTypesConverter {
     static const string toLong;
     static const string toInt;
+    static const string toDouble;
 };
 
 struct BaseType {
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fdatasync_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/fdatasync_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ce4a8bfc81fd4fb130d5819365ba492ab186f3f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fdatasync_ani.cpp
@@ -0,0 +1,44 @@
+/*
+ * 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 "fdatasync_ani.h"
+
+#include <string>
+
+#include "error_handler.h"
+#include "fdatasync_core.h"
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+void FDataSyncAni::FDataSyncSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd)
+{
+    auto ret = FDataSyncCore::DoFDataSync(static_cast<int32_t>(fd));
+    if (!ret.IsSuccess()) {
+        HILOGE("Fdatasync failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return;
+    }
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fdatasync_ani.h b/interfaces/kits/js/src/mod_fs/properties/ani/fdatasync_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce0b8326125c526b1fc78de7bb0aaba22c67aa71
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fdatasync_ani.h
@@ -0,0 +1,36 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_FDATASYNC_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_FDATASYNC_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class FDataSyncAni final {
+public:
+    static void FDataSyncSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd);
+};
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_FDATASYNC_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3ade60f9dc51278c5d30d452011ae4d6926618b5
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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 "fdopen_stream_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "fdopen_stream_core.h"
+#include "stream_wrapper.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+ani_object FdopenStreamAni::FdopenStreamSync(
+    ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd, ani_string mode)
+{
+    auto [succMode, openMode] = TypeConverter::ToUTF8String(env, mode);
+    if (!succMode) {
+        HILOGE("Invalid mode");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    FsResult<FsStream *> ret = FdopenStreamCore::DoFdopenStream(static_cast<int32_t>(fd), openMode);
+    if (!ret.IsSuccess()) {
+        HILOGE("Fdopen stream failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return nullptr;
+    }
+
+    const FsStream *stream = ret.GetData().value();
+    auto result = StreamWrapper::Wrap(env, move(stream));
+    if (result == nullptr) {
+        ErrorHandler::Throw(env, UNKNOWN_ERR);
+        return nullptr;
+    }
+
+    return result;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.h b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..81f0fde31b630e1e90a6243ba335cd8b5c254215
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.h
@@ -0,0 +1,33 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+class FdopenStreamAni final {
+public:
+    static ani_object FdopenStreamSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd, ani_string mode);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fsync_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/fsync_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f2680914fc313466b722d22ffbe162118d603b6f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fsync_ani.cpp
@@ -0,0 +1,41 @@
+/*
+ * 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 "fsync_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "fsync_core.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+void FsyncAni::FsyncSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd)
+{
+    auto ret = FsyncCore::DoFsync(static_cast<int32_t>(fd));
+    if (!ret.IsSuccess()) {
+        HILOGE("DoFsync failed!");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return;
+    }
+}
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fsync_ani.h b/interfaces/kits/js/src/mod_fs/properties/ani/fsync_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad9d936fe9c5a6cb1b6bf1a536a91d99bc599642
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fsync_ani.h
@@ -0,0 +1,35 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_FSYNC_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_FSYNC_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class FsyncAni final {
+public:
+    static void FsyncSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_FSYNC_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/listfile_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/listfile_ani.cpp
index 6b65ec5ce49d8283d013b6cd76245bb157abb0dd..16339ea59b3c0b0d74b2f8ac6003a36c406516ee 100644
--- a/interfaces/kits/js/src/mod_fs/properties/ani/listfile_ani.cpp
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/listfile_ani.cpp
@@ -65,7 +65,7 @@ tuple<bool, int> ParseIntParam(ani_env *env, ani_object obj, string tag)
     }
     ani_int resultRefRes;
     if (ANI_OK != env->Object_CallMethodByName_Int(
-        static_cast<ani_object>(resultRef), "intValue", nullptr, &resultRefRes)) {
+        static_cast<ani_object>(resultRef), BasicTypesConverter::toInt.c_str(), nullptr, &resultRefRes)) {
         result = -1;
         return { false, result };
     }
@@ -87,7 +87,7 @@ tuple<bool, optional<double>> ParseDoubleParam(ani_env *env, ani_object obj, str
 
     ani_double resultRefRes;
     if (ANI_OK != env->Object_CallMethodByName_Double(
-        static_cast<ani_object>(resultRef), "doubleValue", nullptr, &resultRefRes)) {
+        static_cast<ani_object>(resultRef), BasicTypesConverter::toDouble.c_str(), nullptr, &resultRefRes)) {
         return { false, nullopt };
     }
     double result = static_cast<double>(resultRefRes);
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/lseek_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/lseek_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3f4a4214aac221ace5151526bf7b2b01779e5b2b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/lseek_ani.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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 "lseek_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "lseek_core.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+using namespace std;
+
+optional<SeekPos> ParseSeekPos(const optional<int32_t> &whence)
+{
+    if (!whence.has_value()) {
+        return nullopt;
+    }
+
+    return make_optional(static_cast<SeekPos>(move(whence.value())));
+}
+
+ani_double LseekAni::LseekSync(
+    ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd, ani_double offset, ani_enum_item whence)
+{
+    auto [succWhence, whenceOp] = TypeConverter::EnumToInt32(env, whence);
+    if (!succWhence) {
+        HILOGE("Invalid whence");
+        ErrorHandler::Throw(env, EINVAL);
+        return -1;
+    }
+    
+    auto pos = ParseSeekPos(whenceOp);
+    auto ret = LseekCore::DoLseek(static_cast<int32_t>(fd), static_cast<int64_t>(offset), pos);
+    if (!ret.IsSuccess()) {
+        HILOGE("DoLseek failed!");
+        const FsError &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return -1;
+    }
+
+    return ani_double(static_cast<double>(ret.GetData().value()));
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/lseek_ani.h b/interfaces/kits/js/src/mod_fs/properties/ani/lseek_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a7995d799ec2ab6d000304f4b4a1d9589a58177
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/lseek_ani.h
@@ -0,0 +1,34 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_LSEEK_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_LSEEK_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+class LseekAni final {
+public:
+    static ani_double LseekSync(
+        ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd, ani_double offset, ani_enum_item whence);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_ANI_LSEEK_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fdatasync_core.cpp b/interfaces/kits/js/src/mod_fs/properties/fdatasync_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..645cf65ae2cb38e98903c593022e6a6fa42a4fff
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fdatasync_core.cpp
@@ -0,0 +1,44 @@
+/*
+ * 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 "fdatasync_core.h"
+
+#include <cstring>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "filemgmt_libhilog.h"
+
+namespace OHOS::FileManagement::ModuleFileIO {
+
+FsResult<void> FDataSyncCore::DoFDataSync(const int32_t &fd)
+{
+    std::unique_ptr<uv_fs_t, decltype(FsUtils::FsReqCleanup) *> fDataSyncReq = { new uv_fs_t, FsUtils::FsReqCleanup };
+    if (!fDataSyncReq) {
+        HILOGE("Failed to request heap memory.");
+        return FsResult<void>::Error(ENOMEM);
+    }
+
+    int ret = uv_fs_fdatasync(nullptr, fDataSyncReq.get(), fd, nullptr);
+    if (ret < 0) {
+        HILOGE("Failed to transfer data associated with file descriptor: %{public}d, ret:%{public}d", fd, ret);
+        return FsResult<void>::Error(ret);
+    }
+
+    return FsResult<void>::Success();
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fdatasync_core.h b/interfaces/kits/js/src/mod_fs/properties/fdatasync_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e26c9140dc98c0d582a2ac75d743ae1618546d1
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fdatasync_core.h
@@ -0,0 +1,29 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_FDATASYNC_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDATASYNC_CORE_H
+
+#include "filemgmt_libfs.h"
+#include "fs_utils.h"
+
+namespace OHOS::FileManagement::ModuleFileIO {
+class FDataSyncCore final {
+public:
+    static FsResult<void> DoFDataSync(const int32_t &fd);
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDATASYNC_CORE_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.cpp b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3594d2a5dab5719b67dc70bdc892a080d5fea320
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fdopen_stream_core.h"
+
+#include <memory>
+
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+#include "fs_utils.h"
+#include "stream_entity.h"
+#include "stream_instantiator.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+FsResult<FsStream *> FdopenStreamCore::DoFdopenStream(const int &fd, const string &mode)
+{
+    if (fd < 0) {
+        HILOGE("Invalid fd");
+        return FsResult<FsStream *>::Error(EINVAL);
+    }
+
+    FILE *file = fdopen(fd, mode.c_str());
+    if (!file) {
+        HILOGE("Failed to fopen file by fd");
+        return FsResult<FsStream *>::Error(errno);
+    }
+
+    return StreamInstantiator::InstantiateStream(move(file));
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.h b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e646f24375d2d83a5598a418458af84faaa00c5
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.h
@@ -0,0 +1,38 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_CORE_H
+
+#include "filemgmt_libfs.h"
+#include "fs_stream.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+
+class FdopenStreamCore final {
+public:
+    static FsResult<FsStream *> DoFdopenStream(const int &fd, const string &mode);
+};
+
+struct AsyncFdopenStreamArg {
+    std::shared_ptr<FILE> fp { nullptr };
+};
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_CORE_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fsync_core.cpp b/interfaces/kits/js/src/mod_fs/properties/fsync_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d35b60ed2d0d3cbee9931836e2213e047dbe9631
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fsync_core.cpp
@@ -0,0 +1,43 @@
+/*
+ * 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 "fsync_core.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.h>
+
+#include "filemgmt_libhilog.h"
+#include "fs_utils.h"
+
+namespace OHOS::FileManagement::ModuleFileIO {
+using namespace std;
+
+FsResult<void> FsyncCore::DoFsync(const int32_t &fd)
+{
+    std::unique_ptr<uv_fs_t, decltype(FsUtils::FsReqCleanup) *> fsyncReq = { new uv_fs_t, FsUtils::FsReqCleanup };
+    if (!fsyncReq) {
+        HILOGE("Failed to request heap memory.");
+        return FsResult<void>::Error(ENOMEM);
+    }
+
+    int ret = uv_fs_fsync(nullptr, fsyncReq.get(), fd, nullptr);
+    if (ret < 0) {
+        HILOGE("Failed to transfer data associated with file descriptor: %{public}d", fd);
+        return FsResult<void>::Error(ret);
+    }
+    return FsResult<void>::Success();
+}
+} // namespace OHOS::FileManagement::ModuleFileIO
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fsync_core.h b/interfaces/kits/js/src/mod_fs/properties/fsync_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c6fb4d5d30576c4cc9a20b536605958019607b1
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fsync_core.h
@@ -0,0 +1,29 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_FSYNC_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FSYNC_CORE_H
+
+#include "filemgmt_libfs.h"
+
+namespace OHOS::FileManagement::ModuleFileIO {
+
+class FsyncCore final {
+public:
+    static FsResult<void> DoFsync(const int32_t &fd);
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FSYNC_CORE_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/lseek_core.cpp b/interfaces/kits/js/src/mod_fs/properties/lseek_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dfec873c9cf2bea50fb4fb2932408c95ca116a2c
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/lseek_core.cpp
@@ -0,0 +1,53 @@
+/*
+ * 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 "lseek_core.h"
+
+#include "filemgmt_libhilog.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+FsResult<int64_t> LseekCore::DoLseek(const int32_t &fd, const int64_t &offset,
+                                     const optional<SeekPos> &pos)
+{
+    if (fd < 0) {
+        HILOGE("Invalid fd from JS first argument");
+        return FsResult<int64_t>::Error(EINVAL);
+    }
+    
+    SeekPos whence = SeekPos::START;
+    if (pos.has_value()) {
+        if (pos.value() < SeekPos::START || pos.value() > SeekPos::END) {
+            HILOGE("Invalid whence from JS third argument");
+            return FsResult<int64_t>::Error(EINVAL);
+        }
+        whence = pos.value();
+    }
+
+    int64_t ret = ::Lseek(fd, offset, whence);
+    if (ret < 0) {
+        HILOGE("Failed to lseek, error:%{public}d", errno);
+        return FsResult<int64_t>::Error(errno);
+    }
+
+    return FsResult<int64_t>::Success(ret);
+}
+
+} // ModuleFileIO
+} // FileManagement
+} // OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/lseek_core.h b/interfaces/kits/js/src/mod_fs/properties/lseek_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd399f652e37dbe23edc17b24be32b74d1f19536
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/lseek_core.h
@@ -0,0 +1,33 @@
+/*
+ * 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_KITS_JS_SRC_MOD_FS_PROPERTIES_LSEEK_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_LSEEK_CORE_H
+
+#include "filemgmt_libfs.h"
+#include "rust_file.h"
+
+namespace OHOS::FileManagement::ModuleFileIO {
+using namespace std;
+
+class LseekCore final {
+public:
+    static FsResult<int64_t> DoLseek(const int32_t &fd, const int64_t &offset,
+                                     const optional<SeekPos> &pos = nullopt);
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_LSEEK_CORE_H
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/fdatasync_core_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/fdatasync_core_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6308de5056abc61308bd14e74bd42bec19f3003
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/fdatasync_core_mock_test.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <filesystem>
+#include <fstream>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "fdatasync_core.h"
+#include "mock/uv_fs_mock.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class FDataSyncCoreMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static inline shared_ptr<UvfsMock> uvMock = nullptr;
+};
+
+void FDataSyncCoreMockTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+    uvMock = std::make_shared<UvfsMock>();
+    Uvfs::ins = uvMock;
+}
+
+void FDataSyncCoreMockTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+    Uvfs::ins = nullptr;
+    uvMock = nullptr;
+}
+
+void FDataSyncCoreMockTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FDataSyncCoreMockTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FDataSyncCoreMockTest_DoFDataSync_001
+ * @tc.desc: Test function of FDataSyncCore::DoFDataSync interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FDataSyncCoreMockTest, FDataSyncCoreMockTest_DoFDataSync_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FDataSyncCoreMockTest-begin FDataSyncCoreMockTest_DoFDataSync_001";
+
+    int fd = 3;
+
+    EXPECT_CALL(*uvMock, uv_fs_fdatasync(_, _, _, _)).WillOnce(Return(1));
+    auto res = FDataSyncCore::DoFDataSync(fd);
+    EXPECT_EQ(res.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FDataSyncCoreMockTest-end FDataSyncCoreMockTest_DoFDataSync_001";
+}
+
+/**
+ * @tc.name: FDataSyncCoreMockTest_DoFDataSync_002
+ * @tc.desc: Test function of FDataSyncCore::DoFDataSync interface for FAILED.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FDataSyncCoreMockTest, FDataSyncCoreMockTest_DoFDataSync_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FDataSyncCoreMockTest-begin FDataSyncCoreMockTest_DoFDataSync_002";
+
+    int fd = 3;
+
+    EXPECT_CALL(*uvMock, uv_fs_fdatasync(_, _, _, _)).WillOnce(Return(-1));
+    auto res = FDataSyncCore::DoFDataSync(fd);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FDataSyncCoreMockTest-end FDataSyncCoreMockTest_DoFDataSync_002";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/fdopen_stream_core_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/fdopen_stream_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3be0e56b9b560f55c53083aaf55ec9f77370aa8
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/fdopen_stream_core_test.cpp
@@ -0,0 +1,117 @@
+/*
+* Copyright (c) 2025 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+#include "fdopen_stream_core.h"
+
+#define FDOPEN_STREAM_FILE_PATH "/data/test/FdopenStreamCoreTest.txt"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+class FdopenStreamCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        int32_t fd = open(FDOPEN_STREAM_FILE_PATH, CREATE | O_RDWR, 0644);
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        rmdir(FDOPEN_STREAM_FILE_PATH);
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+* @tc.name: DoFdopenStreamTest_0001
+* @tc.desc: Test function of DoFdopenStream() interface for success.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(FdopenStreamCoreTest, DoFdopenStreamTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin DoFdopenStreamTest_0001";
+    int32_t fd = open(FDOPEN_STREAM_FILE_PATH, O_RDWR);
+    if (fd <= 0) {
+        close(fd);
+        ASSERT_TRUE(false);
+    }
+
+    auto ret = FdopenStreamCore::DoFdopenStream(fd, "r");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    auto stream = ret.GetData().value();
+    ASSERT_NE(stream, nullptr);
+    auto retClose = stream->Close();
+    EXPECT_TRUE(retClose.IsSuccess());
+
+    close(fd);
+
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-end DoFdopenStreamTest_0001";
+}
+
+/**
+* @tc.name: DoFdopenStreamTest_0002
+* @tc.desc: Test function of DoFdopenStream() interface for fd < 0.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(FdopenStreamCoreTest, DoFdopenStreamTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin DoFdopenStreamTest_0002";
+    auto ret = FdopenStreamCore::DoFdopenStream(-1, "r");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-end DoFdopenStreamTest_0002";
+}
+
+/**
+* @tc.name: DoFdopenStreamTest_0003
+* @tc.desc: Test function of DoFdopenStream() interface for fail.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(FdopenStreamCoreTest, DoFdopenStreamTest_0003, testing::ext::TestSize.Level1)
+{
+    int32_t fd = open(FDOPEN_STREAM_FILE_PATH, O_RDWR);
+    if (fd <= 0) {
+        close(fd);
+        ASSERT_TRUE(false);
+    }
+
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-begin DoFdopenStreamTest_0003";
+    auto ret = FdopenStreamCore::DoFdopenStream(fd, "sssssss");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    close(fd);
+
+    GTEST_LOG_(INFO) << "FdopenStreamCoreTest-end DoFdopenStreamTest_0003";
+}
+
+}
+}
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/fsync_core_mock_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/fsync_core_mock_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..688a5bca0c7b09d532602dee84d177ab87dc8008
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/fsync_core_mock_test.cpp
@@ -0,0 +1,98 @@
+/*
+ * 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 "fsync_core.h"
+#include "uv_fs_mock.h"
+
+#include <gtest/gtest.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class FsyncCoreMockTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static inline shared_ptr<UvfsMock>  uvfs = nullptr;
+};
+
+void FsyncCoreMockTest::SetUpTestCase(void)
+{
+    uvfs = std::make_shared<UvfsMock>();
+    Uvfs::ins = uvfs;
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void FsyncCoreMockTest::TearDownTestCase(void)
+{
+    Uvfs::ins = nullptr;
+    uvfs = nullptr;
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void FsyncCoreMockTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FsyncCoreMockTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsyncCoreMockTest_DoFsync_001
+ * @tc.desc: Test function of RenameCore::DoFsync interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsyncCoreMockTest, FsyncCoreMockTest_DoFsync_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsyncCoreMockTest-begin FsyncCoreMockTest_DoFsync_001";
+
+    EXPECT_CALL(*uvfs, uv_fs_fsync(_, _, _, _)).WillOnce(Return(-1));
+
+    auto res = FsyncCore::DoFsync(1);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "FsyncCoreMockTest-end FsyncCoreMockTest_DoFsync_001";
+}
+
+/**
+ * @tc.name: FsyncCoreMockTest_DoFsync_002
+ * @tc.desc: Test function of RenameCore::DoFsync interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsyncCoreMockTest, FsyncCoreMockTest_DoFsync_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsyncCoreMockTest-begin FsyncCoreMockTest_DoFsync_002";
+
+    EXPECT_CALL(*uvfs, uv_fs_fsync(_, _, _, _)).WillOnce(Return(1));
+
+    auto res = FsyncCore::DoFsync(1);
+    EXPECT_EQ(res.IsSuccess(), true);
+
+    GTEST_LOG_(INFO) << "FsyncCoreMockTest-end FsyncCoreMockTest_DoFsync_002";
+}
+
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/properties/listfile_core_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/listfile_core_test.cpp
index dbea771a41d6ea5c05ff61771b6489d5fe07886d..64387d5b4e1e2e4fbf68f9cf9fbeb8455c4b5e00 100644
--- a/interfaces/test/unittest/js/mod_fs/properties/listfile_core_test.cpp
+++ b/interfaces/test/unittest/js/mod_fs/properties/listfile_core_test.cpp
@@ -90,7 +90,6 @@ public:
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0001, testing::ext::TestSize.Level1)
 {
@@ -117,7 +116,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0001, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0002, testing::ext::TestSize.Level1)
 {
@@ -144,7 +142,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0002, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0003, testing::ext::TestSize.Level1)
 {
@@ -167,7 +164,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0003, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0004, testing::ext::TestSize.Level1)
 {
@@ -195,7 +191,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0004, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0005, testing::ext::TestSize.Level1)
 {
@@ -223,7 +218,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0005, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0006, testing::ext::TestSize.Level1)
 {
@@ -251,7 +245,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0006, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0007, testing::ext::TestSize.Level1)
 {
@@ -278,7 +271,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0007, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0008, testing::ext::TestSize.Level1)
 {
@@ -305,7 +297,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0008, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0009, testing::ext::TestSize.Level1)
 {
@@ -330,7 +321,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0009, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0010, testing::ext::TestSize.Level1)
 {
@@ -355,7 +345,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0010, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0011, testing::ext::TestSize.Level1)
 {
@@ -379,7 +368,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0011, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0012, testing::ext::TestSize.Level1)
 {
@@ -399,7 +387,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0012, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0013, testing::ext::TestSize.Level1)
 {
@@ -422,7 +409,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0013, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0014, testing::ext::TestSize.Level1)
 {
@@ -442,7 +428,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0014, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0015, testing::ext::TestSize.Level1)
 {
@@ -476,7 +461,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0015, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0016, testing::ext::TestSize.Level1)
 {
@@ -503,7 +487,6 @@ HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0016, testing::ext::TestSize.Level
 * @tc.size: MEDIUM
 * @tc.type: FUNC
 * @tc.level Level 1
-* @tc.require: AR000IGDNF
 */
 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0017, testing::ext::TestSize.Level1)
 {
diff --git a/interfaces/test/unittest/js/mod_fs/properties/lseek_core_test.cpp b/interfaces/test/unittest/js/mod_fs/properties/lseek_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f5bd78bb77018d123fb886b8ee6120119131e892
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/properties/lseek_core_test.cpp
@@ -0,0 +1,115 @@
+/*
+ * 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 "lseek_core.h"
+
+#include <gtest/gtest.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class LseekCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void LseekCoreTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void LseekCoreTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void LseekCoreTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void LseekCoreTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: LseekCoreTest_DoLseek_001
+ * @tc.desc: Test function of LseekCore::DoLseek interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(LseekCoreTest, LseekCoreTest_DoLseek_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "LseekCoreTest-begin LseekCoreTest_DoLseek_001";
+
+    int32_t fd = -1;
+    int64_t offset = 0;
+
+    auto res = LseekCore::DoLseek(fd, offset);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "LseekCoreTest-end LseekCoreTest_DoLseek_001";
+}
+
+/**
+ * @tc.name: LseekCoreTest_DoLseek_002
+ * @tc.desc: Test function of LseekCore::DoLseek interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(LseekCoreTest, LseekCoreTest_DoLseek_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "LseekCoreTest-begin LseekCoreTest_DoLseek_002";
+
+    int32_t fd = 1;
+    int64_t offset = 0;
+    optional<SeekPos> pos = std::make_optional(static_cast<SeekPos>(-1));
+
+    auto res = LseekCore::DoLseek(fd, offset, pos);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "LseekCoreTest-end LseekCoreTest_DoLseek_002";
+}
+
+/**
+ * @tc.name: LseekCoreTest_DoLseek_003
+ * @tc.desc: Test function of LseekCore::DoLseek interface for FALSE.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(LseekCoreTest, LseekCoreTest_DoLseek_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "LseekCoreTest-begin LseekCoreTest_DoLseek_003";
+
+    int32_t fd = 1;
+    int64_t offset = 0;
+    optional<SeekPos> pos = std::make_optional(SeekPos::CURRENT);
+
+    auto res = LseekCore::DoLseek(fd, offset, pos);
+    EXPECT_EQ(res.IsSuccess(), false);
+
+    GTEST_LOG_(INFO) << "LseekCoreTest-end LseekCoreTest_DoLseek_003";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file