From fb1c1cefb668c07fe101aa1041f10ccc1b761d7a Mon Sep 17 00:00:00 2001 From: liyuke Date: Sat, 26 Jul 2025 14:22:35 +0800 Subject: [PATCH 1/2] tasksignal Signed-off-by: liyuke Change-Id: I8b85955f60170338f283373a5ed2a4d604e01482 --- .../class_tasksignal/ani/task_signal_ani.cpp | 70 +++ .../class_tasksignal/ani/task_signal_ani.h | 36 ++ .../ani/task_signal_listener_ani.cpp | 63 +++ .../ani/task_signal_listener_ani.h | 47 ++ .../ani/task_signal_wrapper.cpp | 71 +++ .../ani/task_signal_wrapper.h | 37 ++ .../class_tasksignal/fs_task_signal.cpp | 79 +++ .../mod_fs/class_tasksignal/fs_task_signal.h | 50 ++ .../class_atomicfile/fs_atomicfile_test.cpp | 366 ++++++++++++++ .../class_tasksignal/fs_task_signal_test.cpp | 202 ++++++++ .../unittest/task_signal/task_signal_test.cpp | 451 ++++++++++++++---- 11 files changed, 1387 insertions(+), 85 deletions(-) create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.cpp create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.h create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.cpp create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_ani.h create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.cpp create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_wrapper.h create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.cpp create mode 100644 interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.h create mode 100644 interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp create mode 100644 interfaces/test/unittest/js/mod_fs/class_tasksignal/fs_task_signal_test.cpp 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 000000000..2b1229a69 --- /dev/null +++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_ani.cpp @@ -0,0 +1,70 @@ +/* + * 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 000000000..d27e52538 --- /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 + +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 000000000..8f533889c --- /dev/null +++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/ani/task_signal_listener_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 "task_signal_listener_ani.h" + +#include +#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 000000000..ae02a941e --- /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 +#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) + : 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; +}; + +} // 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 000000000..79be64231 --- /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, "nativeTaskSignal", &nativePtr); + if (status != ANI_OK) { + HILOGE("Unwrap taskSignal obj failed! status: %{public}d", status); + return nullptr; + } + uintptr_t ptrValue = static_cast(nativePtr); + FsTaskSignal *copySignal = reinterpret_cast(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(reinterpret_cast(signal)); + + auto status = env->Object_SetFieldByName_Long(object, "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 000000000..4fe9fb143 --- /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 +#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 000000000..d9b4b6ffe --- /dev/null +++ b/interfaces/kits/js/src/mod_fs/class_tasksignal/fs_task_signal.cpp @@ -0,0 +1,79 @@ +/* + * 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> FsTaskSignal::Constructor( + shared_ptr taskSignal, shared_ptr signalListener) +{ + if (!taskSignal) { + HILOGE("Invalid taskSignal"); + return FsResult>::Error(EINVAL); + } + if (!signalListener) { + HILOGE("Invalid signalListener"); + return FsResult>::Error(EINVAL); + } + auto copySignal = CreateSharedPtr(); + if (copySignal == nullptr) { + HILOGE("Failed to request heap memory."); + return FsResult>::Error(ENOMEM); + } + copySignal->taskSignal_ = move(taskSignal); + copySignal->signalListener_ = move(signalListener); + return FsResult>::Success(copySignal); +} + +FsResult FsTaskSignal::Cancel() +{ + if (taskSignal_ == nullptr) { + HILOGE("Failed to get taskSignal"); + return FsResult::Error(EINVAL); + } + auto ret = taskSignal_->Cancel(); + if (ret != ERRNO_NOERR) { + HILOGE("Failed to cancel the task."); + return FsResult::Error(CANCEL_ERR); + } + return FsResult::Success(); +} + +FsResult FsTaskSignal::OnCancel() +{ + if (taskSignal_ == nullptr) { + HILOGE("Failed to get taskSignal"); + return FsResult::Error(EINVAL); + } + taskSignal_->SetTaskSignalListener(signalListener_.get()); + return FsResult::Success(); +} + +shared_ptr 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 000000000..33161108c --- /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> Constructor( + shared_ptr taskSignal, shared_ptr signalListener); + FsResult Cancel(); + FsResult OnCancel(); + shared_ptr GetTaskSignal() const; + +public: + FsTaskSignal() = default; + ~FsTaskSignal() = default; + FsTaskSignal(const FsTaskSignal &other) = delete; + FsTaskSignal &operator=(const FsTaskSignal &other) = delete; + +private: + shared_ptr taskSignal_ = nullptr; + shared_ptr 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 000000000..f506c732f --- /dev/null +++ b/interfaces/test/unittest/js/mod_fs/class_atomicfile/fs_atomicfile_test.cpp @@ -0,0 +1,366 @@ +/* + * 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 +#include + +#include +#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 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 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(PATH_MAX) + 1; + string largeString(largeLength, 'a'); + + auto ret = FsAtomicFile::Constructor(largeString); + ASSERT_TRUE(ret.IsSuccess()); + + shared_ptr 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 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + + auto ret = FsAtomicFile::Constructor(path); + ASSERT_TRUE(ret.IsSuccess()); + + shared_ptr 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/aaaaaaaaaa.txt"; + + auto ret = FsAtomicFile::Constructor(path); + ASSERT_TRUE(ret.IsSuccess()); + + shared_ptr 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 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/test.txt"; + + auto ret = FsAtomicFile::Constructor(path); + ASSERT_TRUE(ret.IsSuccess()); + + shared_ptr 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 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 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 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 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 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 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 000000000..923204771 --- /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 + +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 = nullptr; + shared_ptr 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 = std::make_shared(); + shared_ptr 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 = std::make_shared(); + shared_ptr signalListener = std::make_shared(); + + 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(); + + 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(); + + auto res = fsTaskSignal.OnCancel(); + + EXPECT_NE(fsTaskSignal.taskSignal_, nullptr); + GTEST_LOG_(INFO) << "NClassTest-end FsTaskSignalTest_OnCancel_002"; +} + +} // OHOS::FileManagement::ModuleFileIO::Test diff --git a/interfaces/test/unittest/task_signal/task_signal_test.cpp b/interfaces/test/unittest/task_signal/task_signal_test.cpp index fad6cbfc2..18bbb12e4 100644 --- a/interfaces/test/unittest/task_signal/task_signal_test.cpp +++ b/interfaces/test/unittest/task_signal/task_signal_test.cpp @@ -1,10 +1,10 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 + * 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, @@ -13,146 +13,427 @@ * limitations under the License. */ -#include "task_signal.h" +#include -#include -#include +#include #include -#include +#include "distributed_file_daemon_manager.h" #include "filemgmt_libhilog.h" #include "task_signal_listener.h" +#include "task_signal.h" + +using namespace OHOS; +using namespace OHOS::Storage::DistributedFile; + +class MockDistributedFileDaemonManager : public DistributedFileDaemonManager { +public: + MOCK_METHOD(int32_t, CancelCopyTask, (const std::string &sessionName), (override)); + + int32_t OpenP2PConnection(const DistributedHardware::DmDeviceInfo &deviceInfo) override + { + return 0; + } + + int32_t CloseP2PConnection(const DistributedHardware::DmDeviceInfo &deviceInfo) override + { + return 0; + } + + int32_t OpenP2PConnectionEx(const std::string &networkId, sptr remoteReverseObj) override + { + return 0; + } + + int32_t CloseP2PConnectionEx(const std::string &networkId) override + { + return 0; + } + + int32_t PrepareSession(const std::string &srcUri, const std::string &dstUri, const std::string &srcDeviceId, + const sptr &listener, HmdfsInfo &info) override + { + return 0; + } + + int32_t PushAsset( + int32_t userId, const sptr &assetObj, const sptr &sendCallback) override + { + return 0; + } + + int32_t RegisterAssetCallback(const sptr &recvCallback) override + { + return 0; + } + + int32_t UnRegisterAssetCallback(const sptr &recvCallback) override + { + return 0; + } + + int32_t GetSize(const std::string &uri, bool isSrcUri, uint64_t &size) override + { + return 0; + } + + int32_t IsDirectory(const std::string &uri, bool isSrcUri, bool &isDirectory) override + { + return 0; + } + + int32_t Copy(const std::string &srcUri, const std::string &destUri, ProcessCallback processCallback) override + { + return 0; + } + + int32_t Cancel(const std::string &srcUri, const std::string &destUri) override + { + return 0; + } + + int32_t Cancel() override + { + return 0; + } + + static MockDistributedFileDaemonManager &GetInstance() + { + static MockDistributedFileDaemonManager instance; + return instance; + } +}; + +static MockDistributedFileDaemonManager &g_mockDistributedFileDaemonManager = + MockDistributedFileDaemonManager::GetInstance(); + +#ifdef ENABLE_DISTRIBUTED_FILE_MOCK +DistributedFileDaemonManager &DistributedFileDaemonManager::GetInstance() +{ + return MockDistributedFileDaemonManager::GetInstance(); +} +#endif + +class MockTaskSignalListener : public OHOS::DistributedFS::ModuleTaskSignal::TaskSignalListener { +public: + MOCK_METHOD(void, OnCancel, (), (override)); +}; namespace OHOS { namespace DistributedFS { +namespace ModuleTaskSignal { +namespace Test { using namespace std; using namespace OHOS::DistributedFS::ModuleTaskSignal; -using namespace FileManagement; class TaskSignalTest : public testing::Test { public: - static void SetUpTestCase(void){}; - static void TearDownTestCase(){}; - void SetUp(){}; - void TearDown(){}; - - static std::condition_variable taskListenerCv_; - static std::mutex taskListenerCallbackLock_; - static std::string canceledFilePath_; -}; + static void SetUpTestSuite(void) {} + static void TearDownTestSuite(void) {} -std::condition_variable TaskSignalTest::taskListenerCv_; -std::mutex TaskSignalTest::taskListenerCallbackLock_; -std::string TaskSignalTest::canceledFilePath_; + void SetUp() override + { + taskSignal_ = std::make_unique(); + } -class TaskSignalListenerTestImpl : public TaskSignalListener { -public: - ~TaskSignalListenerTestImpl() = default; - void OnCancel() + void TearDown() override { - string path = "aaa"; - TaskSignalTest::canceledFilePath_ = path; - TaskSignalTest::taskListenerCv_.notify_one(); - HILOGI("OnCancel in. path = %{public}s", path.c_str()); + taskSignal_.reset(); } + + MockDistributedFileDaemonManager &GetMock() + { + return g_mockDistributedFileDaemonManager; + } + +protected: + std::unique_ptr taskSignal_; }; /** - * @tc.name: Task_Signal_Cancel_0000 - * @tc.desc: Test function of Cancel() interface for SUCCESS. + * @tc.name: TaskSignalTest_Cancel_001 + * @tc.desc: Test function of TaskSignal::Cancel interface for SUCCESS when remoteTask_ is false. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_001"; + // Prepare test condition + taskSignal_->remoteTask_.store(false); + // Do testing + auto result = taskSignal_->Cancel(); + // Verify results + EXPECT_EQ(result, 0); + EXPECT_TRUE(taskSignal_->needCancel_.load()); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_001"; +} + +/** + * @tc.name: TaskSignalTest_Cancel_002 + * @tc.desc: Test function of TaskSignal::Cancel interface for SUCCESS when remoteTask_ is false. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_002"; + // Prepare test condition + taskSignal_->remoteTask_.store(true); + taskSignal_->sessionName_ = "TaskSignalTest_Cancel_002"; + // Set mock behaviors + int expectedCode = 0; + EXPECT_CALL(GetMock(), CancelCopyTask(testing::_)).WillOnce(testing::Return(expectedCode)); + // Do testing + auto result = taskSignal_->Cancel(); + // Verify results + EXPECT_EQ(result, 0); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_002"; +} + +/** + * @tc.name: TaskSignalTest_Cancel_003 + * @tc.desc: Test function of TaskSignal::Cancel interface for FAILURE when sessionName_ is empty. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 - * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, Task_Signal_Cancel_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_003, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_Cancel_0000"; - auto signal = std::make_shared(); - auto ret = signal->Cancel(); - EXPECT_TRUE(ret == 0); + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_003"; + // Prepare test parameters + taskSignal_->remoteTask_.store(true); + taskSignal_->sessionName_ = ""; + // Do testing + auto result = taskSignal_->Cancel(); + // Verify results + EXPECT_EQ(result, -3); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_003"; } /** - * @tc.name: Task_Signal_IsCancel_0000 - * @tc.desc: Test function of IsCanceled() interface + * @tc.name: TaskSignalTest_Cancel_004 + * @tc.desc: Test function of TaskSignal::Cancel interface for FAILURE when CancelCopyTask fails. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 - * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, Task_Signal_IsCancel_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_004, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_IsCancel_0000"; - auto signal = std::make_shared(); - auto isCanceled = signal->IsCanceled(); - EXPECT_TRUE(!isCanceled); - - auto ret = signal->Cancel(); - EXPECT_TRUE(ret == 0); - isCanceled = signal->IsCanceled(); - EXPECT_TRUE(isCanceled); + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_004"; + // Prepare test parameters + taskSignal_->remoteTask_.store(true); + taskSignal_->sessionName_ = "TaskSignalTest_Cancel_004"; + // Set mock behaviors + int expectedCode = -1; + EXPECT_CALL(GetMock(), CancelCopyTask(testing::_)).WillOnce(testing::Return(expectedCode)); + // Do testing + auto result = taskSignal_->Cancel(); + // Verify results + EXPECT_EQ(result, expectedCode); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_004"; } /** - * @tc.name: Task_Signal_SetTaskSignalListener_0000 - * @tc.desc: Test function of SetTaskSignalListener() interface for SUCCESS. + * @tc.name: TaskSignalTest_IsCanceled_001 + * @tc.desc: Test function of TaskSignal::IsCanceled interface for case when needCancel_ is true. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 - * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, Task_Signal_SetTaskSignalListener_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_001, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_SetTaskSignalListener_0000"; - std::unique_lock lock(TaskSignalTest::taskListenerCallbackLock_); - auto signal = std::make_shared(); - auto listener = std::make_shared(); - signal->SetTaskSignalListener(listener.get()); - std::string filePath = "aaa"; - listener->OnCancel(); - signal->CheckCancelIfNeed(filePath); - EXPECT_EQ(TaskSignalTest::canceledFilePath_, filePath); + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_IsCanceled_001"; + // Prepare test condition + taskSignal_->needCancel_.store(true); + // Do testing + bool result = taskSignal_->IsCanceled(); + // Verify results + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_IsCanceled_001"; } /** - * @tc.name: Task_Signal_MarkRemoteTask_0000 - * @tc.desc: Test function of MarkRemoteTask() and SetFileInfoOfRemoteTask() interface for SUCCESS. + * @tc.name: TaskSignalTest_IsCanceled_002 + * @tc.desc: Test function of TaskSignal::IsCanceled interface for case when remoteTask_ is true. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 - * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, Task_Signal_MarkRemoteTask_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_002, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_MarkRemoteTask_0000"; - auto signal = std::make_shared(); - signal->MarkRemoteTask(); - std::string sessionName = "DistributedDevice0"; - std::string filePath = "aaa"; - signal->SetFileInfoOfRemoteTask(sessionName, filePath); - auto ret = signal->Cancel(); - EXPECT_EQ(ret, 4); + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_IsCanceled_002"; + // Prepare test condition + taskSignal_->remoteTask_.store(true); + // Do testing + bool result = taskSignal_->IsCanceled(); + // Verify results + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_IsCanceled_002"; } /** - * @tc.name: Task_Signal_MarkDfsTask_0000 - * @tc.desc: Test function of MarkDfsTask() interface for SUCCESS. + * @tc.name: TaskSignalTest_IsCanceled_003 + * @tc.desc: Test function of TaskSignal::IsCanceled interface for case when both needCancel_ and remoteTask_ are false. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 - * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, Task_Signal_MarkDfsTask_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_003, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_MarkDfsTask_0000"; - auto signal = std::make_shared(); - signal->MarkDfsTask(); - std::string localUri = "/data/test/test.txt"; - std::string dstUri = "/data/test/test.txt"; - signal->SetCopyTaskUri(localUri, dstUri); - auto ret = signal->Cancel(); - EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_IsCanceled_003"; + // Prepare test condition + taskSignal_->needCancel_.store(false); + taskSignal_->remoteTask_.store(false); + // Do testing + bool result = taskSignal_->IsCanceled(); + // Verify results + EXPECT_FALSE(result); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_IsCanceled_003"; } + +/** + * @tc.name: TaskSignalTest_SetTaskSignalListener_001 + * @tc.desc: Test function of TaskSignal::SetTaskSignalListener interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_SetTaskSignalListener_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_SetTaskSignalListener_001"; + // Prepare test parameters + MockTaskSignalListener mockListener; + // Do testing + taskSignal_->SetTaskSignalListener(&mockListener); + // Verify results + EXPECT_EQ(taskSignal_->signalListener_, &mockListener); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_SetTaskSignalListener_001"; +} + +/** + * @tc.name: TaskSignalTest_SetTaskSignalListener_002 + * @tc.desc: Test function of TaskSignal::SetTaskSignalListener interface for FAILURE. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_SetTaskSignalListener_002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_SetTaskSignalListener_002"; + // Prepare test parameters + MockTaskSignalListener expectedListener; + // Prepre test condition + MockTaskSignalListener mockListener; + taskSignal_->signalListener_ = &mockListener; + // Do testing + taskSignal_->SetTaskSignalListener(&expectedListener); + // Verify results + EXPECT_EQ(taskSignal_->signalListener_, &mockListener); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_SetTaskSignalListener_002"; +} + +/** + * @tc.name: TaskSignalTest_OnCancel_001 + * @tc.desc: Test function of TaskSignal::OnCancel interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_OnCancel_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_OnCancel_001"; + // Set mock behaviors + MockTaskSignalListener mockListener; + taskSignal_->signalListener_ = &mockListener; + EXPECT_CALL(mockListener, OnCancel()).Times(1); + // Do testing + taskSignal_->OnCancel(); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_OnCancel_001"; +} + +/** + * @tc.name: TaskSignalTest_CheckCancelIfNeed_001 + * @tc.desc: Test function of TaskSignal::CheckCancelIfNeed interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_CheckCancelIfNeed_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_CheckCancelIfNeed_001"; + // Set mock behaviors + taskSignal_->needCancel_.store(true); + MockTaskSignalListener mockListener; + taskSignal_->signalListener_ = &mockListener; + EXPECT_CALL(mockListener, OnCancel()).Times(1); + // Do testing + bool result = taskSignal_->CheckCancelIfNeed("TaskSignalTest_CheckCancelIfNeed_001"); + // Verify results + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_CheckCancelIfNeed_001"; +} + +/** + * @tc.name: TaskSignalTest_CheckCancelIfNeed_002 + * @tc.desc: Test function of TaskSignal::CheckCancelIfNeed interface for FAILURE when needCancel_ is false. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_CheckCancelIfNeed_002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_CheckCancelIfNeed_002"; + // Prepare test condition + taskSignal_->needCancel_.store(false); + // Do testing + bool result = taskSignal_->CheckCancelIfNeed("TaskSignalTest_CheckCancelIfNeed_002"); + // Verify results + EXPECT_FALSE(result); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_CheckCancelIfNeed_002"; +} + +/** + * @tc.name: TaskSignalTest_MarkRemoteTask_001 + * @tc.desc: Test function of TaskSignal::MarkRemoteTask interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_MarkRemoteTask_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_MarkRemoteTask_001"; + // Do testing + taskSignal_->MarkRemoteTask(); + // Verify results + EXPECT_TRUE(taskSignal_->remoteTask_.load()); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_MarkRemoteTask_001"; +} + +/** + * @tc.name: TaskSignalTest_SetFileInfoOfRemoteTask_001 + * @tc.desc: Test function of TaskSignal::SetFileInfoOfRemoteTask interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_SetFileInfoOfRemoteTask_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_SetFileInfoOfRemoteTask_001"; + // Prepare test parameters + std::string sessionName = "testSession"; + std::string filePath = "testFilePath"; + // Do testing + taskSignal_->SetFileInfoOfRemoteTask(sessionName, filePath); + // Verify results + EXPECT_EQ(taskSignal_->sessionName_, sessionName); + EXPECT_EQ(taskSignal_->filePath_, filePath); + GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_SetFileInfoOfRemoteTask_001"; +} + +} // namespace Test +} // namespace ModuleTaskSignal } // namespace DistributedFS } // namespace OHOS \ No newline at end of file -- Gitee From 44bf9ef628285bd9136c85b577ebfd67fdc18720 Mon Sep 17 00:00:00 2001 From: liyuke Date: Sat, 26 Jul 2025 17:46:40 +0800 Subject: [PATCH 2/2] =?UTF-8?q?tasksignal=20=E4=BB=A3=E7=A0=81=E4=BF=AE?= =?UTF-8?q?=E5=A4=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liyuke Change-Id: I0f1fc268a00105cd48bc9e91dad8690c85139da9 --- .../src/common/ani_helper/ani_signature.cpp | 1 + .../js/src/common/ani_helper/ani_signature.h | 1 + .../class_tasksignal/ani/task_signal_ani.cpp | 2 + .../ani/task_signal_listener_ani.cpp | 2 + .../ani/task_signal_wrapper.cpp | 4 +- .../class_tasksignal/fs_task_signal.cpp | 1 + .../class_atomicfile/fs_atomicfile_test.cpp | 9 +- .../unittest/task_signal/task_signal_test.cpp | 451 ++++-------------- 8 files changed, 99 insertions(+), 372 deletions(-) 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 f46a4fdd4..d92dd44d0 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 de58ba8cb..122459794 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 index 2b1229a69..0ac364b35 100644 --- 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 @@ -38,6 +38,7 @@ void TaskSignalAni::Cancel(ani_env *env, [[maybe_unused]] ani_object object) ErrorHandler::Throw(env, EINVAL); return; } + auto ret = copySignal->Cancel(); if (!ret.IsSuccess()) { HILOGE("Cannot Cancel!"); @@ -55,6 +56,7 @@ void TaskSignalAni::OnCancel(ani_env *env, [[maybe_unused]] ani_object object) ErrorHandler::Throw(env, EINVAL); return; } + auto ret = copySignal->OnCancel(); if (!ret.IsSuccess()) { HILOGE("Cannot Cancel!"); 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 index 8f533889c..5bb6daff8 100644 --- 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 @@ -43,6 +43,7 @@ void TaskSignalListenerAni::SendCancelEvent(const string &filepath) const 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."); @@ -53,6 +54,7 @@ void TaskSignalListenerAni::SendCancelEvent(const string &filepath) const 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); 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 index 79be64231..cc3085418 100644 --- 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 @@ -32,7 +32,7 @@ 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, "nativeTaskSignal", &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; @@ -56,7 +56,7 @@ bool TaskSignalWrapper::Wrap(ani_env *env, ani_object object, const FsTaskSignal ani_long ptr = static_cast(reinterpret_cast(signal)); - auto status = env->Object_SetFieldByName_Long(object, "nativeTaskSignal", ptr); + 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; 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 index d9b4b6ffe..76bf8cd87 100644 --- 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 @@ -51,6 +51,7 @@ FsResult FsTaskSignal::Cancel() HILOGE("Failed to get taskSignal"); return FsResult::Error(EINVAL); } + auto ret = taskSignal_->Cancel(); if (ret != ERRNO_NOERR) { HILOGE("Failed to cancel the task."); 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 index f506c732f..af2465938 100644 --- 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 @@ -112,7 +112,8 @@ HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_002, testing::ext::TestS GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_002"; size_t largeLength = static_cast(PATH_MAX) + 1; - string largeString(largeLength, 'a'); + char text = 'a'; + string largeString(largeLength, text); auto ret = FsAtomicFile::Constructor(largeString); ASSERT_TRUE(ret.IsSuccess()); @@ -135,7 +136,7 @@ HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_003, testing::ext::TestS { GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_003"; - string path = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + string path = "FsAtomicfileTest_GetBaseFile_003_aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; auto ret = FsAtomicFile::Constructor(path); ASSERT_TRUE(ret.IsSuccess()); @@ -158,7 +159,7 @@ HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_GetBaseFile_004, testing::ext::TestS { GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_GetBaseFile_004"; - string path = "/data/test/aaaaaaaaaa.txt"; + string path = "/data/test/FsAtomicfileTest_GetBaseFile_004_aaaaaaaaaa.txt"; auto ret = FsAtomicFile::Constructor(path); ASSERT_TRUE(ret.IsSuccess()); @@ -202,7 +203,7 @@ HWTEST_F(FsAtomicfileTest, FsAtomicfileTest_StartWrite_002, testing::ext::TestSi { GTEST_LOG_(INFO) << "FsAtomicfileTest-begin FsAtomicfileTest_StartWrite_002"; - string path = "/data/local/tmp/test/test/test/test.txt"; + string path = "/data/local/tmp/test/test/test/FsAtomicfileTest_StartWrite_002_test.txt"; auto ret = FsAtomicFile::Constructor(path); ASSERT_TRUE(ret.IsSuccess()); diff --git a/interfaces/test/unittest/task_signal/task_signal_test.cpp b/interfaces/test/unittest/task_signal/task_signal_test.cpp index 18bbb12e4..fad6cbfc2 100644 --- a/interfaces/test/unittest/task_signal/task_signal_test.cpp +++ b/interfaces/test/unittest/task_signal/task_signal_test.cpp @@ -1,10 +1,10 @@ /* - * Copyright (c) 2024-2025 Huawei Device Co., Ltd. + * 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 + * 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, @@ -13,427 +13,146 @@ * limitations under the License. */ -#include +#include "task_signal.h" -#include +#include +#include #include +#include -#include "distributed_file_daemon_manager.h" #include "filemgmt_libhilog.h" #include "task_signal_listener.h" -#include "task_signal.h" - -using namespace OHOS; -using namespace OHOS::Storage::DistributedFile; - -class MockDistributedFileDaemonManager : public DistributedFileDaemonManager { -public: - MOCK_METHOD(int32_t, CancelCopyTask, (const std::string &sessionName), (override)); - - int32_t OpenP2PConnection(const DistributedHardware::DmDeviceInfo &deviceInfo) override - { - return 0; - } - - int32_t CloseP2PConnection(const DistributedHardware::DmDeviceInfo &deviceInfo) override - { - return 0; - } - - int32_t OpenP2PConnectionEx(const std::string &networkId, sptr remoteReverseObj) override - { - return 0; - } - - int32_t CloseP2PConnectionEx(const std::string &networkId) override - { - return 0; - } - - int32_t PrepareSession(const std::string &srcUri, const std::string &dstUri, const std::string &srcDeviceId, - const sptr &listener, HmdfsInfo &info) override - { - return 0; - } - - int32_t PushAsset( - int32_t userId, const sptr &assetObj, const sptr &sendCallback) override - { - return 0; - } - - int32_t RegisterAssetCallback(const sptr &recvCallback) override - { - return 0; - } - - int32_t UnRegisterAssetCallback(const sptr &recvCallback) override - { - return 0; - } - - int32_t GetSize(const std::string &uri, bool isSrcUri, uint64_t &size) override - { - return 0; - } - - int32_t IsDirectory(const std::string &uri, bool isSrcUri, bool &isDirectory) override - { - return 0; - } - - int32_t Copy(const std::string &srcUri, const std::string &destUri, ProcessCallback processCallback) override - { - return 0; - } - - int32_t Cancel(const std::string &srcUri, const std::string &destUri) override - { - return 0; - } - - int32_t Cancel() override - { - return 0; - } - - static MockDistributedFileDaemonManager &GetInstance() - { - static MockDistributedFileDaemonManager instance; - return instance; - } -}; - -static MockDistributedFileDaemonManager &g_mockDistributedFileDaemonManager = - MockDistributedFileDaemonManager::GetInstance(); - -#ifdef ENABLE_DISTRIBUTED_FILE_MOCK -DistributedFileDaemonManager &DistributedFileDaemonManager::GetInstance() -{ - return MockDistributedFileDaemonManager::GetInstance(); -} -#endif - -class MockTaskSignalListener : public OHOS::DistributedFS::ModuleTaskSignal::TaskSignalListener { -public: - MOCK_METHOD(void, OnCancel, (), (override)); -}; namespace OHOS { namespace DistributedFS { -namespace ModuleTaskSignal { -namespace Test { using namespace std; using namespace OHOS::DistributedFS::ModuleTaskSignal; +using namespace FileManagement; class TaskSignalTest : public testing::Test { public: - static void SetUpTestSuite(void) {} - static void TearDownTestSuite(void) {} + static void SetUpTestCase(void){}; + static void TearDownTestCase(){}; + void SetUp(){}; + void TearDown(){}; + + static std::condition_variable taskListenerCv_; + static std::mutex taskListenerCallbackLock_; + static std::string canceledFilePath_; +}; - void SetUp() override - { - taskSignal_ = std::make_unique(); - } +std::condition_variable TaskSignalTest::taskListenerCv_; +std::mutex TaskSignalTest::taskListenerCallbackLock_; +std::string TaskSignalTest::canceledFilePath_; - void TearDown() override - { - taskSignal_.reset(); - } - - MockDistributedFileDaemonManager &GetMock() +class TaskSignalListenerTestImpl : public TaskSignalListener { +public: + ~TaskSignalListenerTestImpl() = default; + void OnCancel() { - return g_mockDistributedFileDaemonManager; + string path = "aaa"; + TaskSignalTest::canceledFilePath_ = path; + TaskSignalTest::taskListenerCv_.notify_one(); + HILOGI("OnCancel in. path = %{public}s", path.c_str()); } - -protected: - std::unique_ptr taskSignal_; }; /** - * @tc.name: TaskSignalTest_Cancel_001 - * @tc.desc: Test function of TaskSignal::Cancel interface for SUCCESS when remoteTask_ is false. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_001"; - // Prepare test condition - taskSignal_->remoteTask_.store(false); - // Do testing - auto result = taskSignal_->Cancel(); - // Verify results - EXPECT_EQ(result, 0); - EXPECT_TRUE(taskSignal_->needCancel_.load()); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_001"; -} - -/** - * @tc.name: TaskSignalTest_Cancel_002 - * @tc.desc: Test function of TaskSignal::Cancel interface for SUCCESS when remoteTask_ is false. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_002"; - // Prepare test condition - taskSignal_->remoteTask_.store(true); - taskSignal_->sessionName_ = "TaskSignalTest_Cancel_002"; - // Set mock behaviors - int expectedCode = 0; - EXPECT_CALL(GetMock(), CancelCopyTask(testing::_)).WillOnce(testing::Return(expectedCode)); - // Do testing - auto result = taskSignal_->Cancel(); - // Verify results - EXPECT_EQ(result, 0); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_002"; -} - -/** - * @tc.name: TaskSignalTest_Cancel_003 - * @tc.desc: Test function of TaskSignal::Cancel interface for FAILURE when sessionName_ is empty. + * @tc.name: Task_Signal_Cancel_0000 + * @tc.desc: Test function of Cancel() interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 + * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_003, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, Task_Signal_Cancel_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_003"; - // Prepare test parameters - taskSignal_->remoteTask_.store(true); - taskSignal_->sessionName_ = ""; - // Do testing - auto result = taskSignal_->Cancel(); - // Verify results - EXPECT_EQ(result, -3); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_003"; + GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_Cancel_0000"; + auto signal = std::make_shared(); + auto ret = signal->Cancel(); + EXPECT_TRUE(ret == 0); } /** - * @tc.name: TaskSignalTest_Cancel_004 - * @tc.desc: Test function of TaskSignal::Cancel interface for FAILURE when CancelCopyTask fails. + * @tc.name: Task_Signal_IsCancel_0000 + * @tc.desc: Test function of IsCanceled() interface * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 + * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_004, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, Task_Signal_IsCancel_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_Cancel_004"; - // Prepare test parameters - taskSignal_->remoteTask_.store(true); - taskSignal_->sessionName_ = "TaskSignalTest_Cancel_004"; - // Set mock behaviors - int expectedCode = -1; - EXPECT_CALL(GetMock(), CancelCopyTask(testing::_)).WillOnce(testing::Return(expectedCode)); - // Do testing - auto result = taskSignal_->Cancel(); - // Verify results - EXPECT_EQ(result, expectedCode); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_Cancel_004"; + GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_IsCancel_0000"; + auto signal = std::make_shared(); + auto isCanceled = signal->IsCanceled(); + EXPECT_TRUE(!isCanceled); + + auto ret = signal->Cancel(); + EXPECT_TRUE(ret == 0); + isCanceled = signal->IsCanceled(); + EXPECT_TRUE(isCanceled); } /** - * @tc.name: TaskSignalTest_IsCanceled_001 - * @tc.desc: Test function of TaskSignal::IsCanceled interface for case when needCancel_ is true. + * @tc.name: Task_Signal_SetTaskSignalListener_0000 + * @tc.desc: Test function of SetTaskSignalListener() interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 + * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_001, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, Task_Signal_SetTaskSignalListener_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_IsCanceled_001"; - // Prepare test condition - taskSignal_->needCancel_.store(true); - // Do testing - bool result = taskSignal_->IsCanceled(); - // Verify results - EXPECT_TRUE(result); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_IsCanceled_001"; + GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_SetTaskSignalListener_0000"; + std::unique_lock lock(TaskSignalTest::taskListenerCallbackLock_); + auto signal = std::make_shared(); + auto listener = std::make_shared(); + signal->SetTaskSignalListener(listener.get()); + std::string filePath = "aaa"; + listener->OnCancel(); + signal->CheckCancelIfNeed(filePath); + EXPECT_EQ(TaskSignalTest::canceledFilePath_, filePath); } /** - * @tc.name: TaskSignalTest_IsCanceled_002 - * @tc.desc: Test function of TaskSignal::IsCanceled interface for case when remoteTask_ is true. + * @tc.name: Task_Signal_MarkRemoteTask_0000 + * @tc.desc: Test function of MarkRemoteTask() and SetFileInfoOfRemoteTask() interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 + * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_002, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, Task_Signal_MarkRemoteTask_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_IsCanceled_002"; - // Prepare test condition - taskSignal_->remoteTask_.store(true); - // Do testing - bool result = taskSignal_->IsCanceled(); - // Verify results - EXPECT_TRUE(result); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_IsCanceled_002"; + GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_MarkRemoteTask_0000"; + auto signal = std::make_shared(); + signal->MarkRemoteTask(); + std::string sessionName = "DistributedDevice0"; + std::string filePath = "aaa"; + signal->SetFileInfoOfRemoteTask(sessionName, filePath); + auto ret = signal->Cancel(); + EXPECT_EQ(ret, 4); } /** - * @tc.name: TaskSignalTest_IsCanceled_003 - * @tc.desc: Test function of TaskSignal::IsCanceled interface for case when both needCancel_ and remoteTask_ are false. + * @tc.name: Task_Signal_MarkDfsTask_0000 + * @tc.desc: Test function of MarkDfsTask() interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 + * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_003, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, Task_Signal_MarkDfsTask_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_IsCanceled_003"; - // Prepare test condition - taskSignal_->needCancel_.store(false); - taskSignal_->remoteTask_.store(false); - // Do testing - bool result = taskSignal_->IsCanceled(); - // Verify results - EXPECT_FALSE(result); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_IsCanceled_003"; + GTEST_LOG_(INFO) << "TaskSignalTest-begin Task_Signal_MarkDfsTask_0000"; + auto signal = std::make_shared(); + signal->MarkDfsTask(); + std::string localUri = "/data/test/test.txt"; + std::string dstUri = "/data/test/test.txt"; + signal->SetCopyTaskUri(localUri, dstUri); + auto ret = signal->Cancel(); + EXPECT_EQ(ret, 0); } - -/** - * @tc.name: TaskSignalTest_SetTaskSignalListener_001 - * @tc.desc: Test function of TaskSignal::SetTaskSignalListener interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_SetTaskSignalListener_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_SetTaskSignalListener_001"; - // Prepare test parameters - MockTaskSignalListener mockListener; - // Do testing - taskSignal_->SetTaskSignalListener(&mockListener); - // Verify results - EXPECT_EQ(taskSignal_->signalListener_, &mockListener); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_SetTaskSignalListener_001"; -} - -/** - * @tc.name: TaskSignalTest_SetTaskSignalListener_002 - * @tc.desc: Test function of TaskSignal::SetTaskSignalListener interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_SetTaskSignalListener_002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_SetTaskSignalListener_002"; - // Prepare test parameters - MockTaskSignalListener expectedListener; - // Prepre test condition - MockTaskSignalListener mockListener; - taskSignal_->signalListener_ = &mockListener; - // Do testing - taskSignal_->SetTaskSignalListener(&expectedListener); - // Verify results - EXPECT_EQ(taskSignal_->signalListener_, &mockListener); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_SetTaskSignalListener_002"; -} - -/** - * @tc.name: TaskSignalTest_OnCancel_001 - * @tc.desc: Test function of TaskSignal::OnCancel interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_OnCancel_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_OnCancel_001"; - // Set mock behaviors - MockTaskSignalListener mockListener; - taskSignal_->signalListener_ = &mockListener; - EXPECT_CALL(mockListener, OnCancel()).Times(1); - // Do testing - taskSignal_->OnCancel(); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_OnCancel_001"; -} - -/** - * @tc.name: TaskSignalTest_CheckCancelIfNeed_001 - * @tc.desc: Test function of TaskSignal::CheckCancelIfNeed interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_CheckCancelIfNeed_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_CheckCancelIfNeed_001"; - // Set mock behaviors - taskSignal_->needCancel_.store(true); - MockTaskSignalListener mockListener; - taskSignal_->signalListener_ = &mockListener; - EXPECT_CALL(mockListener, OnCancel()).Times(1); - // Do testing - bool result = taskSignal_->CheckCancelIfNeed("TaskSignalTest_CheckCancelIfNeed_001"); - // Verify results - EXPECT_TRUE(result); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_CheckCancelIfNeed_001"; -} - -/** - * @tc.name: TaskSignalTest_CheckCancelIfNeed_002 - * @tc.desc: Test function of TaskSignal::CheckCancelIfNeed interface for FAILURE when needCancel_ is false. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_CheckCancelIfNeed_002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_CheckCancelIfNeed_002"; - // Prepare test condition - taskSignal_->needCancel_.store(false); - // Do testing - bool result = taskSignal_->CheckCancelIfNeed("TaskSignalTest_CheckCancelIfNeed_002"); - // Verify results - EXPECT_FALSE(result); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_CheckCancelIfNeed_002"; -} - -/** - * @tc.name: TaskSignalTest_MarkRemoteTask_001 - * @tc.desc: Test function of TaskSignal::MarkRemoteTask interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_MarkRemoteTask_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_MarkRemoteTask_001"; - // Do testing - taskSignal_->MarkRemoteTask(); - // Verify results - EXPECT_TRUE(taskSignal_->remoteTask_.load()); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_MarkRemoteTask_001"; -} - -/** - * @tc.name: TaskSignalTest_SetFileInfoOfRemoteTask_001 - * @tc.desc: Test function of TaskSignal::SetFileInfoOfRemoteTask interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - */ -HWTEST_F(TaskSignalTest, TaskSignalTest_SetFileInfoOfRemoteTask_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TaskSignalTest-begin TaskSignalTest_SetFileInfoOfRemoteTask_001"; - // Prepare test parameters - std::string sessionName = "testSession"; - std::string filePath = "testFilePath"; - // Do testing - taskSignal_->SetFileInfoOfRemoteTask(sessionName, filePath); - // Verify results - EXPECT_EQ(taskSignal_->sessionName_, sessionName); - EXPECT_EQ(taskSignal_->filePath_, filePath); - GTEST_LOG_(INFO) << "TaskSignalTest-end TaskSignalTest_SetFileInfoOfRemoteTask_001"; -} - -} // namespace Test -} // namespace ModuleTaskSignal } // namespace DistributedFS } // namespace OHOS \ No newline at end of file -- Gitee