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..d92dd44d0dfc5d401388fc84b6a46ed1be677485 100644
--- a/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
+++ b/interfaces/kits/js/src/common/ani_helper/ani_signature.cpp
@@ -111,6 +111,7 @@ const string FS::StreamInner::ctorSig = Builder::BuildSignatureDescriptor({ Basi
 const Type FS::TaskSignal::classType = Builder::BuildClass("@ohos.file.fs.fileIo.TaskSignal");
 const string FS::TaskSignal::classDesc = FS::TaskSignal::classType.Descriptor();
 const string FS::TaskSignal::ctorSig = Builder::BuildSignatureDescriptor({ BasicTypes::longType });
+const string FS::TaskSignal::nativeTaskSignal = "nativeTaskSignal";
 // FS::WatcherInner
 const Type FS::WatcherInner::classType = Builder::BuildClass("@ohos.file.fs.fileIo.WatcherInner");
 const string FS::WatcherInner::classDesc = FS::WatcherInner::classType.Descriptor();
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..122459794de9f7b69c53e3b8ec62eda521c3c609 100644
--- a/interfaces/kits/js/src/common/ani_helper/ani_signature.h
+++ b/interfaces/kits/js/src/common/ani_helper/ani_signature.h
@@ -183,6 +183,7 @@ struct TaskSignal : public BaseType {
     static const Type classType;
     static const string classDesc;
     static const string ctorSig;
+    static const string nativeTaskSignal;
 };
 
 struct WatcherInner : public BaseType {
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.cpp b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ac364b3572155a9c64cdca95ba822ea8d1d6b8b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.cpp
@@ -0,0 +1,72 @@
+/*
+ * 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 "task_signal_ani.h"
+
+#include "ani_helper.h"
+#include "copy_core.h"
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "fs_task_signal.h"
+#include "task_signal_wrapper.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+void TaskSignalAni::Cancel(ani_env *env, [[maybe_unused]] ani_object object)
+{
+    FsTaskSignal *copySignal = TaskSignalWrapper::Unwrap(env, object);
+    if (copySignal == nullptr) {
+        HILOGE("Cannot unwrap copySignal!");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto ret = copySignal->Cancel();
+    if (!ret.IsSuccess()) {
+        HILOGE("Cannot Cancel!");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return;
+    }
+}
+
+void TaskSignalAni::OnCancel(ani_env *env, [[maybe_unused]] ani_object object)
+{
+    FsTaskSignal *copySignal = TaskSignalWrapper::Unwrap(env, object);
+    if (copySignal == nullptr) {
+        HILOGE("Cannot unwrap copySignal!");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto ret = copySignal->OnCancel();
+    if (!ret.IsSuccess()) {
+        HILOGE("Cannot Cancel!");
+        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/class_tasksignal/ani/task_signal_ani.h b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..d27e5253882fa7fae16a068317cf914a75a03202
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_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_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class TaskSignalAni final {
+public:
+    static void Cancel(ani_env *env, [[maybe_unused]] ani_object object);
+    static void OnCancel(ani_env *env, [[maybe_unused]] ani_object object);
+};
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.cpp b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5bb6daff863409042cf7df87f461d6149f5bd1e2
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.cpp
@@ -0,0 +1,65 @@
+/*
+ * 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 "task_signal_listener_ani.h"
+
+#include <memory>
+#include "ani_helper.h"
+#include "ani_signature.h"
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+#include "type_converter.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::ANI {
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
+
+void TaskSignalListenerAni::OnCancel()
+{
+    auto filepath = taskSignal->filePath_;
+    auto task = [this, filepath]() { SendCancelEvent(filepath); };
+    AniHelper::SendEventToMainThread(task);
+}
+
+void TaskSignalListenerAni::SendCancelEvent(const string &filepath) const
+{
+    if (vm == nullptr) {
+        HILOGE("Cannot send cancel event because the vm is null.");
+        return;
+    }
+    if (signalObj == nullptr) {
+        HILOGE("Cannot send cancel event because the signalObj is null.");
+        return;
+    }
+
+    ani_env *env = AniHelper::GetThreadEnv(vm);
+    if (env == nullptr) {
+        HILOGE("Cannot send cancel event because the env is null.");
+        return;
+    }
+    auto [succ, aniPath] = TypeConverter::ToAniString(env, filepath);
+    if (!succ) {
+        HILOGE("Cannot convert filepath to ani string!");
+        return;
+    }
+
+    auto ret = env->Object_CallMethodByName_Void(signalObj, "onCancelCallback", nullptr, aniPath);
+    if (ret != ANI_OK) {
+        HILOGE("Call onCancelCallback failed, err: %{public}d", ret);
+        return;
+    }
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::ANI
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.h b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae02a941eb6253816412bf12073cba68370c330b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 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_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_LISTENER_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_LISTENER_ANI_H
+
+#include <ani.h>
+#include "task_signal_listener.h"
+#include "task_signal.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::ANI {
+using namespace DistributedFS::ModuleTaskSignal;
+
+class TaskSignalListenerAni : public TaskSignalListener {
+public:
+    TaskSignalListenerAni(ani_vm *vm, const ani_object &signalObj, std::shared_ptr<TaskSignal> taskSignal)
+        : vm(vm), signalObj(signalObj), taskSignal(taskSignal) {}
+    void OnCancel() override;
+
+public:
+    TaskSignalListenerAni() = default;
+    ~TaskSignalListenerAni() = default;
+
+private:
+    void SendCancelEvent(const std::string &filepath) const;
+
+private:
+    ani_vm *vm;
+    ani_object signalObj;
+    std::shared_ptr<TaskSignal> taskSignal;
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO::ANI
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_LISTENER_ANI_H
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cc30854185643a69979ee7c5622da78b32963e60
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp
@@ -0,0 +1,71 @@
+/*
+ * 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 "task_signal_wrapper.h"
+
+#include "ani_signature.h"
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "fs_task_signal.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
+
+FsTaskSignal *TaskSignalWrapper::Unwrap(ani_env *env, ani_object object)
+{
+    ani_long nativePtr;
+    auto status = env->Object_GetFieldByName_Long(object, FS::TaskSignal::nativeTaskSignal, &nativePtr);
+    if (status != ANI_OK) {
+        HILOGE("Unwrap taskSignal obj failed! status: %{public}d", status);
+        return nullptr;
+    }
+    uintptr_t ptrValue = static_cast<uintptr_t>(nativePtr);
+    FsTaskSignal *copySignal = reinterpret_cast<FsTaskSignal *>(ptrValue);
+    return copySignal;
+}
+
+bool TaskSignalWrapper::Wrap(ani_env *env, ani_object object, const FsTaskSignal *signal)
+{
+    if (object == nullptr) {
+        HILOGE("TaskSignal obj is null!");
+        return false;
+    }
+
+    if (signal == nullptr) {
+        HILOGE("FsTaskSignal pointer is null!");
+        return false;
+    }
+
+    ani_long ptr = static_cast<ani_long>(reinterpret_cast<std::uintptr_t>(signal));
+
+    auto status = env->Object_SetFieldByName_Long(object, FS::TaskSignal::nativeTaskSignal, ptr);
+    if (status != ANI_OK) {
+        HILOGE("Wrap taskSignal obj failed! status: %{public}d", status);
+        return false;
+    }
+
+    return true;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.h b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..4fe9fb143277d646d0823d2234785d59d43beb89
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.h
@@ -0,0 +1,37 @@
+/*
+ * 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_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_WRAPPER_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_WRAPPER_H
+
+#include <ani.h>
+#include "fs_task_signal.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class TaskSignalWrapper final {
+public:
+    static FsTaskSignal *Unwrap(ani_env *env, ani_object object);
+    static bool Wrap(ani_env *env, ani_object object, const FsTaskSignal *signal);
+};
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_ANI_TASK_SIGNAL_WRAPPER_H
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.cpp b/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..76bf8cd8700dafbc31b9abb6be22bf832ab0ec03
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.cpp
@@ -0,0 +1,80 @@
+/*
+ * 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_task_signal.h"
+
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+#include "fs_utils.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+FsResult<shared_ptr<FsTaskSignal>> FsTaskSignal::Constructor(
+    shared_ptr<TaskSignal> taskSignal, shared_ptr<TaskSignalListener> signalListener)
+{
+    if (!taskSignal) {
+        HILOGE("Invalid taskSignal");
+        return FsResult<shared_ptr<FsTaskSignal>>::Error(EINVAL);
+    }
+    if (!signalListener) {
+        HILOGE("Invalid signalListener");
+        return FsResult<shared_ptr<FsTaskSignal>>::Error(EINVAL);
+    }
+    auto copySignal = CreateSharedPtr<FsTaskSignal>();
+    if (copySignal == nullptr) {
+        HILOGE("Failed to request heap memory.");
+        return FsResult<shared_ptr<FsTaskSignal>>::Error(ENOMEM);
+    }
+    copySignal->taskSignal_ = move(taskSignal);
+    copySignal->signalListener_ = move(signalListener);
+    return FsResult<shared_ptr<FsTaskSignal>>::Success(copySignal);
+}
+
+FsResult<void> FsTaskSignal::Cancel()
+{
+    if (taskSignal_ == nullptr) {
+        HILOGE("Failed to get taskSignal");
+        return FsResult<void>::Error(EINVAL);
+    }
+
+    auto ret = taskSignal_->Cancel();
+    if (ret != ERRNO_NOERR) {
+        HILOGE("Failed to cancel the task.");
+        return FsResult<void>::Error(CANCEL_ERR);
+    }
+    return FsResult<void>::Success();
+}
+
+FsResult<void> FsTaskSignal::OnCancel()
+{
+    if (taskSignal_ == nullptr) {
+        HILOGE("Failed to get taskSignal");
+        return FsResult<void>::Error(EINVAL);
+    }
+    taskSignal_->SetTaskSignalListener(signalListener_.get());
+    return FsResult<void>::Success();
+}
+
+shared_ptr<TaskSignal> FsTaskSignal::GetTaskSignal() const
+{
+    return taskSignal_;
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.h b/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.h
new file mode 100644
index 0000000000000000000000000000000000000000..33161108c3b9c231d61d346682654c80fc97094d
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.h
@@ -0,0 +1,50 @@
+/*
+ * 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_CLASS_TASKSIGNAL_FS_TASK_SIGNAL_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_FS_TASK_SIGNAL_H
+
+#include "filemgmt_libfs.h"
+#include "task_signal.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+using namespace DistributedFS::ModuleTaskSignal;
+
+class FsTaskSignal {
+public:
+    static FsResult<shared_ptr<FsTaskSignal>> Constructor(
+        shared_ptr<TaskSignal> taskSignal, shared_ptr<TaskSignalListener> signalListener);
+    FsResult<void> Cancel();
+    FsResult<void> OnCancel();
+    shared_ptr<TaskSignal> GetTaskSignal() const;
+
+public:
+    FsTaskSignal() = default;
+    ~FsTaskSignal() = default;
+    FsTaskSignal(const FsTaskSignal &other) = delete;
+    FsTaskSignal &operator=(const FsTaskSignal &other) = delete;
+
+private:
+    shared_ptr<TaskSignal> taskSignal_ = nullptr;
+    shared_ptr<TaskSignalListener> signalListener_ = nullptr;
+};
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_TASKSIGNAL_FS_TASK_SIGNAL_H
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp b/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af24659388db3e4564c83fc33ac5b32b9768e444
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp
@@ -0,0 +1,367 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <filesystem>
+#include <fstream>
+
+#include <gtest/gtest.h>
+#include "fs_atomicfile.h"
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace std;
+namespace fs = std::filesystem;
+
+string g_filePath = "/data/test/FsAtomicfileTest.txt";
+string g_deleteFile = "/data/test/FsAtomicfileDelTest.txt";
+
+class FsAtomicfileTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void FsAtomicfileTest::SetUpTestCase(void)
+{
+    ofstream tempfile(g_filePath);
+    tempfile << "hello world";
+    tempfile.close();
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void FsAtomicfileTest::TearDownTestCase(void)
+{
+    filesystem::remove(g_filePath);
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void FsAtomicfileTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FsAtomicfileTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetPath_001
+ * @tc.desc: Test function of FsAtomicFile::GetPath interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetPath_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetPath_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    string path = stream->GetPath();
+    EXPECT_EQ(path, g_filePath);
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetPath_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_001
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_TRUE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_002
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for path > PATH_MAX.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_002";
+
+    size_t largeLength = static_cast<size_t>(PATH_MAX) + 1;
+    char text = 'a';
+    string largeString(largeLength, text);
+
+    auto ret = FsAtomicFile::Constructor(largeString);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_002";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_003
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for failed realpath.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_003";
+
+    string path = "FsAtomicfileTest_GetBaseFile_003_aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_003";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_GetBaseFile_004
+ * @tc.desc: Test function of FsAtomicFile::GetBaseFile interface for failed open.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_004";
+
+    string path = "/data/test/FsAtomicfileTest_GetBaseFile_004_aaaaaaaaaa.txt";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->GetBaseFile();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_GetBaseFile_004";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_StartWrite_001
+ * @tc.desc: Test function of FsAtomicFile::StartWrite interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    EXPECT_TRUE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_StartWrite_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_StartWrite_002
+ * @tc.desc: Test function of FsAtomicFile::StartWrite interface for no parent dir.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_002";
+
+    string path = "/data/local/tmp/test/test/test/FsAtomicfileTest_StartWrite_002_test.txt";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_StartWrite_002";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_StartWrite_003
+ * @tc.desc: Test function of FsAtomicFile::StartWrite interface for no permission.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_003";
+
+    string path = "/sys/kernel/address_bits";
+
+    auto ret = FsAtomicFile::Constructor(path);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    EXPECT_FALSE(retFl.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_StartWrite_003";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_FinishWrite_001
+ * @tc.desc: Test function of FsAtomicFile::FinishWrite interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_FinishWrite_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_FinishWrite_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    ASSERT_TRUE(retFl.IsSuccess());
+    string newPath = retFl.GetData().value();
+    ofstream tempfile(newPath);
+    tempfile << "hello world";
+    tempfile.close();
+
+    auto retFW = stream->FinishWrite();
+    EXPECT_TRUE(retFW.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_FinishWrite_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_FailWrite_001
+ * @tc.desc: Test function of FsAtomicFile::FailWrite interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_FailWrite_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_FailWrite_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    ASSERT_TRUE(retFl.IsSuccess());
+    string newPath = retFl.GetData().value();
+    ofstream tempfile(newPath);
+    tempfile << "hello world";
+    tempfile.close();
+
+    auto retFW = stream->FailWrite();
+    EXPECT_TRUE(retFW.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_FailWrite_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_Delete_001
+ * @tc.desc: Test function of FsAtomicFile::Delete interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_Delete_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_Delete_001";
+
+    auto ret = FsAtomicFile::Constructor(g_deleteFile);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto retFl = stream->StartWrite();
+    ASSERT_TRUE(retFl.IsSuccess());
+    string newPath = retFl.GetData().value();
+    ofstream tempfile(newPath);
+    tempfile << "hello world";
+    tempfile.close();
+
+    auto retFW = stream->Delete();
+    EXPECT_TRUE(retFW.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_Delete_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_ReadFully_001
+ * @tc.desc: Test function of FsAtomicFile::ReadFully interface for succ.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_ReadFully_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_ReadFully_001";
+
+    auto ret = FsAtomicFile::Constructor(g_filePath);
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto result = stream->ReadFully();
+    ASSERT_TRUE(result.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_ReadFully_001";
+}
+
+/**
+ * @tc.name: FsAtomicfileTest_ReadFully_002
+ * @tc.desc: Test function of FsAtomicFile::ReadFully interface for valied path.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_ReadFully_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_ReadFully_002";
+
+    auto ret = FsAtomicFile::Constructor("aaaaaaaaaaaaaaaa");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    shared_ptr<FsAtomicFile> stream(move(ret.GetData().value()));
+    auto result = stream->ReadFully();
+    ASSERT_FALSE(result.IsSuccess());
+
+    GTEST_LOG_(INFO) << "FsAtomicfileTest-end FsAtomicfileTest_ReadFully_002";
+}
+
+} // namespace OHOS::FileManagement::ModuleFileIO::Test
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_fs/class_tasksignal/fs_task_signal_test.cpp b/interfaces/test/unittest/js/mod_fs/class_tasksignal/fs_task_signal_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9232047719e98ae16cfdc85d49986ca6fbe28e9c
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_fs/class_tasksignal/fs_task_signal_test.cpp
@@ -0,0 +1,202 @@
+/*
+ * 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_task_signal.h"
+
+#include <gtest/gtest.h>
+
+namespace OHOS::FileManagement::ModuleFileIO::Test {
+using namespace testing;
+using namespace testing::ext;
+using namespace std;
+
+class Assistant : public TaskSignalListener {
+public:
+    void OnCancel() {}
+};
+
+class FsTaskSignalTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void FsTaskSignalTest::SetUpTestCase(void)
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase";
+}
+
+void FsTaskSignalTest::TearDownTestCase(void)
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase";
+}
+
+void FsTaskSignalTest::SetUp(void)
+{
+    GTEST_LOG_(INFO) << "SetUp";
+}
+
+void FsTaskSignalTest::TearDown(void)
+{
+    GTEST_LOG_(INFO) << "TearDown";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_Constructor_001
+ * @tc.desc: Test function of FsTaskSignal::Constructor interface for False.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_Constructor_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_Constructor_001";
+
+    FsTaskSignal fsTaskSignal;
+    shared_ptr<TaskSignal> taskSignal = nullptr;
+    shared_ptr<TaskSignalListener> signalListener = nullptr;
+
+    auto res = fsTaskSignal.Constructor(taskSignal, signalListener);
+
+    EXPECT_EQ(taskSignal, nullptr);
+    EXPECT_EQ(res.IsSuccess(), false);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_Constructor_001";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_Constructor_002
+ * @tc.desc: Test function of FsTaskSignal::Constructor interface for False.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_Constructor_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_Constructor_002";
+
+    FsTaskSignal fsTaskSignal;
+    shared_ptr<TaskSignal> taskSignal = std::make_shared<TaskSignal>();
+    shared_ptr<TaskSignalListener> signalListener = nullptr;
+
+    auto res = fsTaskSignal.Constructor(taskSignal, signalListener);
+
+    EXPECT_NE(taskSignal, nullptr);
+    EXPECT_EQ(res.IsSuccess(), false);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_Constructor_002";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_Constructor_003
+ * @tc.desc: Test function of FsTaskSignal::Constructor interface for True.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_Constructor_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_Constructor_003";
+
+    FsTaskSignal fsTaskSignal;
+    shared_ptr<TaskSignal> taskSignal = std::make_shared<TaskSignal>();
+    shared_ptr<TaskSignalListener> signalListener = std::make_shared<Assistant>();
+
+    auto res = fsTaskSignal.Constructor(taskSignal, signalListener);
+
+    EXPECT_NE(signalListener, nullptr);
+    EXPECT_EQ(res.IsSuccess(), true);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_Constructor_003";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_Cancel_001
+ * @tc.desc: Test function of FsTaskSignal::Cancel interface for False.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_Cancel_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_Cancel_001";
+
+    FsTaskSignal fsTaskSignal;
+
+    auto res = fsTaskSignal.Cancel();
+
+    EXPECT_EQ(fsTaskSignal.taskSignal_, nullptr);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_Cancel_001";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_Cancel_002
+ * @tc.desc: Test function of FsTaskSignal::Cancel interface for False.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_Cancel_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_Cancel_002";
+
+    FsTaskSignal fsTaskSignal;
+    fsTaskSignal.taskSignal_ = std::make_shared<TaskSignal>();
+
+    auto res = fsTaskSignal.Cancel();
+
+    EXPECT_NE(fsTaskSignal.taskSignal_, nullptr);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_Cancel_002";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_OnCancel_001
+ * @tc.desc: Test function of FsTaskSignal::OnCancel interface for False.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_OnCancel_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_OnCancel_001";
+
+    FsTaskSignal fsTaskSignal;
+
+    auto res = fsTaskSignal.OnCancel();
+
+    EXPECT_EQ(fsTaskSignal.taskSignal_, nullptr);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_OnCancel_001";
+}
+
+/**
+ * @tc.name: FsTaskSignalTest_OnCancel_002
+ * @tc.desc: Test function of FsTaskSignal::OnCancel interface for False.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ */
+HWTEST_F(FsTaskSignalTest, FsTaskSignalTest_OnCancel_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NClassTest-begin FsTaskSignalTest_OnCancel_002";
+
+    FsTaskSignal fsTaskSignal;
+    fsTaskSignal.taskSignal_ = std::make_shared<TaskSignal>();
+
+    auto res = fsTaskSignal.OnCancel();
+
+    EXPECT_NE(fsTaskSignal.taskSignal_, nullptr);
+    GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_OnCancel_002";
+}
+
+} // OHOS::FileManagement::ModuleFileIO::Test