From b8a1164ea779718b89acebad076ad5dcf8413377 Mon Sep 17 00:00:00 2001 From: zhuzhihui Date: Wed, 19 Mar 2025 16:32:50 +0800 Subject: [PATCH] add ut Signed-off-by: zhuzhihui --- .../src/av_receiver_engine_test.cpp | 187 ++++++++++++++++++ .../av_trans_bus_input_filter_test.cpp | 25 +++ .../av_trans_audio_output_filter_test.cpp | 13 +- .../av_trans_audio_output_filter_test.h | 5 + .../av_trans_dsoftbus_output_filter_test.cpp | 20 +- .../av_trans_dsoftbus_output_filter_test.h | 9 + .../src/distributed_hardware_stub_test.cpp | 15 ++ 7 files changed, 272 insertions(+), 2 deletions(-) diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_receiver_engine_test.cpp b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_receiver_engine_test.cpp index b3b2f212..64d8a1c1 100644 --- a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_receiver_engine_test.cpp +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_receiver_engine_test.cpp @@ -324,6 +324,30 @@ HWTEST_F(AvReceiverEngineTest, SetParameter_007, testing::ext::TestSize.Level1) EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); } +HWTEST_F(AvReceiverEngineTest, SetParameter_008, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + std::string value = "123"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->avInput_ = FilterFactory::Instance().CreateFilterWithType(AVINPUT_NAME, "avinput"); + receiver->avOutput_ = FilterFactory::Instance().CreateFilterWithType(AVOUTPUT_NAME, "avoutput"); + std::shared_ptr pipeline_ = nullptr; + receiver->pipeline_ = std::make_shared(); + int32_t ret = receiver->SetParameter(AVTransTag::VIDEO_HEIGHT, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + ret = receiver->SetParameter(AVTransTag::VIDEO_FRAME_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + ret = receiver->SetParameter(AVTransTag::AUDIO_BIT_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + ret = receiver->SetParameter(AVTransTag::VIDEO_BIT_RATE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + ret = receiver->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, value); + EXPECT_EQ(DH_AVT_SUCCESS, ret); + ret = receiver->SetParameter(AVTransTag::INVALID, value); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + HWTEST_F(AvReceiverEngineTest, PreparePipeline_001, testing::ext::TestSize.Level1) { std::string ownerName = "001"; @@ -501,6 +525,19 @@ HWTEST_F(AvReceiverEngineTest, OnChannelEvent_003, testing::ext::TestSize.Level1 EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); } +HWTEST_F(AvReceiverEngineTest, OnChannelEvent_004, 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_REMOVE_STREAM; + receiver->OnChannelEvent(event); + receiver->currentState_ = StateId::BUTT; + EXPECT_EQ(StateId::BUTT, receiver->currentState_); +} + HWTEST_F(AvReceiverEngineTest, Release_001, testing::ext::TestSize.Level1) { std::string ownerName = OWNER_NAME_D_CAMERA; @@ -522,6 +559,7 @@ HWTEST_F(AvReceiverEngineTest, Release_001, testing::ext::TestSize.Level1) std::string codecType = MIME_VIDEO_H264; receiver->SetVideoCodecType(codecType); codecType = MIME_VIDEO_H265; + receiver->SetVideoCodecType(MIME_VIDEO_RAW); receiver->SetVideoCodecType(codecType); receiver->SetAudioCodecType(codecType); receiver->SetAudioChannelMask(value); @@ -585,6 +623,42 @@ HWTEST_F(AvReceiverEngineTest, Release_002, testing::ext::TestSize.Level1) EXPECT_EQ(DH_AVT_SUCCESS, ret); } +HWTEST_F(AvReceiverEngineTest, Release_003, 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->avInput_ = nullptr; + receiver->avOutput_ = nullptr; + 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(AvReceiverEngineTest, StartDumpMediaData_001, testing::ext::TestSize.Level1) { std::string ownerName = OWNER_NAME_D_CAMERA; @@ -663,6 +737,24 @@ HWTEST_F(AvReceiverEngineTest, HandleOutputBuffer_001, testing::ext::TestSize.Le EXPECT_EQ(ERR_DH_AVT_OUTPUT_DATA_FAILED, ret); } +HWTEST_F(AvReceiverEngineTest, HandleOutputBuffer_002, 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 = nullptr; + receiver->receiverCallback_ = std::make_shared(); + int32_t ret = receiver->HandleOutputBuffer(buffer); + EXPECT_EQ(ERR_DH_AVT_OUTPUT_DATA_FAILED, ret); + buffer = std::make_shared(); + std::shared_ptr receiverCallback = receiver->receiverCallback_; + receiver->receiverCallback_ = nullptr; + ret = receiver->HandleOutputBuffer(buffer); + receiver->receiverCallback_ = receiverCallback; + EXPECT_EQ(ERR_DH_AVT_OUTPUT_DATA_FAILED, ret); +} + HWTEST_F(AvReceiverEngineTest, OnEvent_001, testing::ext::TestSize.Level1) { std::string ownerName = OWNER_NAME_D_CAMERA; @@ -682,5 +774,100 @@ HWTEST_F(AvReceiverEngineTest, OnEvent_001, testing::ext::TestSize.Level1) receiver->OnEvent(event); EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); } + +HWTEST_F(AvReceiverEngineTest, OnEvent_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + OHOS::Media::Event event; + event.srcFilter = "filter"; + event.type = OHOS::Media::EventType::EVENT_BUFFER_PROGRESS; + std::shared_ptr buffer = nullptr; + event.param = buffer; + receiver->currentState_ = StateId::INITIALIZED; + receiver->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); + event.param = std::make_shared(); + receiver->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); + receiver->receiverCallback_ = std::make_shared(); + event.type = OHOS::Media::EventType::EVENT_PLUGIN_EVENT; + event.param = PluginEvent{PluginEventType::AUDIO_INTERRUPT, 0, "aaa"}; + receiver->OnEvent(event); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + +HWTEST_F(AvReceiverEngineTest, SetParameterInner_001, testing::ext::TestSize.Level1) +{ + auto receiver = std::make_shared("001", "pEid"); + receiver->avInput_ = FilterFactory::Instance().CreateFilterWithType(AVINPUT_NAME, "avinput"); + receiver->avOutput_ = FilterFactory::Instance().CreateFilterWithType(AVOUTPUT_NAME, "avoutput"); + receiver->SetParameterInner(AVTransTag::VIDEO_CODEC_TYPE, MIME_VIDEO_H264); + EXPECT_EQ(receiver->avInput_->paramsMap_.find(Plugin::Tag::MIME) != receiver->avInput_->paramsMap_.end(), true); + receiver->SetParameterInner(AVTransTag::AUDIO_CODEC_TYPE, MIME_VIDEO_H264); + EXPECT_EQ(receiver->avInput_->paramsMap_.find(Plugin::Tag::MIME) != receiver->avInput_->paramsMap_.end(), true); + receiver->SetParameterInner(AVTransTag::AUDIO_CHANNEL_MASK, "50"); + bool ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::AUDIO_CHANNELS) != + receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::AUDIO_SAMPLE_RATE, "50"); + ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::AUDIO_SAMPLE_RATE) != receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::AUDIO_CHANNEL_LAYOUT, "50"); + ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::AUDIO_CHANNEL_LAYOUT) != + receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::AUDIO_SAMPLE_FORMAT, "50"); + ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::AUDIO_SAMPLE_FORMAT) != + receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::AUDIO_FRAME_SIZE, "50"); + ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::AUDIO_SAMPLE_PER_FRAME) != + receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); +} + +HWTEST_F(AvReceiverEngineTest, SetParameterInner_002, testing::ext::TestSize.Level1) +{ + auto receiver = std::make_shared("001", "pEid"); + receiver->avInput_ = FilterFactory::Instance().CreateFilterWithType(AVINPUT_NAME, "avinput"); + receiver->avOutput_ = FilterFactory::Instance().CreateFilterWithType(AVOUTPUT_NAME, "avoutput"); + receiver->SetParameterInner(AVTransTag::TIME_SYNC_RESULT, MIME_VIDEO_H264); + bool ret = receiver->avOutput_->paramsMap_.find(Plugin::Tag::USER_TIME_SYNC_RESULT) != + receiver->avOutput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::START_AV_SYNC, MIME_VIDEO_H264); + ret = receiver->avOutput_->paramsMap_.find(Plugin::Tag::USER_AV_SYNC_GROUP_INFO) != + receiver->avOutput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::STOP_AV_SYNC, MIME_VIDEO_H264); + ret = receiver->avOutput_->paramsMap_.find(Plugin::Tag::USER_AV_SYNC_GROUP_INFO) != + receiver->avOutput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::SHARED_MEMORY_FD, MIME_VIDEO_H264); + ret = receiver->avOutput_->paramsMap_.find(Plugin::Tag::USER_SHARED_MEMORY_FD) != + receiver->avOutput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->currentState_ = StateId::INITIALIZED; + receiver->SetParameterInner(AVTransTag::ENGINE_READY, MIME_VIDEO_H264); + ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::MEDIA_TYPE) != receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); + receiver->SetParameterInner(AVTransTag::INVALID, MIME_VIDEO_H264); + ret = receiver->avInput_->paramsMap_.find(Plugin::Tag::INVALID) == receiver->avInput_->paramsMap_.end(); + EXPECT_EQ(ret, true); +} + +HWTEST_F(AvReceiverEngineTest, OnStreamReceived_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; + StreamData *data = nullptr; + StreamData *ext = nullptr; + receiver->OnStreamReceived(data, ext); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} } // 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.cpp b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_bus_input_filter_test.cpp index d32904bc..ffd25f85 100644 --- 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 @@ -122,6 +122,19 @@ HWTEST_F(AvTransportBusInputFilterTest, ProcessAndSendBuffer_002, testing::ext:: EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); } +HWTEST_F(AvTransportBusInputFilterTest, ProcessAndSendBuffer_003, testing::ext::TestSize.Level1) +{ + std::shared_ptr avBusInputTest_ = + std::make_shared("builtin.avtrans.audio.input", + Pipeline::FilterType::FILTERTYPE_SOURCE); + std::shared_ptr outputBufQue = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, + Media::MemoryType::VIRTUAL_MEMORY, INPUT_BUFFER_QUEUE_NAME); + avBusInputTest_->outputBufQueProducer_ = outputBufQue->GetProducer(); + std::shared_ptr audioData = std::make_shared(); + Status ret = avBusInputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); +} + HWTEST_F(AvTransportBusInputFilterTest, DoProcessOutputBuffer_001, testing::ext::TestSize.Level1) { std::shared_ptr avBusInputTest_ = @@ -239,6 +252,18 @@ HWTEST_F(AvTransportBusInputFilterTest, DoProcessInputBuffer_001, testing::ext:: EXPECT_EQ(Status::ERROR_WRONG_STATE, ret); } +HWTEST_F(AvTransportBusInputFilterTest, DoProcessInputBuffer_002, 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(); + avBusInputTest_->curState_ = Pipeline::FilterState::RUNNING; + Status ret = avBusInputTest_->DoProcessInputBuffer(1, true); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); +} + HWTEST_F(AvTransportBusInputFilterTest, LinkNext_001, testing::ext::TestSize.Level1) { std::shared_ptr avBusInputTest_ = 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 index be25f336..cf5399ab 100644 --- 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 @@ -154,6 +154,18 @@ HWTEST_F(AvTransportAudioOutputFilterTest, ProcessAndSendBuffer_001, testing::ex EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); } +HWTEST_F(AvTransportAudioOutputFilterTest, ProcessAndSendBuffer_002, testing::ext::TestSize.Level1) +{ + ASSERT_TRUE(dAudioOutputTest_ != nullptr); + std::shared_ptr audioData; + Status ret = dAudioOutputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); + audioData = std::make_shared(); + dAudioOutputTest_->eventReceiver_ = std::make_shared(); + ret = dAudioOutputTest_->ProcessAndSendBuffer(audioData); + EXPECT_EQ(Status::OK, ret); +} + HWTEST_F(AvTransportAudioOutputFilterTest, SetParameterAndGetParameter_001, testing::ext::TestSize.Level1) { std::shared_ptr meta = nullptr; @@ -215,6 +227,5 @@ HWTEST_F(AvTransportAudioOutputFilterTest, OnUnLinked_001, testing::ext::TestSiz 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 index 3b81cc74..7225345e 100644 --- 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 @@ -34,6 +34,11 @@ public: private: std::shared_ptr dAudioOutputTest_; }; + +class EventReceiverTest : public Pipeline::EventReceiver { +public: + void OnEvent(const Pipeline::Event& event) {} +}; } // namespace DistributedHardware } // namespace OHOS 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 index 198057ee..ce18bfbe 100644 --- 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 @@ -221,7 +221,6 @@ HWTEST_F(AvTransportAudioOutputFilterTest, OnUnLinked_001, testing::ext::TestSiz HWTEST_F(AvTransportAudioOutputFilterTest, DoPrepare_002, testing::ext::TestSize.Level1) { ASSERT_TRUE(dSoftbusOutputTest_ != nullptr); - std::shared_ptr meta = std::make_shared(); ASSERT_TRUE(meta != nullptr); dSoftbusOutputTest_->SetParameter(meta); @@ -229,6 +228,8 @@ HWTEST_F(AvTransportAudioOutputFilterTest, DoPrepare_002, testing::ext::TestSize EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); cJSON *jsonObj = cJSON_CreateObject(); ASSERT_TRUE(jsonObj != nullptr); + ret = dSoftbusOutputTest_->DoPrepare(); + EXPECT_EQ(Status::ERROR_NULL_POINTER, ret); std::string ownerName = "audiotest"; cJSON_AddStringToObject(jsonObj, KEY_ONWER_NAME.c_str(), ownerName.c_str()); auto str = cJSON_PrintUnformatted(jsonObj); @@ -248,6 +249,11 @@ HWTEST_F(AvTransportAudioOutputFilterTest, DoPrepare_002, testing::ext::TestSize cJSON_Delete(jsonObj); meta->SetData(Media::Tag::MEDIA_DESCRIPTION, jsonStr); dSoftbusOutputTest_->SetParameter(meta); + std::shared_ptr avAudioEncoderTest_ = + std::make_shared("builtin.recorder.audioencoderfilter", + Pipeline::FilterType::FILTERTYPE_AENC); + ret = dSoftbusOutputTest_->LinkNext(avAudioEncoderTest_, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + ASSERT_TRUE(ret == Status::OK); ret = dSoftbusOutputTest_->DoPrepare(); EXPECT_EQ(Status::OK, ret); } @@ -296,5 +302,17 @@ HWTEST_F(AvTransportAudioOutputFilterTest, ProcessAndSendBuffer_002, testing::ex EXPECT_EQ(Status::ERROR_INVALID_OPERATION, ret); } +HWTEST_F(AvTransportAudioOutputFilterTest, OnChannelEvent_001, testing::ext::TestSize.Level1) +{ + AVTransEvent event; + event.type = EventType::EVENT_REMOVE_STREAM; + dSoftbusOutputTest_->OnChannelEvent(event); + dSoftbusOutputTest_->eventReceiver_ = std::make_shared(); + std::shared_ptr eventReceiverTest_ = std::static_pointer_cast( + dSoftbusOutputTest_->eventReceiver_); + eventReceiverTest_->type_ = OHOS::DistributedHardware::Pipeline::EventType::EVENT_READY; + dSoftbusOutputTest_->OnChannelEvent(event); + EXPECT_EQ(OHOS::DistributedHardware::Pipeline::EventType::EVENT_AUDIO_PROGRESS, eventReceiverTest_->type_); +} } // 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 index c2be517e..956049bc 100644 --- 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 @@ -34,6 +34,15 @@ public: private: std::shared_ptr dSoftbusOutputTest_; }; + +class EventReceiverTest : public Pipeline::EventReceiver { +public: + OHOS::DistributedHardware::Pipeline::EventType type_; + void OnEvent(const Pipeline::Event& event) + { + type_ = event.type; + } +}; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp index 756be4aa..8b9ff738 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp @@ -372,6 +372,21 @@ HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_024, TestSize.Level1) EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); } +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_025, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(0xffff); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_NE(DH_FWK_SUCCESS, ret); +} + /** * @tc.name: RegisterPublisherListenerInner_001 * @tc.desc: Verify the RegisterPublisherListenerInner function -- Gitee