From c35a36e727129b225e30a7de9c959416d0d7505d Mon Sep 17 00:00:00 2001 From: "zhuzhihui7@huawei.com" Date: Tue, 25 Feb 2025 20:04:38 +0800 Subject: [PATCH] add filters ut Signed-off-by: zhuzhihui7@huawei.com --- .../av_trans_audio_decoder_filter_test.cpp | 256 +++++++++++++++ .../av_trans_audio_decoder_filter_test.h | 37 +++ .../av_trans_audio_encoder_filter_test.cpp | 256 +++++++++++++++ .../av_trans_audio_encoder_filter_test.h | 37 +++ .../av_trans_audio_input_filter_test.cpp | 153 +++++++++ .../av_trans_audio_input_filter_test.h | 38 +++ .../av_trans_bus_input_filter_test.cpp | 306 ++++++++++++++++++ .../av_trans_bus_input_filter_test.h | 38 +++ .../av_trans_audio_output_filter_test.cpp | 218 +++++++++++++ .../av_trans_audio_output_filter_test.h | 40 +++ .../av_trans_dsoftbus_output_filter_test.cpp | 219 +++++++++++++ .../av_trans_dsoftbus_output_filter_test.h | 40 +++ 12 files changed, 1638 insertions(+) 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/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/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/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..07fe9de5 --- /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,256 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_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..9df462cf --- /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) 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_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..0f39f56b --- /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,256 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_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..113b1562 --- /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) 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_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/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..ef6381f8 --- /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,153 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_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..b02f82e4 --- /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) 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_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..0111ec95 --- /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,306 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_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, Init_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_->Init(nullptr, nullptr); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoInitAfterLink_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_->DoInitAfterLink(); + EXPECT_EQ(ret, Status::OK); +} + +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, DoProcessOutputBuffer_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_->DoProcessOutputBuffer(0, true, true, 0, 0); + EXPECT_EQ(ret, Status::OK); +} + +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, DoPause_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_->DoPause(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoPauseDragging_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_->DoPauseDragging(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoResume_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_->DoResume(); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, DoResumeDragging_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_->DoResumeDragging(); + 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); +} + +HWTEST_F(AvTransportBusInputFilterTest, UpdateNext_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_->UpdateNext(nullptr, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, UnLinkNext_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_->UnLinkNext(nullptr, Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, OnUpdated_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_->OnUpdated(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, OnUnLinked_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_->OnUnLinked(Pipeline::StreamType::STREAMTYPE_RAW_AUDIO, nullptr); + EXPECT_EQ(Status::OK, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_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); + int64_t pts= 0; + bool ret = avBusInputTest_->UnmarshalAudioMeta("", pts); + EXPECT_EQ(false, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, UnmarshalAudioMeta_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); + int64_t pts= 1; + bool ret = avBusInputTest_->UnmarshalAudioMeta("AUDIO", pts); + EXPECT_EQ(false, ret); +} + +HWTEST_F(AvTransportBusInputFilterTest, TransName2PkgName_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::string test = "TEST"; + std::string result = avBusInputTest_->TransName2PkgName(test); + EXPECT_EQ(EMPTY_STRING, result); +} + +HWTEST_F(AvTransportBusInputFilterTest, TransName2PkgName_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); + std::string result = avBusInputTest_->TransName2PkgName(OWNER_NAME_D_SCREEN); + EXPECT_EQ(PKG_NAME_D_SCREEN, result); +} +} // 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..7898ed35 --- /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) 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_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/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..6126364d --- /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,218 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_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..3b81cc74 --- /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) 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_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..3103e650 --- /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,219 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_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..c2be517e --- /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) 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_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