From a2d2bd74552d627d1de50117e68c904bc1a00ef1 Mon Sep 17 00:00:00 2001 From: "zhuzhihui7@huawei.com" Date: Tue, 25 Feb 2025 20:15:20 +0800 Subject: [PATCH] add sender engine ut Signed-off-by: zhuzhihui7@huawei.com --- .../test/unittest/av_sender_engine/BUILD.gn | 89 ++- .../include/av_audio_sender_engine_test.h | 53 ++ .../src/av_audio_sender_engine_test.cpp | 682 ++++++++++++++++++ .../av_sender_engine_provider/BUILD.gn | 91 ++- .../av_audio_sender_engine_provider_test.h | 40 + .../av_audio_sender_engine_provider_test.cpp | 131 ++++ 6 files changed, 1084 insertions(+), 2 deletions(-) create mode 100644 av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/include/av_audio_sender_engine_test.h create mode 100644 av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp create mode 100644 av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/include/av_audio_sender_engine_provider_test.h create mode 100644 av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/src/av_audio_sender_engine_provider_test.cpp diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/BUILD.gn b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/BUILD.gn index 76e8ae18..a1733461 100644 --- a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/BUILD.gn +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/BUILD.gn @@ -97,7 +97,94 @@ ohos_unittest("AvSenderEngineTest") { ] } +config("module_audio_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${dh_fwk_utils_path}/include", + "${common_path}/include", + "${dh_fwk_sdk_path}/include", + "${engine_path}/av_sender/include", + "${control_center_path}/inner_kits/include", + "${control_center_path}/inner_kits/include/ipc", + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_coder", + "${filters_path}/av_trans_output", + "${engine_path}/av_sender/test/unittest/av_sender_engine/include", + "${interface_path}", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvAudioSenderEngineTest") { + module_out_path = module_out_path + + sources = [ "src/av_audio_sender_engine_test.cpp" ] + + configs = [ ":module_audio_private_config" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + deps = [ + "${dh_fwk_sdk_path}:libdhfwk_sdk", + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + "${engine_path}/av_sender:distributed_av_sender", + "${filters_path}:avtrans_input_filter", + "${filters_path}:avtrans_output_filter", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"AvSenderEngineTest\"", + "LOG_DOMAIN=0xD004101", + ] + + defines += [ + "MEDIA_OHOS", + "RECORDER_SUPPORT", + "VIDEO_SUPPORT", + "HST_ANY_WITH_NO_RTTI", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "graphic_2d:libgraphic_utils", + "graphic_surface:surface", + "hilog:libhilog", + "hisysevent:libhisysevent", + "hitrace:hitrace_meter", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + group("av_sender_engine_test") { testonly = true - deps = [ ":AvSenderEngineTest" ] + deps = [ + ":AvAudioSenderEngineTest", + ":AvSenderEngineTest", + ] } diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/include/av_audio_sender_engine_test.h b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/include/av_audio_sender_engine_test.h new file mode 100644 index 00000000..74657c89 --- /dev/null +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/include/av_audio_sender_engine_test.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AV_AUDIO_SENDER_ENGINE_TEST_H +#define AV_AUDIO_SENDER_ENGINE_TEST_H + +#include + +#include "av_audio_sender_engine.h" + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvAudioSenderEngineTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +class SenderEngineCallback : public IAVSenderEngineCallback { +public: + SenderEngineCallback() = default; + ~SenderEngineCallback() override = default; + int32_t OnSenderEvent(const AVTransEvent &event) override + { + (void) event; + return DH_AVT_SUCCESS; + } + int32_t OnMessageReceived(const std::shared_ptr &message) override + { + (void) message; + return DH_AVT_SUCCESS; + } +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_AUDIO_SENDER_ENGINE_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp new file mode 100644 index 00000000..191617ff --- /dev/null +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp @@ -0,0 +1,682 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_audio_sender_engine_test.h" + +#include "distributed_hardware_fwk_kit.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +using namespace OHOS::Media; + +namespace OHOS { +namespace DistributedHardware { +const std::string FILTERNAME = "avsenderengine"; + +void AvAudioSenderEngineTest::SetUp() +{ +} + +void AvAudioSenderEngineTest::TearDown() +{ +} + +void AvAudioSenderEngineTest::SetUpTestCase() +{ +} + +void AvAudioSenderEngineTest::TearDownTestCase() +{ +} + +HWTEST_F(AvAudioSenderEngineTest, Initialize_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->isInitialized_ = true; + int32_t ret = sender->Initialize(); + std::string value264 = MIME_VIDEO_H264; + sender->SetVideoCodecType(value264); + std::string value = MIME_VIDEO_H265; + sender->SetVideoCodecType(value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, Initialize_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->avInput_ = nullptr; + int32_t ret = sender->Initialize(); + EXPECT_EQ(ERR_DH_AVT_INIT_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, Initialize_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->sessionName_ = ""; + int32_t ret = sender->Initialize(); + sender->pipeline_ = nullptr; + sender->SetEnginePause(ownerName); + sender->pipeline_ = std::make_shared(); + sender->SetEnginePause(ownerName); + EXPECT_EQ(ERR_DH_AVT_INIT_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, InitPipeline_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->pipeline_ = nullptr; + sender->SetEngineResume(ownerName); + sender->pipeline_ = std::make_shared(); + sender->SetEngineResume(ownerName); + int32_t ret = sender->InitPipeline(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, InitPipeline_002, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "pEid"; + auto sender = std::make_shared(OWNER_NAME_D_MIC, peerDevId); + int32_t ret = sender->InitPipeline(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, CreateControlChannel_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + std::vector dstDevIds; + int32_t ret = sender->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, CreateControlChannel_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + std::vector dstDevIds = {peerDevId}; + int32_t ret = sender->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + EXPECT_EQ(ERR_DH_AVT_CREATE_CHANNEL_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, CreateControlChannel_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + std::vector dstDevIds = {peerDevId}; + int32_t ret = sender->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + EXPECT_EQ(ERR_DH_AVT_CREATE_CHANNEL_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, Start_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::IDLE; + sender->pipeline_ = std::make_shared(); + int32_t ret = sender->Start(); + EXPECT_EQ(ERR_DH_AVT_START_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, Start_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::CH_CREATED; + sender->pipeline_ = std::make_shared(); + int32_t ret = sender->Start(); + sender->Stop(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, Start_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::CH_CREATED; + sender->pipeline_ = std::make_shared(); + sender->dhFwkKit_ = std::make_shared(); + int32_t ret = sender->Start(); + sender->Stop(); + EXPECT_EQ(ERR_DH_AVT_CREATE_CHANNEL_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, Stop_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::CH_CREATED; + sender->pipeline_ = std::make_shared(); + sender->Start(); + int32_t ret = sender->Stop(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + int32_t ret = sender->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + int32_t ret = sender->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + int32_t ret = sender->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "123"; + auto sender = std::make_shared(ownerName, peerDevId); + + std::shared_ptr pipeline_ = nullptr; + sender->pipeline_ = std::make_shared(); + int32_t ret = sender->SetParameter(AVTransTag::VIDEO_WIDTH, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_005, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "123"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::VIDEO_WIDTH, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::VIDEO_HEIGHT, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_006, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "123"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::VIDEO_PIXEL_FORMAT, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::VIDEO_FRAME_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_007, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "123"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::AUDIO_BIT_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::VIDEO_BIT_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_008, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "video/avc"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + value = "video/hevc"; + ret = sender->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + value = ""; + ret = sender->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_009, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "12 32"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::AUDIO_CODEC_TYPE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_010, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "video/hevc"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_011, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "500"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::AUDIO_CHANNEL_MASK, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::AUDIO_CHANNEL_LAYOUT, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::AUDIO_SAMPLE_FORMAT, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::AUDIO_FRAME_SIZE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::SHARED_MEMORY_FD, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SetParameter_012, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "500"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->InitPipeline(); + sender->RegRespFunMap(); + + int32_t ret = sender->SetParameter(AVTransTag::ENGINE_READY, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::ENGINE_PAUSE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + ret = sender->SetParameter(AVTransTag::ENGINE_RESUME, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PushData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + std::shared_ptr buffer = std::make_shared(); + sender->currentState_ = StateId::IDLE; + int32_t ret = sender->PushData(buffer); + EXPECT_EQ(ERR_DH_AVT_PUSH_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PushData_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + std::shared_ptr buffer = std::make_shared(); + sender->currentState_ = StateId::IDLE; + int32_t ret = sender->PushData(buffer); + EXPECT_EQ(ERR_DH_AVT_PUSH_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PushData_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + std::shared_ptr buffer = std::make_shared(); + sender->currentState_ = StateId::STARTED; + int32_t ret = sender->PushData(buffer); + EXPECT_EQ(ERR_DH_AVT_PUSH_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PushData_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + std::shared_ptr buffer = std::make_shared(); + sender->currentState_ = StateId::STARTED; + int32_t ret = sender->PushData(buffer); + EXPECT_EQ(ERR_DH_AVT_PUSH_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PushData_005, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + std::shared_ptr buffer = nullptr; + sender->currentState_ = StateId::STARTED; + int32_t ret = sender->PushData(buffer); + EXPECT_EQ(ERR_DH_AVT_PUSH_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PreparePipeline_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::STARTED; + int32_t ret = sender->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_PREPARE_FAILED, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PreparePipeline_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + int32_t ret = sender->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PreparePipeline_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + int32_t ret = sender->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PreparePipeline_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + int32_t ret = sender->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, PreparePipeline_005, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + sender->pipeline_ = std::make_shared(); + + int32_t ret = sender->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, StartDumpMediaData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + bool ret = sender->StartDumpMediaData(); + EXPECT_EQ(true, ret); + sender->avOutput_ = nullptr; + ret = sender->StartDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, StopDumpMediaData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + bool ret = sender->StopDumpMediaData(); + EXPECT_EQ(true, ret); + + sender->avOutput_ = nullptr; + ret = sender->StopDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, ReStartDumpMediaData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto sender = std::make_shared(ownerName, peerDevId); + bool ret = sender->ReStartDumpMediaData(); + EXPECT_EQ(true, ret); + sender->avOutput_ = nullptr; + ret = sender->ReStartDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SendMessage_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_MIC; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + EventType type = EventType::EVENT_ADD_STREAM; + sender->NotifyStreamChange(type); + int32_t ret = sender->SendMessage(nullptr); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SendMessage_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_SPEAKER; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + EventType type = EventType::EVENT_ADD_STREAM; + sender->NotifyStreamChange(type); + std::shared_ptr message = std::make_shared(); + int32_t ret = sender->SendMessage(message); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SendMessage_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_VIRMODEM_MIC; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + EventType type = EventType::EVENT_ADD_STREAM; + sender->NotifyStreamChange(type); + int32_t ret = sender->SendMessage(nullptr); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, SendMessage_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_VIRMODEM_SPEAKER; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + EventType type = EventType::EVENT_ADD_STREAM; + sender->NotifyStreamChange(type); + std::shared_ptr message = std::make_shared(); + int32_t ret = sender->SendMessage(message); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, RegisterSenderCallback_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_SCREEN; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + EventType type = EventType::EVENT_ADD_STREAM; + sender->NotifyStreamChange(type); + std::shared_ptr callback = std::make_shared(); + int32_t ret = sender->RegisterSenderCallback(callback); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, RegisterSenderCallback_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + std::shared_ptr callback = nullptr; + int32_t ret = sender->RegisterSenderCallback(callback); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioSenderEngineTest, OnChannelEvent_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->senderCallback_ = nullptr; + AVTransEvent transEvent; + transEvent.content = "content"; + transEvent.type = EventType::EVENT_CHANNEL_OPENED; + sender->OnChannelEvent(transEvent); + sender->senderCallback_ = std::make_shared(); + sender->OnChannelEvent(transEvent); + + EXPECT_EQ(StateId::CH_CREATED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnChannelEvent_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + AVTransEvent transEvent; + transEvent.content = "content"; + transEvent.type = EventType::EVENT_CHANNEL_OPEN_FAIL; + sender->senderCallback_ = std::make_shared(); + sender->OnChannelEvent(transEvent); + + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnChannelEvent_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + AVTransEvent event; + event.content = "content"; + event.type = EventType::EVENT_CHANNEL_CLOSED; + sender->senderCallback_ = std::make_shared(); + sender->currentState_ = StateId::CH_CREATED; + sender->OnChannelEvent(event); + + event.type = EventType::EVENT_DATA_RECEIVED; + sender->OnChannelEvent(event); + + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnChannelEvent_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + AVTransEvent event; + event.content = "content"; + event.type = EventType::EVENT_CHANNEL_CLOSED; + sender->senderCallback_ = std::make_shared(); + sender->currentState_ = StateId::CH_CREATED; + sender->OnChannelEvent(event); + sender->currentState_ = StateId::IDLE; + sender->OnChannelEvent(event); + sender->currentState_ = StateId::INITIALIZED; + sender->OnChannelEvent(event); + + event.type = EventType::EVENT_ADD_STREAM; + sender->OnChannelEvent(event); + + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnEvent_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + + Pipeline::Event event; + event.srcFilter = "filter"; + event.type = Pipeline::EventType::EVENT_READY; + sender->currentState_ = StateId::INITIALIZED; + + sender->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); + + sender->senderCallback_ = std::make_shared(); + sender->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/BUILD.gn b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/BUILD.gn index f6af26f8..07c3cf87 100644 --- a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/BUILD.gn +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/BUILD.gn @@ -98,7 +98,96 @@ ohos_unittest("AvSenderEngineProviderTest") { ] } +config("module_audio_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${dh_fwk_utils_path}/include", + "${common_path}/include", + "${dh_fwk_sdk_path}/include", + "${engine_path}/av_sender/include", + "${control_center_path}/inner_kits/include", + "${control_center_path}/inner_kits/include/ipc", + "${filters_path}/av_transport_input", + "${filters_path}/av_transport_output", + "${filters_path}/av_trans_coder", + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_output", + "${engine_path}/av_sender/test/unittest/av_sender_engine_provider/include", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + "${interface_path}", + ] +} + +ohos_unittest("AvAudioSenderEngineProviderTest") { + module_out_path = module_out_path + + sources = [ "src/av_audio_sender_engine_provider_test.cpp" ] + + configs = [ ":module_audio_private_config" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + deps = [ + "${dh_fwk_sdk_path}:libdhfwk_sdk", + "${engine_path}/av_sender:distributed_av_sender", + "${filters_path}:avtrans_input_filter", + "${filters_path}:avtrans_output_filter", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"AvAudioSenderEngineProviderTest\"", + "LOG_DOMAIN=0xD004101", + ] + + defines += [ + "MEDIA_OHOS", + "RECORDER_SUPPORT", + "VIDEO_SUPPORT", + "HST_ANY_WITH_NO_RTTI", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "graphic_2d:libgraphic_utils", + "graphic_surface:surface", + "hilog:libhilog", + "hisysevent:libhisysevent", + "hitrace:hitrace_meter", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + group("av_sender_engine_provider_test") { testonly = true - deps = [ ":AvSenderEngineProviderTest" ] + deps = [ + ":AvAudioSenderEngineProviderTest", + ":AvSenderEngineProviderTest", + ] } diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/include/av_audio_sender_engine_provider_test.h b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/include/av_audio_sender_engine_provider_test.h new file mode 100644 index 00000000..4920ba4b --- /dev/null +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/include/av_audio_sender_engine_provider_test.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AV_AUDIO_SENDER_ENGINE_PROVIDER_TEST_H +#define AV_AUDIO_SENDER_ENGINE_PROVIDER_TEST_H + +#include + +#include "av_audio_sender_engine_provider.h" +#include "i_av_engine_provider.h" +#include "softbus_channel_adapter.h" + + +namespace OHOS { +namespace DistributedHardware { + + +class AvAudioSenderEngineProviderTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_AUDIO_SENDER_ENGINE_PROVIDER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/src/av_audio_sender_engine_provider_test.cpp b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/src/av_audio_sender_engine_provider_test.cpp new file mode 100644 index 00000000..4b3d0c28 --- /dev/null +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine_provider/src/av_audio_sender_engine_provider_test.cpp @@ -0,0 +1,131 @@ +/* + * 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_audio_sender_engine_provider_test.h" + +#include "av_audio_sender_engine.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { + +void AvAudioSenderEngineProviderTest::SetUp() +{ +} + +void AvAudioSenderEngineProviderTest::TearDown() +{ +} + +void AvAudioSenderEngineProviderTest::SetUpTestCase() +{ +} + +void AvAudioSenderEngineProviderTest::TearDownTestCase() +{ +} + +class IAVSenderEngineProvider : public IAVEngineProviderCallback { +public: + virtual int32_t OnProviderEvent(const AVTransEvent &event) + { + (void)event; + return DH_AVT_SUCCESS; + } +}; + +HWTEST_F(AvAudioSenderEngineProviderTest, CreateAVSenderEngine_001, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + std::string ownerName = "ownerName"; + auto avSendProTest_ = std::make_shared(ownerName); + auto avSenderEngine = avSendProTest_->CreateAVSenderEngine(peerDevId); + EXPECT_EQ(nullptr, avSenderEngine); +} + +HWTEST_F(AvAudioSenderEngineProviderTest, GetAVSenderEngineList_001, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + std::string ownerName = "ownerName"; + auto avSendProTest_ = std::make_shared(ownerName); + auto avSenderEngine = avSendProTest_->CreateAVSenderEngine(peerDevId); + std::vector> senderEngineList = avSendProTest_->GetAVSenderEngineList(); + bool bRet = (senderEngineList.empty()) ? false : true; + EXPECT_NE(true, bRet); +} + +HWTEST_F(AvAudioSenderEngineProviderTest, GetAVSenderEngineList_002, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + std::string ownerName = "ownerName"; + auto avSendProTest_ = std::make_shared(ownerName); + auto avSenderEngine = avSendProTest_->CreateAVSenderEngine(peerDevId); + auto sender = std::make_shared(ownerName, peerDevId); + avSendProTest_->senderEngineList_.push_back(sender); + std::vector> senderEngineList = avSendProTest_->GetAVSenderEngineList(); + bool bRet = (senderEngineList.empty()) ? false : true; + EXPECT_EQ(true, bRet); +} + +HWTEST_F(AvAudioSenderEngineProviderTest, RegisterProviderCallback_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ownerName"; + std::string peerDevId = "peerDevId"; + auto avSendProTest_ = std::make_shared(ownerName); + std::shared_ptr callback = nullptr; + int32_t ret = avSendProTest_->RegisterProviderCallback(callback); + AVTransEvent event = {EventType::EVENT_ADD_STREAM, ownerName, peerDevId}; + avSendProTest_->providerCallback_ = nullptr; + avSendProTest_->OnChannelEvent(event); + + callback = make_shared(); + avSendProTest_->RegisterProviderCallback(callback); + event.type = EventType::EVENT_CHANNEL_OPENED; + avSendProTest_->OnChannelEvent(event); + + event.type = EventType::EVENT_CHANNEL_CLOSED; + avSendProTest_->OnChannelEvent(event); + + event.type = EventType::EVENT_START_SUCCESS; + avSendProTest_->OnChannelEvent(event); + + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioSenderEngineProviderTest, TransName2PkgName_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ownerName"; + auto avReceiveProTest_ = std::make_shared(ownerName); + std::shared_ptr callback = nullptr; + int32_t ret = avReceiveProTest_->RegisterProviderCallback(callback); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + + AVTransEvent event; + event.type = EventType::EVENT_CHANNEL_OPENED; + avReceiveProTest_->OnChannelEvent(event); + + callback = make_shared(); + avReceiveProTest_->RegisterProviderCallback(callback); + avReceiveProTest_->OnChannelEvent(event); + + std::string test = "TEST"; + std::string result = avReceiveProTest_->TransName2PkgName(test); + EXPECT_EQ(EMPTY_STRING, result); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file -- Gitee