diff --git a/av_transport/av_trans_engine/filters/test/BUILD.gn b/av_transport/av_trans_engine/filters/test/BUILD.gn index 43090d382b3c6657ce521de691608a0850a56660..9788b2aeec75effd9886a0c937c8cc4c03482318 100644 --- a/av_transport/av_trans_engine/filters/test/BUILD.gn +++ b/av_transport/av_trans_engine/filters/test/BUILD.gn @@ -15,6 +15,9 @@ group("filter_test") { testonly = true deps = [ + "av_trans_coder_filter_test:av_trans_coder_filter_unittest", + "av_trans_input_filter_test:av_trans_input_filter_unittest", + "av_trans_output_filter_test:av_trans_audio_output_filter_unittest", "av_transport_input_filter_test:input_filter_unittest", "av_transport_output_filter_test:output_filter_unittest", ] diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0beb9df1e2f3227e2d31b3211354371801f6b8aa --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/BUILD.gn @@ -0,0 +1,134 @@ +# Copyright (c) 2023-2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("../../../../distributed_av_transport.gni") + +module_out_path = "distributed_hardware_fwk/av_trans_coder" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${filters_path}/av_trans_coder", + "${common_path}/include", + "${distributed_av_transport_path}/framework", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvTransportAudioDecoderFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ "av_trans_audio_decoder_filter_test.cpp" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_decoder_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +ohos_unittest("AvTransportAudioEncoderFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ "av_trans_audio_encoder_filter_test.cpp" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_decoder_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +group("av_trans_coder_filter_unittest") { + testonly = true + + deps = [ + ":AvTransportAudioDecoderFilterTest", + ":AvTransportAudioEncoderFilterTest", + ] +} diff --git a/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_coder_filter_test/av_trans_audio_decoder_filter_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..07fe9de5124334e6e6deb7ea7106bd8397adafc6 --- /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 0000000000000000000000000000000000000000..9df462cf16785c687b729b63e7b77958be8f6f56 --- /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 0000000000000000000000000000000000000000..0f39f56b61825f0642d7f1abb7d29c51fb2b3b2c --- /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 0000000000000000000000000000000000000000..113b156236b1b3e1798002c9d3498bbad31846ef --- /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/BUILD.gn b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..bb33a6e8f63b20cd19b3279698ed1cd7a74b1683 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/BUILD.gn @@ -0,0 +1,135 @@ +# Copyright (c) 2023-2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("../../../../distributed_av_transport.gni") + +module_out_path = "distributed_hardware_fwk/av_trans_input" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_coder", + "${common_path}/include", + "${distributed_av_transport_path}/framework", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvTransAudioInputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ "av_trans_audio_input_filter_test.cpp" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_input_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +ohos_unittest("AVTransBusInputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ "av_trans_bus_input_filter_test.cpp" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_bus_input_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +group("av_trans_input_filter_unittest") { + testonly = true + deps = [ + ":AVTransBusInputFilterTest", + ":AvTransAudioInputFilterTest", + ":AVTransBusInputFilterTest", + ] +} diff --git a/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.cpp b/av_transport/av_trans_engine/filters/test/av_trans_input_filter_test/av_trans_audio_input_filter_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ef6381f849887feb1b557773da0dd51f1d14e036 --- /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 0000000000000000000000000000000000000000..b02f82e4fa44a84ca9d874005c18dea01bb578db --- /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 0000000000000000000000000000000000000000..0111ec9535346148f06e2b1100d09b4826cef6e9 --- /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 0000000000000000000000000000000000000000..7898ed3567b536827a25bb5467284945ee29df0a --- /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/BUILD.gn b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ef7b24db1b07507ca03800b10e9ec5e85afdf4d7 --- /dev/null +++ b/av_transport/av_trans_engine/filters/test/av_trans_output_filter_test/BUILD.gn @@ -0,0 +1,135 @@ +# Copyright (c) 2023-2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("../../../../distributed_av_transport.gni") + +module_out_path = "distributed_hardware_fwk/av_trans_output" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${filters_path}/av_trans_input", + "${filters_path}/av_trans_coder", + "${filters_path}/av_trans_output", + "${common_path}/include", + "${distributed_av_transport_path}/framework", + "${distributed_av_transport_path}/framework/filter/include", + "${distributed_av_transport_path}/framework/pipeline/include", + ] +} + +ohos_unittest("AvTransAudioOutputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ "av_trans_audio_output_filter_test.cpp" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_audio_output_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +ohos_unittest("AVTransAudioDSoftbusOutputFilterTest") { + module_out_path = module_out_path + + configs = [ ":module_private_config" ] + + sources = [ "av_trans_dsoftbus_output_filter_test.cpp" ] + + cflags = [ + "-O2", + "-fPIC", + "-Wall", + "-fexceptions", + "-Dprivate = public", + "-Dprotected = public", + ] + cflags_cc = cflags + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"av_trans_dsoftbus_output_filter_test\"", + "LOG_DOMAIN=0xD004101", + ] + + deps = [ + "${distributed_av_transport_path}/framework:distributed_av_pipeline_fwk", + ] + + if (histreamer_compile_part) { + external_deps = [ + "media_foundation:histreamer_base", + "media_foundation:histreamer_codec_filters", + "media_foundation:histreamer_ffmpeg_convert", + ] + } + + external_deps += [ + "av_codec:av_codec_client", + "av_codec:native_media_acodec", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + "c_utils:utils", + "dsoftbus:softbus_client", + "googletest:gtest", + "hilog:libhilog", + "libevdev:libevdev", + ] +} + +group("av_trans_audio_output_filter_unittest") { + testonly = true + deps = [ + ":AVTransAudioDSoftbusOutputFilterTest", + ":AvTransAudioOutputFilterTest", + ] +} 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 0000000000000000000000000000000000000000..6126364d8a0c5884e3f966c50141088943793e36 --- /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 0000000000000000000000000000000000000000..3b81cc74f1f901623d4770a8359ff36dfcc50431 --- /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 0000000000000000000000000000000000000000..3103e65029e7fa23a05aa43d782e4bae02663feb --- /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 0000000000000000000000000000000000000000..c2be517e3b64935a42a22ac29aeaa6848d230fb3 --- /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