diff --git a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp index 62235a9fe5d1647a957b693c325c11171c0711ef..d273fedab52ba53ccab553d9080112eccbd667f4 100644 --- a/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp +++ b/av_transport/av_trans_engine/av_receiver/test/unittest/av_receiver_engine/src/av_audio_receiver_engine_test.cpp @@ -229,6 +229,19 @@ HWTEST_F(AvAudioReceiverEngineTest, Release_003, testing::ext::TestSize.Level1) EXPECT_EQ(result, DH_AVT_SUCCESS); } +HWTEST_F(AvAudioReceiverEngineTest, Release_005, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->isInitialized_ = true; + receiver->pipeline_ = nullptr; + receiver->dhFwkKit_ = std::make_shared(); + receiver->SetCurrentState(StateId::INITIALIZED); + int32_t result = receiver->Release(); + EXPECT_EQ(result, DH_AVT_SUCCESS); +} + HWTEST_F(AvAudioReceiverEngineTest, Stop_001, testing::ext::TestSize.Level1) { std::string ownerName = "001"; @@ -283,6 +296,16 @@ HWTEST_F(AvAudioReceiverEngineTest, SetParameterInner_002, testing::ext::TestSiz EXPECT_EQ(receiver->meta_, nullptr); } +HWTEST_F(AvAudioReceiverEngineTest, SetParameterInner_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->meta_ = nullptr; + receiver->SetParameterInner(AVTransTag::INVALID, "1"); + EXPECT_EQ(receiver->meta_, nullptr); +} + HWTEST_F(AvAudioReceiverEngineTest, Stop_002, testing::ext::TestSize.Level1) { std::string ownerName = "001"; @@ -385,6 +408,7 @@ HWTEST_F(AvAudioReceiverEngineTest, SetParameter_006, testing::ext::TestSize.Lev receiver->SetParameter(AVTransTag::STOP_AV_SYNC, "14"); receiver->SetParameter(AVTransTag::SHARED_MEMORY_FD, "15"); receiver->SetParameter(AVTransTag::ENGINE_READY, "16"); + receiver->SetParameter(AVTransTag::VIDEO_BIT_RATE, "17"); EXPECT_NE(receiver->meta_, nullptr); } @@ -728,5 +752,54 @@ HWTEST_F(AvAudioReceiverEngineTest, Prepare_001, testing::ext::TestSize.Level1) receiver->pipeline_->Prepare(); EXPECT_EQ(receiver->Prepare(), Status::OK); } + +HWTEST_F(AvAudioReceiverEngineTest, OnCallback_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + + receiver->OnCallback(nullptr, Pipeline::FilterCallBackCommand::FILTER_CALLBACK_COMMAND_MAX, + Pipeline::StreamType::STREAMTYPE_MAX); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnCallback_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + + receiver->OnCallback(nullptr, Pipeline::FilterCallBackCommand::NEXT_FILTER_NEEDED, + Pipeline::StreamType::STREAMTYPE_MAX); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnCallback_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + + receiver->OnCallback(nullptr, Pipeline::FilterCallBackCommand::NEXT_FILTER_NEEDED, + Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + +HWTEST_F(AvAudioReceiverEngineTest, OnCallback_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = "001"; + std::string peerDevId = "pEid"; + auto receiver = std::make_shared(ownerName, peerDevId); + receiver->currentState_ = StateId::INITIALIZED; + + receiver->OnCallback(nullptr, Pipeline::FilterCallBackCommand::NEXT_FILTER_NEEDED, + Pipeline::StreamType::STREAMTYPE_DECODED_AUDIO); + EXPECT_EQ(StateId::INITIALIZED, receiver->currentState_); +} + } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp index ef580d7a037e7f7e39802ad0218d8d9da9205f60..855cbfa6ea11e675a9882ec7d5f40fe888a1b641 100644 --- a/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp +++ b/av_transport/av_trans_engine/av_sender/test/unittest/av_sender_engine/src/av_audio_sender_engine_test.cpp @@ -428,6 +428,19 @@ HWTEST_F(AvAudioSenderEngineTest, SetParameter_014, testing::ext::TestSize.Level EXPECT_EQ(sender->meta_, nullptr); } +HWTEST_F(AvAudioSenderEngineTest, SetParameterInner_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = "ohos.dhardware.dscreen"; + std::string peerDevId = "pEid"; + std::string value = "500"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->meta_ = nullptr; + sender->SetParameterInner(AVTransTag::INVALID, "H264"); + sender->SetVideoPixelFormat("10"); + sender->SetVideoBitRate("11"); + EXPECT_EQ(sender->meta_, nullptr); +} + HWTEST_F(AvAudioSenderEngineTest, PushData_001, testing::ext::TestSize.Level1) { std::string ownerName = "001"; @@ -702,6 +715,17 @@ HWTEST_F(AvAudioSenderEngineTest, SendMessage_005, testing::ext::TestSize.Level1 EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); } +HWTEST_F(AvAudioSenderEngineTest, SendMessage_006, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + EventType type = EventType::EVENT_ADD_STREAM; + sender->NotifyStreamChange(type); + int32_t ret = sender->SendMessage(nullptr); + EXPECT_EQ(ERR_DH_AVT_INVALID_PARAM, ret); +} + HWTEST_F(AvAudioSenderEngineTest, RegisterSenderCallback_001, testing::ext::TestSize.Level1) { std::string ownerName = OWNER_NAME_D_SCREEN; @@ -812,5 +836,68 @@ HWTEST_F(AvAudioSenderEngineTest, OnEvent_001, testing::ext::TestSize.Level1) sender->OnEvent(event); EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); } + +HWTEST_F(AvAudioSenderEngineTest, OnCallback_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + + sender->OnCallback(nullptr, Pipeline::FilterCallBackCommand::FILTER_CALLBACK_COMMAND_MAX, + Pipeline::StreamType::STREAMTYPE_MAX); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnCallback_002, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + + sender->OnCallback(nullptr, Pipeline::FilterCallBackCommand::NEXT_FILTER_NEEDED, + Pipeline::StreamType::STREAMTYPE_MAX); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnCallback_003, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + + sender->OnCallback(nullptr, Pipeline::FilterCallBackCommand::NEXT_FILTER_NEEDED, + Pipeline::StreamType::STREAMTYPE_RAW_AUDIO); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, OnCallback_004, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + + sender->OnCallback(nullptr, Pipeline::FilterCallBackCommand::NEXT_FILTER_NEEDED, + Pipeline::StreamType::STREAMTYPE_ENCODED_AUDIO); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} + +HWTEST_F(AvAudioSenderEngineTest, LinkAudioSinkFilter_001, testing::ext::TestSize.Level1) +{ + std::string ownerName = OWNER_NAME_D_CAMERA; + std::string peerDevId = "pEid"; + auto sender = std::make_shared(ownerName, peerDevId); + sender->currentState_ = StateId::INITIALIZED; + sender->avOutput_ = nullptr; + sender->pipeline_ = nullptr; + + sender->LinkAudioSinkFilter(nullptr, Pipeline::StreamType::STREAMTYPE_ENCODED_AUDIO); + sender->pipeline_ = std::make_shared(); + sender->LinkAudioSinkFilter(nullptr, Pipeline::StreamType::STREAMTYPE_ENCODED_AUDIO); + EXPECT_EQ(StateId::INITIALIZED, sender->currentState_); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/av_transport/common/test/unittest/BUILD.gn b/av_transport/common/test/unittest/BUILD.gn index 57cfea32f108089c7f9ade71456d75f94e2ad5e9..918904af07a0bf8d1f451bc45b4de9a8ae484d6d 100644 --- a/av_transport/common/test/unittest/BUILD.gn +++ b/av_transport/common/test/unittest/BUILD.gn @@ -28,7 +28,10 @@ ohos_unittest("AvSyncUtilsTest") { "${plugin_path}/interface", ] - sources = [ "av_sync_utils_test.cpp" ] + sources = [ + "av_sync_utils_test.cpp", + "ashmem_mock.cpp", + ] deps = [ "${dh_fwk_sdk_path}:libdhfwk_sdk", @@ -49,6 +52,8 @@ ohos_unittest("AvSyncUtilsTest") { "cJSON:cjson", "c_utils:utils", "ipc:ipc_core", + "googletest:gmock", + "googletest:gmock_main", ] cflags = [ diff --git a/av_transport/common/test/unittest/ashmem_mock.cpp b/av_transport/common/test/unittest/ashmem_mock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ca18393bcb40f0b01d29dfdb4bf79de8310ea4af --- /dev/null +++ b/av_transport/common/test/unittest/ashmem_mock.cpp @@ -0,0 +1,51 @@ +/* + * 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 "ashmem_mock.h" + +namespace OHOS { +std::shared_ptr IAshmem::ashmem_; + +constexpr int32_t ASH_MEM_SIZE = 100; +constexpr int32_t FD_FOR_TEST = 50; +constexpr int32_t ASH_MEM_SET_PORTT = 1; + +std::shared_ptr IAshmem::GetOrCreateInstance() +{ + if (!ashmem_) { + ashmem_ = std::make_shared(); + } + return ashmem_; +} + +void IAshmem::ReleaseInstance() +{ + ashmem_.reset(); + ashmem_ = nullptr; +} + +int AshmemGetSize(int fd) +{ + if (fd >= FD_FOR_TEST) { + return fd; + } + return ASH_MEM_SIZE; +} +int AshmemSetProt(int fd, int prot) +{ + return ASH_MEM_SET_PORTT; +} + +} // namespace OHOS diff --git a/av_transport/common/test/unittest/ashmem_mock.h b/av_transport/common/test/unittest/ashmem_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..bc2365cdf431214b40266b78a0fd936787c9b6ed --- /dev/null +++ b/av_transport/common/test/unittest/ashmem_mock.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 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 OHOS_DISTRIBUTED_HARDWARE_ASHMEM_MOCK +#define OHOS_DISTRIBUTED_HARDWARE_ASHMEM_MOCK + +#include + +#include "ashmem.h" + +namespace OHOS { +class IAshmem { +public: + static std::shared_ptr GetOrCreateInstance(); + static void ReleaseInstance(); +public: + static std::shared_ptr ashmem_; +}; + +class MockAshmem : public IAshmem { +public: + virtual ~MockAshmem() = default; +}; +} // namespace OHOS +#endif // OHOS_DISTRIBUTED_HARDWARE_ASHMEM_MOCK \ No newline at end of file diff --git a/av_transport/common/test/unittest/av_sync_utils_test.cpp b/av_transport/common/test/unittest/av_sync_utils_test.cpp index 8f869318005c0a56300ae6db43aa3bfec98d15a3..0864867dc2241a8a8292dcf4e20fbe84c8315e26 100644 --- a/av_transport/common/test/unittest/av_sync_utils_test.cpp +++ b/av_transport/common/test/unittest/av_sync_utils_test.cpp @@ -19,7 +19,9 @@ #include "av_trans_constants.h" #include "cJSON.h" +#include "ashmem_mock.h" +using namespace testing; using namespace testing::ext; namespace OHOS { namespace DistributedHardware { @@ -30,6 +32,8 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); +public: + std::shared_ptr ashmemMock_; }; void AvSyncUtilsTest::SetUpTestCase() @@ -42,10 +46,14 @@ void AvSyncUtilsTest::TearDownTestCase() void AvSyncUtilsTest::SetUp() { + auto ashmem_ = IAshmem::GetOrCreateInstance(); + ashmemMock_ = std::static_pointer_cast(ashmem_); } void AvSyncUtilsTest::TearDown() { + IAshmem::ReleaseInstance(); + ashmemMock_ = nullptr; } HWTEST_F(AvSyncUtilsTest, CreateAVTransSharedMemory_001, TestSize.Level0) @@ -147,5 +155,21 @@ HWTEST_F(AvSyncUtilsTest, UnmarshalSharedMemory_002, TestSize.Level1) cJSON_free(cjson3); cJSON_Delete(cJsonObj3); } + +HWTEST_F(AvSyncUtilsTest, WriteClockUnitToMemory_001, TestSize.Level1) +{ + AVTransSharedMemory memory = { + .fd = 1, + .size = 100, + .name = "name_test", + }; + AVSyncClockUnit unit = { + .index = 1, + .frameNum = 1, + .pts = 1, + }; + auto ret = WriteClockUnitToMemory(memory, unit); + EXPECT_EQ(false, ret == 0); +} } } \ No newline at end of file