From 9300472c9524cae1d3a079246ca749f196a21d39 Mon Sep 17 00:00:00 2001 From: "zhuzhihui7@huawei.com" Date: Wed, 19 Feb 2025 11:02:26 +0800 Subject: [PATCH] add filter ut Signed-off-by: zhuzhihui7@huawei.com --- .../test/unittest/av_receiver_engine/BUILD.gn | 84 ++- .../include/av_audio_receiver_engine_test.h | 60 ++ .../src/av_audio_receiver_engine_test.cpp | 488 +++++++++++++ .../av_audio_receiver_engine_provider_test.h | 40 + ...av_audio_receiver_engine_provider_test.cpp | 129 ++++ .../test/unittest/av_sender_engine/BUILD.gn | 87 ++- .../include/av_audio_sender_engine_test.h | 53 ++ .../src/av_audio_sender_engine_test.cpp | 686 ++++++++++++++++++ .../av_audio_sender_engine_provider_test.h | 40 + .../av_audio_sender_engine_provider_test.cpp | 131 ++++ .../av_trans_engine/filters/test/BUILD.gn | 3 + .../test/av_trans_coder_filter_test/BUILD.gn | 144 ++++ .../av_trans_audio_decoder_filter_test.cpp | 237 ++++++ .../av_trans_audio_decoder_filter_test.h | 37 + .../av_trans_audio_encoder_filter_test.cpp | 237 ++++++ .../av_trans_audio_encoder_filter_test.h | 37 + .../test/av_trans_input_filter_test/BUILD.gn | 138 ++++ .../av_trans_audio_input_filter_test.cpp | 142 ++++ .../av_trans_audio_input_filter_test.h | 38 + .../av_trans_bus_input_filter_test.cpp | 143 ++++ .../av_trans_bus_input_filter_test.h | 38 + .../test/av_trans_output_filter_test/BUILD.gn | 139 ++++ .../av_trans_audio_output_filter_test.cpp | 214 ++++++ .../av_trans_audio_output_filter_test.h | 40 + .../av_trans_dsoftbus_output_filter_test.cpp | 215 ++++++ .../av_trans_dsoftbus_output_filter_test.h | 40 + 26 files changed, 3638 insertions(+), 2 deletions(-) create mode 100644 av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/include/av_audio_receiver_engine_test.h create mode 100644 av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp create mode 100644 av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/include/av_audio_receiver_engine_provider_test.h create mode 100644 av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/src/av_audio_receiver_engine_provider_test.cpp 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 create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.cpp create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.h create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.h create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/BUILD.gn create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.cpp create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.h create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.h create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/BUILD.gn create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.cpp create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.h create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.cpp create mode 100644 av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.h diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/BUILD.gn b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/BUILD.gn index 8fade15e..0277837f 100644 --- a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/BUILD.gn +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/BUILD.gn @@ -96,7 +96,89 @@ ohos_unittest("AvReceiverEngineTest") { ] } +config("module_audio_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${dh_fwk_utils_path}/include", + "${common_path}/include", + "${dh_fwk_sdk_path}/include", + "${engine_path}/av_receiver/include", + "${control_center_path}/inner_kits/include", + "${control_center_path}/inner_kits/include/ipc", + "${filters_path}/av_trans_coder", + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_output", + "${engine_path}/av_receiver/test/unittest/av_receiver_engine/include", + "${interface_path}", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvAudioReceiverEngineTest") { + module_out_path = module_out_path + + sources = [ "src/av_audio_receiver_engine_test.cpp" ] + + configs = [ ":module_audio_private_config" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-frtti", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + deps = [ + "${dh_fwk_sdk_path}:libdhfwk_sdk", + "${engine_path}/av_receiver:distributed_av_receiver", + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"AvReceiverEngineTest\"", + "LOG_DOMAIN=0xD004101", + ] + + defines += [ + "MEDIA_OHOS", + "RECORDER_SUPPORT", + "VIDEO_SUPPORT", + ] + + 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", + "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_receiver_engine_test") { testonly = true - deps = [ ":AvReceiverEngineTest" ] + deps = [ ":AvReceiverEngineTest", + ":AvAudioReceiverEngineTest", ] } diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/include/av_audio_receiver_engine_test.h b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/include/av_audio_receiver_engine_test.h new file mode 100644 index 00000000..288c0f03 --- /dev/null +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/include/av_audio_receiver_engine_test.h @@ -0,0 +1,60 @@ +/* + * 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 AV_AUDIO_RECEIVER_ENGINE_TEST_H +#define AV_TRANSPORT_INPUT_FILTER_TEST_H + +#include + +#include "av_audio_receiver_engine.h" +#include "pipeline_event.h" + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvAudioReceiverEngineTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; + +class ReceiverEngineCallback : public IAVReceiverEngineCallback { +public: + ReceiverEngineCallback() = default; + ~ReceiverEngineCallback() override = default; + int32_t OnReceiverEvent(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; + } + int32_t OnDataAvailable(const std::shared_ptr &buffer) override + { + (void) buffer; + return DH_AVT_SUCCESS; + } +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_INPUT_FILTER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp new file mode 100644 index 00000000..68c55a6a --- /dev/null +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp @@ -0,0 +1,488 @@ +/* + * 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 +#include "av_audio_receiver_engine_test.h" +#include "distributed_hardware_fwk_kit.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { +const std::string FILTERNAME = "avreceivererengine"; + +void AvAudioReceiverEngineTest::SetUp() +{ +} + +void AvAudioReceiverEngineTest::TearDown() +{ +} + +void AvAudioReceiverEngineTest::SetUpTestCase() +{ +} + +void AvAudioReceiverEngineTest::TearDownTestCase() +{ +} + +HWTEST_F(AvAudioReceiverEngineTest, Initialize_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->isInitialized_ = true; + std::string value264 = MIME_VIDEO_H264; + receiver->SetVideoCodecType(value264); + std::string value = MIME_VIDEO_H265; + receiver->SetVideoCodecType(value); + int32_t ret = receiver->Initialize(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, Initialize_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->avInput_ = nullptr; + int32_t ret = receiver->Initialize(); + EXPECT_EQ(ERR_DH_AVT_INIT_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, Initialize_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->sessionName_ = ""; + int32_t ret = receiver->Initialize(); + EXPECT_EQ(ERR_DH_AVT_INIT_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, InitPipeline_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->pipeline_ = nullptr; + receiver->SetEngineReady(ownerName); + receiver->pipeline_ = std::make_shared(); + receiver->SetEngineReady(ownerName); + int32_t ret = receiver->InitPipeline(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, InitPipeline_002, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(OWNER_NAME_D_MIC, peerDevId); + int32_t ret = receiver->InitPipeline(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, InitPipeline_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_SCREEN; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + int32_t ret = receiver->InitPipeline(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, CreateControlChannel_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + std::vector dstDevIds; + int32_t ret = receiver->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, CreateControlChannel_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + std::vector dstDevIds = {peerDevId}; + int32_t ret = receiver->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + EXPECT_EQ(ERR_DH_AVT_CREATE_CHANNEL_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, CreateControlChannel_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + std::vector dstDevIds = {peerDevId}; + int32_t ret = receiver->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + EXPECT_EQ(ERR_DH_AVT_CREATE_CHANNEL_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, Start_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::IDLE; + receiver->pipeline_ = std::make_shared(); + int32_t ret = receiver->Start(); + EXPECT_EQ(ERR_DH_AVT_START_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, Start_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::CH_CREATED; + receiver->pipeline_ = std::make_shared(); + int32_t ret = receiver->Start(); + receiver->Stop(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, Stop_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::CH_CREATED; + receiver->pipeline_ = std::make_shared(); + receiver->Start(); + int32_t ret = receiver->Stop(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, SetParameter_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + int32_t ret = receiver->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, SetParameter_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + int32_t ret = receiver->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, SetParameter_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + int32_t ret = receiver->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, SetParameter_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "123"; + auto receiver = std::make_shared(ownerName, peerDevId); + + std::shared_ptr pipeline_ = nullptr; + receiver->pipeline_ = std::make_shared(); + int32_t ret = receiver->SetParameter(AVTransTag::VIDEO_WIDTH, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, PreparePipeline_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::STARTED; + int32_t ret = receiver->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_PREPARE_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, PreparePipeline_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + int32_t ret = receiver->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, PreparePipeline_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + int32_t ret = receiver->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, PreparePipeline_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + int32_t ret = receiver->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_NULL_POINTER, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, PreparePipeline_005, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_MIC; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->pipeline_ = std::make_shared(); + int32_t ret = receiver->PreparePipeline(configParam); + EXPECT_EQ(ERR_DH_AVT_PREPARE_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, SendMessage_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string configParam = "value"; + auto receiver = std::make_shared(ownerName, peerDevId); + int32_t ret = receiver->SendMessage(nullptr); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, SendMessage_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + auto avMessage = std::make_shared((uint32_t)AVTransTag::START_AV_SYNC, + ownerName, peerDevId); + + int32_t ret = receiver->SendMessage(avMessage); + EXPECT_EQ(ERR_DH_AVT_SEND_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, RegisterReceiverCallback_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + std::shared_ptr callback = nullptr; + int32_t ret = receiver->RegisterReceiverCallback(callback); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, RegisterReceiverCallback_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + std::shared_ptr callback = std::make_shared(); + int32_t ret = receiver->RegisterReceiverCallback(callback); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnChannelEvent_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->receiverCallback_ = nullptr; + AVTransEvent transEvent; + transEvent.content = "content"; + transEvent.type = EventType::EVENT_CHANNEL_OPENED; + receiver->OnChannelEvent(transEvent); + receiver->receiverCallback_ = std::make_shared(); + receiver->OnChannelEvent(transEvent); + + EXPECT_EQ(StateId::CH_CREATED, receiver->currentState_); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnChannelEvent_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + AVTransEvent transEvent; + transEvent.content = "content"; + transEvent.type = EventType::EVENT_CHANNEL_OPEN_FAIL; + receiver->receiverCallback_ = std::make_shared(); + receiver->OnChannelEvent(transEvent); + + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnChannelEvent_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + AVTransEvent event; + event.content = "content"; + event.type = EventType::EVENT_CHANNEL_CLOSED; + receiver->receiverCallback_ = std::make_shared(); + receiver->currentState_ = StateId::CH_CREATED; + receiver->OnChannelEvent(event); + receiver->currentState_ = StateId::IDLE; + receiver->OnChannelEvent(event); + receiver->currentState_ = StateId::INITIALIZED; + receiver->OnChannelEvent(event); + + event.type = EventType::EVENT_DATA_RECEIVED; + receiver->OnChannelEvent(event); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + +HWTEST_F(AvAudioReceiverEngineTest, Release_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->RegRespFunMap(); + std::string value = "50"; + receiver->SetVideoWidth(value); + receiver->SetVideoHeight(value); + receiver->SetVideoFrameRate(value); + receiver->SetAudioBitRate(value); + receiver->SetVideoBitRate(value); + std::string codecType = MIME_VIDEO_H264; + receiver->SetVideoCodecType(codecType); + codecType = MIME_VIDEO_H265; + receiver->SetVideoCodecType(codecType); + receiver->SetAudioCodecType(codecType); + receiver->SetAudioChannelMask(value); + receiver->SetAudioSampleRate(value); + receiver->SetAudioChannelLayout(value); + receiver->SetAudioSampleFormat(value); + receiver->SetAudioFrameSize(value); + + std::string params = ""; + receiver->SetSyncResult(params); + receiver->SetStartAvSync(params); + receiver->SetStopAvSync(params); + receiver->SetSharedMemoryFd(params); + receiver->SetEngineReady(params); + + receiver->currentState_ = StateId::IDLE; + receiver->dhFwkKit_ = std::make_shared(); + int32_t ret = receiver->Release(); + EXPECT_EQ(DH_AVT_SUCCESS, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, StartDumpMediaData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->avInput_ = nullptr; + bool ret = receiver->StartDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, StartDumpMediaData_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + bool ret = receiver->StartDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, StopDumpMediaData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->avInput_ = nullptr; + bool ret = receiver->StopDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, StopDumpMediaData_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + bool ret = receiver->StopDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, ReStartDumpMediaData_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->avInput_ = nullptr; + bool ret = receiver->ReStartDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, ReStartDumpMediaData_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + bool ret = receiver->ReStartDumpMediaData(); + EXPECT_EQ(true, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, HandleOutputBuffer_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + std::shared_ptr buffer = std::make_shared(); + receiver->receiverCallback_ = std::make_shared(); + int32_t ret = receiver->HandleOutputBuffer(buffer); + EXPECT_EQ(ERR_DH_AVT_OUTPUT_DATA_FAILED, ret); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnEvent_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + + Pipeline::Event event; + event.srcFilter = "filter"; + event.type = Pipeline::EventType::EVENT_READY; + receiver->currentState_ = StateId::INITIALIZED; + + receiver->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); + + receiver->receiverCallback_ = std::make_shared(); + receiver->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/include/av_audio_receiver_engine_provider_test.h b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/include/av_audio_receiver_engine_provider_test.h new file mode 100644 index 00000000..9110d070 --- /dev/null +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/include/av_audio_receiver_engine_provider_test.h @@ -0,0 +1,40 @@ +/* + * 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 AV_AUDIO_RECEIVER_ENGINE_PROVIDER_TEST_H +#define AV_AUDIO_RECEIVER_ENGINE_PROVIDER_TEST_H + +#include + +#include "av_audio_receiver_engine_provider.h" +#include "i_av_engine_provider.h" +#include "softbus_channel_adapter.h" + + +namespace OHOS { +namespace DistributedHardware { + + +class AvAudioReceiverEngineProviderTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_AUDIO_RECEIVER_ENGINE_PROVIDER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/src/av_audio_receiver_engine_provider_test.cpp b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/src/av_audio_receiver_engine_provider_test.cpp new file mode 100644 index 00000000..bed67538 --- /dev/null +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/src/av_audio_receiver_engine_provider_test.cpp @@ -0,0 +1,129 @@ +/* + * 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_receiver_engine_provider_test.h" + +#include "av_audio_receiver_engine.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { + +void AvAudioReceiverEngineProviderTest::SetUp() +{ +} + +void AvAudioReceiverEngineProviderTest::TearDown() +{ +} + +void AvAudioReceiverEngineProviderTest::SetUpTestCase() +{ +} + +void AvAudioReceiverEngineProviderTest::TearDownTestCase() +{ +} + +class IAVReceiverEngineProvider : public IAVEngineProviderCallback { +public: + virtual int32_t OnProviderEvent(const AVTransEvent &event) + { + (void)event; + return DH_AVT_SUCCESS; + } +}; + +HWTEST_F(AvAudioReceiverEngineProviderTest, CreateAVReceiverEngine_001, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + std::string ownerName = "ownerName"; + auto avReceiveProTest_ = std::make_shared(ownerName); + auto avReceiverEngine = avReceiveProTest_->CreateAVReceiverEngine(peerDevId); + EXPECT_EQ(nullptr, avReceiverEngine); +} + +HWTEST_F(AvAudioReceiverEngineProviderTest, GetAVReceiverEngineList_001, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + std::string ownerName = "ownerName"; + auto avReceiveProTest_ = std::make_shared(ownerName); + auto avReceiverEngine = avReceiveProTest_->CreateAVReceiverEngine(peerDevId); + std::vector> receiverEngineList = avReceiveProTest_->GetAVReceiverEngineList(); + bool bRet = (receiverEngineList.empty()) ? false : true; + EXPECT_NE(true, bRet); +} + +HWTEST_F(AvAudioReceiverEngineProviderTest, GetAVReceiverEngineList_002, testing::ext::TestSize.Level1) +{ + std::string peerDevId = "peerDevId"; + std::string ownerName = "ownerName"; + auto avReceiveProTest_ = std::make_shared(ownerName); + auto avReceiverEngine = avReceiveProTest_->CreateAVReceiverEngine(peerDevId); + auto receiver = std::make_shared(ownerName, peerDevId); + avReceiveProTest_->receiverEngineList_.push_back(receiver); + std::vector> receiverEngineList = avReceiveProTest_->GetAVReceiverEngineList(); + bool bRet = (receiverEngineList.empty()) ? false : true; + EXPECT_EQ(true, bRet); +} + +HWTEST_F(AvAudioReceiverEngineProviderTest, RegisterProviderCallback_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); + + event.type = EventType::EVENT_CHANNEL_CLOSED; + avReceiveProTest_->OnChannelEvent(event); + + event.type = EventType::EVENT_START_SUCCESS; + avReceiveProTest_->OnChannelEvent(event); +} + +HWTEST_F(AvAudioReceiverEngineProviderTest, 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 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..fc885e5c 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,92 @@ 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", + "${engine_path}/av_sender:distributed_av_sender", + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + "${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 = [ ":AvSenderEngineTest", + ":AvAudioSenderEngineTest" ] } 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..70b18c4b --- /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) 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 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..a33679d2 --- /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,686 @@ +/* + * 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_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 = ""; + 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/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..d5e14ab7 --- /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) 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 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 diff --git a/av_transport/av_trans_engine/filters/test/BUILD.gn b/av_transport/av_trans_engine/filters/test/BUILD.gn index 43090d38..6c795db8 100644 --- a/av_transport/av_trans_engine/filters/test/BUILD.gn +++ b/av_transport/av_trans_engine/filters/test/BUILD.gn @@ -17,5 +17,8 @@ group("filter_test") { deps = [ "av_transport_input_filter_test:input_filter_unittest", "av_transport_output_filter_test:output_filter_unittest", + "av_trans_coder_filter_test:av_trans_coder_filter_unittest", + "av_trans_input_filter_test:av_trans_input_filter_unittest", + "av_trans_output_filter_test:av_trans_audio_output_filter_unittest", ] } diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn new file mode 100644 index 00000000..160625f6 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn @@ -0,0 +1,144 @@ +# Copyright (c) 2023-2024 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("../../../../distributed_av_transport.gni") + +module_out_path = "distributed_hardware_fwk/av_trans_coder" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${filters_path}/av_trans_coder", + "${common_path}/include", + "${distributed_av_transport_path}/framework", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvTransportAudioDecoderFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ + "av_trans_audio_decoder_filter_test.cpp", + ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_decoder_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + # "media_foundation:media_foundation", + # "media_foundation:native_media_core", + "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", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +ohos_unittest("AvTransportAudioEncoderFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ + "av_trans_audio_encoder_filter_test.cpp", + ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_decoder_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + # "media_foundation:media_foundation", + # "media_foundation:native_media_core", + "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", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +group("av_trans_coder_filter_unittest") { + testonly = true + + deps = [ + ":AvTransportAudioDecoderFilterTest", + ":AvTransportAudioEncoderFilterTest", + ] +} diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.cpp new file mode 100644 index 00000000..4a501ea5 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.cpp @@ -0,0 +1,237 @@ +/* + * 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_trans_audio_decoder_filter_test.h" + +#include "av_trans_constants.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { + +const std::string FILTERNAME = "audioDec"; +static constexpr int32_t DEFAULT_BUFFER_NUM = 8; +const std::string INPUT_BUFFERQUEUE_NAME = "AvTransDecoderBufferQueue"; + +void AvTransportAudioDecoderFilterTest::SetUp() +{ +} + +void AvTransportAudioDecoderFilterTest::TearDown() +{ +} + +void AvTransportAudioDecoderFilterTest::SetUpTestCase() +{ +} + +void AvTransportAudioDecoderFilterTest::TearDownTestCase() +{ +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, PrepareInputBufferQueue_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->PrepareInputBufferQueue(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, StartAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->StartAudioCodec(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); + + // Create Audio Codec + ret = avAudioDecoderTest_->CreateAudioCodec(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, StopAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->StopAudioCodec(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, ReleaseAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->ReleaseAudioCodec(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, ConfigureAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Pipeline::ADecInitParams decInitParams; + Status ret = avAudioDecoderTest_->ConfigureAudioCodec(decInitParams); + EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, CreateAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->CreateAudioCodec(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, CheckDecoderFormat_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Pipeline::ADecInitParams decInitParams; + Status ret = avAudioDecoderTest_->CheckDecoderFormat(decInitParams); + EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, SetDecoderFormat_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Pipeline::ADecInitParams decInitParams; + Status ret = avAudioDecoderTest_->SetDecoderFormat(decInitParams); + EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, ProcessData_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + std::shared_ptr audioData; + Status ret = avAudioDecoderTest_->ProcessData(audioData, 0, nullptr); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + + // initial codeMem + OH_AVBuffer *codecMem = nullptr; + ret = avAudioDecoderTest_->ProcessData(audioData, 0, codecMem); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + delete codecMem; +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, OnDecInputBufferAvailable_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + avAudioDecoderTest_->OnDecInputBufferAvailable(1, nullptr); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, OnDecOutputBufferAvailable_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + avAudioDecoderTest_->OnDecOutputBufferAvailable(1, nullptr); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, DoPrepare_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->DoPrepare(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, DoStart_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->DoStart(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, DoStop_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->DoStop(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, DoFlush_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->DoFlush(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, DoRelease_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->DoRelease(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, DoProcessInputBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + + Status ret = avAudioDecoderTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); + + avAudioDecoderTest_->inputBufferQueue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, + INPUT_BUFFERQUEUE_NAME); + ret = avAudioDecoderTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, LinkNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->LinkNext(nullptr, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioDecoderFilterTest, OnLinked_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioDecoderTest_ = + std::make_shared("builtin.recorder.audiodecoderfilter", Pipeline::FilterType::FILTERTYPE_ADEC); + ASSERT_TRUE(avAudioDecoderTest_ != nullptr); + Status ret = avAudioDecoderTest_->OnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr, nullptr); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.h b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.h new file mode 100644 index 00000000..ccb78b6a --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.h @@ -0,0 +1,37 @@ +/* + * 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 AV_TRANSPORT_AUDIO_DECODER_FILTER_TEST_H +#define AV_TRANSPORT_AUDIO_DECODER_FILTER_TEST_H + +#include +#include "av_trans_audio_decoder_filter.h" + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvTransportAudioDecoderFilterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_AUDIO_DECODER_FILTER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp new file mode 100644 index 00000000..bc4e492f --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.cpp @@ -0,0 +1,237 @@ +/* + * 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_trans_audio_encoder_filter_test.h" + +#include "av_trans_constants.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { + +const std::string FILTERNAME = "audioEnc"; +static constexpr int32_t DEFAULT_BUFFER_NUM = 8; +const std::string INPUT_BUFFERQUEUE_NAME = "AvTransEncoderBufferQueue"; + +void AvTransportAudioEncoderFilterTest::SetUp() +{ +} + +void AvTransportAudioEncoderFilterTest::TearDown() +{ +} + +void AvTransportAudioEncoderFilterTest::SetUpTestCase() +{ +} + +void AvTransportAudioEncoderFilterTest::TearDownTestCase() +{ +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, PrepareInputBufferQueue_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->PrepareInputBufferQueue(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, StartAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->StartAudioCodec(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); + + // Create Audio Codec + ret = avAudioEncoderTest_->CreateAudioCodec(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, StopAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->StopAudioCodec(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, ReleaseAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->ReleaseAudioCodec(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, ConfigureAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Pipeline::AEncInitParams encInitParams; + Status ret = avAudioEncoderTest_->ConfigureAudioCodec(encInitParams); + EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, CreateAudioCodec_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->CreateAudioCodec(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, CheckDecoderFormat_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Pipeline::AEncInitParams encInitParams; + Status ret = avAudioEncoderTest_->CheckEncoderFormat(encInitParams); + EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, SetDecoderFormat_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Pipeline::AEncInitParams encInitParams; + Status ret = avAudioEncoderTest_->SetEncoderFormat(encInitParams); + EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, ProcessData_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + std::shared_ptr audioData; + Status ret = avAudioEncoderTest_->ProcessData(audioData, 0, nullptr); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + + // initial codeMem + OH_AVBuffer *codecMem = nullptr; + ret = avAudioEncoderTest_->ProcessData(audioData, 0, codecMem); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + delete codecMem; +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncInputBufferAvailable_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + avAudioEncoderTest_->OnEncInputBufferAvailable(1, nullptr); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, OnEncOutputBufferAvailable_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + avAudioEncoderTest_->OnEncOutputBufferAvailable(1, nullptr); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, DoPrepare_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->DoPrepare(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, DoStart_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->DoStart(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, DoStop_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->DoStop(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, DoFlush_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->DoFlush(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, DoRelease_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->DoRelease(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, DoProcessInputBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + + Status ret = avAudioEncoderTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); + + avAudioEncoderTest_->inputBufferQueue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, + INPUT_BUFFERQUEUE_NAME); + ret = avAudioEncoderTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, LinkNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->LinkNext(nullptr, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioEncoderFilterTest, OnLinked_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + ASSERT_TRUE(avAudioEncoderTest_ != nullptr); + Status ret = avAudioEncoderTest_->OnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr, nullptr); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.h b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.h new file mode 100644 index 00000000..4d4acacf --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_encoder_filter_test.h @@ -0,0 +1,37 @@ +/* + * 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 AV_TRANSPORT_AUDIO_ENCODER_FILTER_TEST_H +#define AV_TRANSPORT_AUDIO_ENCODER_FILTER_TEST_H + +#include +#include "av_trans_audio_encoder_filter.h" + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvTransportAudioEncoderFilterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_INPUT_FILTER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/BUILD.gn b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/BUILD.gn new file mode 100644 index 00000000..d02862c3 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/BUILD.gn @@ -0,0 +1,138 @@ +# Copyright (c) 2023-2024 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("../../../../distributed_av_transport.gni") + +module_out_path = "distributed_hardware_fwk/av_trans_input" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_coder", + "${common_path}/include", + "${distributed_av_transport_path}/framework", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvTransAudioInputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ + "av_trans_audio_input_filter_test.cpp", + ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_input_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + 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", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +ohos_unittest("AVTransBusInputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ + "av_trans_bus_input_filter_test.cpp", + ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_bus_input_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + 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", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +group("av_trans_input_filter_unittest") { + testonly = true + deps = [ + ":AvTransAudioInputFilterTest", + ":AVTransBusInputFilterTest", + ] +} diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.cpp new file mode 100644 index 00000000..84f0e1b8 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.cpp @@ -0,0 +1,142 @@ +/* + * 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_trans_audio_input_filter_test.h" +#include "av_trans_audio_encoder_filter.h" +#include "av_trans_constants.h" +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t DEFAULT_BUFFER_NUM = 8; +const std::string INPUT_BUFFER_QUEUE_NAME = "AVTransAudioInputBufferQueue"; + +void AvTransportAudioInputFilterTest::SetUp() +{ +} + +void AvTransportAudioInputFilterTest::TearDown() +{ +} + +void AvTransportAudioInputFilterTest::SetUpTestCase() +{ +} + +void AvTransportAudioInputFilterTest::TearDownTestCase() +{ +} + +HWTEST_F(AvTransportAudioInputFilterTest, PrepareInputBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + avAudioInputTest_->PrepareInputBuffer(); +} + +HWTEST_F(AvTransportAudioInputFilterTest, ProcessAndSendBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + std::shared_ptr audioData = std::make_shared(); + Status ret = avAudioInputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, DoPrepare_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->DoPrepare(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, DoStart_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->DoStart(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, DoStop_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->DoStop(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, DoFlush_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->DoFlush(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, DoRelease_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->DoRelease(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, DoProcessInputBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_WRONG_STATE, ret); + + avAudioInputTest_->inputBufQue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, + INPUT_BUFFER_QUEUE_NAME); + ret = avAudioInputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_WRONG_STATE, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, LinkNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = avAudioInputTest_->LinkNext(avAudioEncoderTest_, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioInputFilterTest, OnLinked_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avAudioInputTest_ = + std::make_shared("builtin.avtrans.audio.input", Pipeline::FilterType::FILTERTYPE_SOURCE); + ASSERT_TRUE(avAudioInputTest_ != nullptr); + Status ret = avAudioInputTest_->OnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr, nullptr); + EXPECT_EQ(Status::OK, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.h b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.h new file mode 100644 index 00000000..60e667f5 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_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 AV_TRANSPORT_AUDIO_INPUT_FILTER_TEST_H +#define AV_TRANSPORT_AUDIO_INPUT_FILTER_TEST_H + +#include +#include "av_trans_audio_input_filter.h" + + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvTransportAudioInputFilterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_AUDIO_INPUT_FILTER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp new file mode 100644 index 00000000..75fc8c48 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp @@ -0,0 +1,143 @@ +/* + * 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_trans_bus_input_filter_test.h" +#include "av_trans_constants.h" +#include "av_trans_audio_encoder_filter.h" +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t DEFAULT_BUFFER_NUM = 8; +const std::string INPUT_BUFFER_QUEUE_NAME = "AVTransBusInputBufferQueue"; + +void AvTransportBusInputFilterTest::SetUp() +{ +} + +void AvTransportBusInputFilterTest::TearDown() +{ +} + +void AvTransportBusInputFilterTest::SetUpTestCase() +{ +} + +void AvTransportBusInputFilterTest::TearDownTestCase() +{ +} + +HWTEST_F(AvTransportBusInputFilterTest, PrepareInputBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + avBusInputTest_->PrepareInputBuffer(); +} + +HWTEST_F(AvTransportBusInputFilterTest, ProcessAndSendBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + std::shared_ptr audioData = std::make_shared(); + Status ret = avBusInputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoPrepare_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + Status ret = avBusInputTest_->DoPrepare(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoStart_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + Status ret = avBusInputTest_->DoStart(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoStop_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + Status ret = avBusInputTest_->DoStop(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoFlush_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + Status ret = avBusInputTest_->DoFlush(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoRelease_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + Status ret = avBusInputTest_->DoRelease(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoProcessInputBuffer_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + + Status ret = avBusInputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_WRONG_STATE, ret); + + avBusInputTest_->inputBufQue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, + INPUT_BUFFER_QUEUE_NAME); + ret = avBusInputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_WRONG_STATE, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, LinkNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = avBusInputTest_->LinkNext(avAudioEncoderTest_, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, OnLinked_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.softbus.input", Pipeline::FilterType::AUDIO_DATA_SOURCE); + ASSERT_TRUE(avBusInputTest_ != nullptr); + Status ret = avBusInputTest_->OnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr, nullptr); + EXPECT_EQ(Status::OK, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.h b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.h new file mode 100644 index 00000000..af2768fb --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_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 AV_TRANSPORT_BUS_INPUT_FILTER_TEST_H +#define AV_TRANSPORT_BUS_INPUT_FILTER_TEST_H + +#include +#include "av_trans_bus_input_filter.h" + + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvTransportBusInputFilterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_AUDIO_INPUT_FILTER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/BUILD.gn b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/BUILD.gn new file mode 100644 index 00000000..237e0390 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/BUILD.gn @@ -0,0 +1,139 @@ +# Copyright (c) 2023-2024 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("../../../../distributed_av_transport.gni") + +module_out_path = "distributed_hardware_fwk/av_trans_output" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_coder", + "${filters_path}/av_trans_output", + "${common_path}/include", + "${distributed_av_transport_path}/framework", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvTransAudioOutputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ + "av_trans_audio_output_filter_test.cpp", + ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_output_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + 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", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +ohos_unittest("AVTransAudioDSoftbusOutputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ + "av_trans_dsoftbus_output_filter_test.cpp", + ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_dsoftbus_output_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + 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", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +group("av_trans_audio_output_filter_unittest") { + testonly = true + deps = [ + ":AvTransAudioOutputFilterTest", + ":AVTransAudioDSoftbusOutputFilterTest", + ] +} diff --git a/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.cpp new file mode 100644 index 00000000..187c0694 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.cpp @@ -0,0 +1,214 @@ +/* + * 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_trans_audio_output_filter_test.h" +#include "av_trans_audio_encoder_filter.h" +#include "av_trans_constants.h" +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t DEFAULT_BUFFER_NUM = 8; +const std::string INPUT_BUFFER_QUEUE_NAME = "AVTransAudioInputBufferQueue"; + +void AvTransportAudioOutputFilterTest::SetUp() +{ + dAudioOutputTest_ = std::make_shared("builtin.daudio.output", + Pipeline::FilterType::FILTERTYPE_SSINK); +} + +void AvTransportAudioOutputFilterTest::TearDown() +{ +} + +void AvTransportAudioOutputFilterTest::SetUpTestCase() +{ +} + +void AvTransportAudioOutputFilterTest::TearDownTestCase() +{ +} + +HWTEST_F(AvTransportAudioOutputFilterTest, Init_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + dAudioOutputTest_->Init(nullptr, nullptr); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoInitAfterLink_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoInitAfterLink(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, PrepareInputBuffer_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + dAudioOutputTest_->PrepareInputBuffer(); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoPrepare_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoPrepare(); + EXPECT_NE(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoStart_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoStart(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoPause_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoPause(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoPauseDragging_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoPauseDragging(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoResume_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoResume(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoResumeDragging_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoResumeDragging(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoStop_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoStop(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoFlush_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoFlush(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoRelease_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + Status ret = dAudioOutputTest_->DoRelease(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoProcessInputBuffer_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + dAudioOutputTest_->PrepareInputBuffer(); + Status ret = dAudioOutputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + + dAudioOutputTest_->outputBufQue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFER_QUEUE_NAME); + ret = dAudioOutputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoProcessOutputBuffer_001, testing::ext::TestSize.Level1) +{ + Status ret = dAudioOutputTest_->DoProcessOutputBuffer(1, true, true , 2, 3); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, ProcessAndSendBuffer_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + std::shared_ptr audioData = std::make_shared(); + Status ret = dAudioOutputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, SetParameterAndGetParameter_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr meta = nullptr; + std::shared_ptr meta2 = std::make_shared(); + dAudioOutputTest_->SetParameter(meta2); + dAudioOutputTest_->GetParameter(meta); + EXPECT_EQ(meta, meta2); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, LinkNext_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dAudioOutputTest_->LinkNext(avAudioEncoderTest_, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, UpdateNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr filter = + std::make_shared("builtin.recorder.audioencoderfilter2", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dAudioOutputTest_->UpdateNext(filter, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, UnLinkNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr filter = + std::make_shared("builtin.recorder.audioencoderfilter2", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dAudioOutputTest_->UnLinkNext(filter, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, OnLinked_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + std::shared_ptr meta = std::make_shared(); + Status ret = dAudioOutputTest_->OnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, meta, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, OnUpdated_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + std::shared_ptr meta = std::make_shared(); + Status ret = dAudioOutputTest_->OnUpdated(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, meta, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, OnUnLinked_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr filter = + std::make_shared("builtin.recorder.audioencoderfilter2", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dAudioOutputTest_->OnUnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.h b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.h new file mode 100644 index 00000000..25a9a89f --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_audio_output_filter_test.h @@ -0,0 +1,40 @@ +/* + * 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 AV_TRANSPORT_AUDIO_OUTPUT_FILTER_TEST_H +#define AV_TRANSPORT_AUDIO_OUTPUT_FILTER_TEST_H + +#include +#include "daudio_output_filter.h" + + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvTransportAudioOutputFilterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +private: + std::shared_ptr dAudioOutputTest_; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_AUDIO_OUTPUT_FILTER_TEST_H \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.cpp new file mode 100644 index 00000000..4551fbdb --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.cpp @@ -0,0 +1,215 @@ +/* + * 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_trans_dsoftbus_output_filter_test.h" +#include "av_trans_audio_encoder_filter.h" +#include "av_trans_constants.h" +using namespace testing::ext; +using namespace OHOS::DistributedHardware; +using namespace std; + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t DEFAULT_BUFFER_NUM = 8; +const std::string INPUT_BUFFER_QUEUE_NAME = "AVTransAudioInputBufferQueue"; + +void AvTransportAudioOutputFilterTest::SetUp() +{ + dSoftbusOutputTest_ = std::make_shared("builtin.daudio.output", + Pipeline::FilterType::FILTERTYPE_SSINK); +} + +void AvTransportAudioOutputFilterTest::TearDown() +{ +} + +void AvTransportAudioOutputFilterTest::SetUpTestCase() +{ +} + +void AvTransportAudioOutputFilterTest::TearDownTestCase() +{ +} + +HWTEST_F(AvTransportAudioOutputFilterTest, Init_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + std::string receiverId = std::string("AVreceiverEngineTest"); + dSoftbusOutputTest_->Init(nullptr, nullptr); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoInitAfterLink_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoInitAfterLink(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, PrepareInputBuffer_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + dSoftbusOutputTest_->PrepareInputBuffer(); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoPrepare_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoPrepare(); + EXPECT_NE(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoStart_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoStart(); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoPause_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoPause(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoPauseDragging_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoPauseDragging(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoResume_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoResume(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoResumeDragging_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoResumeDragging(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoStop_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoStop(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoFlush_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoFlush(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoRelease_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + Status ret = dSoftbusOutputTest_->DoRelease(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoProcessInputBuffer_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + dSoftbusOutputTest_->PrepareInputBuffer(); + Status ret = dSoftbusOutputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + + dSoftbusOutputTest_->outputBufQue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFER_QUEUE_NAME); + ret = dSoftbusOutputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, DoProcessOutputBuffer_001, testing::ext::TestSize.Level1) +{ + Status ret = dSoftbusOutputTest_->DoProcessOutputBuffer(1, true, true , 2, 3); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, ProcessAndSendBuffer_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + std::shared_ptr audioData = std::make_shared(); + Status ret = dSoftbusOutputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, SetParameterAndGetParameter_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr meta = nullptr; + std::shared_ptr meta2 = std::make_shared(); + dSoftbusOutputTest_->SetParameter(meta2); + dSoftbusOutputTest_->GetParameter(meta); + EXPECT_EQ(meta, meta2); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, LinkNext_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dSoftbusOutputTest_->LinkNext(avAudioEncoderTest_, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, UpdateNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr filter = + std::make_shared("builtin.recorder.audioencoderfilter2", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dSoftbusOutputTest_->UpdateNext(filter, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, UnLinkNext_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr filter = + std::make_shared("builtin.recorder.audioencoderfilter2", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dSoftbusOutputTest_->UnLinkNext(filter, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, OnLinked_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + std::shared_ptr meta = std::make_shared(); + Status ret = dSoftbusOutputTest_->OnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, meta, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, OnUpdated_001, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); + std::shared_ptr meta = std::make_shared(); + Status ret = dSoftbusOutputTest_->OnUpdated(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, meta, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportAudioOutputFilterTest, OnUnLinked_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr filter = + std::make_shared("builtin.recorder.audioencoderfilter2", Pipeline::FilterType::FILTERTYPE_AENC); + Status ret = dSoftbusOutputTest_->OnUnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.h b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.h new file mode 100644 index 00000000..d7ae72c9 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/av_trans_dsoftbus_output_filter_test.h @@ -0,0 +1,40 @@ +/* + * 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 AV_TRANSPORT_DSOFTBUS_OUTPUT_FILTER_TEST_H +#define AV_TRANSPORT_DSOFTBUS_OUTPUT_FILTER_TEST_H + +#include +#include "dsoftbus_output_filter.h" + + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::Media; + +class AvTransportAudioOutputFilterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +private: + std::shared_ptr dSoftbusOutputTest_; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // AV_TRANSPORT_DSOFTBUS_OUTPUT_FILTER_TEST_H \ No newline at end of file -- Gitee