admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update MockAudioEncoderFactory to override Create instead of MakeAudioEncoder

Browse Source 
MakeAudioEncoder planned to be removed, and Create planned to become pure virtual

While at it, cleanup nearby mock usage:
Remove ON_CALL that by default return default constructed result
Remove EXPECT_CALL().Times(AnyNumber()) for a NiceMock
Remove parameters in EXPECT_CALL when all are wildcard
Remove redundant get to deference a smart pointer

Bug: webrtc:343086059
Change-Id: Ica90a4980350cb82bcebd11df6c63a01b828bb9d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/356884
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Gustaf Ullberg <gustaf@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42622}
This commit is contained in:
Danil Chapovalov 2024-07-10 19:22:07 +02:00 committed by WebRTC LUCI CQ
parent 7fac89f3f9
commit 954e72b654
3 changed files with 40 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
audio/audio_send_stream_unittest.cc
View File

@ -51,6 +51,7 @@ using ::testing::Ne;
using ::testing::NiceMock; using ::testing::NiceMock;
using ::testing::Return; using ::testing::Return;
using ::testing::StrEq; using ::testing::StrEq;
using ::testing::WithArg;
static const float kTolerance = 0.0001f; static const float kTolerance = 0.0001f;
@ -100,21 +101,19 @@ class MockLimitObserver : public BitrateAllocator::LimitObserver {
}; };
std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock( std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
int payload_type,
const SdpAudioFormat& format) { const SdpAudioFormat& format) {
for (const auto& spec : kCodecSpecs) { for (const auto& spec : kCodecSpecs) {
if (format == spec.format) { if (format == spec.format) {
std::unique_ptr<MockAudioEncoder> encoder( auto encoder = std::make_unique<NiceMock<MockAudioEncoder>>();
new ::testing::NiceMock<MockAudioEncoder>()); ON_CALL(*encoder, SampleRateHz)
ON_CALL(*encoder.get(), SampleRateHz())
.WillByDefault(Return(spec.info.sample_rate_hz)); .WillByDefault(Return(spec.info.sample_rate_hz));
ON_CALL(*encoder.get(), NumChannels()) ON_CALL(*encoder, NumChannels)
.WillByDefault(Return(spec.info.num_channels)); .WillByDefault(Return(spec.info.num_channels));
ON_CALL(*encoder.get(), RtpTimestampRateHz()) ON_CALL(*encoder, RtpTimestampRateHz)
.WillByDefault(Return(spec.format.clockrate_hz)); .WillByDefault(Return(spec.format.clockrate_hz));
ON_CALL(*encoder.get(), GetFrameLengthRange()) ON_CALL(*encoder, GetFrameLengthRange)
.WillByDefault(Return(absl::optional<std::pair<TimeDelta, TimeDelta>>{ .WillByDefault(Return(
{TimeDelta::Millis(20), TimeDelta::Millis(120)}})); std::make_pair(TimeDelta::Millis(20), TimeDelta::Millis(120))));
return encoder; return encoder;
} }
} }
@ -124,11 +123,11 @@ std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() { rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() {
rtc::scoped_refptr<MockAudioEncoderFactory> factory = rtc::scoped_refptr<MockAudioEncoderFactory> factory =
rtc::make_ref_counted<MockAudioEncoderFactory>(); rtc::make_ref_counted<MockAudioEncoderFactory>();
ON_CALL(*factory.get(), GetSupportedEncoders()) ON_CALL(*factory, GetSupportedEncoders)
.WillByDefault(Return(std::vector<AudioCodecSpec>( .WillByDefault(Return(std::vector<AudioCodecSpec>(
std::begin(kCodecSpecs), std::end(kCodecSpecs)))); std::begin(kCodecSpecs), std::end(kCodecSpecs))));
ON_CALL(*factory.get(), QueryAudioEncoder(_)) ON_CALL(*factory, QueryAudioEncoder)
.WillByDefault(Invoke( .WillByDefault(
[](const SdpAudioFormat& format) -> absl::optional<AudioCodecInfo> { [](const SdpAudioFormat& format) -> absl::optional<AudioCodecInfo> {
for (const auto& spec : kCodecSpecs) { for (const auto& spec : kCodecSpecs) {
if (format == spec.format) { if (format == spec.format) {
@ -136,13 +135,8 @@ rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() {
} }
} }
return absl::nullopt; return absl::nullopt;
})); });
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _)) ON_CALL(*factory, Create).WillByDefault(WithArg<1>(&SetupAudioEncoderMock));
.WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* return_value) {
*return_value = SetupAudioEncoderMock(payload_type, format);
}));
return factory; return factory;
} }
@ -518,19 +512,17 @@ TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
helper.config().audio_network_adaptor_config = kAnaConfigString; helper.config().audio_network_adaptor_config = kAnaConfigString;
EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _, _)) EXPECT_CALL(helper.mock_encoder_factory(), Create)
.WillOnce(Invoke([&kAnaConfigString, &kAnaReconfigString]( .WillOnce(WithArg<1>([&kAnaConfigString, &kAnaReconfigString](
int payload_type, const SdpAudioFormat& format, const SdpAudioFormat& format) {
absl::optional<AudioCodecPairId> codec_pair_id, auto mock_encoder = SetupAudioEncoderMock(format);
std::unique_ptr<AudioEncoder>* return_value) {
auto mock_encoder = SetupAudioEncoderMock(payload_type, format);
EXPECT_CALL(*mock_encoder, EXPECT_CALL(*mock_encoder,
EnableAudioNetworkAdaptor(StrEq(kAnaConfigString), _)) EnableAudioNetworkAdaptor(StrEq(kAnaConfigString), _))
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_CALL(*mock_encoder, EXPECT_CALL(*mock_encoder,
EnableAudioNetworkAdaptor(StrEq(kAnaReconfigString), _)) EnableAudioNetworkAdaptor(StrEq(kAnaReconfigString), _))
.WillOnce(Return(true)); .WillOnce(Return(true));
*return_value = std::move(mock_encoder); return mock_encoder;
})); }));
auto send_stream = helper.CreateAudioSendStream(); auto send_stream = helper.CreateAudioSendStream();
@ -549,12 +541,10 @@ TEST(AudioSendStreamTest, AudioNetworkAdaptorReceivesOverhead) {
AudioSendStream::Config::SendCodecSpec(0, kOpusFormat); AudioSendStream::Config::SendCodecSpec(0, kOpusFormat);
const std::string kAnaConfigString = "abcde"; const std::string kAnaConfigString = "abcde";
EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _, _)) EXPECT_CALL(helper.mock_encoder_factory(), Create)
.WillOnce(Invoke( .WillOnce(
[&kAnaConfigString](int payload_type, const SdpAudioFormat& format, WithArg<1>([&kAnaConfigString](const SdpAudioFormat& format) {
absl::optional<AudioCodecPairId> codec_pair_id, auto mock_encoder = SetupAudioEncoderMock(format);
std::unique_ptr<AudioEncoder>* return_value) {
auto mock_encoder = SetupAudioEncoderMock(payload_type, format);
InSequence s; InSequence s;
EXPECT_CALL( EXPECT_CALL(
*mock_encoder, *mock_encoder,
@ -565,9 +555,8 @@ TEST(AudioSendStreamTest, AudioNetworkAdaptorReceivesOverhead) {
// Note: Overhead is received AFTER ANA has been enabled. // Note: Overhead is received AFTER ANA has been enabled.
EXPECT_CALL( EXPECT_CALL(
*mock_encoder, *mock_encoder,
OnReceivedOverhead(Eq(kOverheadPerPacket.bytes<size_t>()))) OnReceivedOverhead(Eq(kOverheadPerPacket.bytes<size_t>())));
.WillOnce(Return()); return mock_encoder;
*return_value = std::move(mock_encoder);
})); }));
EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
.WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>())); .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>()));
@ -960,14 +949,12 @@ TEST(AudioSendStreamTest, UseEncoderBitrateRange) {
ConfigHelper helper(true, true, true); ConfigHelper helper(true, true, true);
std::pair<DataRate, DataRate> bitrate_range{DataRate::BitsPerSec(5000), std::pair<DataRate, DataRate> bitrate_range{DataRate::BitsPerSec(5000),
DataRate::BitsPerSec(10000)}; DataRate::BitsPerSec(10000)};
EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _, _)) EXPECT_CALL(helper.mock_encoder_factory(), Create)
.WillOnce(Invoke([&](int payload_type, const SdpAudioFormat& format, .WillOnce(WithArg<1>([&](const SdpAudioFormat& format) {
absl::optional<AudioCodecPairId> codec_pair_id, auto mock_encoder = SetupAudioEncoderMock(format);
std::unique_ptr<AudioEncoder>* return_value) { EXPECT_CALL(*mock_encoder, GetBitrateRange)
auto mock_encoder = SetupAudioEncoderMock(payload_type, format);
EXPECT_CALL(*mock_encoder, GetBitrateRange())
.WillRepeatedly(Return(bitrate_range)); .WillRepeatedly(Return(bitrate_range));
*return_value = std::move(mock_encoder); return mock_encoder;
})); }));
auto send_stream = helper.CreateAudioSendStream(); auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _)) EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))

1
test/BUILD.gn
View File

@ -1184,6 +1184,7 @@ rtc_library("audio_codec_mocks") {
"../api:scoped_refptr", "../api:scoped_refptr",
"../api/audio_codecs:audio_codecs_api", "../api/audio_codecs:audio_codecs_api",
"../api/audio_codecs:builtin_audio_decoder_factory", "../api/audio_codecs:builtin_audio_decoder_factory",
"../api/environment",
] ]
} }

60
test/mock_audio_encoder_factory.h
View File

@ -15,6 +15,7 @@
#include <vector> #include <vector>
#include "api/audio_codecs/audio_encoder_factory.h" #include "api/audio_codecs/audio_encoder_factory.h"
#include "api/environment/environment.h"
#include "api/make_ref_counted.h" #include "api/make_ref_counted.h"
#include "api/scoped_refptr.h" #include "api/scoped_refptr.h"
#include "test/gmock.h" #include "test/gmock.h"
@ -32,66 +33,25 @@ class MockAudioEncoderFactory
QueryAudioEncoder, QueryAudioEncoder,
(const SdpAudioFormat& format), (const SdpAudioFormat& format),
(override)); (override));
MOCK_METHOD(std::unique_ptr<AudioEncoder>,
std::unique_ptr<AudioEncoder> MakeAudioEncoder( Create,
int payload_type, (const Environment&, const SdpAudioFormat&, Options),
const SdpAudioFormat& format, (override));
absl::optional<AudioCodecPairId> codec_pair_id) override {
std::unique_ptr<AudioEncoder> return_value;
MakeAudioEncoderMock(payload_type, format, codec_pair_id, &return_value);
return return_value;
}
MOCK_METHOD(void,
MakeAudioEncoderMock,
(int payload_type,
const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>*));
// Creates a MockAudioEncoderFactory with no formats and that may not be // Creates a MockAudioEncoderFactory with no formats and that may not be
// invoked to create a codec - useful for initializing a voice engine, for // invoked to create a codec - useful for initializing a voice engine, for
// example. // example.
static rtc::scoped_refptr<webrtc::MockAudioEncoderFactory> static scoped_refptr<MockAudioEncoderFactory> CreateUnusedFactory() {
CreateUnusedFactory() { auto factory = make_ref_counted<MockAudioEncoderFactory>();
using ::testing::_; EXPECT_CALL(*factory, Create).Times(0);
using ::testing::AnyNumber;
using ::testing::Return;
auto factory = rtc::make_ref_counted<webrtc::MockAudioEncoderFactory>();
ON_CALL(*factory.get(), GetSupportedEncoders())
.WillByDefault(Return(std::vector<webrtc::AudioCodecSpec>()));
ON_CALL(*factory.get(), QueryAudioEncoder(_))
.WillByDefault(Return(absl::nullopt));
EXPECT_CALL(*factory.get(), GetSupportedEncoders()).Times(AnyNumber());
EXPECT_CALL(*factory.get(), QueryAudioEncoder(_)).Times(AnyNumber());
EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _)).Times(0);
return factory; return factory;
} }
// Creates a MockAudioEncoderFactory with no formats that may be invoked to // Creates a MockAudioEncoderFactory with no formats that may be invoked to
// create a codec any number of times. It will, though, return nullptr on each // create a codec any number of times. It will, though, return nullptr on each
// call, since it supports no codecs. // call, since it supports no codecs.
static rtc::scoped_refptr<webrtc::MockAudioEncoderFactory> static scoped_refptr<MockAudioEncoderFactory> CreateEmptyFactory() {
CreateEmptyFactory() { return make_ref_counted<MockAudioEncoderFactory>();
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::Return;
using ::testing::SetArgPointee;
auto factory = rtc::make_ref_counted<webrtc::MockAudioEncoderFactory>();
ON_CALL(*factory.get(), GetSupportedEncoders())
.WillByDefault(Return(std::vector<webrtc::AudioCodecSpec>()));
ON_CALL(*factory.get(), QueryAudioEncoder(_))
.WillByDefault(Return(absl::nullopt));
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _))
.WillByDefault(SetArgPointee<3>(nullptr));
EXPECT_CALL(*factory.get(), GetSupportedEncoders()).Times(AnyNumber());
EXPECT_CALL(*factory.get(), QueryAudioEncoder(_)).Times(AnyNumber());
EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _))
.Times(AnyNumber());
return factory;
} }
}; };