From 07252d02fccf8f3129eaa718bd8350c0e9356287 Mon Sep 17 00:00:00 2001 From: "zhuzhihui7@huawei.com" Date: Tue, 25 Feb 2025 20:00:10 +0800 Subject: [PATCH] add receiver engine ut Signed-off-by: zhuzhihui7@huawei.com --- .../test/unittest/av_receiver_engine/BUILD.gn | 86 +++- .../include/av_audio_receiver_engine_test.h | 60 +++ .../src/av_audio_receiver_engine_test.cpp | 487 ++++++++++++++++++ .../av_receiver_engine_provider/BUILD.gn | 89 +++- .../av_audio_receiver_engine_provider_test.h | 40 ++ ...av_audio_receiver_engine_provider_test.cpp | 129 +++++ 6 files changed, 889 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 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..ae091ada 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,91 @@ 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", + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + "${engine_path}/av_receiver:distributed_av_receiver", + ] + + 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 = [ + ":AvAudioReceiverEngineTest", + ":AvReceiverEngineTest", + ] } 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..b1ad2467 --- /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) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AV_AUDIO_RECEIVER_ENGINE_TEST_H +#define AV_AUDIO_RECEIVER_ENGINE_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_AUDIO_RECEIVER_ENGINE_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..6296fd7c --- /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,487 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "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/BUILD.gn b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/BUILD.gn index d029012d..c3f3fe20 100644 --- a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/BUILD.gn +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine_provider/BUILD.gn @@ -96,7 +96,94 @@ ohos_unittest("AvReceiverEngineProviderTest") { ] } +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_transport_input", + "${filters_path}/av_transport_output", + "${filters_path}/av_trans_coder", + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_output", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + "${engine_path}/av_receiver/test/unittest/av_receiver_engine_provider/include", + "${interface_path}", + ] +} + +ohos_unittest("AvAudioReceiverEngineProviderTest") { + module_out_path = module_out_path + + sources = [ "src/av_audio_receiver_engine_provider_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", + "${filters_path}:avtrans_input_filter", + "${filters_path}:avtrans_output_filter", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"AvAudioReceiverEngineProviderTest\"", + "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_provider_test") { testonly = true - deps = [ ":AvReceiverEngineProviderTest" ] + deps = [ + ":AvAudioReceiverEngineProviderTest", + ":AvReceiverEngineProviderTest", + ] } 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..cf78c247 --- /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) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AV_AUDIO_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 -- Gitee