From e19e5c7a5e2fb24793572f1ff452cd7d0b4fa95f Mon Sep 17 00:00:00 2001 From: w30042960 Date: Thu, 6 Jul 2023 20:37:27 +0800 Subject: [PATCH 1/2] add UT Signed-off-by: w30042960 --- .../audiotransport/test/unittest/BUILD.gn | 2 + .../test/unittest/receiverengine/BUILD.gn | 68 ++++++ .../engineutils/include/engine_test_utils.h | 193 +++++++++++++++++ .../include/av_receiver_engine_adapter_test.h | 39 ++++ .../av_receiver_engine_transport_test.h | 38 ++++ .../src/av_receiver_engine_adapter_test.cpp | 187 ++++++++++++++++ .../src/av_receiver_engine_transport_test.cpp | 157 ++++++++++++++ .../test/unittest/senderengine/BUILD.gn | 69 ++++++ .../include/av_sender_engine_adapter_test.h | 38 ++++ .../include/av_sender_engine_transport_test.h | 38 ++++ .../src/av_sender_engine_adapter_test.cpp | 200 ++++++++++++++++++ .../src/av_sender_engine_transport_test.cpp | 168 +++++++++++++++ 12 files changed, 1197 insertions(+) create mode 100644 services/audiotransport/test/unittest/receiverengine/BUILD.gn create mode 100644 services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h create mode 100644 services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_adapter_test.h create mode 100644 services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_transport_test.h create mode 100644 services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp create mode 100644 services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp create mode 100644 services/audiotransport/test/unittest/senderengine/BUILD.gn create mode 100644 services/audiotransport/test/unittest/senderengine/include/av_sender_engine_adapter_test.h create mode 100644 services/audiotransport/test/unittest/senderengine/include/av_sender_engine_transport_test.h create mode 100644 services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp create mode 100644 services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp diff --git a/services/audiotransport/test/unittest/BUILD.gn b/services/audiotransport/test/unittest/BUILD.gn index 9df9215a..2f06aba4 100644 --- a/services/audiotransport/test/unittest/BUILD.gn +++ b/services/audiotransport/test/unittest/BUILD.gn @@ -24,5 +24,7 @@ group("daudio_transport_test") { "${audio_transport_path}/test/unittest/audiotransportstatus:transport_status_test", "${audio_transport_path}/test/unittest/decodetransport:decode_transport_test", "${audio_transport_path}/test/unittest/encodetransport:encode_transport_test", + "${audio_transport_path}/test/unittest/encodetransport:encode_transport_test", + "${audio_transport_path}/test/unittest/receiverengine:av_receiver_engine_adapter_test", ] } diff --git a/services/audiotransport/test/unittest/receiverengine/BUILD.gn b/services/audiotransport/test/unittest/receiverengine/BUILD.gn new file mode 100644 index 00000000..ed8a0b52 --- /dev/null +++ b/services/audiotransport/test/unittest/receiverengine/BUILD.gn @@ -0,0 +1,68 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("../../../../../distributedaudio.gni") + +module_out_path = "distributed_audio/services/audiotransport/receiver_engine_test" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${mediastandard_path}/interfaces/innerkits/native/media/include", + "${mediastandardfwk_path}/audiocommon/include", + "//third_party/json/include", + ] + + include_dirs += [ + "include", + "${common_path}/include", + "${common_path}/dfx_utils/include", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/test/unittest/receiverengine/engineutils/include", + "${audio_transport_path}/senderengine/include", + "${services_path}/common/audiodata/include", + "${services_path}/common/audioparam", + "${softbusadapter_path}/include", + ] +} + +## UnitTest av_receiver_engine_adapter_test +ohos_unittest("AVTransReceiverAdapterTest") { + module_out_path = module_out_path + + sources = [ + "src/av_receiver_engine_adapter_test.cpp", + "src/av_receiver_engine_transport_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${audio_transport_path}/decodetransport:distributed_audio_decode_transport", + "${services_path}/common:distributed_audio_utils", + "//third_party/googletest:gmock", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "distributed_hardware_fwk:distributed_av_receiver", + "dsoftbus:softbus_client", + ] +} + +group("av_receiver_engine_adapter_test") { + testonly = true + deps = [ ":AVTransReceiverAdapterTest" ] +} diff --git a/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h b/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h new file mode 100644 index 00000000..fb677b23 --- /dev/null +++ b/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ENGINE_TEST_UTILS_H +#define OHOS_ENGINE_TEST_UTILS_H + +#include "i_av_receiver_engine.h" +#include "i_av_sender_engine.h" +#include "av_receiver_engine_adapter.h" +#include "av_sender_engine_adapter.h" +#include "av_sender_engine_transport.h" +#include "av_receiver_engine_transport.h" +#include "audio_data.h" + +namespace OHOS { +namespace DistributedHardware { +class MockAVReceiverAdapterCallback : public AVReceiverAdapterCallback { +public: + explicit MockAVReceiverAdapterCallback() {} + ~MockAVReceiverAdapterCallback() {} + void OnEngineEvent(const AVTransEvent &event) override + { + } + void OnEngineMessage(const std::shared_ptr &message) override + { + } + void OnEngineDataAvailable(const std::shared_ptr &buffer) override + { + } +}; + +class MockAVSenderAdapterCallback : public AVSenderAdapterCallback { +public: + explicit MockAVSenderAdapterCallback() {} + ~MockAVSenderAdapterCallback() {} + void OnEngineEvent(const AVTransEvent &event) override + { + } + void OnEngineMessage(const std::shared_ptr &message) override + { + } +}; + +class MockAVReceiverTransportCallback : public AVReceiverTransportCallback { +public: + explicit MockAVReceiverTransportCallback() {} + ~MockAVReceiverTransportCallback() {} + void OnEngineTransEvent(const AVTransEvent &event) override + { + } + void OnEngineTransMessage(const std::shared_ptr &message) override + { + } + void OnEngineTransDataAvailable(const std::shared_ptr &audioData) override + { + } +}; + +class MockAVSenderTransportCallback : public AVSenderTransportCallback { +public: + explicit MockAVSenderTransportCallback() {} + ~MockAVSenderTransportCallback() {} + void OnEngineTransEvent(const AVTransEvent &event) override + { + } + void OnEngineTransMessage(const std::shared_ptr &message) override + { + } +}; + +class MockIAVReceiverEngine : public IAVReceiverEngine { +public: + explicit MockIAVReceiverEngine() {} + ~MockIAVReceiverEngine() {} + + int32_t Initialize() override + { + return 0; + } + + int32_t Start() override + { + return 0; + } + + int32_t Stop() override + { + return 0; + } + + int32_t Release() override + { + return 0; + } + + int32_t SetParameter(AVTransTag tag, const std::string &value) override + { + (void) tag; + (void) value; + return 0; + } + + int32_t SendMessage(const std::shared_ptr &message) override + { + return 0; + } + + int32_t CreateControlChannel(const std::vector &dstDevIds, + const ChannelAttribute &attribution) override + { + (void) dstDevIds; + (void) attribution; + return 0; + } + + int32_t RegisterReceiverCallback(const std::shared_ptr &callback) + { + (void) callback; + return 0; + } +}; + +class MockIAVSenderEngine : public IAVSenderEngine { +public: + explicit MockIAVSenderEngine() {} + ~MockIAVSenderEngine() {} + + int32_t Initialize() override + { + return 0; + } + + int32_t Start() override + { + return 0; + } + + int32_t Stop() override + { + return 0; + } + + int32_t Release() override + { + return 0; + } + + int32_t PushData(const std::shared_ptr &buffer) override + { + return 0; + } + + int32_t SetParameter(AVTransTag tag, const std::string &value) override + { + (void) tag; + (void) value; + return 0; + } + + int32_t SendMessage(const std::shared_ptr &message) override + { + return 0; + } + + int32_t CreateControlChannel(const std::vector &dstDevIds, + const ChannelAttribute &attribution) override + { + (void) dstDevIds; + (void) attribution; + return 0; + } + + int32_t RegisterSenderCallback(const std::shared_ptr &callback) + { + (void) callback; + return 0; + } +}; +} // DistributedHardware +} // OHOS +#endif // OHOS_ENGINE_TEST_UTILS_H \ No newline at end of file diff --git a/services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_adapter_test.h b/services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_adapter_test.h new file mode 100644 index 00000000..c0b27579 --- /dev/null +++ b/services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_adapter_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DAUDIO_AV_RECEIVER_ENGINE_ADAPTER_TEST_H +#define OHOS_DAUDIO_AV_RECEIVER_ENGINE_ADAPTER_TEST_H + +#include +#include + +#define private public +#include "av_receiver_engine_adapter.h" +#undef private + +namespace OHOS { +namespace DistributedHardware { +class AVTransReceiverAdapterTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr receiverAdapter_ = nullptr; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DAUDIO_AV_RECEIVER_ENGINE_ADAPTER_TEST_H diff --git a/services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_transport_test.h b/services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_transport_test.h new file mode 100644 index 00000000..1bfb3b8e --- /dev/null +++ b/services/audiotransport/test/unittest/receiverengine/include/av_receiver_engine_transport_test.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DAUDIO_AV_RECEIVER_ENGINE_transport_TEST_H +#define OHOS_DAUDIO_AV_RECEIVER_ENGINE_transport_TEST_H + +#include + +#define private public +#include "av_receiver_engine_transport.h" +#undef private + +namespace OHOS { +namespace DistributedHardware { +class AVTransReceiverTransportTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr receiverTrans_ = nullptr; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DAUDIO_AV_RECEIVER_ENGINE_transport_TEST_H diff --git a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp new file mode 100644 index 00000000..7ffee7b1 --- /dev/null +++ b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_adapter_test.cpp @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_receiver_engine_adapter_test.h" + +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" +#include "engine_test_utils.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void AVTransReceiverAdapterTest::SetUpTestCase(void) {} + +void AVTransReceiverAdapterTest::TearDownTestCase(void) {} + +void AVTransReceiverAdapterTest::SetUp(void) +{ + receiverAdapter_ = std::make_shared(); +} + +void AVTransReceiverAdapterTest::TearDown(void) +{ + receiverAdapter_ = nullptr; +} + +/** + * @tc.name: Initialize_001 + * @tc.desc: Verify the Initialize function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, Initialize_001, TestSize.Level1) +{ + IAVEngineProvider *providerPtr = nullptr; + std::string peerDevId = "peerDevId"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->Initialize(providerPtr, peerDevId)); + receiverAdapter_->initialized_ = true; + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Initialize(providerPtr, peerDevId)); +} + +/** + * @tc.name: Initialize_002 + * @tc.desc: Verify the Initialize function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, Initialize_002, TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + receiverAdapter_->receiverEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Start()); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Stop()); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Release()); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Start and Stop function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, Start_001, TestSize.Level1) +{ + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->Start()); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->Stop()); +} + +/** + * @tc.name: SetParameter_001 + * @tc.desc: Verify the Start and SetParameter function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, SetParameter_001, TestSize.Level1) +{ + std::string param = "param"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param)); +} + +/** + * @tc.name: SetParameter_002 + * @tc.desc: Verify the Start and SetParameter function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, SetParameter_002, TestSize.Level1) +{ + std::string param = "param"; + receiverAdapter_->receiverEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param)); +} + +/** + * @tc.name: CreateControlChannel_001 + * @tc.desc: Verify the Start and CreateControlChannel function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, CreateControlChannel_001, TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->CreateControlChannel(peerDevId)); + receiverAdapter_->chnCreateSuccess_ = true; + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->CreateControlChannel(peerDevId)); +} + +/** + * @tc.name: CreateControlChannel_002 + * @tc.desc: Verify the Start and CreateControlChannel function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, CreateControlChannel_002, TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->CreateControlChannel(peerDevId)); + receiverAdapter_->receiverEngine_ = std::make_shared(); + EXPECT_EQ(ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED, receiverAdapter_->CreateControlChannel(peerDevId)); +} + +/** + * @tc.name: SendMessageToRemote_001 + * @tc.desc: Verify the Start and SendMessageToRemote function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, SendMessageToRemote_001, TestSize.Level1) +{ + uint32_t type = 0; + std::string content = "content"; + std::string dstDevId = "dstDevId"; + auto message = std::make_shared(type, content, dstDevId); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->SendMessageToRemote(message)); + receiverAdapter_->receiverEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->SendMessageToRemote(message)); +} + +/** + * @tc.name: RegisterAdapterCallback_001 + * @tc.desc: Verify the Start and RegisterAdapterCallback function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, RegisterAdapterCallback_001, TestSize.Level1) +{ + std::shared_ptr callback = nullptr; + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverAdapter_->RegisterAdapterCallback(callback)); + callback = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->RegisterAdapterCallback(callback)); +} + +/** + * @tc.name: OnReceiverEvent_001 + * @tc.desc: Verify the Start and OnReceiverEvent function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverAdapterTest, OnReceiverEvent_001, TestSize.Level1) +{ + AVTransEvent event; + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnReceiverEvent(event)); + std::shared_ptr message = nullptr; + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnMessageReceived(message)); + std::shared_ptr buffer = nullptr; + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnDataAvailable(buffer)); + receiverAdapter_->adapterCallback_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnReceiverEvent(event)); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnMessageReceived(message)); + EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnDataAvailable(buffer)); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp new file mode 100644 index 00000000..09aa427b --- /dev/null +++ b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_receiver_engine_transport_test.h" + +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" +#include "engine_test_utils.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void AVTransReceiverTransportTest::SetUpTestCase(void) {} + +void AVTransReceiverTransportTest::TearDownTestCase(void) {} + +void AVTransReceiverTransportTest::SetUp(void) +{ + std::string devId = "devId"; + auto callback = std::make_shared(); + receiverTrans_ = std::make_shared(devId, callback); +} + +void AVTransReceiverTransportTest::TearDown(void) +{ + receiverTrans_ = nullptr; +} + +/** + * @tc.name: Setup_001 + * @tc.desc: Verify the Setup function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, SetUp_001, TestSize.Level1) +{ + AudioParam localParam; + AudioParam remoteParam; + std::shared_ptr callback = nullptr; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK)); + receiverTrans_->receiverAdapter_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK)); +} + +/** + * @tc.name: InitEngine_001 + * @tc.desc: Verify the InitEngine function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, InitEngine_001, TestSize.Level1) +{ + IAVEngineProvider *providerPtr = nullptr; + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->InitEngine(providerPtr)); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->Release()); +} + +/** + * @tc.name: CreateCtrl_001 + * @tc.desc: Verify the CreateCtrl function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, CreateCtrl_001, TestSize.Level1) +{ + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->CreateCtrl()); + receiverTrans_->receiverAdapter_ = std::make_shared(); + receiverTrans_->receiverAdapter_->chnCreateSuccess_ = true; + EXPECT_EQ(DH_SUCCESS, receiverTrans_->CreateCtrl()); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Start and Stop function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, Start_001, TestSize.Level1) +{ + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->Start()); + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->Stop()); + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->Release()); + receiverTrans_->receiverAdapter_ = std::make_shared(); + receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->Start()); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->Stop()); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Pause function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, Pause_001, TestSize.Level1) +{ + AudioParam localParam; + AudioParam remoteParam; + size_t bufLen = 4096; + std::shared_ptr audioData = std::make_shared(bufLen); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->Restart(localParam, remoteParam)); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->Pause()); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->FeedAudioData(audioData)); +} + +/** + * @tc.name: SendMessage_001 + * @tc.desc: Verify the SendMessage function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, SendMessage_001, TestSize.Level1) +{ + uint32_t type = 0; + std::string content = "content"; + std::string dstDevId = "dstDevId"; + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, receiverTrans_->SendMessage(type, content, dstDevId)); + receiverTrans_->receiverAdapter_ = std::make_shared(); + receiverTrans_->receiverAdapter_->receiverEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->SendMessage(type, content, dstDevId)); +} + +/** + * @tc.name: SetParameter_001 + * @tc.desc: Verify the SetParameter function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransReceiverTransportTest, SetParameter_001, TestSize.Level1) +{ + AVTransEvent event; + std::shared_ptr message = nullptr; + std::shared_ptr buffer = nullptr; + receiverTrans_->OnEngineEvent(event); + receiverTrans_->OnEngineMessage(message); + receiverTrans_->OnEngineDataAvailable(buffer); + AudioParam audioParam; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetParameter(audioParam)); + receiverTrans_->receiverAdapter_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, receiverTrans_->SetParameter(audioParam)); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/audiotransport/test/unittest/senderengine/BUILD.gn b/services/audiotransport/test/unittest/senderengine/BUILD.gn new file mode 100644 index 00000000..855c3c6a --- /dev/null +++ b/services/audiotransport/test/unittest/senderengine/BUILD.gn @@ -0,0 +1,69 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("../../../../../distributedaudio.gni") + +module_out_path = + "distributed_audio/services/audiotransport/sender_engine_test" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${mediastandard_path}/interfaces/innerkits/native/media/include", + "${mediastandardfwk_path}/audiocommon/include", + "//third_party/json/include", + ] + + include_dirs += [ + "include", + "${common_path}/include", + "${common_path}/dfx_utils/include", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/test/unittest/receiverengine/engineutils/include", + "${audio_transport_path}/senderengine/include", + "${services_path}/common/audiodata/include", + "${services_path}/common/audioparam", + "${softbusadapter_path}/include", + ] +} + +## UnitTest av_sender_engine_adapter_test +ohos_unittest("AVTransSenderAdapterTest") { + module_out_path = module_out_path + + sources = [ + "src/av_sender_engine_adapter_test.cpp", + "src/av_sender_engine_transport_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${audio_transport_path}/encodetransport:distributed_audio_encode_transport", + "${services_path}/common:distributed_audio_utils", + "//third_party/googletest:gmock", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "distributed_hardware_fwk:distributed_av_sender", + "dsoftbus:softbus_client", + ] +} + +group("av_sender_engine_adapter_test") { + testonly = true + deps = [ ":AVTransSenderAdapterTest" ] +} diff --git a/services/audiotransport/test/unittest/senderengine/include/av_sender_engine_adapter_test.h b/services/audiotransport/test/unittest/senderengine/include/av_sender_engine_adapter_test.h new file mode 100644 index 00000000..5f023268 --- /dev/null +++ b/services/audiotransport/test/unittest/senderengine/include/av_sender_engine_adapter_test.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DAUDIO_AV_SENDER_ENGINE_ADAPTER_TEST_H +#define OHOS_DAUDIO_AV_SENDER_ENGINE_ADAPTER_TEST_H + +#include + +#define private public +#include "av_sender_engine_adapter.h" +#undef private + +namespace OHOS { +namespace DistributedHardware { +class AVTransSenderAdapterTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr senderAdapter_ = nullptr; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DAUDIO_AV_SENDER_ENGINE_ADAPTER_TEST_H diff --git a/services/audiotransport/test/unittest/senderengine/include/av_sender_engine_transport_test.h b/services/audiotransport/test/unittest/senderengine/include/av_sender_engine_transport_test.h new file mode 100644 index 00000000..58c63906 --- /dev/null +++ b/services/audiotransport/test/unittest/senderengine/include/av_sender_engine_transport_test.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DAUDIO_AV_SENDER_ENGINE_transport_TEST_H +#define OHOS_DAUDIO_AV_SENDER_ENGINE_transport_TEST_H + +#include + +#define private public +#include "av_sender_engine_transport.h" +#undef private + +namespace OHOS { +namespace DistributedHardware { +class AVTransSenderTransportTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr senderTrans_ = nullptr; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DAUDIO_AV_SENDER_ENGINE_ADAPTER_TEST_H diff --git a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp new file mode 100644 index 00000000..8226cb1a --- /dev/null +++ b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_sender_engine_adapter_test.h" + +#include "audio_data.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" +#include "engine_test_utils.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void AVTransSenderAdapterTest::SetUpTestCase(void) {} + +void AVTransSenderAdapterTest::TearDownTestCase(void) {} + +void AVTransSenderAdapterTest::SetUp(void) +{ + senderAdapter_ = std::make_shared(); +} + +void AVTransSenderAdapterTest::TearDown(void) +{ + senderAdapter_ = nullptr; +} + +/** + * @tc.name: Initialize_001 + * @tc.desc: Verify the Initialize function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, Initialize_001, TestSize.Level1) +{ + IAVEngineProvider *providerPtr = nullptr; + std::string peerDevId = "peerDevId"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->Initialize(providerPtr, peerDevId)); + senderAdapter_->initialized_ = true; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->Initialize(providerPtr, peerDevId)); +} + +/** + * @tc.name: Initialize_002 + * @tc.desc: Verify the Initialize function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, Initialize_002, TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->Start()); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->Stop()); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->Release()); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Start and Stop function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, Start_001, TestSize.Level1) +{ + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->Start()); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->Stop()); +} + +/** + * @tc.name: SetParameter_001 + * @tc.desc: Verify the SetParameter function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, SetParameter_001, TestSize.Level1) +{ + std::string param = "param"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param)); +} + +/** + * @tc.name: SetParameter_002 + * @tc.desc: Verify the SetParameter function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, SetParameter_002, TestSize.Level1) +{ + std::string param = "param"; + senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, param)); +} + +/** + * @tc.name: PushData_001 + * @tc.desc: Verify the PushData function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, PushData_001, TestSize.Level1) +{ + size_t bufLen = 4096; + std::shared_ptr audioData = std::make_shared(bufLen); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->PushData(audioData)); + senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->PushData(audioData)); +} + +/** + * @tc.name: CreateControlChannel_001 + * @tc.desc: Verify the CreateControlChannel function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, CreateControlChannel_001, TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->CreateControlChannel(peerDevId)); + senderAdapter_->chnCreateSuccess_ = true; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->CreateControlChannel(peerDevId)); +} + +/** + * @tc.name: CreateControlChannel_002 + * @tc.desc: Verify the CreateControlChannel function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, CreateControlChannel_002, TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->CreateControlChannel(peerDevId)); + senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED, senderAdapter_->CreateControlChannel(peerDevId)); +} + +/** + * @tc.name: SendMessageToRemote_001 + * @tc.desc: Verify the SendMessageToRemote function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, SendMessageToRemote_001, TestSize.Level1) +{ + uint32_t type = 0; + std::string content = "content"; + std::string dstDevId = "dstDevId"; + auto message = std::make_shared(type, content, dstDevId); + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->SendMessageToRemote(message)); + senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->SendMessageToRemote(message)); +} + +/** + * @tc.name: RegisterAdapterCallback_001 + * @tc.desc: Verify the RegisterAdapterCallback function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, RegisterAdapterCallback_001, TestSize.Level1) +{ + std::shared_ptr callback = nullptr; + EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, senderAdapter_->RegisterAdapterCallback(callback)); + callback = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->RegisterAdapterCallback(callback)); +} + +/** + * @tc.name: OnSenderEvent_001 + * @tc.desc: Verify the OnSenderEvent function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderAdapterTest, OnSenderEvent_001, TestSize.Level1) +{ + AVTransEvent event; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event)); + std::shared_ptr message = nullptr; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnMessageReceived(message)); + senderAdapter_->adapterCallback_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event)); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnMessageReceived(message)); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp new file mode 100644 index 00000000..420e2297 --- /dev/null +++ b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp @@ -0,0 +1,168 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_sender_engine_transport_test.h" + +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" +#include "engine_test_utils.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void AVTransSenderTransportTest::SetUpTestCase(void) {} + +void AVTransSenderTransportTest::TearDownTestCase(void) {} + +void AVTransSenderTransportTest::SetUp(void) +{ + std::string devId = "devId"; + auto callback = std::make_shared(); + senderTrans_ = std::make_shared(devId, callback); +} + +void AVTransSenderTransportTest::TearDown(void) +{ + senderTrans_ = nullptr; +} + +/** + * @tc.name: Setup_001 + * @tc.desc: Verify the Setup function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, SetUp_001, TestSize.Level1) +{ + AudioParam localParam; + AudioParam remoteParam; + std::shared_ptr callback = nullptr; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK)); + senderTrans_->senderAdapter_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderTrans_->SetUp(localParam, remoteParam, callback, CAP_SPK)); +} + +/** + * @tc.name: InitEngine_001 + * @tc.desc: Verify the InitEngine function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, InitEngine_001, TestSize.Level1) +{ + IAVEngineProvider *providerPtr = nullptr; + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->InitEngine(providerPtr)); + EXPECT_EQ(DH_SUCCESS, senderTrans_->Release()); +} + +/** + * @tc.name: CreateCtrl_001 + * @tc.desc: Verify the CreateCtrl function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, CreateCtrl_001, TestSize.Level1) +{ + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->CreateCtrl()); + senderTrans_->senderAdapter_ = std::make_shared(); + senderTrans_->senderAdapter_->chnCreateSuccess_ = true; + EXPECT_EQ(DH_SUCCESS, senderTrans_->CreateCtrl()); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Start and Stop function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, Start_001, TestSize.Level1) +{ + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->Start()); + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->Stop()); + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->Release()); + senderTrans_->senderAdapter_ = std::make_shared(); + senderTrans_->senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderTrans_->Start()); + EXPECT_EQ(DH_SUCCESS, senderTrans_->Stop()); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Pause function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, Pause_001, TestSize.Level1) +{ + AudioParam localParam; + AudioParam remoteParam; + EXPECT_EQ(DH_SUCCESS, senderTrans_->Restart(localParam, remoteParam)); + EXPECT_EQ(DH_SUCCESS, senderTrans_->Pause()); +} + +/** + * @tc.name: SendMessage_001 + * @tc.desc: Verify the SendMessage function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, SendMessage_001, TestSize.Level1) +{ + uint32_t type = 0; + std::string content = "content"; + std::string dstDevId = "dstDevId"; + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->SendMessage(type, content, dstDevId)); + senderTrans_->senderAdapter_ = std::make_shared(); + senderTrans_->senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderTrans_->SendMessage(type, content, dstDevId)); +} + +/** + * @tc.name: FeedAudioData_001 + * @tc.desc: Verify the FeedAudioData function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, FeedAudioData_001, TestSize.Level1) +{ + size_t bufLen = 4096; + std::shared_ptr audioData = std::make_shared(bufLen); + EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, senderTrans_->FeedAudioData(audioData)); + senderTrans_->senderAdapter_ = std::make_shared(); + senderTrans_->senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderTrans_->FeedAudioData(audioData)); +} + +/** + * @tc.name: SetParameter_001 + * @tc.desc: Verify the SetParameter function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVTransSenderTransportTest, SetParameter_001, TestSize.Level1) +{ + AVTransEvent event; + std::shared_ptr message = nullptr; + senderTrans_->OnEngineEvent(event); + senderTrans_->OnEngineMessage(message); + AudioParam audioParam; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetParameter(audioParam)); + senderTrans_->senderAdapter_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderTrans_->SetParameter(audioParam)); +} +} // namespace DistributedHardware +} // namespace OHOS -- Gitee From 321583d6313850708ec09bcf2daffa85b68e5626 Mon Sep 17 00:00:00 2001 From: w30042960 Date: Thu, 6 Jul 2023 21:27:47 +0800 Subject: [PATCH 2/2] add UT Signed-off-by: w30042960 --- services/audiotransport/test/unittest/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/audiotransport/test/unittest/BUILD.gn b/services/audiotransport/test/unittest/BUILD.gn index 2f06aba4..4414bc04 100644 --- a/services/audiotransport/test/unittest/BUILD.gn +++ b/services/audiotransport/test/unittest/BUILD.gn @@ -24,7 +24,7 @@ group("daudio_transport_test") { "${audio_transport_path}/test/unittest/audiotransportstatus:transport_status_test", "${audio_transport_path}/test/unittest/decodetransport:decode_transport_test", "${audio_transport_path}/test/unittest/encodetransport:encode_transport_test", - "${audio_transport_path}/test/unittest/encodetransport:encode_transport_test", "${audio_transport_path}/test/unittest/receiverengine:av_receiver_engine_adapter_test", + "${audio_transport_path}/test/unittest/senderengine:av_sender_engine_adapter_test", ] } -- Gitee