diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 6fce5adccfe977b7e9f5966814ffcc2cb1cc4e1a..9bfe3441a40c5b41326d3b084698c592cb5d1e14 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -1118,6 +1118,7 @@ ohos_unittest("UTTest_device_manager_impl") { "UTTest_device_manager_impl.cpp", "UTTest_device_manager_impl_three.cpp", "UTTest_device_manager_impl_two.cpp", + "UTTest_device_manager_impl_four.cpp", "mock/device_manager_notify_mock.cpp", ] diff --git a/test/unittest/UTTest_device_manager_impl.h b/test/unittest/UTTest_device_manager_impl.h index 21c5bdfbce7801f999a964e2c6f520e7e6be98d9..1b0df413c4311dd58f2fd592f74fa2f008dd556b 100644 --- a/test/unittest/UTTest_device_manager_impl.h +++ b/test/unittest/UTTest_device_manager_impl.h @@ -27,7 +27,10 @@ #include "device_manager_impl.h" #include "softbus_error_code.h" #include "device_manager_notify_mock.h" - +#include "dm_device_info.h" +#include "dm_subscribe_info.h" +#include "device_manager_notify.h" +#include "dm_publish_info.h" namespace OHOS { namespace DistributedHardware { class DeviceManagerImplTest : public testing::Test { @@ -37,7 +40,7 @@ public: void SetUp(); void TearDown(); - static inline std::shared_ptr deviceManagerNotifyMock_ = + static inline std::shared_ptr deviceManagerNotifyMock_ = std::make_shared(); static inline std::shared_ptr ipcClientProxyMock_ = std::make_shared(); }; @@ -154,6 +157,32 @@ public: } void OnBindResult(const PeerTargetId &targetId, int32_t result, int32_t status, std::string content) override {} }; + +class ServiceDiscoveryCallbackTest : public ServiceDiscoveryCallback { +public: + ServiceDiscoveryCallbackTest() = default; + virtual ~ServiceDiscoveryCallbackTest() = default; + void OnServiceFound(const DiscoveryServiceInfo &service) override {} + void OnServiceDiscoveryResult(int32_t resReason) override {} +}; + +class ServiceInfoStateCallbackTest : public ServiceInfoStateCallback { +public: + void OnServiceOnline(int64_t serviceId) override {} + void OnServiceOffline(int64_t serviceId) override {} +}; + +class MockServicePublishCallback : public ServicePublishCallback { +public: + void OnPublishResult(int32_t result, const std::string &publishId) {} +}; + +class ServicePublishCallbackTest : public ServicePublishCallback { +public: + ServicePublishCallbackTest() = default; + virtual ~ServicePublishCallbackTest() = default; + void OnServicePublishResult(int64_t serviceId, int32_t reason) override {} +}; } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_impl_four.cpp b/test/unittest/UTTest_device_manager_impl_four.cpp new file mode 100644 index 0000000000000000000000000000000000000000..04b3ff7ae9028ec859a49e797a2cfe5df65df9b9 --- /dev/null +++ b/test/unittest/UTTest_device_manager_impl_four.cpp @@ -0,0 +1,208 @@ +/* +* Copyright (c) 2022-2023 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 "UTTest_device_manager_impl.h" +#include "dm_device_info.h" + +#include +#include +#include "accesstoken_kit.h" +#include "device_manager_notify.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "ipc_authenticate_device_req.h" +#include "ipc_get_info_by_network_req.h" +#include "ipc_get_info_by_network_rsp.h" +#include "ipc_get_local_device_info_rsp.h" +#include "ipc_get_trustdevice_req.h" +#include "ipc_get_trustdevice_rsp.h" +#include "ipc_req.h" +#include "ipc_rsp.h" +#include "ipc_set_useroperation_req.h" +#include "ipc_skeleton.h" +#include "ipc_publish_req.h" +#include "ipc_unpublish_req.h" +#include "ipc_unauthenticate_device_req.h" +#include "nativetoken_kit.h" +#include "securec.h" +#include "token_setproc.h" +#include "softbus_error_code.h" +#include "ipc_publish_service_info_rsp.h" +using namespace testing; +namespace OHOS { +namespace DistributedHardware { +namespace { +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_001, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = ""; + serviceInfo.serviceInfo.serviceName = "TestService"; + serviceInfo.serviceInfo.serviceDisplayName = "Test Service Display"; + int32_t regServiceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_002, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = "TestType"; + serviceInfo.serviceInfo.serviceName = ""; + serviceInfo.serviceInfo.serviceDisplayName = "Test Service Display"; + int32_t regServiceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_003, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = "TestType"; + serviceInfo.serviceInfo.serviceName = "TestService"; + serviceInfo.serviceInfo.serviceDisplayName = ""; + int32_t regServiceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_004, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = ""; + serviceInfo.serviceInfo.serviceName = ""; + serviceInfo.serviceInfo.serviceDisplayName = ""; + int32_t regServiceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_005, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = "TestType"; + serviceInfo.serviceInfo.serviceName = "TestService"; + serviceInfo.serviceInfo.serviceDisplayName = "Test Service Display"; + int32_t regServiceId = 0; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_006, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = "TestType"; + serviceInfo.serviceInfo.serviceName = "TestService"; + serviceInfo.serviceInfo.serviceDisplayName = "Test Service Display"; + int32_t regServiceId = 0; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(ERR_DM_FAILED); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_007, testing::ext::TestSize.Level0) +{ + ServiceRegInfo serviceInfo; + serviceInfo.serviceInfo.serviceType = "TestType"; + serviceInfo.serviceInfo.serviceName = "TestService"; + serviceInfo.serviceInfo.serviceDisplayName = "Test Service Display"; + int32_t regServiceId = 0; + int32_t expectedRegServiceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(DM_OK); + publishRsp->SetRegServiceId(12345); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, DM_OK); + ASSERT_EQ(regServiceId, expectedRegServiceId); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_001, testing::ext::TestSize.Level0) +{ + int32_t regServiceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_002, testing::ext::TestSize.Level0) +{ + int32_t regServiceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_003, testing::ext::TestSize.Level0) +{ + int32_t regServiceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(ERR_DM_FAILED); + }), + Return(DM_OK) + )); + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_004, testing::ext::TestSize.Level0) +{ + int32_t regServiceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(DM_OK); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, DM_OK); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_device_manager_impl_three.cpp b/test/unittest/UTTest_device_manager_impl_three.cpp index 4fec18209a9c054faae66cda9e76164cba92ba0c..c84312f76fa519c5480284717244ba4d604c109a 100644 --- a/test/unittest/UTTest_device_manager_impl_three.cpp +++ b/test/unittest/UTTest_device_manager_impl_three.cpp @@ -39,7 +39,8 @@ #include "securec.h" #include "token_setproc.h" #include "softbus_error_code.h" - +#include "ipc_publish_service_info_rsp.h" +using namespace testing; namespace OHOS { namespace DistributedHardware { namespace { @@ -1436,6 +1437,572 @@ HWTEST_F(DeviceManagerImplTest, ExportAuthCode_301, testing::ext::TestSize.Level int32_t ret = DeviceManager::GetInstance().ExportAuthCode(authCode); ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); } + +HWTEST_F(DeviceManagerImplTest, StartServiceDiscovery_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + DiscoveryServiceParam discParam; + discParam.serviceType = "testService"; + discParam.discoveryServiceId = 12345; + std::shared_ptr callback = std::make_shared(); + int32_t ret = DeviceManager::GetInstance().StartServiceDiscovery(pkgName, discParam, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartServiceDiscovery_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + DiscoveryServiceParam discParam; + discParam.serviceType = "testService"; + discParam.discoveryServiceId = 12345; + std::shared_ptr callback = nullptr; + int32_t ret = DeviceManager::GetInstance().StartServiceDiscovery(pkgName, discParam, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartServiceDiscovery_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + DiscoveryServiceParam discParam; + discParam.serviceType = ""; + discParam.discoveryServiceId = 12345; + std::shared_ptr callback = std::make_shared(); + int32_t ret = DeviceManager::GetInstance().StartServiceDiscovery(pkgName, discParam, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartServiceDiscovery_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + DiscoveryServiceParam discParam; + discParam.serviceType = "testService"; + discParam.discoveryServiceId = 0; + std::shared_ptr callback = std::make_shared(); + int32_t ret = DeviceManager::GetInstance().StartServiceDiscovery(pkgName, discParam, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartServiceDiscovery_005, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + DiscoveryServiceParam discParam; + discParam.serviceType = "testService"; + discParam.discoveryServiceId = 12345; + std::shared_ptr callback = std::make_shared(); + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + int32_t ret = DeviceManager::GetInstance().StartServiceDiscovery(pkgName, discParam, callback); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, StopServiceDiscovery_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + int32_t discoveryServiceId = 12345; + int32_t ret = DeviceManager::GetInstance().StopServiceDiscovery(pkgName, discoveryServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StopServiceDiscovery_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int32_t discoveryServiceId = 0; + int32_t ret = DeviceManager::GetInstance().StopServiceDiscovery(pkgName, discoveryServiceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StopServiceDiscovery_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int32_t discoveryServiceId = 12345; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + int32_t ret = DeviceManager::GetInstance().StopServiceDiscovery(pkgName, discoveryServiceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, BindServiceTarget_InvalidInput_101, testing::ext::TestSize.Level0) +{ + PeerTargetId targetId; + std::map bindParam; + std::shared_ptr callback = nullptr; + int32_t ret = DeviceManagerImpl::GetInstance().BindServiceTarget("", targetId, bindParam, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, BindServiceTarget_InvalidInput_102, testing::ext::TestSize.Level0) +{ + PeerTargetId invalidTargetId; + std::map bindParam; + std::shared_ptr callback = nullptr; + int32_t ret = DeviceManagerImpl::GetInstance().BindServiceTarget("valid_pkg", invalidTargetId, bindParam, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, BindServiceTarget_IpcRequestFailed_101, testing::ext::TestSize.Level0) +{ + PeerTargetId targetId; + std::map bindParam; + std::shared_ptr callback = nullptr; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + int32_t ret = DeviceManagerImpl::GetInstance().BindServiceTarget("valid_pkg", targetId, bindParam, callback); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, BindServiceTarget_IpcResponseError_101, testing::ext::TestSize.Level0) +{ + PeerTargetId targetId; + std::map bindParam; + std::shared_ptr callback = nullptr; + + std::shared_ptr rsp = std::make_shared(); + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1) + .WillOnce(testing::Return(DM_OK)); + + int32_t ret = DeviceManagerImpl::GetInstance().BindServiceTarget("valid_pkg", targetId, bindParam, callback); + ASSERT_EQ(ret, rsp->GetErrCode()); +} + +HWTEST_F(DeviceManagerImplTest, BindServiceTarget_Success_101, testing::ext::TestSize.Level0) +{ + PeerTargetId targetId; + std::map bindParam; + std::shared_ptr callback = nullptr; + + auto rsp = std::make_shared(); + rsp->SetErrCode(DM_OK); + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1) + .WillOnce(testing::Return(DM_OK)); + + int32_t ret = DeviceManagerImpl::GetInstance().BindServiceTarget("valid_pkg", targetId, bindParam, callback); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, UnbindServiceTarget_InvalidInput_101, testing::ext::TestSize.Level0) { + int32_t ret = DeviceManagerImpl::GetInstance().UnbindServiceTarget("", 12345); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnbindServiceTarget_InvalidInput_102, testing::ext::TestSize.Level0) { + int32_t ret = DeviceManagerImpl::GetInstance().UnbindServiceTarget("valid_pkg", 0); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnbindServiceTarget_IpcFailed_101, testing::ext::TestSize.Level0) { + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + + int32_t ret = DeviceManagerImpl::GetInstance().UnbindServiceTarget("valid_pkg", 12345); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, UnbindServiceTarget_IpcError_101, testing::ext::TestSize.Level0) { + std::shared_ptr rsp = std::make_shared(); + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1) + .WillOnce(testing::Return(DM_OK)); + + int32_t ret = DeviceManagerImpl::GetInstance().UnbindServiceTarget("valid_pkg", 12345); + ASSERT_EQ(ret, rsp->GetErrCode()); +} + +HWTEST_F(DeviceManagerImplTest, UnbindServiceTarget_Success_101, testing::ext::TestSize.Level0) { + auto rsp = std::make_shared(); + rsp->SetErrCode(DM_OK); + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .Times(1) + .WillOnce(testing::Return(DM_OK)); + int32_t ret = DeviceManagerImpl::GetInstance().UnbindServiceTarget("valid_pkg", 12345); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = nullptr; + int64_t serviceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = nullptr; + int64_t serviceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 0; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_005, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 0; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(ERR_DM_FAILED); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_006, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 0; + int64_t expectedServiceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(DM_OK); + publishRsp->SetServiceId(12345); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, DM_OK); + ASSERT_EQ(serviceId, expectedServiceId); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_007, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + publishServiceParam.serviceInfo.serviceType = "test_service"; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 0; + int64_t expectedServiceId = 67890; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(DM_OK); + publishRsp->SetServiceId(67890); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, DM_OK); + ASSERT_EQ(serviceId, expectedServiceId); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_008, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 9999; + int64_t expectedServiceId = 54321; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(DM_OK); + publishRsp->SetServiceId(54321); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, callback, serviceId); + ASSERT_EQ(ret, DM_OK); + ASSERT_EQ(serviceId, expectedServiceId); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_009, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PublishServiceParam publishServiceParam; + std::shared_ptr callback = std::make_shared(); + int64_t serviceId = 0; + int64_t expectedServiceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + std::shared_ptr publishRsp = + std::static_pointer_cast(rsp); + publishRsp->SetErrCode(DM_OK); + publishRsp->SetServiceId(12345); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(pkgName, publishServiceParam, + callback, serviceId); + ASSERT_EQ(ret, DM_OK); + ASSERT_EQ(serviceId, expectedServiceId); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + int64_t serviceId = 0; + std::shared_ptr callback = std::make_shared(); + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceStateCallback(pkgName, serviceId, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceStateCallback_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + int64_t serviceId = 12345; + std::shared_ptr callback = std::make_shared(); + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceStateCallback(pkgName, serviceId, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceStateCallback_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 0; + std::shared_ptr callback = std::make_shared(); + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceStateCallback(pkgName, serviceId, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceStateCallback_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 12345; + std::shared_ptr callback = std::make_shared(); + EXPECT_CALL(*deviceManagerNotifyMock_, RegisterServiceStateCallback(testing::_, testing::_)) + .WillOnce(testing::Return(DM_OK)); + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceStateCallback(pkgName, serviceId, callback); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceStateCallback_005, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 12345; + std::shared_ptr callback = std::make_shared(); + + EXPECT_CALL(*deviceManagerNotifyMock_, RegisterServiceStateCallback(testing::_, testing::_)) + .WillOnce(testing::Return(ERR_DM_FAILED)); + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceStateCallback(pkgName, serviceId, callback); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, RegisterServiceStateCallback_006, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 12345; + std::shared_ptr callback = nullptr; + + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceStateCallback(pkgName, serviceId, callback); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + int64_t serviceId = 0; + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceStateCallback(pkgName, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceStateCallback_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = ""; + int64_t serviceId = 12345; + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceStateCallback(pkgName, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceStateCallback_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 0; + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceStateCallback(pkgName, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceStateCallback_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 12345; + + EXPECT_CALL(*deviceManagerNotifyMock_, UnRegisterServiceStateCallback(testing::_)) + .WillOnce(testing::Return(DM_OK)); + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceStateCallback(pkgName, serviceId); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceStateCallback_005, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + int64_t serviceId = 12345; + + int32_t expectedError = ERR_DM_FAILED; + EXPECT_CALL(*deviceManagerNotifyMock_, UnRegisterServiceStateCallback(testing::_)) + .WillOnce(testing::Return(ERR_DM_FAILED)); + + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceStateCallback(pkgName, serviceId); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_001, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 0; + + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_002, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_003, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 12345; + + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(ERR_DM_FAILED); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_004, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 12345; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(DM_OK); + }), + Return(DM_OK) + )); + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_005, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 67890; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(DM_OK); + }), + Return(DM_OK) + )); + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_006, testing::ext::TestSize.Level0) +{ + int64_t serviceId = -12345; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(DM_OK); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_007, testing::ext::TestSize.Level0) +{ + int64_t serviceId = INT64_MAX; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(DM_OK); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerImplTest, StopPublishService_008, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 12345; + EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) + .WillOnce(DoAll( + WithArg<2>([](std::shared_ptr rsp) { + rsp->SetErrCode(DM_OK); + }), + Return(DM_OK) + )); + + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, DM_OK); +} } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_notify.h b/test/unittest/UTTest_device_manager_notify.h index ed1413bee994cde8190da6d109434159a5fd1ac4..a5b0228527f16c43519ca2fbc5b41d1e391865d6 100644 --- a/test/unittest/UTTest_device_manager_notify.h +++ b/test/unittest/UTTest_device_manager_notify.h @@ -119,6 +119,30 @@ public: void OnDestroyResult(int32_t result) {} void OnPinHolderEvent(DmPinHolderEvent event, int32_t result, const std::string &content) {} }; + +class BindTargetCallbackTest : public BindTargetCallback { +public: + void OnBindResult(const PeerTargetId &targetId, int32_t result, int32_t status, std::string content) override {} +}; + +class ServiceDiscoveryCallbackTest : public ServiceDiscoveryCallback { +public: + void OnServiceFound(const DiscoveryServiceInfo &service) override {} + void OnServiceDiscoveryResult(int32_t resReason) override {} +}; + +class ServiceInfoStateCallbackTest : public ServiceInfoStateCallback { +public: + void OnServiceOnline(int64_t serviceId) override {} + void OnServiceOffline(int64_t serviceId) override {} +}; + +class ServicePublishCallbackTest : public ServicePublishCallback { +public: + ServicePublishCallbackTest() = default; + virtual ~ServicePublishCallbackTest() = default; + void OnServicePublishResult(int64_t serviceId, int32_t reason) override {} +}; } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_notify_three.cpp b/test/unittest/UTTest_device_manager_notify_three.cpp index 820700d7bca1181bac87119768bc5f96b2ee455f..76f2db7a4c8c14e2a60e601658ef1fe3e08d113d 100644 --- a/test/unittest/UTTest_device_manager_notify_three.cpp +++ b/test/unittest/UTTest_device_manager_notify_three.cpp @@ -24,7 +24,8 @@ #include "ipc_set_useroperation_req.h" #include "ipc_rsp.h" #include "ipc_def.h" - +#include "dm_error_type.h" +#include "dm_constants.h" #include namespace OHOS { @@ -1017,6 +1018,431 @@ HWTEST_F(DeviceManagerNotifyTest, RegisterPinHolderCallback_303, testing::ext::T DeviceManagerNotify::GetInstance().RegisterPinHolderCallback(pkgName, callback); EXPECT_EQ(DeviceManagerNotify::GetInstance().pinHolderCallback_.empty(), true); } + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterBindCallback_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(DeviceManagerNotify::GetInstance().bindCallback_.empty()); + + std::string emptyPkgName = "testTargetId"; + PeerTargetId targetId; + DeviceManagerNotify::GetInstance().UnRegisterBindCallback(emptyPkgName, targetId); + ASSERT_TRUE(DeviceManagerNotify::GetInstance().bindCallback_.empty()); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterBindCallback_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PeerTargetId targetId; + std::shared_ptr callback = std::make_shared(); + DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId] = callback; + ASSERT_EQ(DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId], callback); + + std::string nonExistentPkgName = "com.ohos.nonexistent"; + DeviceManagerNotify::GetInstance().UnRegisterBindCallback(nonExistentPkgName, targetId); + ASSERT_EQ(DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId], callback); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterBindCallback_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PeerTargetId targetId; + std::shared_ptr callback = std::make_shared(); + DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId] = callback; + + ASSERT_EQ(DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId], callback); + PeerTargetId nonExistentTargetId; + DeviceManagerNotify::GetInstance().UnRegisterBindCallback(pkgName, nonExistentTargetId); + ASSERT_EQ(DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId], callback); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterBindCallback_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + PeerTargetId targetId; + std::shared_ptr callback = std::make_shared(); + DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId] = callback; + + ASSERT_EQ(DeviceManagerNotify::GetInstance().bindCallback_[pkgName][targetId], callback); + DeviceManagerNotify::GetInstance().UnRegisterBindCallback(pkgName, targetId); + ASSERT_TRUE(DeviceManagerNotify::GetInstance().bindCallback_.empty()); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServiceDiscoveryCallback_001, testing::ext::TestSize.Level0) +{ + int32_t discoveryServiceId = 123; + std::shared_ptr callback = nullptr; + + size_t initialSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DeviceManagerNotify::GetInstance().RegisterServiceDiscoveryCallback(discoveryServiceId, callback); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(initialSize, finalSize); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServiceDiscoveryCallback_002, testing::ext::TestSize.Level0) +{ + int32_t discoveryServiceId = 456; + int count = 0; + std::shared_ptr callback = std::make_shared(); + + size_t initialSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DeviceManagerNotify::GetInstance().RegisterServiceDiscoveryCallback(discoveryServiceId, callback); + + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(initialSize + 1, finalSize); + + auto it = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.find(discoveryServiceId); + ASSERT_NE(it, DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.end()); + ASSERT_EQ(it->second, callback); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceDiscoveryCallback_001, testing::ext::TestSize.Level0) +{ + int32_t nonExistentDiscoveryServiceId = 999; + size_t initialSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DeviceManagerNotify::GetInstance().UnRegisterServiceDiscoveryCallback(nonExistentDiscoveryServiceId); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(initialSize, finalSize); + + auto it = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.find(nonExistentDiscoveryServiceId); + ASSERT_EQ(it, DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.end()); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceDiscoveryCallback_002, testing::ext::TestSize.Level0) +{ + int32_t discoveryServiceId = 456; + int count = 0; + std::shared_ptr callback = std::make_shared(); + + DeviceManagerNotify::GetInstance().RegisterServiceDiscoveryCallback(discoveryServiceId, callback); + size_t sizeAfterRegister = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + auto it = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.find(discoveryServiceId); + ASSERT_NE(it, DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.end()); + DeviceManagerNotify::GetInstance().UnRegisterServiceDiscoveryCallback(discoveryServiceId); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(sizeAfterRegister - 1, finalSize); + it = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.find(discoveryServiceId); + ASSERT_EQ(it, DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.end()); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceDiscoveryCallback_003, testing::ext::TestSize.Level0) +{ + int32_t discoveryServiceId = 789; + int count = 0; + std::shared_ptr callback = std::make_shared(); + + DeviceManagerNotify::GetInstance().RegisterServiceDiscoveryCallback(discoveryServiceId, callback); + DeviceManagerNotify::GetInstance().UnRegisterServiceDiscoveryCallback(discoveryServiceId); + size_t sizeAfterFirstUnregister = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DeviceManagerNotify::GetInstance().UnRegisterServiceDiscoveryCallback(discoveryServiceId); + size_t sizeAfterSecondUnregister = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(sizeAfterFirstUnregister, sizeAfterSecondUnregister); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServiceStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string emptyKey = ""; + int count = 0; + std::shared_ptr callback = std::make_shared(); + int32_t result = DeviceManagerNotify::GetInstance().RegisterServiceStateCallback(emptyKey, callback); + + ASSERT_EQ(result, ERR_DM_INPUT_PARA_INVALID); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServiceStateCallback_002, testing::ext::TestSize.Level0) +{ + std::string key = "test_key"; + std::shared_ptr nullCallback = nullptr; + + int32_t result = DeviceManagerNotify::GetInstance().RegisterServiceStateCallback(key, nullCallback); + ASSERT_EQ(result, ERR_DM_INPUT_PARA_INVALID); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServiceStateCallback_003, testing::ext::TestSize.Level0) +{ + std::string emptyKey = ""; + std::shared_ptr nullCallback = nullptr; + + int32_t result = DeviceManagerNotify::GetInstance().RegisterServiceStateCallback(emptyKey, nullCallback); + ASSERT_EQ(result, ERR_DM_INPUT_PARA_INVALID); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServiceStateCallback_004, testing::ext::TestSize.Level0) +{ + std::string key = "valid_test_key"; + int count = 0; + std::shared_ptr callback = std::make_shared(); + + size_t initialSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + int32_t result = DeviceManagerNotify::GetInstance().RegisterServiceStateCallback(key, callback); + + ASSERT_EQ(result, DM_OK); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, initialSize + 1); + + auto it = DeviceManagerNotify::GetInstance().serviceStateCallback_.find(key); + ASSERT_NE(it, DeviceManagerNotify::GetInstance().serviceStateCallback_.end()); + ASSERT_EQ(it->second, callback); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string emptyKey = ""; + size_t initialSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + int32_t result = DeviceManagerNotify::GetInstance().UnRegisterServiceStateCallback(emptyKey); + ASSERT_EQ(result, ERR_DM_INPUT_PARA_INVALID); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceStateCallback_002, testing::ext::TestSize.Level0) +{ + std::string nonExistentKey = "non_existent_key"; + size_t initialSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + int32_t result = DeviceManagerNotify::GetInstance().UnRegisterServiceStateCallback(nonExistentKey); + ASSERT_EQ(result, ERR_DM_INPUT_PARA_INVALID); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceStateCallback_003, testing::ext::TestSize.Level0) +{ + std::string key = "test_key_to_unregister"; + int count = 0; + std::shared_ptr callback = std::make_shared(); + + DeviceManagerNotify::GetInstance().RegisterServiceStateCallback(key, callback); + size_t sizeAfterRegister = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + auto it = DeviceManagerNotify::GetInstance().serviceStateCallback_.find(key); + ASSERT_NE(it, DeviceManagerNotify::GetInstance().serviceStateCallback_.end()); + + int32_t result = DeviceManagerNotify::GetInstance().UnRegisterServiceStateCallback(key); + ASSERT_EQ(result, DM_OK); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, sizeAfterRegister - 1); + it = DeviceManagerNotify::GetInstance().serviceStateCallback_.find(key); + ASSERT_EQ(it, DeviceManagerNotify::GetInstance().serviceStateCallback_.end()); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServiceStateCallback_EmptyMap, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().serviceStateCallback_.clear(); + std::string key = "any_key"; + int32_t result = DeviceManagerNotify::GetInstance().UnRegisterServiceStateCallback(key); + ASSERT_EQ(result, ERR_DM_INPUT_PARA_INVALID); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServicePublishCallback_001, testing::ext::TestSize.Level0) +{ + int64_t zeroServiceId = 0; + size_t initialSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + DeviceManagerNotify::GetInstance().UnRegisterServicePublishCallback(zeroServiceId); + size_t finalSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServicePublishCallback_002, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 12345; + int count = 0; + auto callback = std::make_shared(); + + DeviceManagerNotify::GetInstance().servicePublishCallback_[serviceId] = callback; + size_t sizeAfterAdd = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + auto it = DeviceManagerNotify::GetInstance().servicePublishCallback_.find(serviceId); + ASSERT_NE(it, DeviceManagerNotify::GetInstance().servicePublishCallback_.end()); + DeviceManagerNotify::GetInstance().UnRegisterServicePublishCallback(serviceId); + size_t finalSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + ASSERT_EQ(finalSize, sizeAfterAdd - 1); + + it = DeviceManagerNotify::GetInstance().servicePublishCallback_.find(serviceId); + ASSERT_EQ(it, DeviceManagerNotify::GetInstance().servicePublishCallback_.end()); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServicePublishCallback_003, testing::ext::TestSize.Level0) +{ + int64_t nonExistentServiceId = 99999; + size_t initialSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + DeviceManagerNotify::GetInstance().UnRegisterServicePublishCallback(nonExistentServiceId); + size_t finalSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, UnRegisterServicePublishCallback_004, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().servicePublishCallback_.clear(); + int64_t serviceId = 11111; + DeviceManagerNotify::GetInstance().UnRegisterServicePublishCallback(serviceId); + size_t finalSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceFound_001, testing::ext::TestSize.Level0) +{ + int32_t nonExistentServiceId = 99999; + DiscoveryServiceInfo serviceInfo; + size_t initialSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DeviceManagerNotify::GetInstance().OnServiceFound(nonExistentServiceId, serviceInfo); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceFound_002, testing::ext::TestSize.Level0) +{ + int32_t serviceId = 12345; + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_[serviceId] = nullptr; + size_t sizeAfterAdd = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DiscoveryServiceInfo serviceInfo; + DeviceManagerNotify::GetInstance().OnServiceFound(serviceId, serviceInfo); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(finalSize, sizeAfterAdd); + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.erase(serviceId); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceFound_003, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.clear(); + int32_t serviceId = 22222; + DiscoveryServiceInfo serviceInfo; + DeviceManagerNotify::GetInstance().OnServiceFound(serviceId, serviceInfo); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceDiscoveryResult_001, testing::ext::TestSize.Level0) +{ + int32_t nonExistentServiceId = 99999; + int32_t resultReason = DM_OK; + size_t initialSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + DeviceManagerNotify::GetInstance().OnServiceDiscoveryResult(nonExistentServiceId, resultReason); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceDiscoveryResult_002, testing::ext::TestSize.Level0) +{ + int32_t serviceId = 12345; + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_[serviceId] = nullptr; + size_t sizeAfterAdd = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + int32_t resultReason = DM_OK; + DeviceManagerNotify::GetInstance().OnServiceDiscoveryResult(serviceId, resultReason); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(finalSize, sizeAfterAdd); + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.erase(serviceId); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceDiscoveryResult_003, testing::ext::TestSize.Level0) +{ + int32_t serviceId = 67890; + std::shared_ptr callback = std::make_shared(); + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_[serviceId] = callback; + int32_t resultReason = DM_OK; + DeviceManagerNotify::GetInstance().OnServiceDiscoveryResult(serviceId, resultReason); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_GE(finalSize, 1); + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.erase(serviceId); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceDiscoveryResult_004, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.clear(); + int32_t serviceId = 33333; + int32_t resultReason = DM_OK; + DeviceManagerNotify::GetInstance().OnServiceDiscoveryResult(serviceId, resultReason); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceDiscoveryCallbacks_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, RegisterServicePublishCallback_ContainerFull, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().servicePublishCallback_.clear(); + int64_t serviceId = 10101; + size_t beforeSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + std::shared_ptr nullCb = nullptr; + DeviceManagerNotify::GetInstance().RegisterServicePublishCallback(serviceId, nullCb); + size_t afterSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + ASSERT_EQ(beforeSize, afterSize); + auto it = DeviceManagerNotify::GetInstance().servicePublishCallback_.find(serviceId); + ASSERT_EQ(it, DeviceManagerNotify::GetInstance().servicePublishCallback_.end()); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServicePublishResult_001, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().servicePublishCallback_.clear(); + int64_t serviceId = 50001; + auto cb = std::make_shared(); + DeviceManagerNotify::GetInstance().servicePublishCallback_[serviceId] = cb; + DeviceManagerNotify::GetInstance().OnServicePublishResult(serviceId, DM_OK); + auto it = DeviceManagerNotify::GetInstance().servicePublishCallback_.find(serviceId); + ASSERT_NE(it, DeviceManagerNotify::GetInstance().servicePublishCallback_.end()); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServicePublishResult_002, testing::ext::TestSize.Level0) +{ + DeviceManagerNotify::GetInstance().servicePublishCallback_.clear(); + int64_t serviceId = 50003; + size_t beforeSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + DeviceManagerNotify::GetInstance().OnServicePublishResult(serviceId, DM_OK); + size_t afterSize = DeviceManagerNotify::GetInstance().servicePublishCallback_.size(); + ASSERT_EQ(beforeSize, afterSize); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceOnline_001, testing::ext::TestSize.Level0) +{ + std::vector emptyServiceIds; + size_t initialSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + DeviceManagerNotify::GetInstance().OnServiceOnline(emptyServiceIds); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, initialSize); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceOnline_002, testing::ext::TestSize.Level0) +{ + std::vector serviceIds = {11111, 22222, 33333}; + DeviceManagerNotify::GetInstance().serviceStateCallback_.clear(); + DeviceManagerNotify::GetInstance().OnServiceOnline(serviceIds); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 0); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceOnline_003, testing::ext::TestSize.Level0) +{ + int64_t existingServiceId1 = 1001; + int64_t existingServiceId2 = 1002; + int64_t nonExistingServiceId = 9999; + std::vector serviceIds = {existingServiceId1, nonExistingServiceId, existingServiceId2}; + DeviceManagerNotify::GetInstance().serviceStateCallback_.clear(); + std::shared_ptr callback1 = std::make_shared(); + DeviceManagerNotify::GetInstance().serviceStateCallback_[std::to_string(existingServiceId1)] = callback1; + std::shared_ptr callback2 = std::make_shared(); + DeviceManagerNotify::GetInstance().serviceStateCallback_[std::to_string(existingServiceId2)] = callback2; + DeviceManagerNotify::GetInstance().OnServiceOnline(serviceIds); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 2); + DeviceManagerNotify::GetInstance().serviceStateCallback_.clear(); +} + +HWTEST_F(DeviceManagerNotifyTest, OnServiceOnline_004, testing::ext::TestSize.Level0) +{ + int64_t serviceId = 3001; + std::vector serviceIds = {serviceId}; + DeviceManagerNotify::GetInstance().serviceStateCallback_.clear(); + + int count = 0; + std::shared_ptr callback = std::make_shared(); + DeviceManagerNotify::GetInstance().serviceStateCallback_[std::to_string(serviceId)] = callback; + DeviceManagerNotify::GetInstance().OnServiceOnline(serviceIds); + size_t finalSize = DeviceManagerNotify::GetInstance().serviceStateCallback_.size(); + ASSERT_EQ(finalSize, 1); + DeviceManagerNotify::GetInstance().serviceStateCallback_.clear(); +} } // namespace DmInitCallbackTest::DmInitCallbackTest(int &count) : DmInitCallback() diff --git a/test/unittest/mock/device_manager_notify_mock.cpp b/test/unittest/mock/device_manager_notify_mock.cpp index acc15eb94d14c74f0fcd7af9ac47add32463eadc..5b91be8f9d3b1ee933a8f4b1f2a5802e0c89697d 100644 --- a/test/unittest/mock/device_manager_notify_mock.cpp +++ b/test/unittest/mock/device_manager_notify_mock.cpp @@ -30,5 +30,16 @@ int32_t DeviceManagerNotify::RegisterGetDeviceIconInfoCallback(const std::string { return DmDeviceManagerNotify::dmDeviceManagerNotify->RegisterGetDeviceIconInfoCallback(pkgName, uk, callback); } + +int32_t DeviceManagerNotify::RegisterServiceStateCallback(const std::string &key, + std::shared_ptr callback) +{ + return DmDeviceManagerNotify::dmDeviceManagerNotify->RegisterServiceStateCallback(key, callback); +} + +int32_t DeviceManagerNotify::UnRegisterServiceStateCallback(const std::string &key) +{ + return DmDeviceManagerNotify::dmDeviceManagerNotify->UnRegisterServiceStateCallback(key); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/device_manager_notify_mock.h b/test/unittest/mock/device_manager_notify_mock.h index a67f46b745769c4aec7149ce7188bf6b46c18068..882cb9820cfae0a34ae9221c452c698ea2c86e06 100644 --- a/test/unittest/mock/device_manager_notify_mock.h +++ b/test/unittest/mock/device_manager_notify_mock.h @@ -30,6 +30,9 @@ public: std::shared_ptr callback) = 0; virtual int32_t RegisterGetDeviceProfileInfoListCallback(const std::string &pkgName, std::shared_ptr callback) = 0; + virtual int32_t RegisterServiceStateCallback(const std::string &key, + std::shared_ptr callback) = 0; + virtual int32_t UnRegisterServiceStateCallback(const std::string &key) = 0; public: static inline std::shared_ptr dmDeviceManagerNotify = nullptr; }; @@ -40,6 +43,9 @@ public: std::shared_ptr)); MOCK_METHOD(int32_t, RegisterGetDeviceProfileInfoListCallback, (const std::string &, std::shared_ptr)); + MOCK_METHOD(int32_t, RegisterServiceStateCallback, (const std::string &key, + std::shared_ptr callback)); + MOCK_METHOD(int32_t, UnRegisterServiceStateCallback, (const std::string &key)); }; } }