From 7a95f4c4daa11a4757a2bfba30dbe18dd3b08662 Mon Sep 17 00:00:00 2001 From: zhuzhihui7 Date: Wed, 12 Mar 2025 09:20:11 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=86=E5=B8=83=E5=BC=8F=E7=9B=B8=E6=9C=BAal?= =?UTF-8?q?lconnect=E8=BF=BD=E5=8A=A0tdd=E6=B5=8B=E8=AF=95=E7=94=A8?= =?UTF-8?q?=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhuzhihui7 --- .../test/unittest/common/channel/BUILD.gn | 8 +- .../dcamera_allconnect_manager_test.cpp | 161 ++++++++++++++++++ .../channel/dcamera_allconnect_manager_test.h | 35 ++++ .../channel/dcamera_softbus_adapter_test.cpp | 84 ++++++++- .../mock/dcamera_channel_listener_mock.h | 36 ++++ .../mock/dcamera_collaboration_mock.cpp | 72 ++++++++ .../channel/mock/dcamera_collaboration_mock.h | 41 +++++ .../unittest/common/channel/mock/dlfcn_mock.h | 39 +++++ .../common/channel/mock/lib_function_mock.cpp | 63 +++++++ 9 files changed, 537 insertions(+), 2 deletions(-) create mode 100644 services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.cpp create mode 100644 services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.h create mode 100644 services/channel/test/unittest/common/channel/mock/dcamera_channel_listener_mock.h create mode 100644 services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.cpp create mode 100644 services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.h create mode 100644 services/channel/test/unittest/common/channel/mock/dlfcn_mock.h create mode 100644 services/channel/test/unittest/common/channel/mock/lib_function_mock.cpp diff --git a/services/channel/test/unittest/common/channel/BUILD.gn b/services/channel/test/unittest/common/channel/BUILD.gn index 64a9eccf..adad7c77 100644 --- a/services/channel/test/unittest/common/channel/BUILD.gn +++ b/services/channel/test/unittest/common/channel/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2024 Huawei Device Co., Ltd. +# Copyright (c) 2022-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 @@ -27,6 +27,7 @@ config("module_private_config") { "${services_path}/channel/include", "${services_path}/channel/include/allconnect", "${services_path}/channel/test/unittest/common/channel", + "${services_path}/channel/test/unittest/common/channel/mock", "${services_path}/cameraservice/cameraoperator/client/include", "${services_path}/cameraservice/cameraoperator/client/include/callback", "${services_path}/cameraservice/cameraoperator/client/include/listener", @@ -60,11 +61,14 @@ ohos_unittest("DCameraChannelTest") { "${services_path}/channel/src/dcamera_softbus_adapter.cpp", "${services_path}/channel/src/dcamera_softbus_latency.cpp", "${services_path}/channel/src/dcamera_softbus_session.cpp", + "dcamera_allconnect_manager_test.cpp", "dcamera_channel_sink_impl_test.cpp", "dcamera_channel_source_impl_test.cpp", "dcamera_softbus_adapter_test.cpp", "dcamera_softbus_latency_test.cpp", "dcamera_softbus_session_test.cpp", + "mock/dcamera_collaboration_mock.cpp", + "mock/lib_function_mock.cpp", "session_bus_center.cpp", "session_mock.cpp", ] @@ -85,6 +89,8 @@ ohos_unittest("DCameraChannelTest") { "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.1", "dsoftbus:softbus_client", "eventhandler:libeventhandler", + "googletest:gmock", + "googletest:gmock_main", "graphic_surface:surface", "hdf_core:libhdi", "hilog:libhilog", diff --git a/services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.cpp b/services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.cpp new file mode 100644 index 00000000..8d57e7af --- /dev/null +++ b/services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.cpp @@ -0,0 +1,161 @@ +/* + * 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 "dcamera_collaboration_mock.h" +#include "dcamera_allconnect_manager_test.h" +#include "dlfcn_mock.h" + +using namespace testing; + +namespace OHOS { +namespace DistributedHardware { +namespace { +constexpr int32_t VALUABLE_SESSION_ID = 10; +constexpr int32_t UNVALUABLE_SESSION_ID = -1; +constexpr const char* DL_HANDLE = "dlhandle success"; +const std::string PEER_NETWORK_ID = "peerNetworkId"; +} // namespace + +bool DCameraAllConnectManagerTest::InitAllConnectManagerMockEnv() +{ + auto dlfcnInstance = DlfcnMock::GetOrCreateInstance(); + if (!dlfcnInstance) { + return false; + } + EXPECT_CALL(*dlfcnInstance, DlopenMock(_, _)).WillOnce(Return((void *)DL_HANDLE)); + EXPECT_CALL(*dlfcnInstance, DlsymMock(_, _)) + .WillOnce(Return((void *)DCameraCollaborationMock::DCameraCollaborationExport)); + DCameraAllConnectManager::GetInstance().InitDCameraAllConnectManager(); + return true; +} + +bool DCameraAllConnectManagerTest::UnInitAllConnectManagerMockEnv() +{ + auto dlfcnInstance = DlfcnMock::GetOrCreateInstance(); + if (!dlfcnInstance) { + return false; + } + if (!DCameraAllConnectManager::IsInited()) { + DlfcnMock::ReleaseInstance(); + return false; + } + + EXPECT_CALL(*dlfcnInstance, DlcloseMock(_)).Times(AtLeast(1)); + DCameraAllConnectManager::GetInstance().UnInitDCameraAllConnectManager(); + DlfcnMock::ReleaseInstance(); + return true; +} + +void DCameraAllConnectManagerTest::SetUp() +{} + +void DCameraAllConnectManagerTest::TearDown() +{} + +void DCameraAllConnectManagerTest::SetUpTestCase(void) +{ + DCameraAllConnectManagerTest::InitAllConnectManagerMockEnv(); +} + +void DCameraAllConnectManagerTest::TearDownTestCase(void) +{ + DCameraAllConnectManagerTest::UnInitAllConnectManagerMockEnv(); +} + +HWTEST_F(DCameraAllConnectManagerTest, PublishServiceState_001, testing::ext::TestSize.Level1) +{ + auto ret = DCameraAllConnectManager::GetInstance().PublishServiceState(PEER_NETWORK_ID, + DCameraCollaborationBussinessStatus::SCM_CONNECTING); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_OK); +} + +HWTEST_F(DCameraAllConnectManagerTest, PublishServiceState_002, testing::ext::TestSize.Level2) +{ + std::string emptyPeerNetworkId; + auto ret = DCameraAllConnectManager::GetInstance().PublishServiceState(emptyPeerNetworkId, + DCameraCollaborationBussinessStatus::SCM_CONNECTING); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_ERR_PUBLISH_STATE); +} + +HWTEST_F(DCameraAllConnectManagerTest, ApplyAdvancedResource_001, testing::ext::TestSize.Level1) +{ + DCameraCollaborationResourceRequestInfoSets resultCallback; + auto ret = DCameraAllConnectManager::GetInstance().ApplyAdvancedResource(PEER_NETWORK_ID, &resultCallback); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_OK); +} + +HWTEST_F(DCameraAllConnectManagerTest, ApplyAdvancedResource_002, testing::ext::TestSize.Level2) +{ + auto ret = DCameraAllConnectManager::GetInstance().ApplyAdvancedResource(PEER_NETWORK_ID, nullptr); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_ERR_APPLY_RESULT); + + std::string emptyPeerNetworkId; + DCameraCollaborationResourceRequestInfoSets resultCallback; + ret = DCameraAllConnectManager::GetInstance().ApplyAdvancedResource(emptyPeerNetworkId, &resultCallback); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_ERR_APPLY_RESULT); +} + +HWTEST_F(DCameraAllConnectManagerTest, RegisterLifecycleCallback_001, testing::ext::TestSize.Level1) +{ + auto ret = DCameraAllConnectManager::GetInstance().RegisterLifecycleCallback(); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_OK); + ret = DCameraAllConnectManager::GetInstance().UnRegisterLifecycleCallback(); + EXPECT_EQ(ret, DistributedCameraErrno::DCAMERA_OK); +} + +HWTEST_F(DCameraAllConnectManagerTest, BuildResourceRequest_001, testing::ext::TestSize.Level1) +{ + auto ret = DCameraAllConnectManager::GetInstance().BuildResourceRequest(); + EXPECT_TRUE(ret != nullptr); +} + +HWTEST_F(DCameraAllConnectManagerTest, SinkSideScenario_001, testing::ext::TestSize.Level1) +{ + DCameraAllConnectManager::SetSinkNetWorkId(PEER_NETWORK_ID, VALUABLE_SESSION_ID); + auto targetNetworkId = DCameraAllConnectManager::GetSinkDevIdBySocket(VALUABLE_SESSION_ID); + EXPECT_STREQ(targetNetworkId.c_str(), PEER_NETWORK_ID.c_str()); + DCameraAllConnectManager::RemoveSinkNetworkId(VALUABLE_SESSION_ID); +} + +HWTEST_F(DCameraAllConnectManagerTest, SinkSideScenario_002, testing::ext::TestSize.Level2) +{ + DCameraAllConnectManager::SetSinkNetWorkId(std::string(), UNVALUABLE_SESSION_ID); + DCameraAllConnectManager::SetSinkNetWorkId(PEER_NETWORK_ID, UNVALUABLE_SESSION_ID); + auto targetNetworkId = DCameraAllConnectManager::GetSinkDevIdBySocket(UNVALUABLE_SESSION_ID); + EXPECT_TRUE(targetNetworkId.empty()); + DCameraAllConnectManager::RemoveSinkNetworkId(VALUABLE_SESSION_ID); +} + +HWTEST_F(DCameraAllConnectManagerTest, SourceSideScenario_001, testing::ext::TestSize.Level1) +{ + DCameraAllConnectManager::SetSourceNetworkId(PEER_NETWORK_ID, VALUABLE_SESSION_ID); + auto targetSessionId = DCameraAllConnectManager::GetSourceSocketByNetworkId(PEER_NETWORK_ID); + EXPECT_EQ(targetSessionId, VALUABLE_SESSION_ID); + DCameraAllConnectManager::RemoveSourceNetworkId(VALUABLE_SESSION_ID); +} + +HWTEST_F(DCameraAllConnectManagerTest, SourceSideScenario_002, testing::ext::TestSize.Level2) +{ + DCameraAllConnectManager::SetSourceNetworkId(std::string(), UNVALUABLE_SESSION_ID); + DCameraAllConnectManager::SetSourceNetworkId(PEER_NETWORK_ID, UNVALUABLE_SESSION_ID); + auto targetSessionId = DCameraAllConnectManager::GetSourceSocketByNetworkId(PEER_NETWORK_ID); + EXPECT_EQ(targetSessionId, UNVALUABLE_SESSION_ID); + DCameraAllConnectManager::RemoveSourceNetworkId(UNVALUABLE_SESSION_ID); +} +} // namespace DistributedHardware +} // OHOS diff --git a/services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.h b/services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.h new file mode 100644 index 00000000..93c1b092 --- /dev/null +++ b/services/channel/test/unittest/common/channel/dcamera_allconnect_manager_test.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DCAMERA_ALLCONNECT_MANAGER_TEST_H +#define OHOS_DCAMERA_ALLCONNECT_MANAGER_TEST_H + +#include "distributed_camera_allconnect_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class DCameraAllConnectManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + static bool InitAllConnectManagerMockEnv(); + static bool UnInitAllConnectManagerMockEnv(); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DCAMERA_ALLCONNECT_MANAGER_TEST_H diff --git a/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp b/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp index 2e52fde2..6acfb6a1 100644 --- a/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp +++ b/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-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 @@ -21,6 +21,8 @@ #undef private #include "data_buffer.h" +#include "dcamera_allconnect_manager_test.h" +#include "dcamera_channel_listener_mock.h" #include "dcamera_softbus_session.h" #include "dcamera_hisysevent_adapter.h" #include "dcamera_utils_tools.h" @@ -29,6 +31,13 @@ #include "session_bus_center.h" using namespace testing::ext; +using ::testing::_; +using ::testing::An; +using ::testing::Return; +using ::testing::DoAll; +using ::testing::AtLeast; +using ::testing::InSequence; +using ::testing::SetArgReferee; namespace OHOS { namespace DistributedHardware { @@ -43,14 +52,17 @@ public: namespace { const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +constexpr int32_t UNIQUE_SOCKED_ID = 0; } void DCameraSoftbusAdapterTest::SetUpTestCase(void) { + DCameraAllConnectManagerTest::InitAllConnectManagerMockEnv(); } void DCameraSoftbusAdapterTest::TearDownTestCase(void) { + DCameraAllConnectManagerTest::UnInitAllConnectManagerMockEnv(); } void DCameraSoftbusAdapterTest::SetUp(void) @@ -914,5 +926,75 @@ HWTEST_F(DCameraSoftbusAdapterTest, DCameraSoftbusAdapterTest_035, TestSize.Leve sessionMode, role); DCameraSoftbusAdapter::GetInstance().CloseSessionWithNetWorkId("testNetworkId"); } + +HWTEST_F(DCameraSoftbusAdapterTest, DCameraSoftbusAdapterTest_036, TestSize.Level1) +{ + std::string myDevId = "abcde"; + std::string peerSessName = "sink_control"; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + auto ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId, + sessionMode, role); + EXPECT_EQ(ret, UNIQUE_SOCKED_ID); + DCameraSoftbusAdapter::GetInstance().CloseSessionWithNetWorkId(peerDevId); +} + +HWTEST_F(DCameraSoftbusAdapterTest, DCameraSoftbusAdapterTest_037, TestSize.Level1) +{ + std::string myDevId = "abcde"; + std::string sessionName = "sourcetest037"; + std::string peerDevId = TEST_DEVICE_ID; + std::string peerSessName = "sink_control"; + + auto listener = std::make_shared(); + auto session = std::make_shared( + myDevId, sessionName, peerDevId, peerSessName, listener, DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL); + EXPECT_CALL(*listener, OnSessionState(_, _)).Times(AtLeast(1)); + + DCameraSoftbusAdapter::GetInstance().RecordSourceSocketSession(UNIQUE_SOCKED_ID, session); + PeerSocketInfo info = { + .name = const_cast(peerSessName.c_str()), + .pkgName = const_cast(DCAMERA_PKG_NAME.c_str()), + .networkId = const_cast(peerDevId.c_str()), + .dataType = TransDataType::DATA_TYPE_BYTES, + }; + auto ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(UNIQUE_SOCKED_ID, info); + EXPECT_EQ(ret, DCAMERA_OK); + + DCameraSoftbusAdapter::GetInstance().CloseSoftbusSession(UNIQUE_SOCKED_ID); + DCameraAllConnectManager::RemoveSourceNetworkId(UNIQUE_SOCKED_ID); +} + +HWTEST_F(DCameraSoftbusAdapterTest, DCameraSoftbusAdapterTest_038, TestSize.Level1) +{ + std::string mySessionName = "control"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNEL_ROLE::DCAMERA_CHANNLE_ROLE_SINK; + DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL; + std::string myDevId = "abcde"; + std::string peerDevId = TEST_DEVICE_ID; + std::string peerSessionName = peerDevId + "_control"; + DCameraSoftbusAdapter::GetInstance().mySocketSet_.clear(); + ManageSelectChannel::GetInstance().SetSinkConnect(false); + DCameraSoftbusAdapter::GetInstance().CreatSoftBusSinkSocketServer( + mySessionName, role, sessionMode, peerDevId, peerSessionName); + auto listener = std::make_shared(); + EXPECT_CALL(*listener, OnSessionState(_, _)).Times(AtLeast(1)); + auto session = std::make_shared( + myDevId, mySessionName, peerDevId, peerSessionName, listener, DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL); + DCameraSoftbusAdapter::GetInstance().sinkSessions_[mySessionName] = session; + PeerSocketInfo info = { + .name = const_cast(peerSessionName.c_str()), + .pkgName = const_cast(DCAMERA_PKG_NAME.c_str()), + .networkId = const_cast(peerDevId.c_str()), + .dataType = TransDataType::DATA_TYPE_BYTES, + }; + auto ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(UNIQUE_SOCKED_ID, info); + EXPECT_EQ(ret, DCAMERA_OK); + DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(UNIQUE_SOCKED_ID, SHUTDOWN_REASON_UNEXPECTED); + DCameraSoftbusAdapter::GetInstance().CloseSoftbusSession(UNIQUE_SOCKED_ID); + DCameraSoftbusAdapter::GetInstance().mySocketSet_.erase(UNIQUE_SOCKED_ID); + DCameraSoftbusAdapter::GetInstance().sinkSessions_.erase(mySessionName); +} } } \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/mock/dcamera_channel_listener_mock.h b/services/channel/test/unittest/common/channel/mock/dcamera_channel_listener_mock.h new file mode 100644 index 00000000..04388bfa --- /dev/null +++ b/services/channel/test/unittest/common/channel/mock/dcamera_channel_listener_mock.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DCAMERA_CHANNEL_LISTENER_MOCK_H +#define OHOS_DCAMERA_CHANNEL_LISTENER_MOCK_H + +#include +#include "icamera_channel_listener.h" + +namespace OHOS { +namespace DistributedHardware { + +class DCameraChannelListenerMock : public ICameraChannelListener { +public: + DCameraChannelListenerMock() = default; + ~DCameraChannelListenerMock() override = default; + + MOCK_METHOD(void, OnSessionState, (int32_t, std::string)); + MOCK_METHOD(void, OnSessionError, (int32_t, int32_t, std::string)); + MOCK_METHOD(void, OnDataReceived, (std::vector>&)); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DCAMERA_CHANNEL_LISTENER_MOCK_H diff --git a/services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.cpp b/services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.cpp new file mode 100644 index 00000000..3baa9798 --- /dev/null +++ b/services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "dcamera_collaboration_mock.h" +#include "distributed_camera_errno.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t DCameraCollaborationMock::CameraCollaborationPublishServiceState(const char *peerNetworkId, + const char *serviceName, const char *extraInfo, DCameraCollaborationBussinessStatus state) +{ + if (peerNetworkId == nullptr || strlen(peerNetworkId) == 0) { + return -1; + } + return 0; +} + +int32_t DCameraCollaborationMock::CameraCollaborationApplyAdvancedResource(const char *peerNetworkId, + const char *serviceName, + DCameraCollaborationResourceRequestInfoSets *resourceRequest, + DCameraCollaborationCallback *callback) +{ + if (resourceRequest == nullptr || callback == nullptr || callback->applyResult == nullptr) { + return -1; + } + if (peerNetworkId == nullptr || strlen(peerNetworkId) == 0) { + callback->applyResult(DCAMERA_ERR_APPLY_RESULT, REJECT, "failed"); + } else { + callback->applyResult(DCAMERA_OK, PASS, "success"); + if (callback->onStop) { + callback->onStop(peerNetworkId); + } + } + return 0; +} + +int32_t DCameraCollaborationMock::CameraCollaborationRegisterLifecycleCallback(const char *serviceName, + DCameraCollaborationCallback *callback) +{ + return 0; +} + +int32_t DCameraCollaborationMock::CameraCollaborationUnRegisterLifecycleCallback(const char *serviceName) +{ + return 0; +} + +int32_t DCameraCollaborationMock::DCameraCollaborationExport(DCameraCollaborationApi *exportApi) +{ + if (!exportApi) { + return -1; + } + exportApi->dCameraCollaborationPublishServiceState = CameraCollaborationPublishServiceState; + exportApi->dCameraCollaborationApplyAdvancedResource = CameraCollaborationApplyAdvancedResource; + exportApi->dCameraCollaborationRegisterLifecycleCallback = CameraCollaborationRegisterLifecycleCallback; + exportApi->dCameraCollaborationUnRegisterLifecycleCallback = CameraCollaborationUnRegisterLifecycleCallback; + return 0; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.h b/services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.h new file mode 100644 index 00000000..7cd9cddb --- /dev/null +++ b/services/channel/test/unittest/common/channel/mock/dcamera_collaboration_mock.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DCAMERA_COLLABORATION_MOCK_H +#define OHOS_DCAMERA_COLLABORATION_MOCK_H + +#include "dcamera_collaboration_manager_capi.h" + +namespace OHOS { +namespace DistributedHardware { +class DCameraCollaborationMock { +public: + DCameraCollaborationMock() = default; + virtual ~DCameraCollaborationMock() = default; + + static int32_t DCameraCollaborationExport(DCameraCollaborationApi *exportApi); +private: + static int32_t CameraCollaborationPublishServiceState(const char *peerNetworkId, const char *serviceName, + const char *extraInfo, DCameraCollaborationBussinessStatus state); + static int32_t CameraCollaborationApplyAdvancedResource(const char *peerNetworkId, const char *serviceName, + DCameraCollaborationResourceRequestInfoSets *resourceRequest, + DCameraCollaborationCallback *callback); + static int32_t CameraCollaborationRegisterLifecycleCallback(const char *serviceName, + DCameraCollaborationCallback *callback); + static int32_t CameraCollaborationUnRegisterLifecycleCallback(const char *serviceName); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DCAMERA_COLLABORATION_MOCK_H diff --git a/services/channel/test/unittest/common/channel/mock/dlfcn_mock.h b/services/channel/test/unittest/common/channel/mock/dlfcn_mock.h new file mode 100644 index 00000000..135c38db --- /dev/null +++ b/services/channel/test/unittest/common/channel/mock/dlfcn_mock.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DCAMERA_DLFCN_MOCK_H +#define OHOS_DCAMERA_DLFCN_MOCK_H + +#include +#include + +namespace OHOS { +namespace DistributedHardware { +class DlfcnMock { +public: + DlfcnMock() = default; + virtual ~DlfcnMock() = default; + + static std::shared_ptr GetOrCreateInstance(); + static void ReleaseInstance(); + MOCK_METHOD(void *, DlopenMock, (const char *, int)); + MOCK_METHOD(int, DlcloseMock, (void *)); + MOCK_METHOD(void *, DlsymMock, (void *__restrict, const char *__restrict)); +private: + static std::shared_ptr instance_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DCAMERA_DLFCN_MOCK_H diff --git a/services/channel/test/unittest/common/channel/mock/lib_function_mock.cpp b/services/channel/test/unittest/common/channel/mock/lib_function_mock.cpp new file mode 100644 index 00000000..68b00485 --- /dev/null +++ b/services/channel/test/unittest/common/channel/mock/lib_function_mock.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include "dlfcn_mock.h" + +char *realpath(const char *path, char *resolvedPath) +{ + return resolvedPath; +} + +void *dlopen(const char *file, int mode) +{ + auto instance = OHOS::DistributedHardware::DlfcnMock::GetOrCreateInstance(); + return instance->DlopenMock(file, mode); +} + +int dlclose(void *handle) +{ + auto instance = OHOS::DistributedHardware::DlfcnMock::GetOrCreateInstance(); + return instance->DlcloseMock(handle); +} + +void *dlsym(void *__restrict handle, const char *__restrict name) +{ + auto instance = OHOS::DistributedHardware::DlfcnMock::GetOrCreateInstance(); + return instance->DlsymMock(handle, name); +} + +namespace OHOS { +namespace DistributedHardware { +std::shared_ptr DlfcnMock::instance_; + +std::shared_ptr DlfcnMock::GetOrCreateInstance() +{ + if (!instance_) { + instance_ = std::make_shared(); + } + return instance_; +} + +void DlfcnMock::ReleaseInstance() +{ + instance_.reset(); + instance_ = nullptr; +} +} // namespace DistributedHardware +} // namespace OHOS -- Gitee