From 11d7b3a157866d230b2ff4b8f5d25999b9d84ffd Mon Sep 17 00:00:00 2001 From: wangbin Date: Fri, 28 Feb 2025 19:24:44 +0800 Subject: [PATCH 1/3] add ProcessCommunicatorImplTest Signed-off-by: wangbin --- .../adapter/communicator/test/BUILD.gn | 57 +++ .../process_communicator_impl_test.cpp | 402 ++++++++++++++++++ .../test/mock/device_manager_adapter_mock.cpp | 27 ++ .../test/mock/device_manager_adapter_mock.h | 6 + 4 files changed, 492 insertions(+) create mode 100644 services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp diff --git a/services/distributeddataservice/adapter/communicator/test/BUILD.gn b/services/distributeddataservice/adapter/communicator/test/BUILD.gn index 53a8fdc95..4715fcf31 100755 --- a/services/distributeddataservice/adapter/communicator/test/BUILD.gn +++ b/services/distributeddataservice/adapter/communicator/test/BUILD.gn @@ -125,6 +125,62 @@ ohos_unittest("DeviceManagerAdapterTest") { defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] } +ohos_unittest("ProcessCommunicatorImplTest") { + module_out_path = module_output_path + + sources = [ + "${data_service_path}/service/test/mock/device_manager_adapter_mock.cpp", + "../src/communication_provider_impl.cpp", + "../src/communication_provider_impl.h", + "../src/communicator_context.cpp", + "../src/data_buffer.cpp", + "../src/process_communicator_impl.cpp", + "../src/softbus_adapter.h", + "../src/softbus_adapter_standard.cpp", + "../src/softbus_client.cpp", + "../src/softbus_client.h", + "unittest/process_communicator_impl_test.cpp", + ] + + include_dirs = [ + "${data_service_path}/adapter/include/communicator", + "${data_service_path}/framework/include/dfx", + "${data_service_path}/service/test/mock", + "../src", + "../../include/communicator", + "../../include/utils", + "${data_service_path}/adapter/include/communicator", + "${data_service_path}/framework/include/dfx", + "${data_service_path}/framework/include/utils", + ] + + external_deps = [ + "c_utils:utils", + "device_manager:devicemanagersdk", + "dsoftbus:softbus_client", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddb", + ] + + cflags = [ + "-Dprivate=public", + "-Dprotected=public", + ] + + deps = [ + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "../../dfx:distributeddata_dfx", + ] + defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] +} + ohos_unittest("SoftbusAdapterStandardTest") { module_out_path = module_output_path @@ -195,6 +251,7 @@ group("unittest") { ":CommunicatorContextTest", ":CommunicatorDataBufferTest", ":DeviceManagerAdapterTest", + ":ProcessCommunicatorImplTest", ":SoftbusAdapterStandardTest", ":SoftbusClientTest", ] diff --git a/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp b/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp new file mode 100644 index 000000000..c898a1f94 --- /dev/null +++ b/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp @@ -0,0 +1,402 @@ +/* + * 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 +#include +#include +#include "communication_provider.h" +#include "device_manager_adapter_mock.h" +#include "process_communicator_impl.h" + +using namespace testing; +using namespace testing::ext; +using namespace OHOS::AppDistributedKv; +using namespace OHOS::DistributedData; +using OnDeviceChange = DistributedDB::OnDeviceChange; +using OnDataReceive = DistributedDB::OnDataReceive; +using OnSendAble = DistributedDB::OnSendAble; +using DeviceInfos = DistributedDB::DeviceInfos; +using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo; + +namespace OHOS::AppDistributedKv { +class MockCommunicationProvider : public CommunicationProvider { +public: + static MockCommunicationProvider& Init() { + static MockCommunicationProvider instance; + return instance; + } + MOCK_METHOD(Status, StartWatchDataChange, (const AppDataChangeListener *, const PipeInfo &), (override)); + MOCK_METHOD(Status, StopWatchDataChange, (const AppDataChangeListener *, const PipeInfo &), (override)); + MOCK_METHOD(Status, Start, (const PipeInfo&), (override)); + MOCK_METHOD(Status, Stop, (const PipeInfo&), (override)); + MOCK_METHOD((std::pair), SendData, (const PipeInfo&, const DeviceId&, + const DataInfo&, uint32_t, const MessageInfo &), (override)); + MOCK_METHOD(bool, IsSameStartedOnPeer, (const PipeInfo &, const DeviceId &), (const)); + MOCK_METHOD(Status, ReuseConnect, (const PipeInfo&, const DeviceId&), (override)); + MOCK_METHOD(void, SetDeviceQuery, (std::shared_ptr), (override)); + MOCK_METHOD(void, SetMessageTransFlag, (const PipeInfo &, bool), (override)); + MOCK_METHOD(Status, Broadcast, (const PipeInfo &, const LevelInfo &), (override)); + MOCK_METHOD(int32_t, ListenBroadcastMsg, (const PipeInfo &, + std::function), (override)); +}; + +CommunicationProvider& CommunicationProvider::GetInstance() { + return MockCommunicationProvider::Init(); +} + +std::shared_ptr CommunicationProvider::MakeCommunicationProvider() { + static std::shared_ptr instance( + &MockCommunicationProvider::Init(), + [](void*){} + ); + return instance; +} +} + +class ProcessCommunicatorImplTest : public testing::Test { +public: + static inline std::shared_ptr deviceManagerAdapterMock = nullptr; + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown() {} + + ProcessCommunicatorImpl* communicator_; + MockCommunicationProvider* mockProvider; +}; + +namespace OHOS::DistributedData { +class ConcreteRouteHeadHandler : public RouteHeadHandler { + public: + bool ParseHeadData(const uint8_t *data, uint32_t totalLen, uint32_t &headSize, + std::vector &users) override { + if (totalLen == 0) { + return true; + } + return false; + } +}; +} + +void ProcessCommunicatorImplTest::SetUp(void) +{ + communicator_ = ProcessCommunicatorImpl::GetInstance(); + communicator_->Stop(); + mockProvider = &MockCommunicationProvider::Init(); +} + +void ProcessCommunicatorImplTest::SetUpTestCase(void) +{ + deviceManagerAdapterMock = std::make_shared(); + BDeviceManagerAdapter::deviceManagerAdapter = deviceManagerAdapterMock; +} + +void ProcessCommunicatorImplTest::TearDownTestCase() +{ + deviceManagerAdapterMock = nullptr; +} + +/** +* @tc.name: StartTest01 +* @tc.desc: StartTest01 test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, StartTest01, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + EXPECT_CALL(*mockProvider, Start(_)).WillOnce(Return(Status::SUCCESS)); + auto status = communicator_->Start("test_process"); + EXPECT_EQ(status, DistributedDB::OK); + EXPECT_CALL(*mockProvider, Start(_)).WillOnce(Return(Status::INVALID_ARGUMENT)); + status = communicator_->Start("test_process"); + EXPECT_EQ(status, DistributedDB::DB_ERROR); +} + +/** +* @tc.name: StopTest01 +* @tc.desc: StopTest01 test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, StopTest01, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + EXPECT_CALL(*mockProvider, Stop(_)).WillOnce(Return(Status::SUCCESS)); + auto status = communicator_->Stop(); + EXPECT_EQ(status, DistributedDB::OK); + EXPECT_CALL(*mockProvider, Stop(_)).WillRepeatedly(Return(Status::INVALID_ARGUMENT)); + status = communicator_->Stop(); + EXPECT_EQ(status, DistributedDB::DB_ERROR); +} + +/** +* @tc.name: RegOnDeviceChange +* @tc.desc: RegOnDeviceChange test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, RegOnDeviceChange, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + EXPECT_CALL(*deviceManagerAdapterMock, StartWatchDeviceChange(_, _)).WillOnce(Return(Status::SUCCESS)) + .WillRepeatedly(Return(Status::SUCCESS)); + EXPECT_CALL(*deviceManagerAdapterMock, StopWatchDeviceChange(_, _)).WillOnce(Return(Status::SUCCESS)) + .WillRepeatedly(Return(Status::SUCCESS)); + auto myOnDeviceChange = [](const DeviceInfos &devInfo, bool isOnline) {}; + OnDeviceChange callback; + callback = myOnDeviceChange; + auto status = communicator_->RegOnDeviceChange(callback); + EXPECT_EQ(status, DistributedDB::OK); + callback = nullptr; + status = communicator_->RegOnDeviceChange(callback); + EXPECT_EQ(status, DistributedDB::OK); + + EXPECT_CALL(*deviceManagerAdapterMock, StartWatchDeviceChange(_, _)).WillOnce(Return(Status::INVALID_ARGUMENT)) + .WillRepeatedly(Return(Status::SUCCESS)); + EXPECT_CALL(*deviceManagerAdapterMock, StopWatchDeviceChange(_, _)).WillOnce(Return(Status::INVALID_ARGUMENT)) + .WillRepeatedly(Return(Status::SUCCESS)); + status = communicator_->RegOnDeviceChange(callback); + EXPECT_EQ(status, DistributedDB::DB_ERROR); + callback = myOnDeviceChange; + status = communicator_->RegOnDeviceChange(callback); + EXPECT_EQ(status, DistributedDB::DB_ERROR); +} + +/** +* @tc.name: RegOnDataReceive +* @tc.desc: RegOnDataReceive test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, RegOnDataReceive, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + auto myOnDeviceChange = [](const DeviceInfos &devInfo, const uint8_t *data, uint32_t length) {}; + OnDataReceive callback; + callback = myOnDeviceChange; + EXPECT_CALL(*mockProvider, StartWatchDataChange(_, _)).WillRepeatedly(Return(Status::SUCCESS)); + auto status = communicator_->RegOnDataReceive(callback); + EXPECT_EQ(status, DistributedDB::OK); + EXPECT_CALL(*mockProvider, StartWatchDataChange(_, _)).WillRepeatedly(Return(Status::ERROR)); + status = communicator_->RegOnDataReceive(callback); + EXPECT_EQ(status, DistributedDB::DB_ERROR); + + callback = nullptr; + EXPECT_CALL(*mockProvider, StopWatchDataChange(_, _)).WillRepeatedly(Return(Status::SUCCESS)); + status = communicator_->RegOnDataReceive(callback); + EXPECT_EQ(status, DistributedDB::OK); + EXPECT_CALL(*mockProvider, StopWatchDataChange(_, _)).WillRepeatedly(Return(Status::ERROR)); + status = communicator_->RegOnDataReceive(callback); + EXPECT_EQ(status, DistributedDB::DB_ERROR); +} + +/** +* @tc.name: RegOnSendAble +* @tc.desc: RegOnSendAble test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, RegOnSendAble, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + OnSendAble sendAbleCallback = nullptr; + EXPECT_NO_THROW(communicator_->RegOnSendAble(sendAbleCallback)); +} + +/** +* @tc.name: SendData +* @tc.desc: SendData test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, SendData, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + DeviceInfos deviceInfos = {"SendDataTest"}; + const uint8_t *data; + uint8_t exampleData[] = {0x01, 0x02, 0x03, 0x04}; + data = exampleData; + uint32_t length = 1; + uint32_t totalLength = 1; + std::pair myPair = std::make_pair(Status::RATE_LIMIT, 1); + EXPECT_CALL(*mockProvider, SendData(_, _, _, _, _)).WillRepeatedly(Return(myPair)); + auto status = communicator_->SendData(deviceInfos, data, length, totalLength); + EXPECT_EQ(status, DistributedDB::RATE_LIMIT); + myPair = {Status::SUCCESS, 1}; + EXPECT_CALL(*mockProvider, SendData(_, _, _, _, _)).WillRepeatedly(Return(myPair)); + status = communicator_->SendData(deviceInfos, data, length, totalLength); + EXPECT_EQ(status, DistributedDB::OK); + myPair = {Status::ERROR, static_cast(DistributedDB::BUSY)}; + EXPECT_CALL(*mockProvider, SendData(_, _, _, _, _)).WillRepeatedly(Return(myPair)); + status = communicator_->SendData(deviceInfos, data, length, totalLength); + EXPECT_EQ(status, DistributedDB::BUSY); + myPair = {Status::ERROR, 0}; + EXPECT_CALL(*mockProvider, SendData(_, _, _, _, _)).WillRepeatedly(Return(myPair)); + status = communicator_->SendData(deviceInfos, data, length, totalLength); + EXPECT_EQ(status, DistributedDB::DB_ERROR); +} + +/** +* @tc.name: GetRemoteOnlineDeviceInfosList +* @tc.desc: GetRemoteOnlineDeviceInfosList test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, GetRemoteOnlineDeviceInfosList, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + auto remoteDevInfos = communicator_->GetRemoteOnlineDeviceInfosList(); + EXPECT_EQ(remoteDevInfos.empty(), true); + + DeviceInfo deviceInfo; + deviceInfo.uuid = "GetRemoteOnlineDeviceInfosList"; + std::vector devInfos; + devInfos.push_back(deviceInfo); + EXPECT_CALL(*deviceManagerAdapterMock, GetRemoteDevices()).WillRepeatedly(Return(devInfos)); + remoteDevInfos = communicator_->GetRemoteOnlineDeviceInfosList(); + EXPECT_EQ(remoteDevInfos[0].identifier, deviceInfo.uuid); +} + +/** +* @tc.name: OnMessage +* @tc.desc: OnMessage test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, OnMessage, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + DeviceInfo deviceInfo; + deviceInfo.uuid = "OnMessageTest"; + uint8_t data[] = {0x10, 0x20, 0x30, 0x40, 0x50}; + uint8_t *ptr = data; + int size = 1; + PipeInfo pipeInfo; + pipeInfo.pipeId = "OnMessageTest01"; + pipeInfo.userId = "OnMessageTest02"; + auto myOnDeviceChange = [](const DeviceInfos &devInfo, const uint8_t *data, uint32_t length) {}; + communicator_->onDataReceiveHandler_ = nullptr; + EXPECT_NO_THROW(communicator_->OnMessage(deviceInfo, ptr, size, pipeInfo)); + communicator_->onDataReceiveHandler_ = myOnDeviceChange; + EXPECT_NO_THROW(communicator_->OnMessage(deviceInfo, ptr, size, pipeInfo)); +} + +/** +* @tc.name: OnDeviceChanged +* @tc.desc: OnDeviceChanged test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, OnDeviceChanged, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + DeviceInfo deviceInfo; + deviceInfo.uuid = "cloudDeviceUuid"; + EXPECT_NO_THROW(communicator_->OnDeviceChanged(deviceInfo, DeviceChangeType::DEVICE_ONREADY)); + EXPECT_NO_THROW(communicator_->OnDeviceChanged(deviceInfo, DeviceChangeType::DEVICE_OFFLINE)); + deviceInfo.uuid = "OnDeviceChangedTest"; + communicator_->onDeviceChangeHandler_ = nullptr; + EXPECT_NO_THROW(communicator_->OnDeviceChanged(deviceInfo, DeviceChangeType::DEVICE_OFFLINE)); + auto myOnDeviceChange = [](const DeviceInfos &devInfo, bool isOnline) {}; + communicator_->onDeviceChangeHandler_ = myOnDeviceChange; + EXPECT_NO_THROW(communicator_->OnDeviceChanged(deviceInfo, DeviceChangeType::DEVICE_OFFLINE)); +} + +/** +* @tc.name: OnSessionReady +* @tc.desc: OnSessionReady test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, OnSessionReady, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + DeviceInfo deviceInfo; + deviceInfo.uuid = "OnSessionReadyTest"; + communicator_->sessionListener_ = nullptr; + EXPECT_NO_THROW(communicator_->OnSessionReady(deviceInfo, 1)); + auto myOnSendAble = [](const DeviceInfos &deviceInfo, int deviceCommErrCode) {}; + communicator_->sessionListener_ = myOnSendAble; + EXPECT_NO_THROW(communicator_->OnSessionReady(deviceInfo, 1)); +} + +/** +* @tc.name: GetExtendHeaderHandle +* @tc.desc: GetExtendHeaderHandle test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, GetExtendHeaderHandle, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + communicator_->routeHeadHandlerCreator_ = nullptr; + DistributedDB::ExtendInfo info; + auto handle = communicator_->GetExtendHeaderHandle(info); + EXPECT_EQ(handle, nullptr); + communicator_->routeHeadHandlerCreator_ = [](const DistributedDB::ExtendInfo &info) -> + std::shared_ptr { + return std::make_shared(); + }; + handle = communicator_->GetExtendHeaderHandle(info); + EXPECT_NE(handle, nullptr); +} + +/** +* @tc.name: CheckAndGetDataHeadInfo +* @tc.desc: CheckAndGetDataHeadInfo test +* @tc.type: FUNC +* @tc.require: +* @tc.author: wangbin + */ +HWTEST_F(ProcessCommunicatorImplTest, CheckAndGetDataHeadInfo, TestSize.Level0) +{ + ASSERT_NE(communicator_, nullptr); + uint8_t data[] = {0x10, 0x20, 0x30, 0x40, 0x50}; + uint8_t *ptr = data; + uint32_t dataLen = 1; + uint32_t headLen = 1; + std::vector user = {}; + std::vector users = {"user1", "user2", "user3"}; + communicator_->routeHeadHandlerCreator_ = nullptr; + auto status = communicator_->CheckAndGetDataHeadInfo(ptr, dataLen, headLen, users); + EXPECT_EQ(status, DistributedDB::DB_ERROR); + + communicator_->routeHeadHandlerCreator_ = [](const DistributedDB::ExtendInfo &info) -> + std::shared_ptr { + return std::make_shared(); + }; + status = communicator_->CheckAndGetDataHeadInfo(ptr, dataLen, headLen, users); + EXPECT_EQ(status, DistributedDB::INVALID_FORMAT); + dataLen = 0; + status = communicator_->CheckAndGetDataHeadInfo(ptr, dataLen, headLen, user); + EXPECT_EQ(status, DistributedDB::NO_PERMISSION); + status = communicator_->CheckAndGetDataHeadInfo(ptr, dataLen, headLen, users); + EXPECT_EQ(status, DistributedDB::OK); +} diff --git a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp index 015bec1fe..49d1c1193 100644 --- a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp +++ b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.cpp @@ -41,4 +41,31 @@ bool OHOS::DistributedData::DeviceManagerAdapter::IsOHOSType(const std::string & } return BDeviceManagerAdapter::deviceManagerAdapter->IsOHOSType(id); } + +Status OHOS::DistributedData::DeviceManagerAdapter::StartWatchDeviceChange(const AppDeviceChangeListener *observer, + __attribute__((unused)) const PipeInfo &pipeInfo) +{ + if (BDeviceManagerAdapter::deviceManagerAdapter == nullptr) { + return Status::SUCCESS; + } + return BDeviceManagerAdapter::deviceManagerAdapter->StartWatchDeviceChange(observer, pipeInfo); +} + +Status OHOS::DistributedData::DeviceManagerAdapter::StopWatchDeviceChange(const AppDeviceChangeListener *observer, + __attribute__((unused)) const PipeInfo &pipeInfo) +{ + if (BDeviceManagerAdapter::deviceManagerAdapter == nullptr) { + return Status::SUCCESS; + } + return BDeviceManagerAdapter::deviceManagerAdapter->StopWatchDeviceChange(observer, pipeInfo); +} + +std::vector OHOS::DistributedData::DeviceManagerAdapter::GetRemoteDevices() +{ + if (BDeviceManagerAdapter::deviceManagerAdapter == nullptr) { + std::vector info; + return info; + } + return BDeviceManagerAdapter::deviceManagerAdapter->GetRemoteDevices(); +} } \ No newline at end of file diff --git a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h index e302e4003..fde4ec6cd 100644 --- a/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h +++ b/services/distributeddataservice/service/test/mock/device_manager_adapter_mock.h @@ -24,8 +24,11 @@ namespace DistributedData { using namespace OHOS::AppDistributedKv; class BDeviceManagerAdapter { public: + virtual std::vector GetRemoteDevices() = 0; virtual bool IsOHOSType(const std::string &) = 0; virtual std::vector ToUUID(std::vector) = 0; + virtual Status StartWatchDeviceChange(const AppDeviceChangeListener *, const PipeInfo &) = 0; + virtual Status StopWatchDeviceChange(const AppDeviceChangeListener *, const PipeInfo &) = 0; static inline std::shared_ptr deviceManagerAdapter = nullptr; BDeviceManagerAdapter() = default; virtual ~BDeviceManagerAdapter() = default; @@ -33,8 +36,11 @@ public: class DeviceManagerAdapterMock : public BDeviceManagerAdapter { public: + MOCK_METHOD(std::vector, GetRemoteDevices, ()); MOCK_METHOD(bool, IsOHOSType, (const std::string &)); MOCK_METHOD(std::vector, ToUUID, (std::vector)); + MOCK_METHOD(Status, StartWatchDeviceChange, (const AppDeviceChangeListener *, const PipeInfo &)); + MOCK_METHOD(Status, StopWatchDeviceChange, (const AppDeviceChangeListener *, const PipeInfo &)); }; } // namespace DistributedData -- Gitee From ca058f19d666f5f934374cb60852f3ffbbd1686f Mon Sep 17 00:00:00 2001 From: wangbin Date: Fri, 28 Feb 2025 19:50:08 +0800 Subject: [PATCH 2/3] fix Signed-off-by: wangbin --- .../unittest/process_communicator_impl_test.cpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp b/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp index c898a1f94..c23058fa1 100644 --- a/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp +++ b/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp @@ -36,7 +36,8 @@ using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo; namespace OHOS::AppDistributedKv { class MockCommunicationProvider : public CommunicationProvider { public: - static MockCommunicationProvider& Init() { + static MockCommunicationProvider& Init() + { static MockCommunicationProvider instance; return instance; } @@ -55,14 +56,17 @@ public: std::function), (override)); }; -CommunicationProvider& CommunicationProvider::GetInstance() { +CommunicationProvider& CommunicationProvider::GetInstance() +{ return MockCommunicationProvider::Init(); } -std::shared_ptr CommunicationProvider::MakeCommunicationProvider() { +std::shared_ptr CommunicationProvider::MakeCommunicationProvider() +{ static std::shared_ptr instance( &MockCommunicationProvider::Init(), - [](void*){} + [](void*) { + } ); return instance; } @@ -84,7 +88,8 @@ namespace OHOS::DistributedData { class ConcreteRouteHeadHandler : public RouteHeadHandler { public: bool ParseHeadData(const uint8_t *data, uint32_t totalLen, uint32_t &headSize, - std::vector &users) override { + std::vector &users) override + { if (totalLen == 0) { return true; } -- Gitee From b0acb02db29218a7bf078fdacb366c80175bb2e7 Mon Sep 17 00:00:00 2001 From: wangbin Date: Mon, 3 Mar 2025 11:28:21 +0800 Subject: [PATCH 3/3] fix Signed-off-by: wangbin --- .../test/unittest/process_communicator_impl_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp b/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp index c23058fa1..a12057e22 100644 --- a/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp +++ b/services/distributeddataservice/adapter/communicator/test/unittest/process_communicator_impl_test.cpp @@ -88,7 +88,7 @@ namespace OHOS::DistributedData { class ConcreteRouteHeadHandler : public RouteHeadHandler { public: bool ParseHeadData(const uint8_t *data, uint32_t totalLen, uint32_t &headSize, - std::vector &users) override + std::vector &users) { if (totalLen == 0) { return true; -- Gitee