From cc7c500a4f4532dcf9c9ae01f039bc48ec4fc8b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=A7=9C=E5=B0=8F=E6=9E=97?= Date: Mon, 21 Apr 2025 10:52:34 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E5=A2=9E=E5=8A=A0n=5Fclass=E7=9A=84?= =?UTF-8?q?=E7=9B=B8=E5=85=B3=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I772039d30896086fa488f361c7c5c95af1049c1f Signed-off-by: 姜小林 --- .../test/unittest/filemgmt_libn_test/src/n_class_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp b/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp index ccbb9dc17..65047faf9 100644 --- a/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp +++ b/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp @@ -4,7 +4,7 @@ * 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, -- Gitee From f1dc39f76c078f008508b7f0a20d9b747f31c6fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=A7=9C=E5=B0=8F=E6=9E=97?= Date: Tue, 22 Apr 2025 19:23:55 +0800 Subject: [PATCH 2/2] =?UTF-8?q?task=5Fsignal=20TDD=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Id7f9ace802aa7daf5b8236603b7007d074a3b930 Signed-off-by: 姜小林 --- .../test/unittest/filemgmt_libn_test/BUILD.gn | 2 +- .../filemgmt_libn_test/src/n_class_test.cpp | 2 +- interfaces/test/unittest/task_signal/BUILD.gn | 13 +- .../unittest/task_signal/task_signal_test.cpp | 447 +++++++++++++++--- 4 files changed, 386 insertions(+), 78 deletions(-) diff --git a/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn b/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn index 58a86cce6..9641789b8 100644 --- a/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn +++ b/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn @@ -3,7 +3,7 @@ # 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, diff --git a/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp b/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp index 65047faf9..ccbb9dc17 100644 --- a/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp +++ b/interfaces/test/unittest/filemgmt_libn_test/src/n_class_test.cpp @@ -4,7 +4,7 @@ * 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, diff --git a/interfaces/test/unittest/task_signal/BUILD.gn b/interfaces/test/unittest/task_signal/BUILD.gn index d4de828b5..1789fbbc1 100644 --- a/interfaces/test/unittest/task_signal/BUILD.gn +++ b/interfaces/test/unittest/task_signal/BUILD.gn @@ -1,9 +1,9 @@ -# 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, @@ -29,11 +29,18 @@ ohos_unittest("task_signal_test") { deps = [ "${file_api_path}/interfaces/kits/native:task_signal_native", "${utils_path}/filemgmt_libhilog:filemgmt_libhilog", - "//third_party/googletest:gtest_main", ] external_deps = [ "c_utils:utils", + "dfs_service:distributed_file_daemon_kit_inner", + "googletest:gmock_main", + "googletest:gtest_main", "hilog:libhilog", ] + + defines = [ + "ENABLE_DISTRIBUTED_FILE_MOCK", + "private=public", + ] } diff --git a/interfaces/test/unittest/task_signal/task_signal_test.cpp b/interfaces/test/unittest/task_signal/task_signal_test.cpp index def1c403d..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,126 +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 + { + taskSignal_.reset(); + } + + MockDistributedFileDaemonManager &GetMock() { - string path = "aaa"; - TaskSignalTest::canceledFilePath_ = path; - TaskSignalTest::taskListenerCv_.notify_one(); - HILOGI("OnCancel in. path = %{public}s", path.c_str()); + 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 - * @tc.require: NAN */ -HWTEST_F(TaskSignalTest, Task_Signal_Cancel_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_002, 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_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: Task_Signal_IsCancel_0000 - * @tc.desc: Test function of IsCanceled() interface + * @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_IsCancel_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_003, 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_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_SetTaskSignalListener_0000 - * @tc.desc: Test function of SetTaskSignalListener() interface for SUCCESS. + * @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_SetTaskSignalListener_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_Cancel_004, 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_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_MarkRemoteTask_0000 - * @tc.desc: Test function of MarkRemoteTask() and SetFileInfoOfRemoteTask() 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_MarkRemoteTask_0000, testing::ext::TestSize.Level1) +HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_001, 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_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: 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 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_002, 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"; +} + +/** + * @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 + */ +HWTEST_F(TaskSignalTest, TaskSignalTest_IsCanceled_003, 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"; +} + +/** + * @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