From f67672f5d4d5444e64cbafcab90cf91cdb87b4e7 Mon Sep 17 00:00:00 2001 From: wangchaole Date: Tue, 6 Dec 2022 20:16:16 +0800 Subject: [PATCH] fix: add unit test Signed-off-by: wangchaole --- bundle.json | 1 + services/channel/test/unittest/BUILD.gn | 17 + .../test/unittest/common/channel/BUILD.gn | 98 +++ .../dcamera_channel_sink_impl_test.cpp | 233 +++++++ .../dcamera_channel_source_impl_test.cpp | 259 +++++++ .../channel/dcamera_softbus_adapter_test.cpp | 650 ++++++++++++++++++ .../channel/dcamera_softbus_session_test.cpp | 267 +++++++ .../test/unittest/common/channel/session.h | 202 ++++++ .../common/channel/session_bus_center.cpp | 28 + .../common/channel/session_bus_center.h | 42 ++ .../unittest/common/channel/session_mock.cpp | 129 ++++ 11 files changed, 1926 insertions(+) create mode 100644 services/channel/test/unittest/BUILD.gn create mode 100644 services/channel/test/unittest/common/channel/BUILD.gn create mode 100644 services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp create mode 100644 services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp create mode 100644 services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp create mode 100644 services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp create mode 100644 services/channel/test/unittest/common/channel/session.h create mode 100644 services/channel/test/unittest/common/channel/session_bus_center.cpp create mode 100644 services/channel/test/unittest/common/channel/session_bus_center.h create mode 100644 services/channel/test/unittest/common/channel/session_mock.cpp diff --git a/bundle.json b/bundle.json index 135921de..5d2d5e6a 100644 --- a/bundle.json +++ b/bundle.json @@ -96,6 +96,7 @@ "//foundation/distributedhardware/distributed_camera/services/cameraservice/sinkservice/test/unittest:sink_service_test", "//foundation/distributedhardware/distributed_camera/services/cameraservice/sourceservice/test/unittest:source_service_test", "//foundation/distributedhardware/distributed_camera/services/cameraservice/base/test/unittest:services_base_test", + "//foundation/distributedhardware/distributed_camera/services/channel/test/unittest:camera_channel_test", "//foundation/distributedhardware/distributed_camera/services/data_process/test/unittest:data_process_test", "//foundation/distributedhardware/distributed_camera/interfaces/inner_kits/native_cpp/test/fuzztest:fuzztest" ] diff --git a/services/channel/test/unittest/BUILD.gn b/services/channel/test/unittest/BUILD.gn new file mode 100644 index 00000000..b3960492 --- /dev/null +++ b/services/channel/test/unittest/BUILD.gn @@ -0,0 +1,17 @@ +# Copyright (c) 2022 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. + +group("camera_channel_test") { + testonly = true + deps = [ "common/channel:dcamera_channel_test" ] +} diff --git a/services/channel/test/unittest/common/channel/BUILD.gn b/services/channel/test/unittest/common/channel/BUILD.gn new file mode 100644 index 00000000..fa98a7df --- /dev/null +++ b/services/channel/test/unittest/common/channel/BUILD.gn @@ -0,0 +1,98 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import( + "//foundation/distributedhardware/distributed_camera/distributedcamera.gni") + +module_out_path = "distributed_camera/dcamera_channel_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "${common_path}/include/constants", + "${common_path}/include/utils", + "${fwk_common_path}/utils/include", + "${fwk_utils_path}/include", + "${fwk_utils_path}/include/eventbus", + "${services_path}/cameraservice/base/include", + "${services_path}/channel/include", + "${services_path}/cameraservice/base/include", + "${services_path}/cameraservice/cameraoperator/client/include", + "${services_path}/cameraservice/cameraoperator/client/include/callback", + "${services_path}/cameraservice/cameraoperator/client/include/listener", + "${services_path}/cameraservice/cameraoperator/handler/include", + "${services_path}/cameraservice/sinkservice/include/distributedcameramgr", + "${services_path}/cameraservice/sinkservice/include/distributedcameramgr/callback", + "${services_path}/cameraservice/sinkservice/include/distributedcameramgr/eventbus", + "${services_path}/cameraservice/sinkservice/include/distributedcameramgr/interface", + "${services_path}/cameraservice/sinkservice/include/distributedcameramgr/listener", + "${services_path}/cameraservice/sinkservice/test/unittest/common/distributedcameramgr", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcameradata", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcamerastate", + "${services_path}/cameraservice/sourceservice/test/unittest/common/distributedcameramgr", + "${services_path}/data_process/include/utils", + "${innerkits_path}/native_cpp/camera_source/include", + "${innerkits_path}/native_cpp/camera_source/include/callback", + "${graphicstandard_path}/frameworks/surface/include", + "//commonlibrary/c_utils/base/include", + "//utils/system/safwk/native/include", + "//third_party/jsoncpp/include", + ] +} + +ohos_unittest("DCameraChannelTest") { + module_out_path = module_out_path + + sources = [ + "dcamera_channel_sink_impl_test.cpp", + "dcamera_channel_source_impl_test.cpp", + "dcamera_softbus_adapter_test.cpp", + "dcamera_softbus_session_test.cpp", + "session_bus_center.cpp", + "session_mock.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${common_path}:distributed_camera_utils", + "${graphicstandard_path}:libsurface", + "${services_path}/cameraservice/sinkservice:distributed_camera_sink", + "${services_path}/cameraservice/sourceservice:distributed_camera_source", + "${services_path}/channel:distributed_camera_channel", + "${services_path}/data_process:distributed_camera_data_process", + "//third_party/jsoncpp:jsoncpp", + ] + + external_deps = [ + "c_utils:utils", + "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.0", + "eventhandler:libeventhandler", + "graphic_chipsetsdk:buffer_handle", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DCameraChannelTest\"", + "LOG_DOMAIN=0xD004100", + ] +} + +group("dcamera_channel_test") { + testonly = true + deps = [ ":DCameraChannelTest" ] +} diff --git a/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp b/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp new file mode 100644 index 00000000..5a5af79e --- /dev/null +++ b/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2021 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 "dcamera_channel_sink_impl.h" +#include "dcamera_softbus_adapter.h" +#include "dcamera_sink_output.h" +#include "dcamera_sink_output_channel_listener.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_errno.h" +#include "icamera_channel.h" +#include "session_bus_center.h" +#include "session.h" + +#include "mock_camera_operator.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraChannelSinkImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr output_; + std::shared_ptr channel_; + std::shared_ptr listener_; + std::shared_ptr operator_; +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const int32_t TEST_TWO_S = 2; +} +void DCameraChannelSinkImplTest::SetUpTestCase(void) +{ + +} + +void DCameraChannelSinkImplTest::TearDownTestCase(void) +{ +} + +void DCameraChannelSinkImplTest::SetUp(void) +{ + channel_ = std::make_shared(); + +} + +void DCameraChannelSinkImplTest::TearDown(void) +{ + output_ = nullptr; + listener_ = nullptr; + operator_ = nullptr; + channel_ = nullptr; +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_001 + * @tc.desc: Verify the OpenSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_001, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test001"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + operator_ = std::make_shared(); + output_ = std::make_shared(TEST_CAMERA_DH_ID_0, operator_); + + listener_ = std::make_shared(CONTINUOUS_FRAME, output_); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + + int32_t ret = channel_->OpenSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_002 + * @tc.desc: Verify the CloseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_002, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test002"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + operator_ = std::make_shared(); + output_ = std::make_shared(TEST_CAMERA_DH_ID_0, operator_); + + listener_ = std::make_shared(CONTINUOUS_FRAME, output_); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + + int32_t ret = channel_->OpenSession(); + ret = channel_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_003 + * @tc.desc: Verify the ReleaseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_003, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test003"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + operator_ = std::make_shared(); + output_ = std::make_shared(TEST_CAMERA_DH_ID_0, operator_); + + listener_ = std::make_shared(CONTINUOUS_FRAME, output_); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + + int32_t ret = channel_->ReleaseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_004 + * @tc.desc: Verify the SendData function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_004, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test004"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + operator_ = std::make_shared(); + output_ = std::make_shared(TEST_CAMERA_DH_ID_0, operator_); + + listener_ = std::make_shared(CONTINUOUS_FRAME, output_); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + + int32_t ret = channel_->OpenSession(); + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + ret = channel_->SendData(dataBuffer); + sleep(TEST_TWO_S); + channel_->CloseSession(); + ret = channel_->ReleaseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_005 + * @tc.desc: Verify the OpenSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_005, TestSize.Level1) +{ + int32_t ret = channel_->OpenSession(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_006 + * @tc.desc: Verify the CloseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_006, TestSize.Level1) +{ + int32_t ret = channel_->CloseSession(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_007 + * @tc.desc: Verify the ReleaseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_007, TestSize.Level1) +{ + int32_t ret = channel_->ReleaseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_sink_impl_test_008 + * @tc.desc: Verify the SendData function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_008, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + int32_t ret = channel_->SendData(dataBuffer); + sleep(TEST_TWO_S); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} +} +} \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp b/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp new file mode 100644 index 00000000..d1bad027 --- /dev/null +++ b/services/channel/test/unittest/common/channel/dcamera_channel_source_impl_test.cpp @@ -0,0 +1,259 @@ +/* + * Copyright (c) 2021 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 "dcamera_channel_source_impl.h" +#include "dcamera_softbus_adapter.h" +#include "dcamera_source_event.h" +#include "dcamera_source_input.h" +#include "dcamera_source_input_channel_listener.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" +#include "data_buffer.h" +#include "icamera_channel.h" +#include "session_bus_center.h" +#include "session.h" + +#include "mock_dcamera_source_dev.h" +#include "mock_dcamera_source_state_listener.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraChannelSourceImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr input_; + std::shared_ptr camDev_; + std::shared_ptr eventBus_; + std::shared_ptr channel_; + std::shared_ptr listener_; + std::shared_ptr stateListener_; +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const int32_t TEST_TWO_S = 2; +} +void DCameraChannelSourceImplTest::SetUpTestCase(void) +{ + +} + +void DCameraChannelSourceImplTest::TearDownTestCase(void) +{ +} + +void DCameraChannelSourceImplTest::SetUp(void) +{ + channel_ = std::make_shared(); + +} + +void DCameraChannelSourceImplTest::TearDown(void) +{ + input_ = nullptr; + camDev_ = nullptr; + eventBus_ = nullptr; + listener_ = nullptr; + stateListener_ = nullptr; + channel_ = nullptr; +} + +/** + * @tc.name: dcamera_channel_source_impl_test_001 + * @tc.desc: Verify the OpenSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_001, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test001"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + eventBus_ = std::make_shared("SrcDevHandlerTest01"); + stateListener_ = std::make_shared(); + camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); + DCameraSourceEvent event(*camDev_); + eventBus_->AddHandler(event.GetType(), *camDev_); + + input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, eventBus_); + + listener_ = std::make_shared(input_, CONTINUOUS_FRAME); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + + int32_t ret = channel_->OpenSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_002 + * @tc.desc: Verify the CloseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_002, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test002"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + eventBus_ = std::make_shared("SrcDevHandlerTest02"); + stateListener_ = std::make_shared(); + camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); + DCameraSourceEvent event(*camDev_); + eventBus_->AddHandler(event.GetType(), *camDev_); + + input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, eventBus_); + + listener_ = std::make_shared(input_, CONTINUOUS_FRAME); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + + int32_t ret = channel_->OpenSession(); + ret = channel_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_003 + * @tc.desc: Verify the ReleaseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_003, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test003"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + eventBus_ = std::make_shared("SrcDevHandlerTest03"); + stateListener_ = std::make_shared(); + camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); + DCameraSourceEvent event(*camDev_); + eventBus_->AddHandler(event.GetType(), *camDev_); + + input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, eventBus_); + + listener_ = std::make_shared(input_, CONTINUOUS_FRAME); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + int32_t ret = channel_->ReleaseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_004 + * @tc.desc: Verify the SendData function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_004, TestSize.Level1) +{ + std::vector camIndexs; + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + camIndexs.push_back(index); + std::string sessionFlag = "test004"; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_JPEG; + eventBus_ = std::make_shared("SrcDevHandlerTest04"); + stateListener_ = std::make_shared(); + camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); + DCameraSourceEvent event(*camDev_); + eventBus_->AddHandler(event.GetType(), *camDev_); + + input_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, eventBus_); + + listener_ = std::make_shared(input_, CONTINUOUS_FRAME); + channel_->CreateSession(camIndexs, sessionFlag, sessionMode, listener_); + int32_t ret = channel_->OpenSession(); + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + ret = channel_->SendData(dataBuffer); + sleep(TEST_TWO_S); + channel_->CloseSession(); + ret = channel_->ReleaseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_005 + * @tc.desc: Verify the OpenSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_005, TestSize.Level1) +{ + int32_t ret = channel_->OpenSession(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_006 + * @tc.desc: Verify the CloseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_006, TestSize.Level1) +{ + int32_t ret = channel_->CloseSession(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_007 + * @tc.desc: Verify the ReleaseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_007, TestSize.Level1) +{ + int32_t ret = channel_->ReleaseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_channel_source_impl_test_008 + * @tc.desc: Verify the SendData function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraChannelSourceImplTest, dcamera_channel_source_impl_test_008, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + int32_t ret = channel_->SendData(dataBuffer); + sleep(TEST_TWO_S); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} +} +} \ No newline at end of file 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 new file mode 100644 index 00000000..ffbe0b68 --- /dev/null +++ b/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp @@ -0,0 +1,650 @@ +/* + * Copyright (c) 2022 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 +#define private public +#include "dcamera_softbus_adapter.h" +#undef private + +#include "data_buffer.h" +#include "dcamera_softbus_session.h" +#include "dcamera_hisysevent_adapter.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_errno.h" +#include "session_bus_center.h" +#include "session.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraSoftbusAdapterTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const int32_t TEST_TWO_S = 2; +} + +void DCameraSoftbusAdapterTest::SetUpTestCase(void) +{ + +} + +void DCameraSoftbusAdapterTest::TearDownTestCase(void) +{ +} + +void DCameraSoftbusAdapterTest::SetUp(void) +{ + +} + +void DCameraSoftbusAdapterTest::TearDown(void) +{ + +} + +/** + * @tc.name: dcamera_softbus_adapter_test_001 + * @tc.desc: Verify the CreateSoftbusSessionServer function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_001, TestSize.Level1) +{ + std::string sessionName = "sourcetest01"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_002 + * @tc.desc: Verify the DestroySoftbusSessionServer function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_002, TestSize.Level1) +{ + std::string sessionName = "sourcetest02"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + sleep(TEST_TWO_S); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_003 + * @tc.desc: Verify the DestroySoftbusSessionServer function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_003, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + ret = DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_004 + * @tc.desc: Verify the DestroySoftbusSessionServer function. + * @tc.type: FUNC + * @tc.require: + */ + +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_004, TestSize.Level1) +{ + std::string sessionName = "sourcetest04"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest04"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + sleep(TEST_TWO_S); + int32_t sessionId = 1; + ret = DCameraSoftbusAdapter::GetInstance().CloseSoftbusSession(sessionId); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_005 + * @tc.desc: Verify the SendSofbusBytes function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_005, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + int32_t sessionId = 2; + ret = DCameraSoftbusAdapter::GetInstance().SendSofbusBytes(sessionId, dataBuffer); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_006 + * @tc.desc: Verify the SendSofbusStream function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_006, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + int32_t sessionId = 2; + ret = DCameraSoftbusAdapter::GetInstance().SendSofbusStream(sessionId, dataBuffer); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_007 + * @tc.desc: Verify the GetLocalNetworkId function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_007, TestSize.Level1) +{ + std::string devId = TEST_DEVICE_ID; + int32_t ret = DCameraSoftbusAdapter::GetInstance().GetLocalNetworkId(devId); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_008 + * @tc.desc: Verify the OnSourceSessionOpened function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_008, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + std::shared_ptr session = std::make_shared(); + DCameraSoftbusAdapter::GetInstance().sourceSessions_.emplace(peerDevId + mySessName, session); + ret = DCameraSoftbusAdapter::GetInstance().OnSourceSessionOpened(sessionId, result); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_009 + * @tc.desc: Verify the OnSourceSessionClosed function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_009, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + DCameraSoftbusAdapter::GetInstance().OnSourceSessionOpened(sessionId, result); + + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSourceSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_010 + * @tc.desc: Verify the OnSourceBytesReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_010, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSourceSessionOpened(sessionId, result); + const void *data = "testdata"; + uint32_t dataLen = 8; + DCameraSoftbusAdapter::GetInstance().OnSourceBytesReceived(sessionId, data, dataLen); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSourceSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_011 + * @tc.desc: Verify the OnSourceBytesReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_011, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSourceSessionOpened(sessionId, result); + const void *data = "testdata"; + uint32_t dataLen = 8; + DCameraSoftbusAdapter::GetInstance().OnSourceMessageReceived(sessionId, data, dataLen); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSourceSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_012 + * @tc.desc: Verify the OnSourceBytesReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_012, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSourceSessionOpened(sessionId, result); + std::string buff01 = "testbuffer01"; + StreamData test01; + test01.buf = const_cast(buff01.c_str()); + test01.bufLen = buff01.size(); + StreamData test02; + std::string buff02 = "testbuffer01"; + test02.buf = const_cast(buff02.c_str()); + test02.bufLen = buff02.size(); + StreamFrameInfo param01; + StreamData *data = &test01; + StreamData *ext = &test02; + StreamFrameInfo *param = ¶m01; + DCameraSoftbusAdapter::GetInstance().OnSourceStreamReceived(sessionId, data, ext, param); + data = nullptr; + DCameraSoftbusAdapter::GetInstance().OnSourceStreamReceived(sessionId, data, ext, param); + StreamData test03; + test01.buf = const_cast(buff01.c_str()); + test01.bufLen = 0; + data = &test03; + DCameraSoftbusAdapter::GetInstance().OnSourceStreamReceived(sessionId, data, ext, param); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSourceSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_012 + * @tc.desc: Verify the OnSinkSessionOpened function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_013, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + std::shared_ptr session = std::make_shared(); + DCameraSoftbusAdapter::GetInstance().sinkSessions_.emplace(peerDevId + mySessName, session); + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} +/** + * @tc.name: dcamera_softbus_adapter_test_014 + * @tc.desc: Verify the OnSinkSessionClosed function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_014, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSinkSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_015 + * @tc.desc: Verify the OnSinkBytesReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_015, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + const void *data = "testdata"; + uint32_t dataLen = 8; + DCameraSoftbusAdapter::GetInstance().OnSinkBytesReceived(sessionId, data, dataLen); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSinkSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_016 + * @tc.desc: Verify the OnSinkMessageReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_016, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + const void *data = "testdata"; + uint32_t dataLen = 8; + DCameraSoftbusAdapter::GetInstance().OnSinkMessageReceived(sessionId, data, dataLen); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSinkSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_017 + * @tc.desc: Verify the OnSinkStreamReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_017, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + std::string buff01 = "testbuffer01"; + StreamData test01; + test01.buf = const_cast(buff01.c_str()); + test01.bufLen = buff01.size(); + StreamData test02; + std::string buff02 = "testbuffer01"; + test02.buf = const_cast(buff02.c_str()); + test02.bufLen = buff02.size(); + StreamFrameInfo param01; + const StreamData *data = &test01; + const StreamData *ext = &test02; + const StreamFrameInfo *param = ¶m01; + DCameraSoftbusAdapter::GetInstance().OnSinkStreamReceived(sessionId, data, ext, param); + sleep(TEST_TWO_S); + DCameraSoftbusAdapter::GetInstance().OnSinkSessionClosed(sessionId); + ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_018 + * @tc.desc: Verify the DCameraSoftbusSourceGetSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_018, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + std::shared_ptr session = std::make_shared(); + int32_t result = 0; + ret = DCameraSoftbusAdapter::GetInstance().OnSourceSessionOpened(sessionId, result); + ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSourceGetSession(sessionId, session); + + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_019 + * @tc.desc: Verify the DCameraSoftbusSinkGetSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_019, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + std::shared_ptr session = std::make_shared(); + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSinkGetSession(sessionId, session); + + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_020 + * @tc.desc: Verify the DCameraSoftbusGetSessionById function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_020, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = 2; + int32_t result = 0; + std::shared_ptr session = std::make_shared(); + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusGetSessionById(sessionId, session); + + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_021 + * @tc.desc: Verify the OpenSoftbusSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_021, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 1; + std::string peerDevId = TEST_DEVICE_ID; + ret = DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_022 + * @tc.desc: Verify the OpenSoftbusSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_022, TestSize.Level1) +{ + std::string sessionName = "sourcetest03"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest03"; + std::string peerSessName = "sinktest02"; + int32_t sessionMode = 2; + std::string peerDevId = TEST_DEVICE_ID; + ret = DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_adapter_test_023 + * @tc.desc: Verify the DCameraSoftbusGetSessionById function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_023, TestSize.Level1) +{ + std::string sessionName = "sourcetest013"; + DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE; + int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftbusSessionServer(sessionName, role); + std::string mySessName = "sourcetest013"; + std::string peerSessName = "sinktest012"; + int32_t sessionMode = 0; + std::string peerDevId = TEST_DEVICE_ID; + DCameraSoftbusAdapter::GetInstance().OpenSoftbusSession(mySessName, peerSessName, sessionMode, peerDevId); + int32_t sessionId = -1; + int32_t result = 0; + std::shared_ptr session = std::make_shared(); + ret = DCameraSoftbusAdapter::GetInstance().OnSinkSessionOpened(sessionId, result); + ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusGetSessionById(sessionId, session); + + DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} +} +} \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp new file mode 100644 index 00000000..6b9ce018 --- /dev/null +++ b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2021 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 +#define private public +#include "dcamera_softbus_session.h" +#undef private + +#include "data_buffer.h" +#include "dcamera_softbus_adapter.h" +#include "dcamera_sink_output.h" +#include "dcamera_sink_output_channel_listener.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_errno.h" +#include "icamera_channel.h" +#include "mock_camera_operator.h" +#include "session_bus_center.h" +#include "session.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraSoftbusSessionTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr output_; + std::shared_ptr softbusSession_; + std::shared_ptr listener_; + std::shared_ptr operator_; +}; + +namespace { +const std::string TEST_MYDEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_PEERDEVICE_ID = "bb536a637105409e904d4da83790a4a9"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +} + +void DCameraSoftbusSessionTest::SetUpTestCase(void) +{ + +} + +void DCameraSoftbusSessionTest::TearDownTestCase(void) +{ +} + +void DCameraSoftbusSessionTest::SetUp(void) +{ + std::string myDevId = TEST_MYDEVICE_ID; + std::string mySessionName = "testmysession"; + std::string peerSessionName = "testpeersession"; + std::string peerDevId = TEST_PEERDEVICE_ID; + DCameraSessionMode sessionMode = DCAMERA_SESSION_MODE_VIDEO; + operator_ = std::make_shared(); + output_ = std::make_shared(TEST_CAMERA_DH_ID_0, operator_); + + listener_ = std::make_shared(CONTINUOUS_FRAME, output_); + + softbusSession_ = std::make_shared(myDevId, mySessionName, peerDevId, + peerSessionName, listener_, sessionMode); +} + +void DCameraSoftbusSessionTest::TearDown(void) +{ + output_ = nullptr; + listener_ = nullptr; + operator_ = nullptr; + softbusSession_ = nullptr; +} + +/** + * @tc.name: dcamera_softbus_session_test_001 + * @tc.desc: Verify the CloseSession function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_001, TestSize.Level1) +{ + softbusSession_->sessionId_ = 2; + int32_t ret = softbusSession_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + + +/** + * @tc.name: dcamera_softbus_session_test_002 + * @tc.desc: Verify the OnSessionOpend function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_002, TestSize.Level1) +{ + int32_t sessionId = 1; + int32_t result = -6; + int32_t ret = softbusSession_->OnSessionOpend(sessionId, result); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_003 + * @tc.desc: Verify the OnDataReceived function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_003, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr buffer = std::make_shared(capacity); + std::string mySessionName = "testmysession"; + auto runner = AppExecFwk::EventRunner::Create(mySessionName); + softbusSession_->eventHandler_ = std::make_shared(runner); + int32_t ret = softbusSession_->OnDataReceived(buffer); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_004 + * @tc.desc: Verify the DealRecvData function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_004, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr buffer = std::make_shared(capacity); + softbusSession_->mode_ = DCAMERA_SESSION_MODE_VIDEO; + softbusSession_->DealRecvData(buffer); + softbusSession_->mode_ = DCAMERA_SESSION_MODE_VIDEO; + softbusSession_->DealRecvData(buffer); + int32_t ret = softbusSession_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_005 + * @tc.desc: Verify the PackRecvData function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_005, TestSize.Level1) +{ + size_t capacity = 1; + size_t offset = 0; + size_t size = 22; + std::shared_ptr buffer = std::make_shared(capacity); + buffer->SetRange(offset, size); + softbusSession_->PackRecvData(buffer); + size = 2; + softbusSession_->PackRecvData(buffer); + int32_t ret = softbusSession_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_006 + * @tc.desc: Verify the AssembleNoFrag function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_006, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr buffer = std::make_shared(capacity); + DCameraSoftbusSession::SessionDataHeader headerPara; + headerPara.dataLen = 1; + headerPara.totalLen = 2; + softbusSession_->AssembleNoFrag(buffer, headerPara); + headerPara.totalLen = 1; + softbusSession_->AssembleNoFrag(buffer, headerPara); + int32_t ret = softbusSession_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_007 + * @tc.desc: Verify the AssembleFrag function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_007, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr buffer = std::make_shared(capacity); + DCameraSoftbusSession::SessionDataHeader headerPara; + headerPara.dataLen = 1; + headerPara.totalLen = 2; + headerPara.fragFlag = DCameraSoftbusSession::FRAG_START; + softbusSession_->AssembleFrag(buffer, headerPara); + headerPara.fragFlag = DCameraSoftbusSession::FRAG_MID; + softbusSession_->AssembleFrag(buffer, headerPara); + headerPara.fragFlag = DCameraSoftbusSession::FRAG_END; + softbusSession_->AssembleFrag(buffer, headerPara); + int32_t ret = softbusSession_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_008 + * @tc.desc: Verify the CheckUnPackBuffer function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_008, TestSize.Level1) +{ + DCameraSoftbusSession::SessionDataHeader headerPara; + headerPara.dataLen = 1; + headerPara.totalLen = 2; + headerPara.fragFlag = DCameraSoftbusSession::FRAG_START; + softbusSession_->isWaiting_ = false; + int32_t ret = softbusSession_->CheckUnPackBuffer(headerPara); + softbusSession_->isWaiting_ = true; + softbusSession_->nowSeq_ = 1; + headerPara.seqNum = 2; + ret = softbusSession_->CheckUnPackBuffer(headerPara); + softbusSession_->nowSubSeq_ = 0; + headerPara.seqNum = 1; + headerPara.subSeq = 1; + ret = softbusSession_->CheckUnPackBuffer(headerPara); + softbusSession_->offset_ = 3; + softbusSession_->totalLen_ = 2; + ret = softbusSession_->CheckUnPackBuffer(headerPara); + softbusSession_->offset_ = 0; + ret = softbusSession_->CheckUnPackBuffer(headerPara); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_softbus_session_test_009 + * @tc.desc: Verify the GetFragDataLen function. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_009, TestSize.Level1) +{ + DCameraSoftbusSession::SessionDataHeader headerPara; + headerPara.dataLen = 1; + headerPara.totalLen = 2; + headerPara.fragFlag = DCameraSoftbusSession::FRAG_START; + uint8_t ptr = 9; + uint8_t *ptrPacket = &ptr; + softbusSession_->GetFragDataLen(ptrPacket, headerPara); + softbusSession_->U16Get(ptrPacket); + softbusSession_->U32Get(ptrPacket); + int32_t ret = softbusSession_->CloseSession(); + EXPECT_EQ(DCAMERA_OK, ret); +} +} +} \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/session.h b/services/channel/test/unittest/common/channel/session.h new file mode 100644 index 00000000..2753938b --- /dev/null +++ b/services/channel/test/unittest/common/channel/session.h @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2022 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. + */ + +/** + * @addtogroup Softbus + * @{ + * + * @brief Provides high-speed, secure communication between devices. + * + * This module implements unified distributed communication capability management between + * nearby devices, and provides link-independent device discovery and transmission interfaces + * to support service publishing and data transmission. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file session.h + * + * @brief Declares unified data transmission interfaces. + * + * This file provides data transmission capabilities, including creating and removing a session server, + * opening and closing sessions, receiving data, and querying basic session information. \n + * After multiple nearby devices are discovered and networked, these interfaces can be used to + * transmit data across devices. \n + * + * @since 1.0 + * @version 1.0 + */ +#ifndef SESSION_H +#define SESSION_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif +/** + * @brief business type of session + * + * @since 1.0 + * @version 1.0 + */ +typedef enum { + TYPE_MESSAGE = 1, + TYPE_BYTES, + TYPE_FILE, + TYPE_STREAM, + TYPE_BUTT, +} SessionType; + +typedef enum { + INVALID = -1, + /* + * Send any segment of a frame each time. + */ + RAW_STREAM, + /* + * Send a whole video frame each time. + */ + COMMON_VIDEO_STREAM, + /* + * Send a whole audio frame each time. + */ + COMMON_AUDIO_STREAM, + /* + * Slice frame mode. + */ + VIDEO_SLICE_STREAM, +} StreamType; + +typedef enum { + LINK_TYPE_WIFI_WLAN_5G = 1, + LINK_TYPE_WIFI_WLAN_2G = 2, + LINK_TYPE_WIFI_P2P = 3, + LINK_TYPE_BR = 4, + LINK_TYPE_MAX = 4, +} LinkType; + +typedef struct { + /** @brief dataType{@link SessionType} */ + int dataType; + int linkTypeNum; + LinkType linkType[LINK_TYPE_MAX]; + union { + struct StreamAttr { + int streamType; + } streamAttr; + } attr; +} SessionAttribute; + +typedef struct { + char *buf; + int bufLen; +} StreamData; + +typedef struct { + int type; + int64_t value; +} TV; + +typedef struct { + int frameType; + int64_t timeStamp; + int seqNum; + int seqSubNum; + int level; + int bitMap; + int tvCount; + TV *tvList; +} FrameInfo; + +enum FrameType { + NONE, + VIDEO_I, + VIDEO_P, + VIDEO_MAX = 50, + RADIO = VIDEO_MAX + 1, + RADIO_MAX = 100, +}; +// APP should update StreamFrameInfo each time. +struct StreamFrameInfo { + uint32_t streamId = 0; + uint32_t seqNum = 0; + uint32_t level = 0; + FrameType frameType = NONE; + uint32_t timestamp = 0; + uint32_t bitrate = 0; +}; + +constexpr uint32_t DEVICE_ID_SIZE_MAX = 65; +constexpr uint32_t CHAR_ARRAY_SIZE = 100; + +typedef struct { + int (*OnSessionOpened)(int sessionId, int result); + void (*OnSessionClosed)(int sessionId); + void (*OnBytesReceived)(int sessionId, const void *data, unsigned int dataLen); + void (*OnMessageReceived)(int sessionId, const void *data, unsigned int dataLen); + void (*OnStreamReceived)(int sessionId, const StreamData *data, const StreamData *ext, + const StreamFrameInfo *param); +} ISessionListener; + +typedef struct { + int (*OnReceiveFileStarted)(int sessionId, const char *files, int fileCnt); + int (*OnReceiveFileProcess)(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal); + void (*OnReceiveFileFinished)(int sessionId, const char *files, int fileCnt); + void (*OnFileTransError)(int sessionId); +} IFileReceiveListener; + +typedef struct { + int (*OnSendFileProcess)(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal); + int (*OnSendFileFinished)(int sessionId, const char *firstFile); + void (*OnFileTransError)(int sessionId); +} IFileSendListener; + +int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener); + +int RemoveSessionServer(const char *pkgName, const char *sessionName); + +int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerDeviceId, const char *groupId, + const SessionAttribute *attr); +void OpenSessionResult(void); + +void CloseSession(int sessionId); + +int SendBytes(int sessionId, const void *data, unsigned int len); + +int SendMessage(int sessionId, const void *data, unsigned int len); + +int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param); + +int GetMySessionName(int sessionId, char *sessionName, unsigned int len); + +int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len); + +int GetPeerDeviceId(int sessionId, char *devId, unsigned int len); + +int GetSessionSide(int sessionId); + +int SetFileReceiveListener(const char *pkgName, const char *sessionName, const IFileReceiveListener *recvListener, + const char *rootDir); + +int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener); + +int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt); +#ifdef __cplusplus +} +#endif +#endif // SESSION_H \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/session_bus_center.cpp b/services/channel/test/unittest/common/channel/session_bus_center.cpp new file mode 100644 index 00000000..b2d93970 --- /dev/null +++ b/services/channel/test/unittest/common/channel/session_bus_center.cpp @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2022 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 "softbus_bus_center.h" + +constexpr int32_t DH_SUCCESS = 0; +int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info) +{ + NodeBasicInfo nodeBasicInfo_ = { + .networkId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00", + .deviceName = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591", + .deviceTypeId = 1}; + (void)pkgName; + *info = nodeBasicInfo_; + return DH_SUCCESS; +} \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/session_bus_center.h b/services/channel/test/unittest/common/channel/session_bus_center.h new file mode 100644 index 00000000..455d08f0 --- /dev/null +++ b/services/channel/test/unittest/common/channel/session_bus_center.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022 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 SOFTBUS_BUS_CENTER_H +#define SOFTBUS_BUS_CENTER_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif +constexpr uint32_t MOCK_NETWORK_ID_BUF_LEN = 65; +constexpr uint32_t MOCK_DEVICE_NAME_BUF_LEN = 65; +/** + * @brief Defines the basic information about a device. + * + * @since 1.0 + * @version 1.0 + */ +typedef struct { + char networkId[MOCK_NETWORK_ID_BUF_LEN]; /**< Device ID */ + char deviceName[MOCK_DEVICE_NAME_BUF_LEN]; /**< Device name */ + uint16_t deviceTypeId; +} NodeBasicInfo; + +int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info); +#ifdef __cplusplus +} +#endif +#endif // SOFTBUS_BUS_CENTER_H \ No newline at end of file diff --git a/services/channel/test/unittest/common/channel/session_mock.cpp b/services/channel/test/unittest/common/channel/session_mock.cpp new file mode 100644 index 00000000..2e6f0cfe --- /dev/null +++ b/services/channel/test/unittest/common/channel/session_mock.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2022 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 "session.h" + +constexpr int32_t DH_SUCCESS = 0; +constexpr int32_t DH_ERROR = -1; +constexpr int32_t MOCK_SESSION_ID = 1; +static ISessionListener listener_; +static char peerDeviceId_[CHAR_ARRAY_SIZE]; +static char peerSessionName_[CHAR_ARRAY_SIZE]; +static char mySessionName_[CHAR_ARRAY_SIZE]; +int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener) +{ + std::cout << "CreateSessionServer start sessionName:" << sessionName << std::endl; + std::string tmpstr = sessionName; + if (tmpstr.size() <= 0) { + std::cout << "CreateSessionServer sessionName is empty." << std::endl; + return DH_ERROR; + } + if (listener == nullptr) { + std::cout << "CreateSessionServer listener is null." << std::endl; + return DH_ERROR; + } + strcpy(mySessionName_, tmpstr.c_str()); + listener_.OnBytesReceived = listener->OnBytesReceived; + listener_.OnMessageReceived = listener->OnMessageReceived; + listener_.OnSessionClosed = listener->OnSessionClosed; + listener_.OnSessionOpened = listener->OnSessionOpened; + listener_.OnStreamReceived = listener->OnStreamReceived; + return DH_SUCCESS; +} + +int RemoveSessionServer(const char *pkgName, const char *sessionName) +{ + return DH_SUCCESS; +} + +int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerDeviceId, const char *groupId, + const SessionAttribute *attr) +{ + if (strlen(peerSessionName) <= 0) { + return DH_ERROR; + } + if (strlen(peerDeviceId) <= 0) { + return DH_ERROR; + } + strncpy(peerSessionName_, peerSessionName, CHAR_ARRAY_SIZE); + strncpy(peerDeviceId_, peerDeviceId, DEVICE_ID_SIZE_MAX); + std::thread thd(OpenSessionResult); + thd.detach(); + return MOCK_SESSION_ID; +} + +void OpenSessionResult() +{ + listener_.OnSessionOpened(MOCK_SESSION_ID, DH_SUCCESS); +} + +void CloseSession(int sessionId) {} + +int SendBytes(int sessionId, const void *data, unsigned int len) +{ + return DH_SUCCESS; +} + +int SendMessage(int sessionId, const void *data, unsigned int len) +{ + return DH_SUCCESS; +} + +int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param) +{ + return DH_SUCCESS; +} + +int GetMySessionName(int sessionId, char *sessionName, unsigned int len) +{ + strncpy(sessionName, mySessionName_, CHAR_ARRAY_SIZE); + return DH_SUCCESS; +} + +int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len) +{ + strncpy(sessionName, peerSessionName_, CHAR_ARRAY_SIZE); + return DH_SUCCESS; +} + +int GetPeerDeviceId(int sessionId, char *devId, unsigned int len) +{ + strncpy(devId, peerDeviceId_, DEVICE_ID_SIZE_MAX); + return DH_SUCCESS; +} + +int GetSessionSide(int sessionId) +{ + return DH_SUCCESS; +} + +int SetFileReceiveListener(const char *pkgName, const char *sessionName, const IFileReceiveListener *recvListener, + const char *rootDir) +{ + return DH_SUCCESS; +} + +int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener) +{ + return DH_SUCCESS; +} + +int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt) +{ + return DH_SUCCESS; +} \ No newline at end of file -- Gitee